1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
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"
52 #include "event-loop.h"
53 #include "event-top.h"
59 #include "gdbcore.h" /* for exec_bfd */
61 #include "remote-fileio.h"
63 /* Prototypes for local functions. */
64 static void cleanup_sigint_signal_handler (void *dummy
);
65 static void initialize_sigint_signal_handler (void);
66 static int getpkt_sane (char **buf
, long *sizeof_buf
, int forever
);
68 static void handle_remote_sigint (int);
69 static void handle_remote_sigint_twice (int);
70 static void async_remote_interrupt (gdb_client_data
);
71 void async_remote_interrupt_twice (gdb_client_data
);
73 static void build_remote_gdbarch_data (void);
75 static void remote_files_info (struct target_ops
*ignore
);
77 static void remote_prepare_to_store (void);
79 static void remote_fetch_registers (int regno
);
81 static void remote_resume (ptid_t ptid
, int step
,
82 enum target_signal siggnal
);
83 static void remote_async_resume (ptid_t ptid
, int step
,
84 enum target_signal siggnal
);
85 static void remote_open (char *name
, int from_tty
);
86 static void remote_async_open (char *name
, int from_tty
);
88 static void extended_remote_open (char *name
, int from_tty
);
89 static void extended_remote_async_open (char *name
, int from_tty
);
91 static void remote_open_1 (char *, int, struct target_ops
*, int extended_p
,
94 static void remote_close (int quitting
);
96 static void remote_store_registers (int regno
);
98 static void remote_mourn (void);
99 static void remote_async_mourn (void);
101 static void extended_remote_restart (void);
103 static void extended_remote_mourn (void);
105 static void remote_mourn_1 (struct target_ops
*);
107 static void remote_send (char **buf
, long *sizeof_buf_p
);
109 static int readchar (int timeout
);
111 static ptid_t
remote_wait (ptid_t ptid
,
112 struct target_waitstatus
*status
);
113 static ptid_t
remote_async_wait (ptid_t ptid
,
114 struct target_waitstatus
*status
);
116 static void remote_kill (void);
117 static void remote_async_kill (void);
119 static int tohex (int nib
);
121 static void remote_detach (char *args
, int from_tty
);
123 static void remote_interrupt (int signo
);
125 static void remote_interrupt_twice (int signo
);
127 static void interrupt_query (void);
129 static void set_thread (int, int);
131 static int remote_thread_alive (ptid_t
);
133 static void get_offsets (void);
135 static void skip_frame (void);
137 static long read_frame (char **buf_p
, long *sizeof_buf
);
139 static int hexnumlen (ULONGEST num
);
141 static void init_remote_ops (void);
143 static void init_extended_remote_ops (void);
145 static void remote_stop (void);
147 static int ishex (int ch
, int *val
);
149 static int stubhex (int ch
);
151 static int hexnumstr (char *, ULONGEST
);
153 static int hexnumnstr (char *, ULONGEST
, int);
155 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
157 static void print_packet (char *);
159 static unsigned long crc32 (unsigned char *, int, unsigned int);
161 static void compare_sections_command (char *, int);
163 static void packet_command (char *, int);
165 static int stub_unpack_int (char *buff
, int fieldlength
);
167 static ptid_t
remote_current_thread (ptid_t oldptid
);
169 static void remote_find_new_threads (void);
171 static void record_currthread (int currthread
);
173 static int fromhex (int a
);
175 static int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
177 static int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
179 static int putpkt_binary (char *buf
, int cnt
);
181 static void check_binary_download (CORE_ADDR addr
);
183 struct packet_config
;
185 static void show_packet_config_cmd (struct packet_config
*config
);
187 static void update_packet_config (struct packet_config
*config
);
189 void _initialize_remote (void);
191 /* Description of the remote protocol state for the currently
192 connected target. This is per-target state, and independent of the
193 selected architecture. */
197 /* A buffer to use for incoming packets, and its current size. The
198 buffer is grown dynamically for larger incoming packets.
199 Outgoing packets may also be constructed in this buffer.
200 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
201 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
207 /* This data could be associated with a target, but we do not always
208 have access to the current target when we need it, so for now it is
209 static. This will be fine for as long as only one target is in use
211 static struct remote_state remote_state
;
213 static struct remote_state
*
214 get_remote_state (void)
216 return &remote_state
;
219 /* Description of the remote protocol for a given architecture. */
223 long offset
; /* Offset into G packet. */
224 long regnum
; /* GDB's internal register number. */
225 LONGEST pnum
; /* Remote protocol register number. */
226 int in_g_packet
; /* Always part of G packet. */
227 /* long size in bytes; == register_size (current_gdbarch, regnum);
229 /* char *name; == REGISTER_NAME (regnum); at present. */
232 struct remote_arch_state
234 /* Description of the remote protocol registers. */
235 long sizeof_g_packet
;
237 /* Description of the remote protocol registers indexed by REGNUM
238 (making an array of NUM_REGS + NUM_PSEUDO_REGS in size). */
239 struct packet_reg
*regs
;
241 /* This is the size (in chars) of the first response to the ``g''
242 packet. It is used as a heuristic when determining the maximum
243 size of memory-read and memory-write packets. A target will
244 typically only reserve a buffer large enough to hold the ``g''
245 packet. The size does not include packet overhead (headers and
247 long actual_register_packet_size
;
249 /* This is the maximum size (in chars) of a non read/write packet.
250 It is also used as a cap on the size of read/write packets. */
251 long remote_packet_size
;
255 /* Handle for retreving the remote protocol data from gdbarch. */
256 static struct gdbarch_data
*remote_gdbarch_data_handle
;
258 static struct remote_arch_state
*
259 get_remote_arch_state (void)
261 return gdbarch_data (current_gdbarch
, remote_gdbarch_data_handle
);
265 init_remote_state (struct gdbarch
*gdbarch
)
268 struct remote_state
*rs
= get_remote_state ();
269 struct remote_arch_state
*rsa
;
271 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
273 rsa
->sizeof_g_packet
= 0;
275 /* Assume a 1:1 regnum<->pnum table. */
276 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
, NUM_REGS
+ NUM_PSEUDO_REGS
,
278 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
280 struct packet_reg
*r
= &rsa
->regs
[regnum
];
283 r
->offset
= DEPRECATED_REGISTER_BYTE (regnum
);
284 r
->in_g_packet
= (regnum
< NUM_REGS
);
285 /* ...name = REGISTER_NAME (regnum); */
287 /* Compute packet size by accumulating the size of all registers. */
288 if (regnum
< NUM_REGS
)
289 rsa
->sizeof_g_packet
+= register_size (current_gdbarch
, regnum
);
292 /* Default maximum number of characters in a packet body. Many
293 remote stubs have a hardwired buffer size of 400 bytes
294 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
295 as the maximum packet-size to ensure that the packet and an extra
296 NUL character can always fit in the buffer. This stops GDB
297 trashing stubs that try to squeeze an extra NUL into what is
298 already a full buffer (As of 1999-12-04 that was most stubs). */
299 rsa
->remote_packet_size
= 400 - 1;
301 /* This one is filled in when a ``g'' packet is received. */
302 rsa
->actual_register_packet_size
= 0;
304 /* Should rsa->sizeof_g_packet needs more space than the
305 default, adjust the size accordingly. Remember that each byte is
306 encoded as two characters. 32 is the overhead for the packet
307 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
308 (``$NN:G...#NN'') is a better guess, the below has been padded a
310 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
311 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
313 /* Make sure that the packet buffer is plenty big enough for
314 this architecture. */
315 if (rs
->buf_size
< rsa
->remote_packet_size
)
317 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
318 rs
->buf
= xmalloc (rs
->buf_size
);
324 /* Return the current allowed size of a remote packet. This is
325 inferred from the current architecture, and should be used to
326 limit the length of outgoing packets. */
328 get_remote_packet_size (void)
330 struct remote_arch_state
*rsa
= get_remote_arch_state ();
332 return rsa
->remote_packet_size
;
335 static struct packet_reg
*
336 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
338 if (regnum
< 0 && regnum
>= NUM_REGS
+ NUM_PSEUDO_REGS
)
342 struct packet_reg
*r
= &rsa
->regs
[regnum
];
343 gdb_assert (r
->regnum
== regnum
);
348 static struct packet_reg
*
349 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
352 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
354 struct packet_reg
*r
= &rsa
->regs
[i
];
361 /* FIXME: graces/2002-08-08: These variables should eventually be
362 bound to an instance of the target object (as in gdbarch-tdep()),
363 when such a thing exists. */
365 /* This is set to the data address of the access causing the target
366 to stop for a watchpoint. */
367 static CORE_ADDR remote_watch_data_address
;
369 /* This is non-zero if target stopped for a watchpoint. */
370 static int remote_stopped_by_watchpoint_p
;
372 static struct target_ops remote_ops
;
374 static struct target_ops extended_remote_ops
;
376 /* Temporary target ops. Just like the remote_ops and
377 extended_remote_ops, but with asynchronous support. */
378 static struct target_ops remote_async_ops
;
380 static struct target_ops extended_async_remote_ops
;
382 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
383 ``forever'' still use the normal timeout mechanism. This is
384 currently used by the ASYNC code to guarentee that target reads
385 during the initial connect always time-out. Once getpkt has been
386 modified to return a timeout indication and, in turn
387 remote_wait()/wait_for_inferior() have gained a timeout parameter
389 static int wait_forever_enabled_p
= 1;
392 /* This variable chooses whether to send a ^C or a break when the user
393 requests program interruption. Although ^C is usually what remote
394 systems expect, and that is the default here, sometimes a break is
395 preferable instead. */
397 static int remote_break
;
399 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
400 remote_open knows that we don't have a file open when the program
402 static struct serial
*remote_desc
= NULL
;
404 /* This variable sets the number of bits in an address that are to be
405 sent in a memory ("M" or "m") packet. Normally, after stripping
406 leading zeros, the entire address would be sent. This variable
407 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
408 initial implementation of remote.c restricted the address sent in
409 memory packets to ``host::sizeof long'' bytes - (typically 32
410 bits). Consequently, for 64 bit targets, the upper 32 bits of an
411 address was never sent. Since fixing this bug may cause a break in
412 some remote targets this variable is principly provided to
413 facilitate backward compatibility. */
415 static int remote_address_size
;
417 /* Tempoary to track who currently owns the terminal. See
418 target_async_terminal_* for more details. */
420 static int remote_async_terminal_ours_p
;
423 /* User configurable variables for the number of characters in a
424 memory read/write packet. MIN (rsa->remote_packet_size,
425 rsa->sizeof_g_packet) is the default. Some targets need smaller
426 values (fifo overruns, et.al.) and some users need larger values
427 (speed up transfers). The variables ``preferred_*'' (the user
428 request), ``current_*'' (what was actually set) and ``forced_*''
429 (Positive - a soft limit, negative - a hard limit). */
431 struct memory_packet_config
438 /* Compute the current size of a read/write packet. Since this makes
439 use of ``actual_register_packet_size'' the computation is dynamic. */
442 get_memory_packet_size (struct memory_packet_config
*config
)
444 struct remote_state
*rs
= get_remote_state ();
445 struct remote_arch_state
*rsa
= get_remote_arch_state ();
447 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
448 law?) that some hosts don't cope very well with large alloca()
449 calls. Eventually the alloca() code will be replaced by calls to
450 xmalloc() and make_cleanups() allowing this restriction to either
451 be lifted or removed. */
452 #ifndef MAX_REMOTE_PACKET_SIZE
453 #define MAX_REMOTE_PACKET_SIZE 16384
455 /* NOTE: 20 ensures we can write at least one byte. */
456 #ifndef MIN_REMOTE_PACKET_SIZE
457 #define MIN_REMOTE_PACKET_SIZE 20
462 if (config
->size
<= 0)
463 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
465 what_they_get
= config
->size
;
469 what_they_get
= get_remote_packet_size ();
470 /* Limit the packet to the size specified by the user. */
472 && what_they_get
> config
->size
)
473 what_they_get
= config
->size
;
474 /* Limit it to the size of the targets ``g'' response. */
475 if ((rsa
->actual_register_packet_size
) > 0
476 && what_they_get
> (rsa
->actual_register_packet_size
))
477 what_they_get
= (rsa
->actual_register_packet_size
);
479 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
480 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
481 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
482 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
484 /* Make sure there is room in the global buffer for this packet
485 (including its trailing NUL byte). */
486 if (rs
->buf_size
< what_they_get
+ 1)
488 rs
->buf_size
= 2 * what_they_get
;
489 rs
->buf
= xrealloc (rs
->buf
, 2 * what_they_get
);
492 return what_they_get
;
495 /* Update the size of a read/write packet. If they user wants
496 something really big then do a sanity check. */
499 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
501 int fixed_p
= config
->fixed_p
;
502 long size
= config
->size
;
504 error (_("Argument required (integer, `fixed' or `limited')."));
505 else if (strcmp (args
, "hard") == 0
506 || strcmp (args
, "fixed") == 0)
508 else if (strcmp (args
, "soft") == 0
509 || strcmp (args
, "limit") == 0)
514 size
= strtoul (args
, &end
, 0);
516 error (_("Invalid %s (bad syntax)."), config
->name
);
518 /* Instead of explicitly capping the size of a packet to
519 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
520 instead allowed to set the size to something arbitrarily
522 if (size
> MAX_REMOTE_PACKET_SIZE
)
523 error (_("Invalid %s (too large)."), config
->name
);
527 if (fixed_p
&& !config
->fixed_p
)
529 if (! query (_("The target may not be able to correctly handle a %s\n"
530 "of %ld bytes. Change the packet size? "),
532 error (_("Packet size not changed."));
534 /* Update the config. */
535 config
->fixed_p
= fixed_p
;
540 show_memory_packet_size (struct memory_packet_config
*config
)
542 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
544 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
545 get_memory_packet_size (config
));
547 printf_filtered (_("Packets are limited to %ld bytes.\n"),
548 get_memory_packet_size (config
));
551 static struct memory_packet_config memory_write_packet_config
=
553 "memory-write-packet-size",
557 set_memory_write_packet_size (char *args
, int from_tty
)
559 set_memory_packet_size (args
, &memory_write_packet_config
);
563 show_memory_write_packet_size (char *args
, int from_tty
)
565 show_memory_packet_size (&memory_write_packet_config
);
569 get_memory_write_packet_size (void)
571 return get_memory_packet_size (&memory_write_packet_config
);
574 static struct memory_packet_config memory_read_packet_config
=
576 "memory-read-packet-size",
580 set_memory_read_packet_size (char *args
, int from_tty
)
582 set_memory_packet_size (args
, &memory_read_packet_config
);
586 show_memory_read_packet_size (char *args
, int from_tty
)
588 show_memory_packet_size (&memory_read_packet_config
);
592 get_memory_read_packet_size (void)
594 long size
= get_memory_packet_size (&memory_read_packet_config
);
595 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
596 extra buffer size argument before the memory read size can be
597 increased beyond this. */
598 if (size
> get_remote_packet_size ())
599 size
= get_remote_packet_size ();
604 /* Generic configuration support for packets the stub optionally
605 supports. Allows the user to specify the use of the packet as well
606 as allowing GDB to auto-detect support in the remote stub. */
610 PACKET_SUPPORT_UNKNOWN
= 0,
619 enum auto_boolean detect
;
620 enum packet_support support
;
623 /* Analyze a packet's return value and update the packet config
634 update_packet_config (struct packet_config
*config
)
636 switch (config
->detect
)
638 case AUTO_BOOLEAN_TRUE
:
639 config
->support
= PACKET_ENABLE
;
641 case AUTO_BOOLEAN_FALSE
:
642 config
->support
= PACKET_DISABLE
;
644 case AUTO_BOOLEAN_AUTO
:
645 config
->support
= PACKET_SUPPORT_UNKNOWN
;
651 show_packet_config_cmd (struct packet_config
*config
)
653 char *support
= "internal-error";
654 switch (config
->support
)
660 support
= "disabled";
662 case PACKET_SUPPORT_UNKNOWN
:
666 switch (config
->detect
)
668 case AUTO_BOOLEAN_AUTO
:
669 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
670 config
->name
, support
);
672 case AUTO_BOOLEAN_TRUE
:
673 case AUTO_BOOLEAN_FALSE
:
674 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
675 config
->name
, support
);
681 add_packet_config_cmd (struct packet_config
*config
,
684 cmd_sfunc_ftype
*set_func
,
685 show_value_ftype
*show_func
,
686 struct cmd_list_element
**set_remote_list
,
687 struct cmd_list_element
**show_remote_list
,
695 config
->title
= title
;
696 config
->detect
= AUTO_BOOLEAN_AUTO
;
697 config
->support
= PACKET_SUPPORT_UNKNOWN
;
698 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
700 show_doc
= xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
702 /* set/show TITLE-packet {auto,on,off} */
703 cmd_name
= xstrprintf ("%s-packet", title
);
704 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
705 &config
->detect
, set_doc
, show_doc
, NULL
, /* help_doc */
707 set_remote_list
, show_remote_list
);
708 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
712 legacy_name
= xstrprintf ("%s-packet", name
);
713 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
715 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
720 static enum packet_result
721 packet_ok (const char *buf
, struct packet_config
*config
)
725 /* The stub recognized the packet request. Check that the
726 operation succeeded. */
727 switch (config
->support
)
729 case PACKET_SUPPORT_UNKNOWN
:
731 fprintf_unfiltered (gdb_stdlog
,
732 "Packet %s (%s) is supported\n",
733 config
->name
, config
->title
);
734 config
->support
= PACKET_ENABLE
;
737 internal_error (__FILE__
, __LINE__
,
738 _("packet_ok: attempt to use a disabled packet"));
743 if (buf
[0] == 'O' && buf
[1] == 'K' && buf
[2] == '\0')
744 /* "OK" - definitly OK. */
747 && isxdigit (buf
[1]) && isxdigit (buf
[2])
749 /* "Enn" - definitly an error. */
751 /* The packet may or may not be OK. Just assume it is. */
756 /* The stub does not support the packet. */
757 switch (config
->support
)
760 if (config
->detect
== AUTO_BOOLEAN_AUTO
)
761 /* If the stub previously indicated that the packet was
762 supported then there is a protocol error.. */
763 error (_("Protocol error: %s (%s) conflicting enabled responses."),
764 config
->name
, config
->title
);
766 /* The user set it wrong. */
767 error (_("Enabled packet %s (%s) not recognized by stub"),
768 config
->name
, config
->title
);
770 case PACKET_SUPPORT_UNKNOWN
:
772 fprintf_unfiltered (gdb_stdlog
,
773 "Packet %s (%s) is NOT supported\n",
774 config
->name
, config
->title
);
775 config
->support
= PACKET_DISABLE
;
780 return PACKET_UNKNOWN
;
800 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
803 set_remote_protocol_packet_cmd (char *args
, int from_tty
,
804 struct cmd_list_element
*c
)
806 struct packet_config
*packet
;
808 for (packet
= remote_protocol_packets
;
809 packet
< &remote_protocol_packets
[PACKET_MAX
];
812 if (&packet
->detect
== c
->var
)
814 update_packet_config (packet
);
818 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
823 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
824 struct cmd_list_element
*c
,
827 struct packet_config
*packet
;
829 for (packet
= remote_protocol_packets
;
830 packet
< &remote_protocol_packets
[PACKET_MAX
];
833 if (&packet
->detect
== c
->var
)
835 show_packet_config_cmd (packet
);
839 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
843 /* Should we try one of the 'Z' requests? */
847 Z_PACKET_SOFTWARE_BP
,
848 Z_PACKET_HARDWARE_BP
,
855 /* For compatibility with older distributions. Provide a ``set remote
856 Z-packet ...'' command that updates all the Z packet types. */
858 static enum auto_boolean remote_Z_packet_detect
;
861 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
862 struct cmd_list_element
*c
)
865 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
867 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
868 update_packet_config (&remote_protocol_packets
[PACKET_Z0
+ i
]);
873 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
874 struct cmd_list_element
*c
,
878 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
880 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
884 /* Should we try the 'ThreadInfo' query packet?
886 This variable (NOT available to the user: auto-detect only!)
887 determines whether GDB will use the new, simpler "ThreadInfo"
888 query or the older, more complex syntax for thread queries.
889 This is an auto-detect variable (set to true at each connect,
890 and set to false when the target fails to recognize it). */
892 static int use_threadinfo_query
;
893 static int use_threadextra_query
;
895 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
896 static void *sigint_remote_twice_token
;
897 static void *sigint_remote_token
;
899 /* These are pointers to hook functions that may be set in order to
900 modify resume/wait behavior for a particular architecture. */
902 void (*deprecated_target_resume_hook
) (void);
903 void (*deprecated_target_wait_loop_hook
) (void);
907 /* These are the threads which we last sent to the remote system.
908 -1 for all or -2 for not sent yet. */
909 static int general_thread
;
910 static int continue_thread
;
912 /* Call this function as a result of
913 1) A halt indication (T packet) containing a thread id
914 2) A direct query of currthread
915 3) Successful execution of set thread
919 record_currthread (int currthread
)
921 general_thread
= currthread
;
923 /* If this is a new thread, add it to GDB's thread list.
924 If we leave it up to WFI to do this, bad things will happen. */
925 if (!in_thread_list (pid_to_ptid (currthread
)))
927 add_thread (pid_to_ptid (currthread
));
928 ui_out_text (uiout
, "[New ");
929 ui_out_text (uiout
, target_pid_to_str (pid_to_ptid (currthread
)));
930 ui_out_text (uiout
, "]\n");
934 #define MAGIC_NULL_PID 42000
937 set_thread (int th
, int gen
)
939 struct remote_state
*rs
= get_remote_state ();
941 int state
= gen
? general_thread
: continue_thread
;
947 buf
[1] = gen
? 'g' : 'c';
948 if (th
== MAGIC_NULL_PID
)
954 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "-%x", -th
);
956 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "%x", th
);
958 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
962 continue_thread
= th
;
965 /* Return nonzero if the thread TH is still alive on the remote system. */
968 remote_thread_alive (ptid_t ptid
)
970 struct remote_state
*rs
= get_remote_state ();
971 int tid
= PIDGET (ptid
);
975 xsnprintf (buf
, get_remote_packet_size (), "T-%08x", -tid
);
977 xsnprintf (buf
, get_remote_packet_size (), "T%08x", tid
);
979 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
980 return (buf
[0] == 'O' && buf
[1] == 'K');
983 /* About these extended threadlist and threadinfo packets. They are
984 variable length packets but, the fields within them are often fixed
985 length. They are redundent enough to send over UDP as is the
986 remote protocol in general. There is a matching unit test module
989 #define OPAQUETHREADBYTES 8
991 /* a 64 bit opaque identifier */
992 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
994 /* WARNING: This threadref data structure comes from the remote O.S.,
995 libstub protocol encoding, and remote.c. it is not particularly
998 /* Right now, the internal structure is int. We want it to be bigger.
1002 typedef int gdb_threadref
; /* Internal GDB thread reference. */
1004 /* gdb_ext_thread_info is an internal GDB data structure which is
1005 equivalent to the reply of the remote threadinfo packet. */
1007 struct gdb_ext_thread_info
1009 threadref threadid
; /* External form of thread reference. */
1010 int active
; /* Has state interesting to GDB?
1012 char display
[256]; /* Brief state display, name,
1013 blocked/suspended. */
1014 char shortname
[32]; /* To be used to name threads. */
1015 char more_display
[256]; /* Long info, statistics, queue depth,
1019 /* The volume of remote transfers can be limited by submitting
1020 a mask containing bits specifying the desired information.
1021 Use a union of these values as the 'selection' parameter to
1022 get_thread_info. FIXME: Make these TAG names more thread specific.
1025 #define TAG_THREADID 1
1026 #define TAG_EXISTS 2
1027 #define TAG_DISPLAY 4
1028 #define TAG_THREADNAME 8
1029 #define TAG_MOREDISPLAY 16
1031 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1033 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1035 static char *unpack_nibble (char *buf
, int *val
);
1037 static char *pack_nibble (char *buf
, int nibble
);
1039 static char *pack_hex_byte (char *pkt
, int /* unsigned char */ byte
);
1041 static char *unpack_byte (char *buf
, int *value
);
1043 static char *pack_int (char *buf
, int value
);
1045 static char *unpack_int (char *buf
, int *value
);
1047 static char *unpack_string (char *src
, char *dest
, int length
);
1049 static char *pack_threadid (char *pkt
, threadref
*id
);
1051 static char *unpack_threadid (char *inbuf
, threadref
*id
);
1053 void int_to_threadref (threadref
*id
, int value
);
1055 static int threadref_to_int (threadref
*ref
);
1057 static void copy_threadref (threadref
*dest
, threadref
*src
);
1059 static int threadmatch (threadref
*dest
, threadref
*src
);
1061 static char *pack_threadinfo_request (char *pkt
, int mode
,
1064 static int remote_unpack_thread_info_response (char *pkt
,
1065 threadref
*expectedref
,
1066 struct gdb_ext_thread_info
1070 static int remote_get_threadinfo (threadref
*threadid
,
1071 int fieldset
, /*TAG mask */
1072 struct gdb_ext_thread_info
*info
);
1074 static char *pack_threadlist_request (char *pkt
, int startflag
,
1076 threadref
*nextthread
);
1078 static int parse_threadlist_response (char *pkt
,
1080 threadref
*original_echo
,
1081 threadref
*resultlist
,
1084 static int remote_get_threadlist (int startflag
,
1085 threadref
*nextthread
,
1089 threadref
*threadlist
);
1091 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
1093 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
1094 void *context
, int looplimit
);
1096 static int remote_newthread_step (threadref
*ref
, void *context
);
1098 /* Encode 64 bits in 16 chars of hex. */
1100 static const char hexchars
[] = "0123456789abcdef";
1103 ishex (int ch
, int *val
)
1105 if ((ch
>= 'a') && (ch
<= 'f'))
1107 *val
= ch
- 'a' + 10;
1110 if ((ch
>= 'A') && (ch
<= 'F'))
1112 *val
= ch
- 'A' + 10;
1115 if ((ch
>= '0') && (ch
<= '9'))
1126 if (ch
>= 'a' && ch
<= 'f')
1127 return ch
- 'a' + 10;
1128 if (ch
>= '0' && ch
<= '9')
1130 if (ch
>= 'A' && ch
<= 'F')
1131 return ch
- 'A' + 10;
1136 stub_unpack_int (char *buff
, int fieldlength
)
1143 nibble
= stubhex (*buff
++);
1147 retval
= retval
<< 4;
1153 unpack_varlen_hex (char *buff
, /* packet to parse */
1159 while (ishex (*buff
, &nibble
))
1162 retval
= retval
<< 4;
1163 retval
|= nibble
& 0x0f;
1170 unpack_nibble (char *buf
, int *val
)
1172 ishex (*buf
++, val
);
1177 pack_nibble (char *buf
, int nibble
)
1179 *buf
++ = hexchars
[(nibble
& 0x0f)];
1184 pack_hex_byte (char *pkt
, int byte
)
1186 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
1187 *pkt
++ = hexchars
[(byte
& 0xf)];
1192 unpack_byte (char *buf
, int *value
)
1194 *value
= stub_unpack_int (buf
, 2);
1199 pack_int (char *buf
, int value
)
1201 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
1202 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
1203 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
1204 buf
= pack_hex_byte (buf
, (value
& 0xff));
1209 unpack_int (char *buf
, int *value
)
1211 *value
= stub_unpack_int (buf
, 8);
1215 #if 0 /* Currently unused, uncomment when needed. */
1216 static char *pack_string (char *pkt
, char *string
);
1219 pack_string (char *pkt
, char *string
)
1224 len
= strlen (string
);
1226 len
= 200; /* Bigger than most GDB packets, junk??? */
1227 pkt
= pack_hex_byte (pkt
, len
);
1231 if ((ch
== '\0') || (ch
== '#'))
1232 ch
= '*'; /* Protect encapsulation. */
1237 #endif /* 0 (unused) */
1240 unpack_string (char *src
, char *dest
, int length
)
1249 pack_threadid (char *pkt
, threadref
*id
)
1252 unsigned char *altid
;
1254 altid
= (unsigned char *) id
;
1255 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
1257 pkt
= pack_hex_byte (pkt
, *altid
++);
1263 unpack_threadid (char *inbuf
, threadref
*id
)
1266 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
1269 altref
= (char *) id
;
1271 while (inbuf
< limit
)
1273 x
= stubhex (*inbuf
++);
1274 y
= stubhex (*inbuf
++);
1275 *altref
++ = (x
<< 4) | y
;
1280 /* Externally, threadrefs are 64 bits but internally, they are still
1281 ints. This is due to a mismatch of specifications. We would like
1282 to use 64bit thread references internally. This is an adapter
1286 int_to_threadref (threadref
*id
, int value
)
1288 unsigned char *scan
;
1290 scan
= (unsigned char *) id
;
1296 *scan
++ = (value
>> 24) & 0xff;
1297 *scan
++ = (value
>> 16) & 0xff;
1298 *scan
++ = (value
>> 8) & 0xff;
1299 *scan
++ = (value
& 0xff);
1303 threadref_to_int (threadref
*ref
)
1306 unsigned char *scan
;
1312 value
= (value
<< 8) | ((*scan
++) & 0xff);
1317 copy_threadref (threadref
*dest
, threadref
*src
)
1320 unsigned char *csrc
, *cdest
;
1322 csrc
= (unsigned char *) src
;
1323 cdest
= (unsigned char *) dest
;
1330 threadmatch (threadref
*dest
, threadref
*src
)
1332 /* Things are broken right now, so just assume we got a match. */
1334 unsigned char *srcp
, *destp
;
1336 srcp
= (char *) src
;
1337 destp
= (char *) dest
;
1341 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
1348 threadid:1, # always request threadid
1355 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1358 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
1360 *pkt
++ = 'q'; /* Info Query */
1361 *pkt
++ = 'P'; /* process or thread info */
1362 pkt
= pack_int (pkt
, mode
); /* mode */
1363 pkt
= pack_threadid (pkt
, id
); /* threadid */
1364 *pkt
= '\0'; /* terminate */
1368 /* These values tag the fields in a thread info response packet. */
1369 /* Tagging the fields allows us to request specific fields and to
1370 add more fields as time goes by. */
1372 #define TAG_THREADID 1 /* Echo the thread identifier. */
1373 #define TAG_EXISTS 2 /* Is this process defined enough to
1374 fetch registers and its stack? */
1375 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1376 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1377 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1381 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
1382 struct gdb_ext_thread_info
*info
)
1384 struct remote_state
*rs
= get_remote_state ();
1388 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
1391 /* info->threadid = 0; FIXME: implement zero_threadref. */
1393 info
->display
[0] = '\0';
1394 info
->shortname
[0] = '\0';
1395 info
->more_display
[0] = '\0';
1397 /* Assume the characters indicating the packet type have been
1399 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
1400 pkt
= unpack_threadid (pkt
, &ref
);
1403 warning (_("Incomplete response to threadinfo request."));
1404 if (!threadmatch (&ref
, expectedref
))
1405 { /* This is an answer to a different request. */
1406 warning (_("ERROR RMT Thread info mismatch."));
1409 copy_threadref (&info
->threadid
, &ref
);
1411 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1413 /* Packets are terminated with nulls. */
1414 while ((pkt
< limit
) && mask
&& *pkt
)
1416 pkt
= unpack_int (pkt
, &tag
); /* tag */
1417 pkt
= unpack_byte (pkt
, &length
); /* length */
1418 if (!(tag
& mask
)) /* Tags out of synch with mask. */
1420 warning (_("ERROR RMT: threadinfo tag mismatch."));
1424 if (tag
== TAG_THREADID
)
1428 warning (_("ERROR RMT: length of threadid is not 16."));
1432 pkt
= unpack_threadid (pkt
, &ref
);
1433 mask
= mask
& ~TAG_THREADID
;
1436 if (tag
== TAG_EXISTS
)
1438 info
->active
= stub_unpack_int (pkt
, length
);
1440 mask
= mask
& ~(TAG_EXISTS
);
1443 warning (_("ERROR RMT: 'exists' length too long."));
1449 if (tag
== TAG_THREADNAME
)
1451 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
1452 mask
= mask
& ~TAG_THREADNAME
;
1455 if (tag
== TAG_DISPLAY
)
1457 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
1458 mask
= mask
& ~TAG_DISPLAY
;
1461 if (tag
== TAG_MOREDISPLAY
)
1463 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
1464 mask
= mask
& ~TAG_MOREDISPLAY
;
1467 warning (_("ERROR RMT: unknown thread info tag."));
1468 break; /* Not a tag we know about. */
1474 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
1475 struct gdb_ext_thread_info
*info
)
1477 struct remote_state
*rs
= get_remote_state ();
1479 char *threadinfo_pkt
= rs
->buf
;
1481 pack_threadinfo_request (threadinfo_pkt
, fieldset
, threadid
);
1482 putpkt (threadinfo_pkt
);
1483 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1484 result
= remote_unpack_thread_info_response (threadinfo_pkt
+ 2,
1489 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1492 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
1493 threadref
*nextthread
)
1495 *pkt
++ = 'q'; /* info query packet */
1496 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
1497 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
1498 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
1499 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
1504 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1507 parse_threadlist_response (char *pkt
, int result_limit
,
1508 threadref
*original_echo
, threadref
*resultlist
,
1511 struct remote_state
*rs
= get_remote_state ();
1513 int count
, resultcount
, done
;
1516 /* Assume the 'q' and 'M chars have been stripped. */
1517 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
1518 /* done parse past here */
1519 pkt
= unpack_byte (pkt
, &count
); /* count field */
1520 pkt
= unpack_nibble (pkt
, &done
);
1521 /* The first threadid is the argument threadid. */
1522 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
1523 while ((count
-- > 0) && (pkt
< limit
))
1525 pkt
= unpack_threadid (pkt
, resultlist
++);
1526 if (resultcount
++ >= result_limit
)
1535 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
1536 int *done
, int *result_count
, threadref
*threadlist
)
1538 struct remote_state
*rs
= get_remote_state ();
1539 static threadref echo_nextthread
;
1540 char *threadlist_packet
= rs
->buf
;
1543 /* Trancate result limit to be smaller than the packet size. */
1544 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10) >= get_remote_packet_size ())
1545 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
1547 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
1549 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1552 parse_threadlist_response (rs
->buf
+ 2, result_limit
, &echo_nextthread
,
1555 if (!threadmatch (&echo_nextthread
, nextthread
))
1557 /* FIXME: This is a good reason to drop the packet. */
1558 /* Possably, there is a duplicate response. */
1560 retransmit immediatly - race conditions
1561 retransmit after timeout - yes
1563 wait for packet, then exit
1565 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1566 return 0; /* I choose simply exiting. */
1568 if (*result_count
<= 0)
1572 warning (_("RMT ERROR : failed to get remote thread list."));
1575 return result
; /* break; */
1577 if (*result_count
> result_limit
)
1580 warning (_("RMT ERROR: threadlist response longer than requested."));
1586 /* This is the interface between remote and threads, remotes upper
1589 /* remote_find_new_threads retrieves the thread list and for each
1590 thread in the list, looks up the thread in GDB's internal list,
1591 ading the thread if it does not already exist. This involves
1592 getting partial thread lists from the remote target so, polling the
1593 quit_flag is required. */
1596 /* About this many threadisds fit in a packet. */
1598 #define MAXTHREADLISTRESULTS 32
1601 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
1604 int done
, i
, result_count
;
1608 static threadref nextthread
;
1609 static threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
1614 if (loopcount
++ > looplimit
)
1617 warning (_("Remote fetch threadlist -infinite loop-."));
1620 if (!remote_get_threadlist (startflag
, &nextthread
, MAXTHREADLISTRESULTS
,
1621 &done
, &result_count
, resultthreadlist
))
1626 /* Clear for later iterations. */
1628 /* Setup to resume next batch of thread references, set nextthread. */
1629 if (result_count
>= 1)
1630 copy_threadref (&nextthread
, &resultthreadlist
[result_count
- 1]);
1632 while (result_count
--)
1633 if (!(result
= (*stepfunction
) (&resultthreadlist
[i
++], context
)))
1640 remote_newthread_step (threadref
*ref
, void *context
)
1644 ptid
= pid_to_ptid (threadref_to_int (ref
));
1646 if (!in_thread_list (ptid
))
1648 return 1; /* continue iterator */
1651 #define CRAZY_MAX_THREADS 1000
1654 remote_current_thread (ptid_t oldpid
)
1656 struct remote_state
*rs
= get_remote_state ();
1657 char *buf
= rs
->buf
;
1660 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1661 if (buf
[0] == 'Q' && buf
[1] == 'C')
1662 /* Use strtoul here, so we'll correctly parse values whose highest
1663 bit is set. The protocol carries them as a simple series of
1664 hex digits; in the absence of a sign, strtol will see such
1665 values as positive numbers out of range for signed 'long', and
1666 return LONG_MAX to indicate an overflow. */
1667 return pid_to_ptid (strtoul (&buf
[2], NULL
, 16));
1672 /* Find new threads for info threads command.
1673 * Original version, using John Metzler's thread protocol.
1677 remote_find_new_threads (void)
1679 remote_threadlist_iterator (remote_newthread_step
, 0,
1681 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
) /* ack ack ack */
1682 inferior_ptid
= remote_current_thread (inferior_ptid
);
1686 * Find all threads for info threads command.
1687 * Uses new thread protocol contributed by Cisco.
1688 * Falls back and attempts to use the older method (above)
1689 * if the target doesn't respond to the new method.
1693 remote_threads_info (void)
1695 struct remote_state
*rs
= get_remote_state ();
1699 if (remote_desc
== 0) /* paranoia */
1700 error (_("Command can only be used when connected to the remote target."));
1702 if (use_threadinfo_query
)
1704 putpkt ("qfThreadInfo");
1706 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1707 if (bufp
[0] != '\0') /* q packet recognized */
1709 while (*bufp
++ == 'm') /* reply contains one or more TID */
1713 /* Use strtoul here, so we'll correctly parse values
1714 whose highest bit is set. The protocol carries
1715 them as a simple series of hex digits; in the
1716 absence of a sign, strtol will see such values as
1717 positive numbers out of range for signed 'long',
1718 and return LONG_MAX to indicate an overflow. */
1719 tid
= strtoul (bufp
, &bufp
, 16);
1720 if (tid
!= 0 && !in_thread_list (pid_to_ptid (tid
)))
1721 add_thread (pid_to_ptid (tid
));
1723 while (*bufp
++ == ','); /* comma-separated list */
1724 putpkt ("qsThreadInfo");
1726 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1732 /* Else fall back to old method based on jmetzler protocol. */
1733 use_threadinfo_query
= 0;
1734 remote_find_new_threads ();
1739 * Collect a descriptive string about the given thread.
1740 * The target may say anything it wants to about the thread
1741 * (typically info about its blocked / runnable state, name, etc.).
1742 * This string will appear in the info threads display.
1744 * Optional: targets are not required to implement this function.
1748 remote_threads_extra_info (struct thread_info
*tp
)
1750 struct remote_state
*rs
= get_remote_state ();
1754 struct gdb_ext_thread_info threadinfo
;
1755 static char display_buf
[100]; /* arbitrary... */
1756 int n
= 0; /* position in display_buf */
1758 if (remote_desc
== 0) /* paranoia */
1759 internal_error (__FILE__
, __LINE__
,
1760 _("remote_threads_extra_info"));
1762 if (use_threadextra_query
)
1764 char *bufp
= rs
->buf
;
1766 xsnprintf (bufp
, get_remote_packet_size (), "qThreadExtraInfo,%x",
1769 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1772 n
= min (strlen (bufp
) / 2, sizeof (display_buf
));
1773 result
= hex2bin (bufp
, (gdb_byte
*) display_buf
, n
);
1774 display_buf
[result
] = '\0';
1779 /* If the above query fails, fall back to the old method. */
1780 use_threadextra_query
= 0;
1781 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
1782 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
1783 int_to_threadref (&id
, PIDGET (tp
->ptid
));
1784 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
1785 if (threadinfo
.active
)
1787 if (*threadinfo
.shortname
)
1788 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
1789 " Name: %s,", threadinfo
.shortname
);
1790 if (*threadinfo
.display
)
1791 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1792 " State: %s,", threadinfo
.display
);
1793 if (*threadinfo
.more_display
)
1794 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1795 " Priority: %s", threadinfo
.more_display
);
1799 /* For purely cosmetic reasons, clear up trailing commas. */
1800 if (',' == display_buf
[n
-1])
1801 display_buf
[n
-1] = ' ';
1809 /* Restart the remote side; this is an extended protocol operation. */
1812 extended_remote_restart (void)
1814 struct remote_state
*rs
= get_remote_state ();
1816 /* Send the restart command; for reasons I don't understand the
1817 remote side really expects a number after the "R". */
1818 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
1821 /* Now query for status so this looks just like we restarted
1822 gdbserver from scratch. */
1824 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1827 /* Clean up connection to a remote debugger. */
1830 remote_close (int quitting
)
1833 serial_close (remote_desc
);
1837 /* Query the remote side for the text, data and bss offsets. */
1842 struct remote_state
*rs
= get_remote_state ();
1843 char *buf
= rs
->buf
;
1846 CORE_ADDR text_addr
, data_addr
, bss_addr
;
1847 struct section_offsets
*offs
;
1849 putpkt ("qOffsets");
1850 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1852 if (buf
[0] == '\000')
1853 return; /* Return silently. Stub doesn't support
1857 warning (_("Remote failure reply: %s"), buf
);
1861 /* Pick up each field in turn. This used to be done with scanf, but
1862 scanf will make trouble if CORE_ADDR size doesn't match
1863 conversion directives correctly. The following code will work
1864 with any size of CORE_ADDR. */
1865 text_addr
= data_addr
= bss_addr
= 0;
1869 if (strncmp (ptr
, "Text=", 5) == 0)
1872 /* Don't use strtol, could lose on big values. */
1873 while (*ptr
&& *ptr
!= ';')
1874 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
1879 if (!lose
&& strncmp (ptr
, ";Data=", 6) == 0)
1882 while (*ptr
&& *ptr
!= ';')
1883 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
1888 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
1891 while (*ptr
&& *ptr
!= ';')
1892 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
1898 error (_("Malformed response to offset query, %s"), buf
);
1900 if (symfile_objfile
== NULL
)
1903 offs
= ((struct section_offsets
*)
1904 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
1905 memcpy (offs
, symfile_objfile
->section_offsets
,
1906 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
1908 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
1910 /* This is a temporary kludge to force data and bss to use the same offsets
1911 because that's what nlmconv does now. The real solution requires changes
1912 to the stub and remote.c that I don't have time to do right now. */
1914 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
1915 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
1917 objfile_relocate (symfile_objfile
, offs
);
1920 /* Stub for catch_errors. */
1923 remote_start_remote_dummy (struct ui_out
*uiout
, void *dummy
)
1925 start_remote (); /* Initialize gdb process mechanisms. */
1926 /* NOTE: Return something >=0. A -ve value is reserved for
1927 catch_exceptions. */
1932 remote_start_remote (struct ui_out
*uiout
, void *dummy
)
1934 immediate_quit
++; /* Allow user to interrupt it. */
1936 /* Ack any packet which the remote side has already sent. */
1937 serial_write (remote_desc
, "+", 1);
1939 /* Let the stub know that we want it to return the thread. */
1942 inferior_ptid
= remote_current_thread (inferior_ptid
);
1944 get_offsets (); /* Get text, data & bss offsets. */
1946 putpkt ("?"); /* Initiate a query from remote machine. */
1949 remote_start_remote_dummy (uiout
, dummy
);
1952 /* Open a connection to a remote debugger.
1953 NAME is the filename used for communication. */
1956 remote_open (char *name
, int from_tty
)
1958 remote_open_1 (name
, from_tty
, &remote_ops
, 0, 0);
1961 /* Just like remote_open, but with asynchronous support. */
1963 remote_async_open (char *name
, int from_tty
)
1965 remote_open_1 (name
, from_tty
, &remote_async_ops
, 0, 1);
1968 /* Open a connection to a remote debugger using the extended
1969 remote gdb protocol. NAME is the filename used for communication. */
1972 extended_remote_open (char *name
, int from_tty
)
1974 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */,
1978 /* Just like extended_remote_open, but with asynchronous support. */
1980 extended_remote_async_open (char *name
, int from_tty
)
1982 remote_open_1 (name
, from_tty
, &extended_async_remote_ops
,
1983 1 /*extended_p */, 1 /* async_p */);
1986 /* Generic code for opening a connection to a remote target. */
1989 init_all_packet_configs (void)
1992 for (i
= 0; i
< PACKET_MAX
; i
++)
1993 update_packet_config (&remote_protocol_packets
[i
]);
1996 /* Symbol look-up. */
1999 remote_check_symbols (struct objfile
*objfile
)
2001 struct remote_state
*rs
= get_remote_state ();
2002 char *msg
, *reply
, *tmp
;
2003 struct minimal_symbol
*sym
;
2006 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
2009 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2010 because we need both at the same time. */
2011 msg
= alloca (get_remote_packet_size ());
2015 /* Invite target to request symbol lookups. */
2017 putpkt ("qSymbol::");
2018 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2019 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
2021 while (strncmp (reply
, "qSymbol:", 8) == 0)
2024 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
2026 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
2028 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
2030 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
2031 paddr_nz (SYMBOL_VALUE_ADDRESS (sym
)),
2034 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2038 static struct serial
*
2039 remote_serial_open (char *name
)
2041 static int udp_warning
= 0;
2043 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2044 of in ser-tcp.c, because it is the remote protocol assuming that the
2045 serial connection is reliable and not the serial connection promising
2047 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
2050 The remote protocol may be unreliable over UDP.\n\
2051 Some events may be lost, rendering further debugging impossible."));
2055 return serial_open (name
);
2059 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
,
2060 int extended_p
, int async_p
)
2062 struct remote_state
*rs
= get_remote_state ();
2064 error (_("To open a remote debug connection, you need to specify what\n"
2065 "serial device is attached to the remote system\n"
2066 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2068 /* See FIXME above. */
2070 wait_forever_enabled_p
= 1;
2072 reopen_exec_file ();
2075 target_preopen (from_tty
);
2077 unpush_target (target
);
2079 remote_desc
= remote_serial_open (name
);
2081 perror_with_name (name
);
2083 if (baud_rate
!= -1)
2085 if (serial_setbaudrate (remote_desc
, baud_rate
))
2087 /* The requested speed could not be set. Error out to
2088 top level after closing remote_desc. Take care to
2089 set remote_desc to NULL to avoid closing remote_desc
2091 serial_close (remote_desc
);
2093 perror_with_name (name
);
2097 serial_raw (remote_desc
);
2099 /* If there is something sitting in the buffer we might take it as a
2100 response to a command, which would be bad. */
2101 serial_flush_input (remote_desc
);
2105 puts_filtered ("Remote debugging using ");
2106 puts_filtered (name
);
2107 puts_filtered ("\n");
2109 push_target (target
); /* Switch to using remote target now. */
2111 init_all_packet_configs ();
2113 general_thread
= -2;
2114 continue_thread
= -2;
2116 /* Probe for ability to use "ThreadInfo" query, as required. */
2117 use_threadinfo_query
= 1;
2118 use_threadextra_query
= 1;
2120 /* Without this, some commands which require an active target (such
2121 as kill) won't work. This variable serves (at least) double duty
2122 as both the pid of the target process (if it has such), and as a
2123 flag indicating that a target is active. These functions should
2124 be split out into seperate variables, especially since GDB will
2125 someday have a notion of debugging several processes. */
2127 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
2131 /* With this target we start out by owning the terminal. */
2132 remote_async_terminal_ours_p
= 1;
2134 /* FIXME: cagney/1999-09-23: During the initial connection it is
2135 assumed that the target is already ready and able to respond to
2136 requests. Unfortunately remote_start_remote() eventually calls
2137 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2138 around this. Eventually a mechanism that allows
2139 wait_for_inferior() to expect/get timeouts will be
2141 wait_forever_enabled_p
= 0;
2144 /* First delete any symbols previously loaded from shared libraries. */
2145 no_shared_libraries (NULL
, 0);
2147 /* Start the remote connection. If error() or QUIT, discard this
2148 target (we'd otherwise be in an inconsistent state) and then
2149 propogate the error on up the exception chain. This ensures that
2150 the caller doesn't stumble along blindly assuming that the
2151 function succeeded. The CLI doesn't have this problem but other
2152 UI's, such as MI do.
2154 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2155 this function should return an error indication letting the
2156 caller restore the previous state. Unfortunately the command
2157 ``target remote'' is directly wired to this function making that
2158 impossible. On a positive note, the CLI side of this problem has
2159 been fixed - the function set_cmd_context() makes it possible for
2160 all the ``target ....'' commands to share a common callback
2161 function. See cli-dump.c. */
2163 struct gdb_exception ex
2164 = catch_exception (uiout
, remote_start_remote
, NULL
, RETURN_MASK_ALL
);
2169 wait_forever_enabled_p
= 1;
2170 throw_exception (ex
);
2175 wait_forever_enabled_p
= 1;
2179 /* Tell the remote that we are using the extended protocol. */
2181 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2184 post_create_inferior (¤t_target
, from_tty
);
2186 if (exec_bfd
) /* No use without an exec file. */
2187 remote_check_symbols (symfile_objfile
);
2190 /* This takes a program previously attached to and detaches it. After
2191 this is done, GDB can be used to debug some other program. We
2192 better not have left any breakpoints in the target program or it'll
2193 die when it hits one. */
2196 remote_detach (char *args
, int from_tty
)
2198 struct remote_state
*rs
= get_remote_state ();
2201 error (_("Argument given to \"detach\" when remotely debugging."));
2203 /* Tell the remote target to detach. */
2204 strcpy (rs
->buf
, "D");
2205 remote_send (&rs
->buf
, &rs
->buf_size
);
2207 /* Unregister the file descriptor from the event loop. */
2208 if (target_is_async_p ())
2209 serial_async (remote_desc
, NULL
, 0);
2211 target_mourn_inferior ();
2213 puts_filtered ("Ending remote debugging.\n");
2216 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2219 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
2222 error (_("Argument given to \"detach\" when remotely debugging."));
2224 /* Unregister the file descriptor from the event loop. */
2225 if (target_is_async_p ())
2226 serial_async (remote_desc
, NULL
, 0);
2228 target_mourn_inferior ();
2230 puts_filtered ("Ending remote debugging.\n");
2233 /* Convert hex digit A to a number. */
2238 if (a
>= '0' && a
<= '9')
2240 else if (a
>= 'a' && a
<= 'f')
2241 return a
- 'a' + 10;
2242 else if (a
>= 'A' && a
<= 'F')
2243 return a
- 'A' + 10;
2245 error (_("Reply contains invalid hex digit %d"), a
);
2249 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
2253 for (i
= 0; i
< count
; i
++)
2255 if (hex
[0] == 0 || hex
[1] == 0)
2257 /* Hex string is short, or of uneven length.
2258 Return the count that has been converted so far. */
2261 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
2267 /* Convert number NIB to a hex digit. */
2275 return 'a' + nib
- 10;
2279 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
2282 /* May use a length, or a nul-terminated string as input. */
2284 count
= strlen ((char *) bin
);
2286 for (i
= 0; i
< count
; i
++)
2288 *hex
++ = tohex ((*bin
>> 4) & 0xf);
2289 *hex
++ = tohex (*bin
++ & 0xf);
2295 /* Check for the availability of vCont. This function should also check
2299 remote_vcont_probe (struct remote_state
*rs
)
2301 char *buf
= rs
->buf
;
2303 strcpy (buf
, "vCont?");
2305 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2307 /* Make sure that the features we assume are supported. */
2308 if (strncmp (buf
, "vCont", 5) == 0)
2311 int support_s
, support_S
, support_c
, support_C
;
2317 while (p
&& *p
== ';')
2320 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2322 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2324 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2326 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2329 p
= strchr (p
, ';');
2332 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2333 BUF will make packet_ok disable the packet. */
2334 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
2338 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
2341 /* Resume the remote inferior by using a "vCont" packet. The thread
2342 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2343 resumed thread should be single-stepped and/or signalled. If PTID's
2344 PID is -1, then all threads are resumed; the thread to be stepped and/or
2345 signalled is given in the global INFERIOR_PTID. This function returns
2346 non-zero iff it resumes the inferior.
2348 This function issues a strict subset of all possible vCont commands at the
2352 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2354 struct remote_state
*rs
= get_remote_state ();
2355 int pid
= PIDGET (ptid
);
2356 char *buf
= NULL
, *outbuf
;
2357 struct cleanup
*old_cleanup
;
2359 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
2360 remote_vcont_probe (rs
);
2362 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
2365 /* If we could generate a wider range of packets, we'd have to worry
2366 about overflowing BUF. Should there be a generic
2367 "multi-part-packet" packet? */
2369 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
)
2371 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2372 don't have any PID numbers the inferior will understand. Make sure
2373 to only send forms that do not specify a PID. */
2374 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2375 outbuf
= xstrprintf ("vCont;S%02x", siggnal
);
2377 outbuf
= xstrprintf ("vCont;s");
2378 else if (siggnal
!= TARGET_SIGNAL_0
)
2379 outbuf
= xstrprintf ("vCont;C%02x", siggnal
);
2381 outbuf
= xstrprintf ("vCont;c");
2385 /* Resume all threads, with preference for INFERIOR_PTID. */
2386 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2387 outbuf
= xstrprintf ("vCont;S%02x:%x;c", siggnal
,
2388 PIDGET (inferior_ptid
));
2390 outbuf
= xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid
));
2391 else if (siggnal
!= TARGET_SIGNAL_0
)
2392 outbuf
= xstrprintf ("vCont;C%02x:%x;c", siggnal
,
2393 PIDGET (inferior_ptid
));
2395 outbuf
= xstrprintf ("vCont;c");
2399 /* Scheduler locking; resume only PTID. */
2400 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2401 outbuf
= xstrprintf ("vCont;S%02x:%x", siggnal
, pid
);
2403 outbuf
= xstrprintf ("vCont;s:%x", pid
);
2404 else if (siggnal
!= TARGET_SIGNAL_0
)
2405 outbuf
= xstrprintf ("vCont;C%02x:%x", siggnal
, pid
);
2407 outbuf
= xstrprintf ("vCont;c:%x", pid
);
2410 gdb_assert (outbuf
&& strlen (outbuf
) < get_remote_packet_size ());
2411 old_cleanup
= make_cleanup (xfree
, outbuf
);
2415 do_cleanups (old_cleanup
);
2420 /* Tell the remote machine to resume. */
2422 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
2424 static int last_sent_step
;
2427 remote_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2429 struct remote_state
*rs
= get_remote_state ();
2430 char *buf
= rs
->buf
;
2431 int pid
= PIDGET (ptid
);
2433 last_sent_signal
= siggnal
;
2434 last_sent_step
= step
;
2436 /* A hook for when we need to do something at the last moment before
2438 if (deprecated_target_resume_hook
)
2439 (*deprecated_target_resume_hook
) ();
2441 /* The vCont packet doesn't need to specify threads via Hc. */
2442 if (remote_vcont_resume (ptid
, step
, siggnal
))
2445 /* All other supported resume packets do use Hc, so call set_thread. */
2447 set_thread (0, 0); /* Run any thread. */
2449 set_thread (pid
, 0); /* Run this thread. */
2451 if (siggnal
!= TARGET_SIGNAL_0
)
2453 buf
[0] = step
? 'S' : 'C';
2454 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
2455 buf
[2] = tohex (((int) siggnal
) & 0xf);
2459 strcpy (buf
, step
? "s" : "c");
2464 /* Same as remote_resume, but with async support. */
2466 remote_async_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2468 remote_resume (ptid
, step
, siggnal
);
2470 /* We are about to start executing the inferior, let's register it
2471 with the event loop. NOTE: this is the one place where all the
2472 execution commands end up. We could alternatively do this in each
2473 of the execution commands in infcmd.c. */
2474 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2475 into infcmd.c in order to allow inferior function calls to work
2476 NOT asynchronously. */
2477 if (target_can_async_p ())
2478 target_async (inferior_event_handler
, 0);
2479 /* Tell the world that the target is now executing. */
2480 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2481 this? Instead, should the client of target just assume (for
2482 async targets) that the target is going to start executing? Is
2483 this information already found in the continuation block? */
2484 if (target_is_async_p ())
2485 target_executing
= 1;
2489 /* Set up the signal handler for SIGINT, while the target is
2490 executing, ovewriting the 'regular' SIGINT signal handler. */
2492 initialize_sigint_signal_handler (void)
2494 sigint_remote_token
=
2495 create_async_signal_handler (async_remote_interrupt
, NULL
);
2496 signal (SIGINT
, handle_remote_sigint
);
2499 /* Signal handler for SIGINT, while the target is executing. */
2501 handle_remote_sigint (int sig
)
2503 signal (sig
, handle_remote_sigint_twice
);
2504 sigint_remote_twice_token
=
2505 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
2506 mark_async_signal_handler_wrapper (sigint_remote_token
);
2509 /* Signal handler for SIGINT, installed after SIGINT has already been
2510 sent once. It will take effect the second time that the user sends
2513 handle_remote_sigint_twice (int sig
)
2515 signal (sig
, handle_sigint
);
2516 sigint_remote_twice_token
=
2517 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
2518 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
2521 /* Perform the real interruption of the target execution, in response
2524 async_remote_interrupt (gdb_client_data arg
)
2527 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2532 /* Perform interrupt, if the first attempt did not succeed. Just give
2533 up on the target alltogether. */
2535 async_remote_interrupt_twice (gdb_client_data arg
)
2538 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
2539 /* Do something only if the target was not killed by the previous
2541 if (target_executing
)
2544 signal (SIGINT
, handle_remote_sigint
);
2548 /* Reinstall the usual SIGINT handlers, after the target has
2551 cleanup_sigint_signal_handler (void *dummy
)
2553 signal (SIGINT
, handle_sigint
);
2554 if (sigint_remote_twice_token
)
2555 delete_async_signal_handler ((struct async_signal_handler
**)
2556 &sigint_remote_twice_token
);
2557 if (sigint_remote_token
)
2558 delete_async_signal_handler ((struct async_signal_handler
**)
2559 &sigint_remote_token
);
2562 /* Send ^C to target to halt it. Target will respond, and send us a
2564 static void (*ofunc
) (int);
2566 /* The command line interface's stop routine. This function is installed
2567 as a signal handler for SIGINT. The first time a user requests a
2568 stop, we call remote_stop to send a break or ^C. If there is no
2569 response from the target (it didn't stop when the user requested it),
2570 we ask the user if he'd like to detach from the target. */
2572 remote_interrupt (int signo
)
2574 /* If this doesn't work, try more severe steps. */
2575 signal (signo
, remote_interrupt_twice
);
2578 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2583 /* The user typed ^C twice. */
2586 remote_interrupt_twice (int signo
)
2588 signal (signo
, ofunc
);
2590 signal (signo
, remote_interrupt
);
2593 /* This is the generic stop called via the target vector. When a target
2594 interrupt is requested, either by the command line or the GUI, we
2595 will eventually end up here. */
2599 /* Send a break or a ^C, depending on user preference. */
2601 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
2604 serial_send_break (remote_desc
);
2606 serial_write (remote_desc
, "\003", 1);
2609 /* Ask the user what to do when an interrupt is received. */
2612 interrupt_query (void)
2614 target_terminal_ours ();
2616 if (query ("Interrupted while waiting for the program.\n\
2617 Give up (and stop debugging it)? "))
2619 target_mourn_inferior ();
2620 deprecated_throw_reason (RETURN_QUIT
);
2623 target_terminal_inferior ();
2626 /* Enable/disable target terminal ownership. Most targets can use
2627 terminal groups to control terminal ownership. Remote targets are
2628 different in that explicit transfer of ownership to/from GDB/target
2632 remote_async_terminal_inferior (void)
2634 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
2635 sync_execution here. This function should only be called when
2636 GDB is resuming the inferior in the forground. A background
2637 resume (``run&'') should leave GDB in control of the terminal and
2638 consequently should not call this code. */
2639 if (!sync_execution
)
2641 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
2642 calls target_terminal_*() idenpotent. The event-loop GDB talking
2643 to an asynchronous target with a synchronous command calls this
2644 function from both event-top.c and infrun.c/infcmd.c. Once GDB
2645 stops trying to transfer the terminal to the target when it
2646 shouldn't this guard can go away. */
2647 if (!remote_async_terminal_ours_p
)
2649 delete_file_handler (input_fd
);
2650 remote_async_terminal_ours_p
= 0;
2651 initialize_sigint_signal_handler ();
2652 /* NOTE: At this point we could also register our selves as the
2653 recipient of all input. Any characters typed could then be
2654 passed on down to the target. */
2658 remote_async_terminal_ours (void)
2660 /* See FIXME in remote_async_terminal_inferior. */
2661 if (!sync_execution
)
2663 /* See FIXME in remote_async_terminal_inferior. */
2664 if (remote_async_terminal_ours_p
)
2666 cleanup_sigint_signal_handler (NULL
);
2667 add_file_handler (input_fd
, stdin_event_handler
, 0);
2668 remote_async_terminal_ours_p
= 1;
2671 /* If nonzero, ignore the next kill. */
2676 remote_console_output (char *msg
)
2680 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
2683 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
2686 fputs_unfiltered (tb
, gdb_stdtarg
);
2688 gdb_flush (gdb_stdtarg
);
2691 /* Wait until the remote machine stops, then return,
2692 storing status in STATUS just as `wait' would.
2693 Returns "pid", which in the case of a multi-threaded
2694 remote OS, is the thread-id. */
2697 remote_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2699 struct remote_state
*rs
= get_remote_state ();
2700 struct remote_arch_state
*rsa
= get_remote_arch_state ();
2701 char *buf
= rs
->buf
;
2702 ULONGEST thread_num
= -1;
2705 status
->kind
= TARGET_WAITKIND_EXITED
;
2706 status
->value
.integer
= 0;
2712 ofunc
= signal (SIGINT
, remote_interrupt
);
2713 getpkt (&rs
->buf
, &rs
->buf_size
, 1);
2714 signal (SIGINT
, ofunc
);
2716 /* This is a hook for when we need to do something (perhaps the
2717 collection of trace data) every time the target stops. */
2718 if (deprecated_target_wait_loop_hook
)
2719 (*deprecated_target_wait_loop_hook
) ();
2721 remote_stopped_by_watchpoint_p
= 0;
2725 case 'E': /* Error of some sort. */
2726 warning (_("Remote failure reply: %s"), buf
);
2728 case 'F': /* File-I/O request. */
2729 remote_fileio_request (buf
);
2731 case 'T': /* Status with PC, SP, FP, ... */
2733 gdb_byte regs
[MAX_REGISTER_SIZE
];
2735 /* Expedited reply, containing Signal, {regno, reg} repeat. */
2736 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
2738 n... = register number
2739 r... = register contents
2741 p
= &buf
[3]; /* after Txx */
2750 /* If the packet contains a register number save it in
2751 pnum and set p1 to point to the character following
2752 it. Otherwise p1 points to p. */
2754 /* If this packet is an awatch packet, don't parse the
2755 'a' as a register number. */
2757 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
2759 /* Read the ``P'' register number. */
2760 pnum
= strtol (p
, &p_temp
, 16);
2766 if (p1
== p
) /* No register number present here. */
2768 p1
= strchr (p
, ':');
2770 error (_("Malformed packet(a) (missing colon): %s\n\
2773 if (strncmp (p
, "thread", p1
- p
) == 0)
2775 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
2776 record_currthread (thread_num
);
2779 else if ((strncmp (p
, "watch", p1
- p
) == 0)
2780 || (strncmp (p
, "rwatch", p1
- p
) == 0)
2781 || (strncmp (p
, "awatch", p1
- p
) == 0))
2783 remote_stopped_by_watchpoint_p
= 1;
2784 p
= unpack_varlen_hex (++p1
, &addr
);
2785 remote_watch_data_address
= (CORE_ADDR
)addr
;
2789 /* Silently skip unknown optional info. */
2790 p_temp
= strchr (p1
+ 1, ';');
2797 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
2801 error (_("Malformed packet(b) (missing colon): %s\n\
2806 error (_("Remote sent bad register number %s: %s\n\
2808 phex_nz (pnum
, 0), p
, buf
);
2810 fieldsize
= hex2bin (p
, regs
,
2811 register_size (current_gdbarch
,
2814 if (fieldsize
< register_size (current_gdbarch
,
2816 warning (_("Remote reply is too short: %s"), buf
);
2817 regcache_raw_supply (current_regcache
,
2822 error (_("Remote register badly formatted: %s\nhere: %s"),
2827 case 'S': /* Old style status, just signal only. */
2828 status
->kind
= TARGET_WAITKIND_STOPPED
;
2829 status
->value
.sig
= (enum target_signal
)
2830 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
2834 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
2835 record_currthread (thread_num
);
2838 case 'W': /* Target exited. */
2840 /* The remote process exited. */
2841 status
->kind
= TARGET_WAITKIND_EXITED
;
2842 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
2846 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
2847 status
->value
.sig
= (enum target_signal
)
2848 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
2852 case 'O': /* Console output. */
2853 remote_console_output (buf
+ 1);
2856 if (last_sent_signal
!= TARGET_SIGNAL_0
)
2858 /* Zero length reply means that we tried 'S' or 'C' and
2859 the remote system doesn't support it. */
2860 target_terminal_ours_for_output ();
2862 ("Can't send signals to this remote system. %s not sent.\n",
2863 target_signal_to_name (last_sent_signal
));
2864 last_sent_signal
= TARGET_SIGNAL_0
;
2865 target_terminal_inferior ();
2867 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
2868 putpkt ((char *) buf
);
2871 /* else fallthrough */
2873 warning (_("Invalid remote reply: %s"), buf
);
2878 if (thread_num
!= -1)
2880 return pid_to_ptid (thread_num
);
2882 return inferior_ptid
;
2885 /* Async version of remote_wait. */
2887 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2889 struct remote_state
*rs
= get_remote_state ();
2890 struct remote_arch_state
*rsa
= get_remote_arch_state ();
2891 char *buf
= rs
->buf
;
2892 ULONGEST thread_num
= -1;
2895 status
->kind
= TARGET_WAITKIND_EXITED
;
2896 status
->value
.integer
= 0;
2898 remote_stopped_by_watchpoint_p
= 0;
2904 if (!target_is_async_p ())
2905 ofunc
= signal (SIGINT
, remote_interrupt
);
2906 /* FIXME: cagney/1999-09-27: If we're in async mode we should
2907 _never_ wait for ever -> test on target_is_async_p().
2908 However, before we do that we need to ensure that the caller
2909 knows how to take the target into/out of async mode. */
2910 getpkt (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
2911 if (!target_is_async_p ())
2912 signal (SIGINT
, ofunc
);
2914 /* This is a hook for when we need to do something (perhaps the
2915 collection of trace data) every time the target stops. */
2916 if (deprecated_target_wait_loop_hook
)
2917 (*deprecated_target_wait_loop_hook
) ();
2921 case 'E': /* Error of some sort. */
2922 warning (_("Remote failure reply: %s"), buf
);
2924 case 'F': /* File-I/O request. */
2925 remote_fileio_request (buf
);
2927 case 'T': /* Status with PC, SP, FP, ... */
2929 gdb_byte regs
[MAX_REGISTER_SIZE
];
2931 /* Expedited reply, containing Signal, {regno, reg} repeat. */
2932 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
2934 n... = register number
2935 r... = register contents
2937 p
= &buf
[3]; /* after Txx */
2946 /* If the packet contains a register number, save it
2947 in pnum and set p1 to point to the character
2948 following it. Otherwise p1 points to p. */
2950 /* If this packet is an awatch packet, don't parse the 'a'
2951 as a register number. */
2953 if (!strncmp (p
, "awatch", strlen ("awatch")) != 0)
2955 /* Read the register number. */
2956 pnum
= strtol (p
, &p_temp
, 16);
2962 if (p1
== p
) /* No register number present here. */
2964 p1
= strchr (p
, ':');
2966 error (_("Malformed packet(a) (missing colon): %s\n\
2969 if (strncmp (p
, "thread", p1
- p
) == 0)
2971 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
2972 record_currthread (thread_num
);
2975 else if ((strncmp (p
, "watch", p1
- p
) == 0)
2976 || (strncmp (p
, "rwatch", p1
- p
) == 0)
2977 || (strncmp (p
, "awatch", p1
- p
) == 0))
2979 remote_stopped_by_watchpoint_p
= 1;
2980 p
= unpack_varlen_hex (++p1
, &addr
);
2981 remote_watch_data_address
= (CORE_ADDR
)addr
;
2985 /* Silently skip unknown optional info. */
2986 p_temp
= strchr (p1
+ 1, ';');
2994 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
2997 error (_("Malformed packet(b) (missing colon): %s\n\
3002 error (_("Remote sent bad register number %ld: %s\n\
3006 fieldsize
= hex2bin (p
, regs
,
3007 register_size (current_gdbarch
,
3010 if (fieldsize
< register_size (current_gdbarch
,
3012 warning (_("Remote reply is too short: %s"), buf
);
3013 regcache_raw_supply (current_regcache
, reg
->regnum
, regs
);
3017 error (_("Remote register badly formatted: %s\nhere: %s"),
3022 case 'S': /* Old style status, just signal only. */
3023 status
->kind
= TARGET_WAITKIND_STOPPED
;
3024 status
->value
.sig
= (enum target_signal
)
3025 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3029 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3030 record_currthread (thread_num
);
3033 case 'W': /* Target exited. */
3035 /* The remote process exited. */
3036 status
->kind
= TARGET_WAITKIND_EXITED
;
3037 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3041 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3042 status
->value
.sig
= (enum target_signal
)
3043 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3047 case 'O': /* Console output. */
3048 remote_console_output (buf
+ 1);
3049 /* Return immediately to the event loop. The event loop will
3050 still be waiting on the inferior afterwards. */
3051 status
->kind
= TARGET_WAITKIND_IGNORE
;
3054 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3056 /* Zero length reply means that we tried 'S' or 'C' and
3057 the remote system doesn't support it. */
3058 target_terminal_ours_for_output ();
3060 ("Can't send signals to this remote system. %s not sent.\n",
3061 target_signal_to_name (last_sent_signal
));
3062 last_sent_signal
= TARGET_SIGNAL_0
;
3063 target_terminal_inferior ();
3065 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3066 putpkt ((char *) buf
);
3069 /* else fallthrough */
3071 warning (_("Invalid remote reply: %s"), buf
);
3076 if (thread_num
!= -1)
3078 return pid_to_ptid (thread_num
);
3080 return inferior_ptid
;
3083 /* Number of bytes of registers this stub implements. */
3085 static int register_bytes_found
;
3087 /* Read the remote registers into the block REGS. */
3088 /* Currently we just read all the registers, so we don't use regnum. */
3091 fetch_register_using_p (int regnum
)
3093 struct remote_state
*rs
= get_remote_state ();
3094 char *buf
= rs
->buf
, *p
;
3095 char regp
[MAX_REGISTER_SIZE
];
3100 p
+= hexnumstr (p
, regnum
);
3102 remote_send (&rs
->buf
, &rs
->buf_size
);
3104 /* If the stub didn't recognize the packet, or if we got an error,
3106 if (buf
[0] == '\0' || buf
[0] == 'E')
3109 /* If this register is unfetchable, tell the regcache. */
3112 regcache_raw_supply (current_regcache
, regnum
, NULL
);
3113 set_register_cached (regnum
, -1);
3117 /* Otherwise, parse and supply the value. */
3124 error (_("fetch_register_using_p: early buf termination"));
3128 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3131 regcache_raw_supply (current_regcache
, regnum
, regp
);
3136 remote_fetch_registers (int regnum
)
3138 struct remote_state
*rs
= get_remote_state ();
3139 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3140 char *buf
= rs
->buf
;
3143 char *regs
= alloca (rsa
->sizeof_g_packet
);
3145 set_thread (PIDGET (inferior_ptid
), 1);
3149 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3150 gdb_assert (reg
!= NULL
);
3151 if (!reg
->in_g_packet
)
3152 internal_error (__FILE__
, __LINE__
,
3153 _("Attempt to fetch a non G-packet register when this "
3154 "remote.c does not support the p-packet."));
3156 switch (remote_protocol_packets
[PACKET_p
].support
)
3158 case PACKET_DISABLE
:
3161 if (fetch_register_using_p (regnum
))
3164 error (_("Protocol error: p packet not recognized by stub"));
3165 case PACKET_SUPPORT_UNKNOWN
:
3166 if (fetch_register_using_p (regnum
))
3168 /* The stub recognized the 'p' packet. Remember this. */
3169 remote_protocol_packets
[PACKET_p
].support
= PACKET_ENABLE
;
3174 /* The stub does not support the 'P' packet. Use 'G'
3175 instead, and don't try using 'P' in the future (it
3176 will just waste our time). */
3177 remote_protocol_packets
[PACKET_p
].support
= PACKET_DISABLE
;
3183 remote_send (&rs
->buf
, &rs
->buf_size
);
3185 /* Save the size of the packet sent to us by the target. Its used
3186 as a heuristic when determining the max size of packets that the
3187 target can safely receive. */
3188 if ((rsa
->actual_register_packet_size
) == 0)
3189 (rsa
->actual_register_packet_size
) = strlen (buf
);
3191 /* Unimplemented registers read as all bits zero. */
3192 memset (regs
, 0, rsa
->sizeof_g_packet
);
3194 /* We can get out of synch in various cases. If the first character
3195 in the buffer is not a hex character, assume that has happened
3196 and try to fetch another packet to read. */
3197 while ((buf
[0] < '0' || buf
[0] > '9')
3198 && (buf
[0] < 'A' || buf
[0] > 'F')
3199 && (buf
[0] < 'a' || buf
[0] > 'f')
3200 && buf
[0] != 'x') /* New: unavailable register value. */
3203 fprintf_unfiltered (gdb_stdlog
,
3204 "Bad register packet; fetching a new packet\n");
3205 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3208 /* Reply describes registers byte by byte, each byte encoded as two
3209 hex characters. Suck them all up, then supply them to the
3210 register cacheing/storage mechanism. */
3213 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3219 warning (_("Remote reply is of odd length: %s"), buf
);
3220 /* Don't change register_bytes_found in this case, and don't
3221 print a second warning. */
3224 if (p
[0] == 'x' && p
[1] == 'x')
3225 regs
[i
] = 0; /* 'x' */
3227 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3231 if (i
!= register_bytes_found
)
3233 register_bytes_found
= i
;
3234 if (REGISTER_BYTES_OK_P ()
3235 && !REGISTER_BYTES_OK (i
))
3236 warning (_("Remote reply is too short: %s"), buf
);
3242 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
3244 struct packet_reg
*r
= &rsa
->regs
[i
];
3247 if (r
->offset
* 2 >= strlen (buf
))
3248 /* A short packet that didn't include the register's
3249 value, this implies that the register is zero (and
3250 not that the register is unavailable). Supply that
3252 regcache_raw_supply (current_regcache
, r
->regnum
, NULL
);
3253 else if (buf
[r
->offset
* 2] == 'x')
3255 gdb_assert (r
->offset
* 2 < strlen (buf
));
3256 /* The register isn't available, mark it as such (at
3257 the same time setting the value to zero). */
3258 regcache_raw_supply (current_regcache
, r
->regnum
, NULL
);
3259 set_register_cached (i
, -1);
3262 regcache_raw_supply (current_regcache
, r
->regnum
,
3269 /* Prepare to store registers. Since we may send them all (using a
3270 'G' request), we have to read out the ones we don't want to change
3274 remote_prepare_to_store (void)
3276 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3278 gdb_byte buf
[MAX_REGISTER_SIZE
];
3280 /* Make sure the entire registers array is valid. */
3281 switch (remote_protocol_packets
[PACKET_P
].support
)
3283 case PACKET_DISABLE
:
3284 case PACKET_SUPPORT_UNKNOWN
:
3285 /* Make sure all the necessary registers are cached. */
3286 for (i
= 0; i
< NUM_REGS
; i
++)
3287 if (rsa
->regs
[i
].in_g_packet
)
3288 regcache_raw_read (current_regcache
, rsa
->regs
[i
].regnum
, buf
);
3295 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3296 packet was not recognized. */
3299 store_register_using_P (int regnum
)
3301 struct remote_state
*rs
= get_remote_state ();
3302 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3303 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3304 /* Try storing a single register. */
3305 char *buf
= rs
->buf
;
3306 gdb_byte regp
[MAX_REGISTER_SIZE
];
3309 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
3310 p
= buf
+ strlen (buf
);
3311 regcache_raw_collect (current_regcache
, reg
->regnum
, regp
);
3312 bin2hex (regp
, p
, register_size (current_gdbarch
, reg
->regnum
));
3313 remote_send (&rs
->buf
, &rs
->buf_size
);
3315 return buf
[0] != '\0';
3319 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3320 contents of the register cache buffer. FIXME: ignores errors. */
3323 remote_store_registers (int regnum
)
3325 struct remote_state
*rs
= get_remote_state ();
3326 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3330 set_thread (PIDGET (inferior_ptid
), 1);
3334 switch (remote_protocol_packets
[PACKET_P
].support
)
3336 case PACKET_DISABLE
:
3339 if (store_register_using_P (regnum
))
3342 error (_("Protocol error: P packet not recognized by stub"));
3343 case PACKET_SUPPORT_UNKNOWN
:
3344 if (store_register_using_P (regnum
))
3346 /* The stub recognized the 'P' packet. Remember this. */
3347 remote_protocol_packets
[PACKET_P
].support
= PACKET_ENABLE
;
3352 /* The stub does not support the 'P' packet. Use 'G'
3353 instead, and don't try using 'P' in the future (it
3354 will just waste our time). */
3355 remote_protocol_packets
[PACKET_P
].support
= PACKET_DISABLE
;
3361 /* Extract all the registers in the regcache copying them into a
3365 regs
= alloca (rsa
->sizeof_g_packet
);
3366 memset (regs
, 0, rsa
->sizeof_g_packet
);
3367 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
3369 struct packet_reg
*r
= &rsa
->regs
[i
];
3371 regcache_raw_collect (current_regcache
, r
->regnum
, regs
+ r
->offset
);
3375 /* Command describes registers byte by byte,
3376 each byte encoded as two hex characters. */
3379 /* remote_prepare_to_store insures that register_bytes_found gets set. */
3380 bin2hex (regs
, p
, register_bytes_found
);
3381 remote_send (&rs
->buf
, &rs
->buf_size
);
3385 /* Return the number of hex digits in num. */
3388 hexnumlen (ULONGEST num
)
3392 for (i
= 0; num
!= 0; i
++)
3398 /* Set BUF to the minimum number of hex digits representing NUM. */
3401 hexnumstr (char *buf
, ULONGEST num
)
3403 int len
= hexnumlen (num
);
3404 return hexnumnstr (buf
, num
, len
);
3408 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3411 hexnumnstr (char *buf
, ULONGEST num
, int width
)
3417 for (i
= width
- 1; i
>= 0; i
--)
3419 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
3426 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3429 remote_address_masked (CORE_ADDR addr
)
3431 if (remote_address_size
> 0
3432 && remote_address_size
< (sizeof (ULONGEST
) * 8))
3434 /* Only create a mask when that mask can safely be constructed
3435 in a ULONGEST variable. */
3437 mask
= (mask
<< remote_address_size
) - 1;
3443 /* Determine whether the remote target supports binary downloading.
3444 This is accomplished by sending a no-op memory write of zero length
3445 to the target at the specified address. It does not suffice to send
3446 the whole packet, since many stubs strip the eighth bit and
3447 subsequently compute a wrong checksum, which causes real havoc with
3450 NOTE: This can still lose if the serial line is not eight-bit
3451 clean. In cases like this, the user should clear "remote
3455 check_binary_download (CORE_ADDR addr
)
3457 struct remote_state
*rs
= get_remote_state ();
3459 switch (remote_protocol_packets
[PACKET_X
].support
)
3461 case PACKET_DISABLE
:
3465 case PACKET_SUPPORT_UNKNOWN
:
3467 char *buf
= rs
->buf
;
3472 p
+= hexnumstr (p
, (ULONGEST
) addr
);
3474 p
+= hexnumstr (p
, (ULONGEST
) 0);
3478 putpkt_binary (buf
, (int) (p
- buf
));
3479 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3484 fprintf_unfiltered (gdb_stdlog
,
3485 "binary downloading NOT suppported by target\n");
3486 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
3491 fprintf_unfiltered (gdb_stdlog
,
3492 "binary downloading suppported by target\n");
3493 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
3500 /* Write memory data directly to the remote machine.
3501 This does not inform the data cache; the data cache uses this.
3502 MEMADDR is the address in the remote memory space.
3503 MYADDR is the address of the buffer in our space.
3504 LEN is the number of bytes.
3506 Returns number of bytes transferred, or 0 (setting errno) for
3507 error. Only transfer a single packet. */
3510 remote_write_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
3512 struct remote_state
*rs
= get_remote_state ();
3520 char *payload_start
;
3522 /* Verify that the target can support a binary download. */
3523 check_binary_download (memaddr
);
3525 payload_size
= get_memory_write_packet_size ();
3527 /* The packet buffer will be large enough for the payload;
3528 get_memory_packet_size ensures this. */
3531 /* Compute the size of the actual payload by subtracting out the
3532 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
3534 payload_size
-= strlen ("$M,:#NN");
3535 payload_size
-= hexnumlen (memaddr
);
3537 /* Construct the packet header: "[MX]<memaddr>,<len>:". */
3539 /* Append "[XM]". Compute a best guess of the number of bytes
3540 actually transfered. */
3542 switch (remote_protocol_packets
[PACKET_X
].support
)
3546 /* Best guess at number of bytes that will fit. */
3547 todo
= min (len
, payload_size
);
3548 payload_size
-= hexnumlen (todo
);
3549 todo
= min (todo
, payload_size
);
3551 case PACKET_DISABLE
:
3553 /* Num bytes that will fit. */
3554 todo
= min (len
, payload_size
/ 2);
3555 payload_size
-= hexnumlen (todo
);
3556 todo
= min (todo
, payload_size
/ 2);
3558 case PACKET_SUPPORT_UNKNOWN
:
3559 internal_error (__FILE__
, __LINE__
,
3560 _("remote_write_bytes: bad internal state"));
3562 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3565 internal_error (__FILE__
, __LINE__
,
3566 _("minumum packet size too small to write data"));
3568 /* Append "<memaddr>". */
3569 memaddr
= remote_address_masked (memaddr
);
3570 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
3575 /* Append <len>. Retain the location/size of <len>. It may need to
3576 be adjusted once the packet body has been created. */
3578 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
3585 /* Append the packet body. */
3587 switch (remote_protocol_packets
[PACKET_X
].support
)
3590 /* Binary mode. Send target system values byte by byte, in
3591 increasing byte addresses. Only escape certain critical
3594 (nr_bytes
< todo
) && (p
- payload_start
) < payload_size
;
3597 switch (myaddr
[nr_bytes
] & 0xff)
3602 /* These must be escaped. */
3604 *p
++ = (myaddr
[nr_bytes
] & 0xff) ^ 0x20;
3607 *p
++ = myaddr
[nr_bytes
] & 0xff;
3611 if (nr_bytes
< todo
)
3613 /* Escape chars have filled up the buffer prematurely,
3614 and we have actually sent fewer bytes than planned.
3615 Fix-up the length field of the packet. Use the same
3616 number of characters as before. */
3617 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
3618 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
3621 case PACKET_DISABLE
:
3622 /* Normal mode: Send target system values byte by byte, in
3623 increasing byte addresses. Each byte is encoded as a two hex
3625 nr_bytes
= bin2hex (myaddr
, p
, todo
);
3628 case PACKET_SUPPORT_UNKNOWN
:
3629 internal_error (__FILE__
, __LINE__
,
3630 _("remote_write_bytes: bad internal state"));
3632 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3635 putpkt_binary (buf
, (int) (p
- buf
));
3636 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3640 /* There is no correspondance between what the remote protocol
3641 uses for errors and errno codes. We would like a cleaner way
3642 of representing errors (big enough to include errno codes,
3643 bfd_error codes, and others). But for now just return EIO. */
3648 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
3649 fewer bytes than we'd planned. */
3653 /* Read memory data directly from the remote machine.
3654 This does not use the data cache; the data cache uses this.
3655 MEMADDR is the address in the remote memory space.
3656 MYADDR is the address of the buffer in our space.
3657 LEN is the number of bytes.
3659 Returns number of bytes transferred, or 0 for error. */
3661 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
3662 remote targets) shouldn't attempt to read the entire buffer.
3663 Instead it should read a single packet worth of data and then
3664 return the byte size of that packet to the caller. The caller (its
3665 caller and its callers caller ;-) already contains code for
3666 handling partial reads. */
3669 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
3671 struct remote_state
*rs
= get_remote_state ();
3673 int max_buf_size
; /* Max size of packet output buffer. */
3676 max_buf_size
= get_memory_read_packet_size ();
3677 /* The packet buffer will be large enough for the payload;
3678 get_memory_packet_size ensures this. */
3688 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
3690 /* construct "m"<memaddr>","<len>" */
3691 /* sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo); */
3692 memaddr
= remote_address_masked (memaddr
);
3695 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
3697 p
+= hexnumstr (p
, (ULONGEST
) todo
);
3701 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3704 && isxdigit (buf
[1]) && isxdigit (buf
[2])
3707 /* There is no correspondance between what the remote
3708 protocol uses for errors and errno codes. We would like
3709 a cleaner way of representing errors (big enough to
3710 include errno codes, bfd_error codes, and others). But
3711 for now just return EIO. */
3716 /* Reply describes memory byte by byte,
3717 each byte encoded as two hex characters. */
3720 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
3722 /* Reply is short. This means that we were able to read
3723 only part of what we wanted to. */
3724 return i
+ (origlen
- len
);
3733 /* Read or write LEN bytes from inferior memory at MEMADDR,
3734 transferring to or from debugger address BUFFER. Write to inferior
3735 if SHOULD_WRITE is nonzero. Returns length of data written or
3736 read; 0 for error. TARGET is unused. */
3739 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
3740 int should_write
, struct mem_attrib
*attrib
,
3741 struct target_ops
*target
)
3743 CORE_ADDR targ_addr
;
3747 /* Should this be the selected frame? */
3748 gdbarch_remote_translate_xfer_address (current_gdbarch
,
3751 &targ_addr
, &targ_len
);
3756 res
= remote_write_bytes (targ_addr
, buffer
, targ_len
);
3758 res
= remote_read_bytes (targ_addr
, buffer
, targ_len
);
3764 remote_files_info (struct target_ops
*ignore
)
3766 puts_filtered ("Debugging a target over a serial line.\n");
3769 /* Stuff for dealing with the packets which are part of this protocol.
3770 See comment at top of file for details. */
3772 /* Read a single character from the remote end, masking it down to 7
3776 readchar (int timeout
)
3780 ch
= serial_readchar (remote_desc
, timeout
);
3785 switch ((enum serial_rc
) ch
)
3788 target_mourn_inferior ();
3789 error (_("Remote connection closed"));
3792 perror_with_name (_("Remote communication error"));
3794 case SERIAL_TIMEOUT
:
3800 /* Send the command in *BUF to the remote machine, and read the reply
3801 into *BUF. Report an error if we get an error reply. Resize
3802 *BUF using xrealloc if necessary to hold the result, and update
3806 remote_send (char **buf
,
3810 getpkt (buf
, sizeof_buf
, 0);
3812 if ((*buf
)[0] == 'E')
3813 error (_("Remote failure reply: %s"), *buf
);
3816 /* Display a null-terminated packet on stdout, for debugging, using C
3820 print_packet (char *buf
)
3822 puts_filtered ("\"");
3823 fputstr_filtered (buf
, '"', gdb_stdout
);
3824 puts_filtered ("\"");
3830 return putpkt_binary (buf
, strlen (buf
));
3833 /* Send a packet to the remote machine, with error checking. The data
3834 of the packet is in BUF. The string in BUF can be at most
3835 get_remote_packet_size () - 5 to account for the $, # and checksum,
3836 and for a possible /0 if we are debugging (remote_debug) and want
3837 to print the sent packet as a string. */
3840 putpkt_binary (char *buf
, int cnt
)
3843 unsigned char csum
= 0;
3844 char *buf2
= alloca (cnt
+ 6);
3850 /* Copy the packet into buffer BUF2, encapsulating it
3851 and giving it a checksum. */
3856 for (i
= 0; i
< cnt
; i
++)
3862 *p
++ = tohex ((csum
>> 4) & 0xf);
3863 *p
++ = tohex (csum
& 0xf);
3865 /* Send it over and over until we get a positive ack. */
3869 int started_error_output
= 0;
3874 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
3875 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
3876 fprintf_unfiltered (gdb_stdlog
, "...");
3877 gdb_flush (gdb_stdlog
);
3879 if (serial_write (remote_desc
, buf2
, p
- buf2
))
3880 perror_with_name (_("putpkt: write failed"));
3882 /* Read until either a timeout occurs (-2) or '+' is read. */
3885 ch
= readchar (remote_timeout
);
3893 case SERIAL_TIMEOUT
:
3895 if (started_error_output
)
3897 putchar_unfiltered ('\n');
3898 started_error_output
= 0;
3907 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
3911 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
3912 case SERIAL_TIMEOUT
:
3916 break; /* Retransmit buffer. */
3920 fprintf_unfiltered (gdb_stdlog
,
3921 "Packet instead of Ack, ignoring it\n");
3922 /* It's probably an old response sent because an ACK
3923 was lost. Gobble up the packet and ack it so it
3924 doesn't get retransmitted when we resend this
3927 serial_write (remote_desc
, "+", 1);
3928 continue; /* Now, go look for +. */
3933 if (!started_error_output
)
3935 started_error_output
= 1;
3936 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
3938 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
3942 break; /* Here to retransmit. */
3946 /* This is wrong. If doing a long backtrace, the user should be
3947 able to get out next time we call QUIT, without anything as
3948 violent as interrupt_query. If we want to provide a way out of
3949 here without getting to the next QUIT, it should be based on
3950 hitting ^C twice as in remote_wait. */
3960 /* Come here after finding the start of a frame when we expected an
3961 ack. Do our best to discard the rest of this packet. */
3970 c
= readchar (remote_timeout
);
3973 case SERIAL_TIMEOUT
:
3974 /* Nothing we can do. */
3977 /* Discard the two bytes of checksum and stop. */
3978 c
= readchar (remote_timeout
);
3980 c
= readchar (remote_timeout
);
3983 case '*': /* Run length encoding. */
3984 /* Discard the repeat count. */
3985 c
= readchar (remote_timeout
);
3990 /* A regular character. */
3996 /* Come here after finding the start of the frame. Collect the rest
3997 into *BUF, verifying the checksum, length, and handling run-length
3998 compression. NUL terminate the buffer. If there is not enough room,
3999 expand *BUF using xrealloc.
4001 Returns -1 on error, number of characters in buffer (ignoring the
4002 trailing NULL) on success. (could be extended to return one of the
4003 SERIAL status indications). */
4006 read_frame (char **buf_p
,
4019 c
= readchar (remote_timeout
);
4022 case SERIAL_TIMEOUT
:
4024 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4028 fputs_filtered ("Saw new packet start in middle of old one\n",
4030 return -1; /* Start a new packet, count retries. */
4033 unsigned char pktcsum
;
4039 check_0
= readchar (remote_timeout
);
4041 check_1
= readchar (remote_timeout
);
4043 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4046 fputs_filtered ("Timeout in checksum, retrying\n",
4050 else if (check_0
< 0 || check_1
< 0)
4053 fputs_filtered ("Communication error in checksum\n",
4058 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4059 if (csum
== pktcsum
)
4064 fprintf_filtered (gdb_stdlog
,
4065 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4067 fputs_filtered (buf
, gdb_stdlog
);
4068 fputs_filtered ("\n", gdb_stdlog
);
4070 /* Number of characters in buffer ignoring trailing
4074 case '*': /* Run length encoding. */
4079 c
= readchar (remote_timeout
);
4081 repeat
= c
- ' ' + 3; /* Compute repeat count. */
4083 /* The character before ``*'' is repeated. */
4085 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
4087 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
4089 /* Make some more room in the buffer. */
4090 *sizeof_buf
+= repeat
;
4091 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4095 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4101 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
4105 if (bc
>= *sizeof_buf
- 1)
4107 /* Make some more room in the buffer. */
4109 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4120 /* Read a packet from the remote machine, with error checking, and
4121 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4122 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4123 rather than timing out; this is used (in synchronous mode) to wait
4124 for a target that is is executing user code to stop. */
4125 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4126 don't have to change all the calls to getpkt to deal with the
4127 return value, because at the moment I don't know what the right
4128 thing to do it for those. */
4136 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
4140 /* Read a packet from the remote machine, with error checking, and
4141 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4142 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4143 rather than timing out; this is used (in synchronous mode) to wait
4144 for a target that is is executing user code to stop. If FOREVER ==
4145 0, this function is allowed to time out gracefully and return an
4146 indication of this to the caller. */
4148 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
4155 strcpy (*buf
, "timeout");
4159 timeout
= watchdog
> 0 ? watchdog
: -1;
4163 timeout
= remote_timeout
;
4167 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
4169 /* This can loop forever if the remote side sends us characters
4170 continuously, but if it pauses, we'll get a zero from
4171 readchar because of timeout. Then we'll count that as a
4174 /* Note that we will only wait forever prior to the start of a
4175 packet. After that, we expect characters to arrive at a
4176 brisk pace. They should show up within remote_timeout
4181 c
= readchar (timeout
);
4183 if (c
== SERIAL_TIMEOUT
)
4185 if (forever
) /* Watchdog went off? Kill the target. */
4188 target_mourn_inferior ();
4189 error (_("Watchdog has expired. Target detached."));
4192 fputs_filtered ("Timed out.\n", gdb_stdlog
);
4198 /* We've found the start of a packet, now collect the data. */
4200 val
= read_frame (buf
, sizeof_buf
);
4206 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
4207 fputstr_unfiltered (*buf
, 0, gdb_stdlog
);
4208 fprintf_unfiltered (gdb_stdlog
, "\n");
4210 serial_write (remote_desc
, "+", 1);
4214 /* Try the whole thing again. */
4216 serial_write (remote_desc
, "-", 1);
4219 /* We have tried hard enough, and just can't receive the packet.
4222 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
4223 serial_write (remote_desc
, "+", 1);
4230 /* For some mysterious reason, wait_for_inferior calls kill instead of
4231 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4235 target_mourn_inferior ();
4239 /* Use catch_errors so the user can quit from gdb even when we aren't on
4240 speaking terms with the remote system. */
4241 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4243 /* Don't wait for it to die. I'm not really sure it matters whether
4244 we do or not. For the existing stubs, kill is a noop. */
4245 target_mourn_inferior ();
4248 /* Async version of remote_kill. */
4250 remote_async_kill (void)
4252 /* Unregister the file descriptor from the event loop. */
4253 if (target_is_async_p ())
4254 serial_async (remote_desc
, NULL
, 0);
4256 /* For some mysterious reason, wait_for_inferior calls kill instead of
4257 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4261 target_mourn_inferior ();
4265 /* Use catch_errors so the user can quit from gdb even when we
4266 aren't on speaking terms with the remote system. */
4267 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4269 /* Don't wait for it to die. I'm not really sure it matters whether
4270 we do or not. For the existing stubs, kill is a noop. */
4271 target_mourn_inferior ();
4277 remote_mourn_1 (&remote_ops
);
4281 remote_async_mourn (void)
4283 remote_mourn_1 (&remote_async_ops
);
4287 extended_remote_mourn (void)
4289 /* We do _not_ want to mourn the target like this; this will
4290 remove the extended remote target from the target stack,
4291 and the next time the user says "run" it'll fail.
4293 FIXME: What is the right thing to do here? */
4295 remote_mourn_1 (&extended_remote_ops
);
4299 /* Worker function for remote_mourn. */
4301 remote_mourn_1 (struct target_ops
*target
)
4303 unpush_target (target
);
4304 generic_mourn_inferior ();
4307 /* In the extended protocol we want to be able to do things like
4308 "run" and have them basically work as expected. So we need
4309 a special create_inferior function.
4311 FIXME: One day add support for changing the exec file
4312 we're debugging, arguments and an environment. */
4315 extended_remote_create_inferior (char *exec_file
, char *args
,
4316 char **env
, int from_tty
)
4318 /* Rip out the breakpoints; we'll reinsert them after restarting
4319 the remote server. */
4320 remove_breakpoints ();
4322 /* Now restart the remote server. */
4323 extended_remote_restart ();
4325 /* Now put the breakpoints back in. This way we're safe if the
4326 restart function works via a unix fork on the remote side. */
4327 insert_breakpoints ();
4329 /* Clean up from the last time we were running. */
4330 clear_proceed_status ();
4333 /* Async version of extended_remote_create_inferior. */
4335 extended_remote_async_create_inferior (char *exec_file
, char *args
,
4336 char **env
, int from_tty
)
4338 /* Rip out the breakpoints; we'll reinsert them after restarting
4339 the remote server. */
4340 remove_breakpoints ();
4342 /* If running asynchronously, register the target file descriptor
4343 with the event loop. */
4344 if (target_can_async_p ())
4345 target_async (inferior_event_handler
, 0);
4347 /* Now restart the remote server. */
4348 extended_remote_restart ();
4350 /* Now put the breakpoints back in. This way we're safe if the
4351 restart function works via a unix fork on the remote side. */
4352 insert_breakpoints ();
4354 /* Clean up from the last time we were running. */
4355 clear_proceed_status ();
4359 /* On some machines, e.g. 68k, we may use a different breakpoint
4360 instruction than other targets; in those use
4361 DEPRECATED_REMOTE_BREAKPOINT instead of just BREAKPOINT_FROM_PC.
4362 Also, bi-endian targets may define
4363 DEPRECATED_LITTLE_REMOTE_BREAKPOINT and
4364 DEPRECATED_BIG_REMOTE_BREAKPOINT. If none of these are defined, we
4365 just call the standard routines that are in mem-break.c. */
4367 /* NOTE: cagney/2003-06-08: This is silly. A remote and simulator
4368 target should use an identical BREAKPOINT_FROM_PC. As for native,
4369 the ARCH-OS-tdep.c code can override the default. */
4371 #if defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && defined (DEPRECATED_BIG_REMOTE_BREAKPOINT) && !defined(DEPRECATED_REMOTE_BREAKPOINT)
4372 #define DEPRECATED_REMOTE_BREAKPOINT
4375 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4377 /* If the target isn't bi-endian, just pretend it is. */
4378 #if !defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && !defined (DEPRECATED_BIG_REMOTE_BREAKPOINT)
4379 #define DEPRECATED_LITTLE_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
4380 #define DEPRECATED_BIG_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
4383 static unsigned char big_break_insn
[] = DEPRECATED_BIG_REMOTE_BREAKPOINT
;
4384 static unsigned char little_break_insn
[] = DEPRECATED_LITTLE_REMOTE_BREAKPOINT
;
4386 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4388 /* Insert a breakpoint. On targets that have software breakpoint
4389 support, we ask the remote target to do the work; on targets
4390 which don't, we insert a traditional memory breakpoint. */
4393 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
4395 CORE_ADDR addr
= bp_tgt
->placed_address
;
4396 struct remote_state
*rs
= get_remote_state ();
4397 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4401 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
4402 If it succeeds, then set the support to PACKET_ENABLE. If it
4403 fails, and the user has explicitly requested the Z support then
4404 report an error, otherwise, mark it disabled and go on. */
4406 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
4413 BREAKPOINT_FROM_PC (&bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
4414 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
4415 p
+= hexnumstr (p
, addr
);
4416 sprintf (p
, ",%d", bp_tgt
->placed_size
);
4419 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4421 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
4427 case PACKET_UNKNOWN
:
4432 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4433 bp_tgt
->placed_size
= bp_tgt
->shadow_len
= sizeof big_break_insn
;
4434 val
= target_read_memory (addr
, bp_tgt
->shadow_contents
, bp_tgt
->shadow_len
);
4438 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
4439 val
= target_write_memory (addr
, (char *) big_break_insn
,
4440 sizeof big_break_insn
);
4442 val
= target_write_memory (addr
, (char *) little_break_insn
,
4443 sizeof little_break_insn
);
4448 return memory_insert_breakpoint (bp_tgt
);
4449 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4453 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
4455 CORE_ADDR addr
= bp_tgt
->placed_address
;
4456 struct remote_state
*rs
= get_remote_state ();
4459 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
4467 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
4468 p
+= hexnumstr (p
, addr
);
4469 sprintf (p
, ",%d", bp_tgt
->placed_size
);
4472 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4474 return (rs
->buf
[0] == 'E');
4477 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4478 return target_write_memory (bp_tgt
->placed_address
, bp_tgt
->shadow_contents
,
4479 bp_tgt
->shadow_len
);
4481 return memory_remove_breakpoint (bp_tgt
);
4482 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4486 watchpoint_to_Z_packet (int type
)
4491 return Z_PACKET_WRITE_WP
;
4494 return Z_PACKET_READ_WP
;
4497 return Z_PACKET_ACCESS_WP
;
4500 internal_error (__FILE__
, __LINE__
,
4501 _("hw_bp_to_z: bad watchpoint type %d"), type
);
4506 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
4508 struct remote_state
*rs
= get_remote_state ();
4510 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
4512 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
4515 sprintf (rs
->buf
, "Z%x,", packet
);
4516 p
= strchr (rs
->buf
, '\0');
4517 addr
= remote_address_masked (addr
);
4518 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4519 sprintf (p
, ",%x", len
);
4522 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4524 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
4527 case PACKET_UNKNOWN
:
4532 internal_error (__FILE__
, __LINE__
,
4533 _("remote_insert_watchpoint: reached end of function"));
4538 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
4540 struct remote_state
*rs
= get_remote_state ();
4542 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
4544 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
4547 sprintf (rs
->buf
, "z%x,", packet
);
4548 p
= strchr (rs
->buf
, '\0');
4549 addr
= remote_address_masked (addr
);
4550 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4551 sprintf (p
, ",%x", len
);
4553 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4555 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
4558 case PACKET_UNKNOWN
:
4563 internal_error (__FILE__
, __LINE__
,
4564 _("remote_remove_watchpoint: reached end of function"));
4568 int remote_hw_watchpoint_limit
= -1;
4569 int remote_hw_breakpoint_limit
= -1;
4572 remote_check_watch_resources (int type
, int cnt
, int ot
)
4574 if (type
== bp_hardware_breakpoint
)
4576 if (remote_hw_breakpoint_limit
== 0)
4578 else if (remote_hw_breakpoint_limit
< 0)
4580 else if (cnt
<= remote_hw_breakpoint_limit
)
4585 if (remote_hw_watchpoint_limit
== 0)
4587 else if (remote_hw_watchpoint_limit
< 0)
4591 else if (cnt
<= remote_hw_watchpoint_limit
)
4598 remote_stopped_by_watchpoint (void)
4600 return remote_stopped_by_watchpoint_p
;
4603 extern int stepped_after_stopped_by_watchpoint
;
4606 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
4609 if (remote_stopped_by_watchpoint ()
4610 || stepped_after_stopped_by_watchpoint
)
4612 *addr_p
= remote_watch_data_address
;
4621 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
4624 struct remote_state
*rs
= get_remote_state ();
4627 /* The length field should be set to the size of a breakpoint
4628 instruction, even though we aren't inserting one ourselves. */
4630 BREAKPOINT_FROM_PC (&bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
4632 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
4639 addr
= remote_address_masked (bp_tgt
->placed_address
);
4640 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4641 sprintf (p
, ",%x", bp_tgt
->placed_size
);
4644 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4646 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
4649 case PACKET_UNKNOWN
:
4654 internal_error (__FILE__
, __LINE__
,
4655 _("remote_insert_hw_breakpoint: reached end of function"));
4660 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
4663 struct remote_state
*rs
= get_remote_state ();
4666 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
4673 addr
= remote_address_masked (bp_tgt
->placed_address
);
4674 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4675 sprintf (p
, ",%x", bp_tgt
->placed_size
);
4678 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4680 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
4683 case PACKET_UNKNOWN
:
4688 internal_error (__FILE__
, __LINE__
,
4689 _("remote_remove_hw_breakpoint: reached end of function"));
4692 /* Some targets are only capable of doing downloads, and afterwards
4693 they switch to the remote serial protocol. This function provides
4694 a clean way to get from the download target to the remote target.
4695 It's basically just a wrapper so that we don't have to expose any
4696 of the internal workings of remote.c.
4698 Prior to calling this routine, you should shutdown the current
4699 target code, else you will get the "A program is being debugged
4700 already..." message. Usually a call to pop_target() suffices. */
4703 push_remote_target (char *name
, int from_tty
)
4705 printf_filtered (_("Switching to remote protocol\n"));
4706 remote_open (name
, from_tty
);
4709 /* Table used by the crc32 function to calcuate the checksum. */
4711 static unsigned long crc32_table
[256] =
4714 static unsigned long
4715 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
4717 if (!crc32_table
[1])
4719 /* Initialize the CRC table and the decoding table. */
4723 for (i
= 0; i
< 256; i
++)
4725 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
4726 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
4733 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
4739 /* compare-sections command
4741 With no arguments, compares each loadable section in the exec bfd
4742 with the same memory range on the target, and reports mismatches.
4743 Useful for verifying the image on the target against the exec file.
4744 Depends on the target understanding the new "qCRC:" request. */
4746 /* FIXME: cagney/1999-10-26: This command should be broken down into a
4747 target method (target verify memory) and generic version of the
4748 actual command. This will allow other high-level code (especially
4749 generic_load()) to make use of this target functionality. */
4752 compare_sections_command (char *args
, int from_tty
)
4754 struct remote_state
*rs
= get_remote_state ();
4756 unsigned long host_crc
, target_crc
;
4757 extern bfd
*exec_bfd
;
4758 struct cleanup
*old_chain
;
4761 const char *sectname
;
4768 error (_("command cannot be used without an exec file"));
4769 if (!current_target
.to_shortname
||
4770 strcmp (current_target
.to_shortname
, "remote") != 0)
4771 error (_("command can only be used with remote target"));
4773 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4775 if (!(s
->flags
& SEC_LOAD
))
4776 continue; /* skip non-loadable section */
4778 size
= bfd_get_section_size (s
);
4780 continue; /* skip zero-length section */
4782 sectname
= bfd_get_section_name (exec_bfd
, s
);
4783 if (args
&& strcmp (args
, sectname
) != 0)
4784 continue; /* not the section selected by user */
4786 matched
= 1; /* do this section */
4788 /* FIXME: assumes lma can fit into long. */
4789 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
4790 (long) lma
, (long) size
);
4793 /* Be clever; compute the host_crc before waiting for target
4795 sectdata
= xmalloc (size
);
4796 old_chain
= make_cleanup (xfree
, sectdata
);
4797 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
4798 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
4800 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4801 if (rs
->buf
[0] == 'E')
4802 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
4803 sectname
, paddr (lma
), paddr (lma
+ size
));
4804 if (rs
->buf
[0] != 'C')
4805 error (_("remote target does not support this operation"));
4807 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
4808 target_crc
= target_crc
* 16 + fromhex (*tmp
);
4810 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
4811 sectname
, paddr (lma
), paddr (lma
+ size
));
4812 if (host_crc
== target_crc
)
4813 printf_filtered ("matched.\n");
4816 printf_filtered ("MIS-MATCHED!\n");
4820 do_cleanups (old_chain
);
4823 warning (_("One or more sections of the remote executable does not match\n\
4824 the loaded file\n"));
4825 if (args
&& !matched
)
4826 printf_filtered (_("No loaded section named '%s'.\n"), args
);
4830 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4831 const char *annex
, gdb_byte
*readbuf
,
4832 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4834 struct remote_state
*rs
= get_remote_state ();
4839 /* Handle memory using remote_xfer_memory. */
4840 if (object
== TARGET_OBJECT_MEMORY
)
4845 if (writebuf
!= NULL
)
4847 void *buffer
= xmalloc (len
);
4848 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
4849 memcpy (buffer
, writebuf
, len
);
4850 xfered
= remote_xfer_memory (offset
, buffer
, len
, 1, NULL
, ops
);
4851 do_cleanups (cleanup
);
4854 xfered
= remote_xfer_memory (offset
, readbuf
, len
, 0, NULL
, ops
);
4858 else if (xfered
== 0 && errno
== 0)
4864 /* Only handle reads. */
4865 if (writebuf
!= NULL
|| readbuf
== NULL
)
4868 /* Map pre-existing objects onto letters. DO NOT do this for new
4869 objects!!! Instead specify new query packets. */
4872 case TARGET_OBJECT_KOD
:
4875 case TARGET_OBJECT_AVR
:
4879 case TARGET_OBJECT_AUXV
:
4880 if (remote_protocol_packets
[PACKET_qPart_auxv
].support
!= PACKET_DISABLE
)
4882 unsigned int total
= 0;
4885 LONGEST n
= min ((get_remote_packet_size () - 2) / 2, len
);
4886 snprintf (rs
->buf
, get_remote_packet_size (),
4887 "qPart:auxv:read::%s,%s",
4888 phex_nz (offset
, sizeof offset
),
4889 phex_nz (n
, sizeof n
));
4890 i
= putpkt (rs
->buf
);
4892 return total
> 0 ? total
: i
;
4894 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4895 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qPart_auxv
])
4897 return total
> 0 ? total
: -1;
4898 if (strcmp (rs
->buf
, "OK") == 0)
4899 break; /* Got EOF indicator. */
4900 /* Got some data. */
4901 i
= hex2bin (rs
->buf
, readbuf
, len
);
4904 readbuf
= (void *) ((char *) readbuf
+ i
);
4918 /* Note: a zero OFFSET and LEN can be used to query the minimum
4920 if (offset
== 0 && len
== 0)
4921 return (get_remote_packet_size ());
4922 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
4923 large enough let the caller deal with it. */
4924 if (len
< get_remote_packet_size ())
4926 len
= get_remote_packet_size ();
4928 /* Except for querying the minimum buffer size, target must be open. */
4930 error (_("remote query is only available after target open"));
4932 gdb_assert (annex
!= NULL
);
4933 gdb_assert (readbuf
!= NULL
);
4939 /* We used one buffer char for the remote protocol q command and
4940 another for the query type. As the remote protocol encapsulation
4941 uses 4 chars plus one extra in case we are debugging
4942 (remote_debug), we have PBUFZIZ - 7 left to pack the query
4945 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
4947 /* Bad caller may have sent forbidden characters. */
4948 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
4953 gdb_assert (annex
[i
] == '\0');
4955 i
= putpkt (rs
->buf
);
4959 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4960 strcpy ((char *) readbuf
, rs
->buf
);
4962 return strlen ((char *) readbuf
);
4966 remote_rcmd (char *command
,
4967 struct ui_file
*outbuf
)
4969 struct remote_state
*rs
= get_remote_state ();
4970 char *buf
= rs
->buf
;
4974 error (_("remote rcmd is only available after target open"));
4976 /* Send a NULL command across as an empty command. */
4977 if (command
== NULL
)
4980 /* The query prefix. */
4981 strcpy (buf
, "qRcmd,");
4982 p
= strchr (buf
, '\0');
4984 if ((strlen (buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
4985 error (_("\"monitor\" command ``%s'' is too long."), command
);
4987 /* Encode the actual command. */
4988 bin2hex ((gdb_byte
*) command
, p
, 0);
4990 if (putpkt (rs
->buf
) < 0)
4991 error (_("Communication problem with target."));
4993 /* get/display the response */
4996 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
4998 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5000 error (_("Target does not support this command."));
5001 if (buf
[0] == 'O' && buf
[1] != 'K')
5003 remote_console_output (buf
+ 1); /* 'O' message from stub. */
5006 if (strcmp (buf
, "OK") == 0)
5008 if (strlen (buf
) == 3 && buf
[0] == 'E'
5009 && isdigit (buf
[1]) && isdigit (buf
[2]))
5011 error (_("Protocol error with Rcmd"));
5013 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5015 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5016 fputc_unfiltered (c
, outbuf
);
5023 packet_command (char *args
, int from_tty
)
5025 struct remote_state
*rs
= get_remote_state ();
5028 error (_("command can only be used with remote target"));
5031 error (_("remote-packet command requires packet text as argument"));
5033 puts_filtered ("sending: ");
5034 print_packet (args
);
5035 puts_filtered ("\n");
5038 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5039 puts_filtered ("received: ");
5040 print_packet (rs
->buf
);
5041 puts_filtered ("\n");
5045 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
5047 static void display_thread_info (struct gdb_ext_thread_info
*info
);
5049 static void threadset_test_cmd (char *cmd
, int tty
);
5051 static void threadalive_test (char *cmd
, int tty
);
5053 static void threadlist_test_cmd (char *cmd
, int tty
);
5055 int get_and_display_threadinfo (threadref
*ref
);
5057 static void threadinfo_test_cmd (char *cmd
, int tty
);
5059 static int thread_display_step (threadref
*ref
, void *context
);
5061 static void threadlist_update_test_cmd (char *cmd
, int tty
);
5063 static void init_remote_threadtests (void);
5065 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
5068 threadset_test_cmd (char *cmd
, int tty
)
5070 int sample_thread
= SAMPLE_THREAD
;
5072 printf_filtered (_("Remote threadset test\n"));
5073 set_thread (sample_thread
, 1);
5078 threadalive_test (char *cmd
, int tty
)
5080 int sample_thread
= SAMPLE_THREAD
;
5082 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
5083 printf_filtered ("PASS: Thread alive test\n");
5085 printf_filtered ("FAIL: Thread alive test\n");
5088 void output_threadid (char *title
, threadref
*ref
);
5091 output_threadid (char *title
, threadref
*ref
)
5095 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
5097 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
5101 threadlist_test_cmd (char *cmd
, int tty
)
5104 threadref nextthread
;
5105 int done
, result_count
;
5106 threadref threadlist
[3];
5108 printf_filtered ("Remote Threadlist test\n");
5109 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
5110 &result_count
, &threadlist
[0]))
5111 printf_filtered ("FAIL: threadlist test\n");
5114 threadref
*scan
= threadlist
;
5115 threadref
*limit
= scan
+ result_count
;
5117 while (scan
< limit
)
5118 output_threadid (" thread ", scan
++);
5123 display_thread_info (struct gdb_ext_thread_info
*info
)
5125 output_threadid ("Threadid: ", &info
->threadid
);
5126 printf_filtered ("Name: %s\n ", info
->shortname
);
5127 printf_filtered ("State: %s\n", info
->display
);
5128 printf_filtered ("other: %s\n\n", info
->more_display
);
5132 get_and_display_threadinfo (threadref
*ref
)
5136 struct gdb_ext_thread_info threadinfo
;
5138 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
5139 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
5140 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
5141 display_thread_info (&threadinfo
);
5146 threadinfo_test_cmd (char *cmd
, int tty
)
5148 int athread
= SAMPLE_THREAD
;
5152 int_to_threadref (&thread
, athread
);
5153 printf_filtered ("Remote Threadinfo test\n");
5154 if (!get_and_display_threadinfo (&thread
))
5155 printf_filtered ("FAIL cannot get thread info\n");
5159 thread_display_step (threadref
*ref
, void *context
)
5161 /* output_threadid(" threadstep ",ref); *//* simple test */
5162 return get_and_display_threadinfo (ref
);
5166 threadlist_update_test_cmd (char *cmd
, int tty
)
5168 printf_filtered ("Remote Threadlist update test\n");
5169 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
5173 init_remote_threadtests (void)
5175 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
5176 Fetch and print the remote list of thread identifiers, one pkt only"));
5177 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
5178 _("Fetch and display info about one thread"));
5179 add_com ("tset", class_obscure
, threadset_test_cmd
,
5180 _("Test setting to a different thread"));
5181 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
5182 _("Iterate through updating all remote thread info"));
5183 add_com ("talive", class_obscure
, threadalive_test
,
5184 _(" Remote thread alive test "));
5189 /* Convert a thread ID to a string. Returns the string in a static
5193 remote_pid_to_str (ptid_t ptid
)
5195 static char buf
[32];
5197 xsnprintf (buf
, sizeof buf
, "thread %d", ptid_get_pid (ptid
));
5201 /* Get the address of the thread local variable in OBJFILE which is
5202 stored at OFFSET within the thread local storage for thread PTID. */
5205 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
5207 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
5209 struct remote_state
*rs
= get_remote_state ();
5211 enum packet_result result
;
5213 strcpy (p
, "qGetTLSAddr:");
5215 p
+= hexnumstr (p
, PIDGET (ptid
));
5217 p
+= hexnumstr (p
, offset
);
5219 p
+= hexnumstr (p
, lm
);
5223 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5224 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
5225 if (result
== PACKET_OK
)
5229 unpack_varlen_hex (rs
->buf
, &result
);
5232 else if (result
== PACKET_UNKNOWN
)
5233 throw_error (TLS_GENERIC_ERROR
,
5234 _("Remote target doesn't support qGetTLSAddr packet"));
5236 throw_error (TLS_GENERIC_ERROR
,
5237 _("Remote target failed to process qGetTLSAddr request"));
5240 throw_error (TLS_GENERIC_ERROR
,
5241 _("TLS not supported or disabled on this target"));
5247 init_remote_ops (void)
5249 remote_ops
.to_shortname
= "remote";
5250 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
5252 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5253 Specify the serial device it is connected to\n\
5254 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
5255 remote_ops
.to_open
= remote_open
;
5256 remote_ops
.to_close
= remote_close
;
5257 remote_ops
.to_detach
= remote_detach
;
5258 remote_ops
.to_disconnect
= remote_disconnect
;
5259 remote_ops
.to_resume
= remote_resume
;
5260 remote_ops
.to_wait
= remote_wait
;
5261 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
5262 remote_ops
.to_store_registers
= remote_store_registers
;
5263 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
5264 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
5265 remote_ops
.to_files_info
= remote_files_info
;
5266 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
5267 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
5268 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
5269 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
5270 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
5271 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
5272 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
5273 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
5274 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
5275 remote_ops
.to_kill
= remote_kill
;
5276 remote_ops
.to_load
= generic_load
;
5277 remote_ops
.to_mourn_inferior
= remote_mourn
;
5278 remote_ops
.to_thread_alive
= remote_thread_alive
;
5279 remote_ops
.to_find_new_threads
= remote_threads_info
;
5280 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
5281 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
5282 remote_ops
.to_stop
= remote_stop
;
5283 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
5284 remote_ops
.to_rcmd
= remote_rcmd
;
5285 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
5286 remote_ops
.to_stratum
= process_stratum
;
5287 remote_ops
.to_has_all_memory
= 1;
5288 remote_ops
.to_has_memory
= 1;
5289 remote_ops
.to_has_stack
= 1;
5290 remote_ops
.to_has_registers
= 1;
5291 remote_ops
.to_has_execution
= 1;
5292 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
5293 remote_ops
.to_magic
= OPS_MAGIC
;
5296 /* Set up the extended remote vector by making a copy of the standard
5297 remote vector and adding to it. */
5300 init_extended_remote_ops (void)
5302 extended_remote_ops
= remote_ops
;
5304 extended_remote_ops
.to_shortname
= "extended-remote";
5305 extended_remote_ops
.to_longname
=
5306 "Extended remote serial target in gdb-specific protocol";
5307 extended_remote_ops
.to_doc
=
5308 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5309 Specify the serial device it is connected to (e.g. /dev/ttya).",
5310 extended_remote_ops
.to_open
= extended_remote_open
;
5311 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
5312 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
5316 remote_can_async_p (void)
5318 /* We're async whenever the serial device is. */
5319 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
5323 remote_is_async_p (void)
5325 /* We're async whenever the serial device is. */
5326 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
5329 /* Pass the SERIAL event on and up to the client. One day this code
5330 will be able to delay notifying the client of an event until the
5331 point where an entire packet has been received. */
5333 static void (*async_client_callback
) (enum inferior_event_type event_type
,
5335 static void *async_client_context
;
5336 static serial_event_ftype remote_async_serial_handler
;
5339 remote_async_serial_handler (struct serial
*scb
, void *context
)
5341 /* Don't propogate error information up to the client. Instead let
5342 the client find out about the error by querying the target. */
5343 async_client_callback (INF_REG_EVENT
, async_client_context
);
5347 remote_async (void (*callback
) (enum inferior_event_type event_type
,
5348 void *context
), void *context
)
5350 if (current_target
.to_async_mask_value
== 0)
5351 internal_error (__FILE__
, __LINE__
,
5352 _("Calling remote_async when async is masked"));
5354 if (callback
!= NULL
)
5356 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
5357 async_client_callback
= callback
;
5358 async_client_context
= context
;
5361 serial_async (remote_desc
, NULL
, NULL
);
5364 /* Target async and target extended-async.
5366 This are temporary targets, until it is all tested. Eventually
5367 async support will be incorporated int the usual 'remote'
5371 init_remote_async_ops (void)
5373 remote_async_ops
.to_shortname
= "async";
5374 remote_async_ops
.to_longname
=
5375 "Remote serial target in async version of the gdb-specific protocol";
5376 remote_async_ops
.to_doc
=
5377 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5378 Specify the serial device it is connected to (e.g. /dev/ttya).";
5379 remote_async_ops
.to_open
= remote_async_open
;
5380 remote_async_ops
.to_close
= remote_close
;
5381 remote_async_ops
.to_detach
= remote_detach
;
5382 remote_async_ops
.to_disconnect
= remote_disconnect
;
5383 remote_async_ops
.to_resume
= remote_async_resume
;
5384 remote_async_ops
.to_wait
= remote_async_wait
;
5385 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
5386 remote_async_ops
.to_store_registers
= remote_store_registers
;
5387 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
5388 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
5389 remote_async_ops
.to_files_info
= remote_files_info
;
5390 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
5391 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
5392 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
5393 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
5394 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
5395 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
5396 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
5397 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
5398 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
5399 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
5400 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
5401 remote_async_ops
.to_kill
= remote_async_kill
;
5402 remote_async_ops
.to_load
= generic_load
;
5403 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
5404 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
5405 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
5406 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
5407 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
5408 remote_async_ops
.to_stop
= remote_stop
;
5409 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
5410 remote_async_ops
.to_rcmd
= remote_rcmd
;
5411 remote_async_ops
.to_stratum
= process_stratum
;
5412 remote_async_ops
.to_has_all_memory
= 1;
5413 remote_async_ops
.to_has_memory
= 1;
5414 remote_async_ops
.to_has_stack
= 1;
5415 remote_async_ops
.to_has_registers
= 1;
5416 remote_async_ops
.to_has_execution
= 1;
5417 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
5418 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
5419 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
5420 remote_async_ops
.to_async
= remote_async
;
5421 remote_async_ops
.to_async_mask_value
= 1;
5422 remote_async_ops
.to_magic
= OPS_MAGIC
;
5425 /* Set up the async extended remote vector by making a copy of the standard
5426 remote vector and adding to it. */
5429 init_extended_async_remote_ops (void)
5431 extended_async_remote_ops
= remote_async_ops
;
5433 extended_async_remote_ops
.to_shortname
= "extended-async";
5434 extended_async_remote_ops
.to_longname
=
5435 "Extended remote serial target in async gdb-specific protocol";
5436 extended_async_remote_ops
.to_doc
=
5437 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
5438 Specify the serial device it is connected to (e.g. /dev/ttya).",
5439 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
5440 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
5441 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
5444 static struct cmd_list_element
*remote_set_cmdlist
;
5445 static struct cmd_list_element
*remote_show_cmdlist
;
5448 set_remote_cmd (char *args
, int from_tty
)
5453 show_remote_cmd (char *args
, int from_tty
)
5455 /* We can't just use cmd_show_list here, because we want to skip
5456 the redundant "show remote Z-packet". */
5457 struct cleanup
*showlist_chain
;
5458 struct cmd_list_element
*list
= remote_show_cmdlist
;
5460 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
5461 for (; list
!= NULL
; list
= list
->next
)
5462 if (strcmp (list
->name
, "Z-packet") == 0)
5464 else if (list
->type
== show_cmd
)
5466 struct cleanup
*option_chain
5467 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
5468 ui_out_field_string (uiout
, "name", list
->name
);
5469 ui_out_text (uiout
, ": ");
5470 do_setshow_command ((char *) NULL
, from_tty
, list
);
5471 /* Close the tuple. */
5472 do_cleanups (option_chain
);
5477 build_remote_gdbarch_data (void)
5479 remote_address_size
= TARGET_ADDR_BIT
;
5482 /* Saved pointer to previous owner of the new_objfile event. */
5483 static void (*remote_new_objfile_chain
) (struct objfile
*);
5485 /* Function to be called whenever a new objfile (shlib) is detected. */
5487 remote_new_objfile (struct objfile
*objfile
)
5489 if (remote_desc
!= 0) /* Have a remote connection. */
5491 remote_check_symbols (objfile
);
5493 /* Call predecessor on chain, if any. */
5494 if (remote_new_objfile_chain
!= 0 &&
5496 remote_new_objfile_chain (objfile
);
5500 _initialize_remote (void)
5502 struct remote_state
*rs
;
5504 /* architecture specific data */
5505 remote_gdbarch_data_handle
=
5506 gdbarch_data_register_post_init (init_remote_state
);
5508 /* Old tacky stuff. NOTE: This comes after the remote protocol so
5509 that the remote protocol has been initialized. */
5510 DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size
);
5511 deprecated_register_gdbarch_swap (NULL
, 0, build_remote_gdbarch_data
);
5513 /* Initialize the per-target state. At the moment there is only one
5514 of these, not one per target. Only one target is active at a
5515 time. The default buffer size is unimportant; it will be expanded
5516 whenever a larger buffer is needed. */
5517 rs
= get_remote_state ();
5519 rs
->buf
= xmalloc (rs
->buf_size
);
5522 add_target (&remote_ops
);
5524 init_extended_remote_ops ();
5525 add_target (&extended_remote_ops
);
5527 init_remote_async_ops ();
5528 add_target (&remote_async_ops
);
5530 init_extended_async_remote_ops ();
5531 add_target (&extended_async_remote_ops
);
5533 /* Hook into new objfile notification. */
5534 remote_new_objfile_chain
= deprecated_target_new_objfile_hook
;
5535 deprecated_target_new_objfile_hook
= remote_new_objfile
;
5538 init_remote_threadtests ();
5541 /* set/show remote ... */
5543 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
5544 Remote protocol specific variables\n\
5545 Configure various remote-protocol specific variables such as\n\
5546 the packets being used"),
5547 &remote_set_cmdlist
, "set remote ",
5548 0 /* allow-unknown */, &setlist
);
5549 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
5550 Remote protocol specific variables\n\
5551 Configure various remote-protocol specific variables such as\n\
5552 the packets being used"),
5553 &remote_show_cmdlist
, "show remote ",
5554 0 /* allow-unknown */, &showlist
);
5556 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
5557 Compare section data on target to the exec file.\n\
5558 Argument is a single section name (default: all loaded sections)."),
5561 add_cmd ("packet", class_maintenance
, packet_command
, _("\
5562 Send an arbitrary packet to a remote target.\n\
5563 maintenance packet TEXT\n\
5564 If GDB is talking to an inferior via the GDB serial protocol, then\n\
5565 this command sends the string TEXT to the inferior, and displays the\n\
5566 response packet. GDB supplies the initial `$' character, and the\n\
5567 terminating `#' character and checksum."),
5570 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
5571 Set whether to send break if interrupted."), _("\
5572 Show whether to send break if interrupted."), _("\
5573 If set, a break, instead of a cntrl-c, is sent to the remote target."),
5574 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
5575 &setlist
, &showlist
);
5577 /* Install commands for configuring memory read/write packets. */
5579 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
5580 Set the maximum number of bytes per memory write packet (deprecated)."),
5582 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
5583 Show the maximum number of bytes per memory write packet (deprecated)."),
5585 add_cmd ("memory-write-packet-size", no_class
,
5586 set_memory_write_packet_size
, _("\
5587 Set the maximum number of bytes per memory-write packet.\n\
5588 Specify the number of bytes in a packet or 0 (zero) for the\n\
5589 default packet size. The actual limit is further reduced\n\
5590 dependent on the target. Specify ``fixed'' to disable the\n\
5591 further restriction and ``limit'' to enable that restriction."),
5592 &remote_set_cmdlist
);
5593 add_cmd ("memory-read-packet-size", no_class
,
5594 set_memory_read_packet_size
, _("\
5595 Set the maximum number of bytes per memory-read packet.\n\
5596 Specify the number of bytes in a packet or 0 (zero) for the\n\
5597 default packet size. The actual limit is further reduced\n\
5598 dependent on the target. Specify ``fixed'' to disable the\n\
5599 further restriction and ``limit'' to enable that restriction."),
5600 &remote_set_cmdlist
);
5601 add_cmd ("memory-write-packet-size", no_class
,
5602 show_memory_write_packet_size
,
5603 _("Show the maximum number of bytes per memory-write packet."),
5604 &remote_show_cmdlist
);
5605 add_cmd ("memory-read-packet-size", no_class
,
5606 show_memory_read_packet_size
,
5607 _("Show the maximum number of bytes per memory-read packet."),
5608 &remote_show_cmdlist
);
5610 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
5611 &remote_hw_watchpoint_limit
, _("\
5612 Set the maximum number of target hardware watchpoints."), _("\
5613 Show the maximum number of target hardware watchpoints."), _("\
5614 Specify a negative limit for unlimited."),
5615 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
5616 &remote_set_cmdlist
, &remote_show_cmdlist
);
5617 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
5618 &remote_hw_breakpoint_limit
, _("\
5619 Set the maximum number of target hardware breakpoints."), _("\
5620 Show the maximum number of target hardware breakpoints."), _("\
5621 Specify a negative limit for unlimited."),
5622 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
5623 &remote_set_cmdlist
, &remote_show_cmdlist
);
5625 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
5626 &remote_address_size
, _("\
5627 Set the maximum size of the address (in bits) in a memory packet."), _("\
5628 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
5630 NULL
, /* FIXME: i18n: */
5631 &setlist
, &showlist
);
5633 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
5634 "X", "binary-download",
5635 set_remote_protocol_packet_cmd
,
5636 show_remote_protocol_packet_cmd
,
5637 &remote_set_cmdlist
, &remote_show_cmdlist
,
5640 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
5641 "vCont", "verbose-resume",
5642 set_remote_protocol_packet_cmd
,
5643 show_remote_protocol_packet_cmd
,
5644 &remote_set_cmdlist
, &remote_show_cmdlist
,
5647 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
5648 "qSymbol", "symbol-lookup",
5649 set_remote_protocol_packet_cmd
,
5650 show_remote_protocol_packet_cmd
,
5651 &remote_set_cmdlist
, &remote_show_cmdlist
,
5654 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
5655 "P", "set-register",
5656 set_remote_protocol_packet_cmd
,
5657 show_remote_protocol_packet_cmd
,
5658 &remote_set_cmdlist
, &remote_show_cmdlist
,
5661 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
5662 "p", "fetch-register",
5663 set_remote_protocol_packet_cmd
,
5664 show_remote_protocol_packet_cmd
,
5665 &remote_set_cmdlist
, &remote_show_cmdlist
,
5668 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
5669 "Z0", "software-breakpoint",
5670 set_remote_protocol_packet_cmd
,
5671 show_remote_protocol_packet_cmd
,
5672 &remote_set_cmdlist
, &remote_show_cmdlist
,
5675 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
5676 "Z1", "hardware-breakpoint",
5677 set_remote_protocol_packet_cmd
,
5678 show_remote_protocol_packet_cmd
,
5679 &remote_set_cmdlist
, &remote_show_cmdlist
,
5682 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
5683 "Z2", "write-watchpoint",
5684 set_remote_protocol_packet_cmd
,
5685 show_remote_protocol_packet_cmd
,
5686 &remote_set_cmdlist
, &remote_show_cmdlist
,
5689 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
5690 "Z3", "read-watchpoint",
5691 set_remote_protocol_packet_cmd
,
5692 show_remote_protocol_packet_cmd
,
5693 &remote_set_cmdlist
, &remote_show_cmdlist
,
5696 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
5697 "Z4", "access-watchpoint",
5698 set_remote_protocol_packet_cmd
,
5699 show_remote_protocol_packet_cmd
,
5700 &remote_set_cmdlist
, &remote_show_cmdlist
,
5703 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qPart_auxv
],
5704 "qPart_auxv", "read-aux-vector",
5705 set_remote_protocol_packet_cmd
,
5706 show_remote_protocol_packet_cmd
,
5707 &remote_set_cmdlist
, &remote_show_cmdlist
,
5710 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
5711 "qGetTLSAddr", "get-thread-local-storage-address",
5712 set_remote_protocol_packet_cmd
,
5713 show_remote_protocol_packet_cmd
,
5714 &remote_set_cmdlist
, &remote_show_cmdlist
,
5717 /* Keep the old ``set remote Z-packet ...'' working. Each individual
5718 Z sub-packet has its own set and show commands, but users may
5719 have sets to this variable in their .gdbinit files (or in their
5721 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
5722 &remote_Z_packet_detect
, _("\
5723 Set use of remote protocol `Z' packets"), _("\
5724 Show use of remote protocol `Z' packets "), _("\
5725 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
5727 set_remote_protocol_Z_packet_cmd
,
5728 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
5729 &remote_set_cmdlist
, &remote_show_cmdlist
);
5731 /* Eventually initialize fileio. See fileio.c */
5732 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);