1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
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., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* See the GDB User Guide for details of the GDB remote protocol. */
27 #include "gdb_string.h"
34 /*#include "terminal.h" */
37 #include "gdb-stabs.h"
38 #include "gdbthread.h"
42 #include "gdb_assert.h"
47 #include <sys/types.h>
50 #include "event-loop.h"
51 #include "event-top.h"
57 #include "gdbcore.h" /* for exec_bfd */
59 #include "remote-fileio.h"
61 /* Prototypes for local functions */
62 static void cleanup_sigint_signal_handler (void *dummy
);
63 static void initialize_sigint_signal_handler (void);
64 static int getpkt_sane (char *buf
, long sizeof_buf
, int forever
);
66 static void handle_remote_sigint (int);
67 static void handle_remote_sigint_twice (int);
68 static void async_remote_interrupt (gdb_client_data
);
69 void async_remote_interrupt_twice (gdb_client_data
);
71 static void build_remote_gdbarch_data (void);
73 static void remote_files_info (struct target_ops
*ignore
);
75 static int remote_xfer_memory (CORE_ADDR memaddr
, char *myaddr
,
76 int len
, int should_write
,
77 struct mem_attrib
*attrib
,
78 struct target_ops
*target
);
80 static void remote_prepare_to_store (void);
82 static void remote_fetch_registers (int regno
);
84 static void remote_resume (ptid_t ptid
, int step
,
85 enum target_signal siggnal
);
86 static void remote_async_resume (ptid_t ptid
, int step
,
87 enum target_signal siggnal
);
88 static int remote_start_remote (struct ui_out
*uiout
, void *dummy
);
90 static void remote_open (char *name
, int from_tty
);
91 static void remote_async_open (char *name
, int from_tty
);
93 static void extended_remote_open (char *name
, int from_tty
);
94 static void extended_remote_async_open (char *name
, int from_tty
);
96 static void remote_open_1 (char *, int, struct target_ops
*, int extended_p
,
99 static void remote_close (int quitting
);
101 static void remote_store_registers (int regno
);
103 static void remote_mourn (void);
104 static void remote_async_mourn (void);
106 static void extended_remote_restart (void);
108 static void extended_remote_mourn (void);
110 static void extended_remote_create_inferior (char *, char *, char **);
111 static void extended_remote_async_create_inferior (char *, char *, char **);
113 static void remote_mourn_1 (struct target_ops
*);
115 static void remote_send (char *buf
, long sizeof_buf
);
117 static int readchar (int timeout
);
119 static ptid_t
remote_wait (ptid_t ptid
,
120 struct target_waitstatus
*status
);
121 static ptid_t
remote_async_wait (ptid_t ptid
,
122 struct target_waitstatus
*status
);
124 static void remote_kill (void);
125 static void remote_async_kill (void);
127 static int tohex (int nib
);
129 static void remote_detach (char *args
, int from_tty
);
131 static void remote_interrupt (int signo
);
133 static void remote_interrupt_twice (int signo
);
135 static void interrupt_query (void);
137 static void set_thread (int, int);
139 static int remote_thread_alive (ptid_t
);
141 static void get_offsets (void);
143 static long read_frame (char *buf
, long sizeof_buf
);
145 static int remote_insert_breakpoint (CORE_ADDR
, char *);
147 static int remote_remove_breakpoint (CORE_ADDR
, char *);
149 static int hexnumlen (ULONGEST num
);
151 static void init_remote_ops (void);
153 static void init_extended_remote_ops (void);
155 static void remote_stop (void);
157 static int ishex (int ch
, int *val
);
159 static int stubhex (int ch
);
161 static int hexnumstr (char *, ULONGEST
);
163 static int hexnumnstr (char *, ULONGEST
, int);
165 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
167 static void print_packet (char *);
169 static unsigned long crc32 (unsigned char *, int, unsigned int);
171 static void compare_sections_command (char *, int);
173 static void packet_command (char *, int);
175 static int stub_unpack_int (char *buff
, int fieldlength
);
177 static ptid_t
remote_current_thread (ptid_t oldptid
);
179 static void remote_find_new_threads (void);
181 static void record_currthread (int currthread
);
183 static int fromhex (int a
);
185 static int hex2bin (const char *hex
, char *bin
, int count
);
187 static int bin2hex (const char *bin
, char *hex
, int count
);
189 static int putpkt_binary (char *buf
, int cnt
);
191 static void check_binary_download (CORE_ADDR addr
);
193 struct packet_config
;
195 static void show_packet_config_cmd (struct packet_config
*config
);
197 static void update_packet_config (struct packet_config
*config
);
199 void _initialize_remote (void);
201 /* Description of the remote protocol. Strictly speaking, when the
202 target is open()ed, remote.c should create a per-target description
203 of the remote protocol using that target's architecture.
204 Unfortunately, the target stack doesn't include local state. For
205 the moment keep the information in the target's architecture
210 long offset
; /* Offset into G packet. */
211 long regnum
; /* GDB's internal register number. */
212 LONGEST pnum
; /* Remote protocol register number. */
213 int in_g_packet
; /* Always part of G packet. */
214 /* long size in bytes; == DEPRECATED_REGISTER_RAW_SIZE (regnum); at present. */
215 /* char *name; == REGISTER_NAME (regnum); at present. */
220 /* Description of the remote protocol registers. */
221 long sizeof_g_packet
;
223 /* Description of the remote protocol registers indexed by REGNUM
224 (making an array of NUM_REGS + NUM_PSEUDO_REGS in size). */
225 struct packet_reg
*regs
;
227 /* This is the size (in chars) of the first response to the ``g''
228 packet. It is used as a heuristic when determining the maximum
229 size of memory-read and memory-write packets. A target will
230 typically only reserve a buffer large enough to hold the ``g''
231 packet. The size does not include packet overhead (headers and
233 long actual_register_packet_size
;
235 /* This is the maximum size (in chars) of a non read/write packet.
236 It is also used as a cap on the size of read/write packets. */
237 long remote_packet_size
;
241 /* Handle for retreving the remote protocol data from gdbarch. */
242 static struct gdbarch_data
*remote_gdbarch_data_handle
;
244 static struct remote_state
*
245 get_remote_state (void)
247 return gdbarch_data (current_gdbarch
, remote_gdbarch_data_handle
);
251 init_remote_state (struct gdbarch
*gdbarch
)
254 struct remote_state
*rs
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_state
);
256 if (DEPRECATED_REGISTER_BYTES
!= 0)
257 rs
->sizeof_g_packet
= DEPRECATED_REGISTER_BYTES
;
259 rs
->sizeof_g_packet
= 0;
261 /* Assume a 1:1 regnum<->pnum table. */
262 rs
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
, NUM_REGS
+ NUM_PSEUDO_REGS
,
264 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
266 struct packet_reg
*r
= &rs
->regs
[regnum
];
269 r
->offset
= DEPRECATED_REGISTER_BYTE (regnum
);
270 r
->in_g_packet
= (regnum
< NUM_REGS
);
271 /* ...name = REGISTER_NAME (regnum); */
273 /* Compute packet size by accumulating the size of all registers. */
274 if (DEPRECATED_REGISTER_BYTES
== 0)
275 rs
->sizeof_g_packet
+= register_size (current_gdbarch
, regnum
);
278 /* Default maximum number of characters in a packet body. Many
279 remote stubs have a hardwired buffer size of 400 bytes
280 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
281 as the maximum packet-size to ensure that the packet and an extra
282 NUL character can always fit in the buffer. This stops GDB
283 trashing stubs that try to squeeze an extra NUL into what is
284 already a full buffer (As of 1999-12-04 that was most stubs. */
285 rs
->remote_packet_size
= 400 - 1;
287 /* Should rs->sizeof_g_packet needs more space than the
288 default, adjust the size accordingly. Remember that each byte is
289 encoded as two characters. 32 is the overhead for the packet
290 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
291 (``$NN:G...#NN'') is a better guess, the below has been padded a
293 if (rs
->sizeof_g_packet
> ((rs
->remote_packet_size
- 32) / 2))
294 rs
->remote_packet_size
= (rs
->sizeof_g_packet
* 2 + 32);
296 /* This one is filled in when a ``g'' packet is received. */
297 rs
->actual_register_packet_size
= 0;
302 static struct packet_reg
*
303 packet_reg_from_regnum (struct remote_state
*rs
, long regnum
)
305 if (regnum
< 0 && regnum
>= NUM_REGS
+ NUM_PSEUDO_REGS
)
309 struct packet_reg
*r
= &rs
->regs
[regnum
];
310 gdb_assert (r
->regnum
== regnum
);
315 static struct packet_reg
*
316 packet_reg_from_pnum (struct remote_state
*rs
, LONGEST pnum
)
319 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
321 struct packet_reg
*r
= &rs
->regs
[i
];
328 /* FIXME: graces/2002-08-08: These variables should eventually be
329 bound to an instance of the target object (as in gdbarch-tdep()),
330 when such a thing exists. */
332 /* This is set to the data address of the access causing the target
333 to stop for a watchpoint. */
334 static CORE_ADDR remote_watch_data_address
;
336 /* This is non-zero if taregt stopped for a watchpoint. */
337 static int remote_stopped_by_watchpoint_p
;
340 static struct target_ops remote_ops
;
342 static struct target_ops extended_remote_ops
;
344 /* Temporary target ops. Just like the remote_ops and
345 extended_remote_ops, but with asynchronous support. */
346 static struct target_ops remote_async_ops
;
348 static struct target_ops extended_async_remote_ops
;
350 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
351 ``forever'' still use the normal timeout mechanism. This is
352 currently used by the ASYNC code to guarentee that target reads
353 during the initial connect always time-out. Once getpkt has been
354 modified to return a timeout indication and, in turn
355 remote_wait()/wait_for_inferior() have gained a timeout parameter
357 static int wait_forever_enabled_p
= 1;
360 /* This variable chooses whether to send a ^C or a break when the user
361 requests program interruption. Although ^C is usually what remote
362 systems expect, and that is the default here, sometimes a break is
363 preferable instead. */
365 static int remote_break
;
367 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
368 remote_open knows that we don't have a file open when the program
370 static struct serial
*remote_desc
= NULL
;
372 /* This variable sets the number of bits in an address that are to be
373 sent in a memory ("M" or "m") packet. Normally, after stripping
374 leading zeros, the entire address would be sent. This variable
375 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
376 initial implementation of remote.c restricted the address sent in
377 memory packets to ``host::sizeof long'' bytes - (typically 32
378 bits). Consequently, for 64 bit targets, the upper 32 bits of an
379 address was never sent. Since fixing this bug may cause a break in
380 some remote targets this variable is principly provided to
381 facilitate backward compatibility. */
383 static int remote_address_size
;
385 /* Tempoary to track who currently owns the terminal. See
386 target_async_terminal_* for more details. */
388 static int remote_async_terminal_ours_p
;
391 /* User configurable variables for the number of characters in a
392 memory read/write packet. MIN ((rs->remote_packet_size),
393 rs->sizeof_g_packet) is the default. Some targets need smaller
394 values (fifo overruns, et.al.) and some users need larger values
395 (speed up transfers). The variables ``preferred_*'' (the user
396 request), ``current_*'' (what was actually set) and ``forced_*''
397 (Positive - a soft limit, negative - a hard limit). */
399 struct memory_packet_config
406 /* Compute the current size of a read/write packet. Since this makes
407 use of ``actual_register_packet_size'' the computation is dynamic. */
410 get_memory_packet_size (struct memory_packet_config
*config
)
412 struct remote_state
*rs
= get_remote_state ();
413 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
414 law?) that some hosts don't cope very well with large alloca()
415 calls. Eventually the alloca() code will be replaced by calls to
416 xmalloc() and make_cleanups() allowing this restriction to either
417 be lifted or removed. */
418 #ifndef MAX_REMOTE_PACKET_SIZE
419 #define MAX_REMOTE_PACKET_SIZE 16384
421 /* NOTE: 16 is just chosen at random. */
422 #ifndef MIN_REMOTE_PACKET_SIZE
423 #define MIN_REMOTE_PACKET_SIZE 16
428 if (config
->size
<= 0)
429 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
431 what_they_get
= config
->size
;
435 what_they_get
= (rs
->remote_packet_size
);
436 /* Limit the packet to the size specified by the user. */
438 && what_they_get
> config
->size
)
439 what_they_get
= config
->size
;
440 /* Limit it to the size of the targets ``g'' response. */
441 if ((rs
->actual_register_packet_size
) > 0
442 && what_they_get
> (rs
->actual_register_packet_size
))
443 what_they_get
= (rs
->actual_register_packet_size
);
445 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
446 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
447 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
448 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
449 return what_they_get
;
452 /* Update the size of a read/write packet. If they user wants
453 something really big then do a sanity check. */
456 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
458 int fixed_p
= config
->fixed_p
;
459 long size
= config
->size
;
461 error ("Argument required (integer, `fixed' or `limited').");
462 else if (strcmp (args
, "hard") == 0
463 || strcmp (args
, "fixed") == 0)
465 else if (strcmp (args
, "soft") == 0
466 || strcmp (args
, "limit") == 0)
471 size
= strtoul (args
, &end
, 0);
473 error ("Invalid %s (bad syntax).", config
->name
);
475 /* Instead of explicitly capping the size of a packet to
476 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
477 instead allowed to set the size to something arbitrarily
479 if (size
> MAX_REMOTE_PACKET_SIZE
)
480 error ("Invalid %s (too large).", config
->name
);
484 if (fixed_p
&& !config
->fixed_p
)
486 if (! query ("The target may not be able to correctly handle a %s\n"
487 "of %ld bytes. Change the packet size? ",
489 error ("Packet size not changed.");
491 /* Update the config. */
492 config
->fixed_p
= fixed_p
;
497 show_memory_packet_size (struct memory_packet_config
*config
)
499 printf_filtered ("The %s is %ld. ", config
->name
, config
->size
);
501 printf_filtered ("Packets are fixed at %ld bytes.\n",
502 get_memory_packet_size (config
));
504 printf_filtered ("Packets are limited to %ld bytes.\n",
505 get_memory_packet_size (config
));
508 static struct memory_packet_config memory_write_packet_config
=
510 "memory-write-packet-size",
514 set_memory_write_packet_size (char *args
, int from_tty
)
516 set_memory_packet_size (args
, &memory_write_packet_config
);
520 show_memory_write_packet_size (char *args
, int from_tty
)
522 show_memory_packet_size (&memory_write_packet_config
);
526 get_memory_write_packet_size (void)
528 return get_memory_packet_size (&memory_write_packet_config
);
531 static struct memory_packet_config memory_read_packet_config
=
533 "memory-read-packet-size",
537 set_memory_read_packet_size (char *args
, int from_tty
)
539 set_memory_packet_size (args
, &memory_read_packet_config
);
543 show_memory_read_packet_size (char *args
, int from_tty
)
545 show_memory_packet_size (&memory_read_packet_config
);
549 get_memory_read_packet_size (void)
551 struct remote_state
*rs
= get_remote_state ();
552 long size
= get_memory_packet_size (&memory_read_packet_config
);
553 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
554 extra buffer size argument before the memory read size can be
555 increased beyond (rs->remote_packet_size). */
556 if (size
> (rs
->remote_packet_size
))
557 size
= (rs
->remote_packet_size
);
562 /* Generic configuration support for packets the stub optionally
563 supports. Allows the user to specify the use of the packet as well
564 as allowing GDB to auto-detect support in the remote stub. */
568 PACKET_SUPPORT_UNKNOWN
= 0,
577 enum auto_boolean detect
;
578 enum packet_support support
;
581 /* Analyze a packet's return value and update the packet config
592 update_packet_config (struct packet_config
*config
)
594 switch (config
->detect
)
596 case AUTO_BOOLEAN_TRUE
:
597 config
->support
= PACKET_ENABLE
;
599 case AUTO_BOOLEAN_FALSE
:
600 config
->support
= PACKET_DISABLE
;
602 case AUTO_BOOLEAN_AUTO
:
603 config
->support
= PACKET_SUPPORT_UNKNOWN
;
609 show_packet_config_cmd (struct packet_config
*config
)
611 char *support
= "internal-error";
612 switch (config
->support
)
618 support
= "disabled";
620 case PACKET_SUPPORT_UNKNOWN
:
624 switch (config
->detect
)
626 case AUTO_BOOLEAN_AUTO
:
627 printf_filtered ("Support for remote protocol `%s' (%s) packet is auto-detected, currently %s.\n",
628 config
->name
, config
->title
, support
);
630 case AUTO_BOOLEAN_TRUE
:
631 case AUTO_BOOLEAN_FALSE
:
632 printf_filtered ("Support for remote protocol `%s' (%s) packet is currently %s.\n",
633 config
->name
, config
->title
, support
);
639 add_packet_config_cmd (struct packet_config
*config
,
642 cmd_sfunc_ftype
*set_func
,
643 cmd_sfunc_ftype
*show_func
,
644 struct cmd_list_element
**set_remote_list
,
645 struct cmd_list_element
**show_remote_list
,
648 struct cmd_list_element
*set_cmd
;
649 struct cmd_list_element
*show_cmd
;
654 config
->title
= title
;
655 config
->detect
= AUTO_BOOLEAN_AUTO
;
656 config
->support
= PACKET_SUPPORT_UNKNOWN
;
657 xasprintf (&set_doc
, "Set use of remote protocol `%s' (%s) packet",
659 xasprintf (&show_doc
, "Show current use of remote protocol `%s' (%s) packet",
661 /* set/show TITLE-packet {auto,on,off} */
662 xasprintf (&cmd_name
, "%s-packet", title
);
663 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
664 &config
->detect
, set_doc
, show_doc
,
666 set_remote_list
, show_remote_list
);
667 /* set/show remote NAME-packet {auto,on,off} -- legacy */
671 xasprintf (&legacy_name
, "%s-packet", name
);
672 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
674 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
679 static enum packet_result
680 packet_ok (const char *buf
, struct packet_config
*config
)
684 /* The stub recognized the packet request. Check that the
685 operation succeeded. */
686 switch (config
->support
)
688 case PACKET_SUPPORT_UNKNOWN
:
690 fprintf_unfiltered (gdb_stdlog
,
691 "Packet %s (%s) is supported\n",
692 config
->name
, config
->title
);
693 config
->support
= PACKET_ENABLE
;
696 internal_error (__FILE__
, __LINE__
,
697 "packet_ok: attempt to use a disabled packet");
702 if (buf
[0] == 'O' && buf
[1] == 'K' && buf
[2] == '\0')
703 /* "OK" - definitly OK. */
706 && isxdigit (buf
[1]) && isxdigit (buf
[2])
708 /* "Enn" - definitly an error. */
710 /* The packet may or may not be OK. Just assume it is */
715 /* The stub does not support the packet. */
716 switch (config
->support
)
719 if (config
->detect
== AUTO_BOOLEAN_AUTO
)
720 /* If the stub previously indicated that the packet was
721 supported then there is a protocol error.. */
722 error ("Protocol error: %s (%s) conflicting enabled responses.",
723 config
->name
, config
->title
);
725 /* The user set it wrong. */
726 error ("Enabled packet %s (%s) not recognized by stub",
727 config
->name
, config
->title
);
729 case PACKET_SUPPORT_UNKNOWN
:
731 fprintf_unfiltered (gdb_stdlog
,
732 "Packet %s (%s) is NOT supported\n",
733 config
->name
, config
->title
);
734 config
->support
= PACKET_DISABLE
;
739 return PACKET_UNKNOWN
;
743 /* Should we try the 'vCont' (descriptive resume) request? */
744 static struct packet_config remote_protocol_vcont
;
747 set_remote_protocol_vcont_packet_cmd (char *args
, int from_tty
,
748 struct cmd_list_element
*c
)
750 update_packet_config (&remote_protocol_vcont
);
754 show_remote_protocol_vcont_packet_cmd (char *args
, int from_tty
,
755 struct cmd_list_element
*c
)
757 show_packet_config_cmd (&remote_protocol_vcont
);
760 /* Should we try the 'qSymbol' (target symbol lookup service) request? */
761 static struct packet_config remote_protocol_qSymbol
;
764 set_remote_protocol_qSymbol_packet_cmd (char *args
, int from_tty
,
765 struct cmd_list_element
*c
)
767 update_packet_config (&remote_protocol_qSymbol
);
771 show_remote_protocol_qSymbol_packet_cmd (char *args
, int from_tty
,
772 struct cmd_list_element
*c
)
774 show_packet_config_cmd (&remote_protocol_qSymbol
);
777 /* Should we try the 'e' (step over range) request? */
778 static struct packet_config remote_protocol_e
;
781 set_remote_protocol_e_packet_cmd (char *args
, int from_tty
,
782 struct cmd_list_element
*c
)
784 update_packet_config (&remote_protocol_e
);
788 show_remote_protocol_e_packet_cmd (char *args
, int from_tty
,
789 struct cmd_list_element
*c
)
791 show_packet_config_cmd (&remote_protocol_e
);
795 /* Should we try the 'E' (step over range / w signal #) request? */
796 static struct packet_config remote_protocol_E
;
799 set_remote_protocol_E_packet_cmd (char *args
, int from_tty
,
800 struct cmd_list_element
*c
)
802 update_packet_config (&remote_protocol_E
);
806 show_remote_protocol_E_packet_cmd (char *args
, int from_tty
,
807 struct cmd_list_element
*c
)
809 show_packet_config_cmd (&remote_protocol_E
);
813 /* Should we try the 'P' (set register) request? */
815 static struct packet_config remote_protocol_P
;
818 set_remote_protocol_P_packet_cmd (char *args
, int from_tty
,
819 struct cmd_list_element
*c
)
821 update_packet_config (&remote_protocol_P
);
825 show_remote_protocol_P_packet_cmd (char *args
, int from_tty
,
826 struct cmd_list_element
*c
)
828 show_packet_config_cmd (&remote_protocol_P
);
831 /* Should we try one of the 'Z' requests? */
835 Z_PACKET_SOFTWARE_BP
,
836 Z_PACKET_HARDWARE_BP
,
843 static struct packet_config remote_protocol_Z
[NR_Z_PACKET_TYPES
];
845 /* FIXME: Instead of having all these boiler plate functions, the
846 command callback should include a context argument. */
849 set_remote_protocol_Z_software_bp_packet_cmd (char *args
, int from_tty
,
850 struct cmd_list_element
*c
)
852 update_packet_config (&remote_protocol_Z
[Z_PACKET_SOFTWARE_BP
]);
856 show_remote_protocol_Z_software_bp_packet_cmd (char *args
, int from_tty
,
857 struct cmd_list_element
*c
)
859 show_packet_config_cmd (&remote_protocol_Z
[Z_PACKET_SOFTWARE_BP
]);
863 set_remote_protocol_Z_hardware_bp_packet_cmd (char *args
, int from_tty
,
864 struct cmd_list_element
*c
)
866 update_packet_config (&remote_protocol_Z
[Z_PACKET_HARDWARE_BP
]);
870 show_remote_protocol_Z_hardware_bp_packet_cmd (char *args
, int from_tty
,
871 struct cmd_list_element
*c
)
873 show_packet_config_cmd (&remote_protocol_Z
[Z_PACKET_HARDWARE_BP
]);
877 set_remote_protocol_Z_write_wp_packet_cmd (char *args
, int from_tty
,
878 struct cmd_list_element
*c
)
880 update_packet_config (&remote_protocol_Z
[Z_PACKET_WRITE_WP
]);
884 show_remote_protocol_Z_write_wp_packet_cmd (char *args
, int from_tty
,
885 struct cmd_list_element
*c
)
887 show_packet_config_cmd (&remote_protocol_Z
[Z_PACKET_WRITE_WP
]);
891 set_remote_protocol_Z_read_wp_packet_cmd (char *args
, int from_tty
,
892 struct cmd_list_element
*c
)
894 update_packet_config (&remote_protocol_Z
[Z_PACKET_READ_WP
]);
898 show_remote_protocol_Z_read_wp_packet_cmd (char *args
, int from_tty
,
899 struct cmd_list_element
*c
)
901 show_packet_config_cmd (&remote_protocol_Z
[Z_PACKET_READ_WP
]);
905 set_remote_protocol_Z_access_wp_packet_cmd (char *args
, int from_tty
,
906 struct cmd_list_element
*c
)
908 update_packet_config (&remote_protocol_Z
[Z_PACKET_ACCESS_WP
]);
912 show_remote_protocol_Z_access_wp_packet_cmd (char *args
, int from_tty
,
913 struct cmd_list_element
*c
)
915 show_packet_config_cmd (&remote_protocol_Z
[Z_PACKET_ACCESS_WP
]);
918 /* For compatibility with older distributions. Provide a ``set remote
919 Z-packet ...'' command that updates all the Z packet types. */
921 static enum auto_boolean remote_Z_packet_detect
;
924 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
925 struct cmd_list_element
*c
)
928 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
930 remote_protocol_Z
[i
].detect
= remote_Z_packet_detect
;
931 update_packet_config (&remote_protocol_Z
[i
]);
936 show_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
937 struct cmd_list_element
*c
)
940 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
942 show_packet_config_cmd (&remote_protocol_Z
[i
]);
946 /* Should we try the 'X' (remote binary download) packet?
948 This variable (available to the user via "set remote X-packet")
949 dictates whether downloads are sent in binary (via the 'X' packet).
950 We assume that the stub can, and attempt to do it. This will be
951 cleared if the stub does not understand it. This switch is still
952 needed, though in cases when the packet is supported in the stub,
953 but the connection does not allow it (i.e., 7-bit serial connection
956 static struct packet_config remote_protocol_binary_download
;
958 /* Should we try the 'ThreadInfo' query packet?
960 This variable (NOT available to the user: auto-detect only!)
961 determines whether GDB will use the new, simpler "ThreadInfo"
962 query or the older, more complex syntax for thread queries.
963 This is an auto-detect variable (set to true at each connect,
964 and set to false when the target fails to recognize it). */
966 static int use_threadinfo_query
;
967 static int use_threadextra_query
;
970 set_remote_protocol_binary_download_cmd (char *args
,
972 struct cmd_list_element
*c
)
974 update_packet_config (&remote_protocol_binary_download
);
978 show_remote_protocol_binary_download_cmd (char *args
, int from_tty
,
979 struct cmd_list_element
*c
)
981 show_packet_config_cmd (&remote_protocol_binary_download
);
984 /* Should we try the 'qPart:auxv' (target auxiliary vector read) request? */
985 static struct packet_config remote_protocol_qPart_auxv
;
988 set_remote_protocol_qPart_auxv_packet_cmd (char *args
, int from_tty
,
989 struct cmd_list_element
*c
)
991 update_packet_config (&remote_protocol_qPart_auxv
);
995 show_remote_protocol_qPart_auxv_packet_cmd (char *args
, int from_tty
,
996 struct cmd_list_element
*c
)
998 show_packet_config_cmd (&remote_protocol_qPart_auxv
);
1002 /* Tokens for use by the asynchronous signal handlers for SIGINT */
1003 static void *sigint_remote_twice_token
;
1004 static void *sigint_remote_token
;
1006 /* These are pointers to hook functions that may be set in order to
1007 modify resume/wait behavior for a particular architecture. */
1009 void (*target_resume_hook
) (void);
1010 void (*target_wait_loop_hook
) (void);
1014 /* These are the threads which we last sent to the remote system.
1015 -1 for all or -2 for not sent yet. */
1016 static int general_thread
;
1017 static int continue_thread
;
1019 /* Call this function as a result of
1020 1) A halt indication (T packet) containing a thread id
1021 2) A direct query of currthread
1022 3) Successful execution of set thread
1026 record_currthread (int currthread
)
1028 general_thread
= currthread
;
1030 /* If this is a new thread, add it to GDB's thread list.
1031 If we leave it up to WFI to do this, bad things will happen. */
1032 if (!in_thread_list (pid_to_ptid (currthread
)))
1034 add_thread (pid_to_ptid (currthread
));
1035 ui_out_text (uiout
, "[New ");
1036 ui_out_text (uiout
, target_pid_to_str (pid_to_ptid (currthread
)));
1037 ui_out_text (uiout
, "]\n");
1041 #define MAGIC_NULL_PID 42000
1044 set_thread (int th
, int gen
)
1046 struct remote_state
*rs
= get_remote_state ();
1047 char *buf
= alloca (rs
->remote_packet_size
);
1048 int state
= gen
? general_thread
: continue_thread
;
1054 buf
[1] = gen
? 'g' : 'c';
1055 if (th
== MAGIC_NULL_PID
)
1061 sprintf (&buf
[2], "-%x", -th
);
1063 sprintf (&buf
[2], "%x", th
);
1065 getpkt (buf
, (rs
->remote_packet_size
), 0);
1067 general_thread
= th
;
1069 continue_thread
= th
;
1072 /* Return nonzero if the thread TH is still alive on the remote system. */
1075 remote_thread_alive (ptid_t ptid
)
1077 int tid
= PIDGET (ptid
);
1081 sprintf (buf
, "T-%08x", -tid
);
1083 sprintf (buf
, "T%08x", tid
);
1085 getpkt (buf
, sizeof (buf
), 0);
1086 return (buf
[0] == 'O' && buf
[1] == 'K');
1089 /* About these extended threadlist and threadinfo packets. They are
1090 variable length packets but, the fields within them are often fixed
1091 length. They are redundent enough to send over UDP as is the
1092 remote protocol in general. There is a matching unit test module
1095 #define OPAQUETHREADBYTES 8
1097 /* a 64 bit opaque identifier */
1098 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
1100 /* WARNING: This threadref data structure comes from the remote O.S., libstub
1101 protocol encoding, and remote.c. it is not particularly changable */
1103 /* Right now, the internal structure is int. We want it to be bigger.
1107 typedef int gdb_threadref
; /* internal GDB thread reference */
1109 /* gdb_ext_thread_info is an internal GDB data structure which is
1110 equivalint to the reply of the remote threadinfo packet */
1112 struct gdb_ext_thread_info
1114 threadref threadid
; /* External form of thread reference */
1115 int active
; /* Has state interesting to GDB? , regs, stack */
1116 char display
[256]; /* Brief state display, name, blocked/syspended */
1117 char shortname
[32]; /* To be used to name threads */
1118 char more_display
[256]; /* Long info, statistics, queue depth, whatever */
1121 /* The volume of remote transfers can be limited by submitting
1122 a mask containing bits specifying the desired information.
1123 Use a union of these values as the 'selection' parameter to
1124 get_thread_info. FIXME: Make these TAG names more thread specific.
1127 #define TAG_THREADID 1
1128 #define TAG_EXISTS 2
1129 #define TAG_DISPLAY 4
1130 #define TAG_THREADNAME 8
1131 #define TAG_MOREDISPLAY 16
1133 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES*2)
1135 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1137 static char *unpack_nibble (char *buf
, int *val
);
1139 static char *pack_nibble (char *buf
, int nibble
);
1141 static char *pack_hex_byte (char *pkt
, int /*unsigned char */ byte
);
1143 static char *unpack_byte (char *buf
, int *value
);
1145 static char *pack_int (char *buf
, int value
);
1147 static char *unpack_int (char *buf
, int *value
);
1149 static char *unpack_string (char *src
, char *dest
, int length
);
1151 static char *pack_threadid (char *pkt
, threadref
* id
);
1153 static char *unpack_threadid (char *inbuf
, threadref
* id
);
1155 void int_to_threadref (threadref
* id
, int value
);
1157 static int threadref_to_int (threadref
* ref
);
1159 static void copy_threadref (threadref
* dest
, threadref
* src
);
1161 static int threadmatch (threadref
* dest
, threadref
* src
);
1163 static char *pack_threadinfo_request (char *pkt
, int mode
, threadref
* id
);
1165 static int remote_unpack_thread_info_response (char *pkt
,
1166 threadref
* expectedref
,
1167 struct gdb_ext_thread_info
1171 static int remote_get_threadinfo (threadref
* threadid
, int fieldset
, /*TAG mask */
1172 struct gdb_ext_thread_info
*info
);
1174 static char *pack_threadlist_request (char *pkt
, int startflag
,
1176 threadref
* nextthread
);
1178 static int parse_threadlist_response (char *pkt
,
1180 threadref
* original_echo
,
1181 threadref
* resultlist
, int *doneflag
);
1183 static int remote_get_threadlist (int startflag
,
1184 threadref
* nextthread
,
1187 int *result_count
, threadref
* threadlist
);
1189 typedef int (*rmt_thread_action
) (threadref
* ref
, void *context
);
1191 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
1192 void *context
, int looplimit
);
1194 static int remote_newthread_step (threadref
* ref
, void *context
);
1196 /* encode 64 bits in 16 chars of hex */
1198 static const char hexchars
[] = "0123456789abcdef";
1201 ishex (int ch
, int *val
)
1203 if ((ch
>= 'a') && (ch
<= 'f'))
1205 *val
= ch
- 'a' + 10;
1208 if ((ch
>= 'A') && (ch
<= 'F'))
1210 *val
= ch
- 'A' + 10;
1213 if ((ch
>= '0') && (ch
<= '9'))
1224 if (ch
>= 'a' && ch
<= 'f')
1225 return ch
- 'a' + 10;
1226 if (ch
>= '0' && ch
<= '9')
1228 if (ch
>= 'A' && ch
<= 'F')
1229 return ch
- 'A' + 10;
1234 stub_unpack_int (char *buff
, int fieldlength
)
1241 nibble
= stubhex (*buff
++);
1245 retval
= retval
<< 4;
1251 unpack_varlen_hex (char *buff
, /* packet to parse */
1257 while (ishex (*buff
, &nibble
))
1260 retval
= retval
<< 4;
1261 retval
|= nibble
& 0x0f;
1268 unpack_nibble (char *buf
, int *val
)
1270 ishex (*buf
++, val
);
1275 pack_nibble (char *buf
, int nibble
)
1277 *buf
++ = hexchars
[(nibble
& 0x0f)];
1282 pack_hex_byte (char *pkt
, int byte
)
1284 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
1285 *pkt
++ = hexchars
[(byte
& 0xf)];
1290 unpack_byte (char *buf
, int *value
)
1292 *value
= stub_unpack_int (buf
, 2);
1297 pack_int (char *buf
, int value
)
1299 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
1300 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
1301 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
1302 buf
= pack_hex_byte (buf
, (value
& 0xff));
1307 unpack_int (char *buf
, int *value
)
1309 *value
= stub_unpack_int (buf
, 8);
1313 #if 0 /* currently unused, uncomment when needed */
1314 static char *pack_string (char *pkt
, char *string
);
1317 pack_string (char *pkt
, char *string
)
1322 len
= strlen (string
);
1324 len
= 200; /* Bigger than most GDB packets, junk??? */
1325 pkt
= pack_hex_byte (pkt
, len
);
1329 if ((ch
== '\0') || (ch
== '#'))
1330 ch
= '*'; /* Protect encapsulation */
1335 #endif /* 0 (unused) */
1338 unpack_string (char *src
, char *dest
, int length
)
1347 pack_threadid (char *pkt
, threadref
*id
)
1350 unsigned char *altid
;
1352 altid
= (unsigned char *) id
;
1353 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
1355 pkt
= pack_hex_byte (pkt
, *altid
++);
1361 unpack_threadid (char *inbuf
, threadref
*id
)
1364 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
1367 altref
= (char *) id
;
1369 while (inbuf
< limit
)
1371 x
= stubhex (*inbuf
++);
1372 y
= stubhex (*inbuf
++);
1373 *altref
++ = (x
<< 4) | y
;
1378 /* Externally, threadrefs are 64 bits but internally, they are still
1379 ints. This is due to a mismatch of specifications. We would like
1380 to use 64bit thread references internally. This is an adapter
1384 int_to_threadref (threadref
*id
, int value
)
1386 unsigned char *scan
;
1388 scan
= (unsigned char *) id
;
1394 *scan
++ = (value
>> 24) & 0xff;
1395 *scan
++ = (value
>> 16) & 0xff;
1396 *scan
++ = (value
>> 8) & 0xff;
1397 *scan
++ = (value
& 0xff);
1401 threadref_to_int (threadref
*ref
)
1404 unsigned char *scan
;
1406 scan
= (char *) ref
;
1410 value
= (value
<< 8) | ((*scan
++) & 0xff);
1415 copy_threadref (threadref
*dest
, threadref
*src
)
1418 unsigned char *csrc
, *cdest
;
1420 csrc
= (unsigned char *) src
;
1421 cdest
= (unsigned char *) dest
;
1428 threadmatch (threadref
*dest
, threadref
*src
)
1430 /* things are broken right now, so just assume we got a match */
1432 unsigned char *srcp
, *destp
;
1434 srcp
= (char *) src
;
1435 destp
= (char *) dest
;
1439 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
1446 threadid:1, # always request threadid
1453 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1456 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
1458 *pkt
++ = 'q'; /* Info Query */
1459 *pkt
++ = 'P'; /* process or thread info */
1460 pkt
= pack_int (pkt
, mode
); /* mode */
1461 pkt
= pack_threadid (pkt
, id
); /* threadid */
1462 *pkt
= '\0'; /* terminate */
1466 /* These values tag the fields in a thread info response packet */
1467 /* Tagging the fields allows us to request specific fields and to
1468 add more fields as time goes by */
1470 #define TAG_THREADID 1 /* Echo the thread identifier */
1471 #define TAG_EXISTS 2 /* Is this process defined enough to
1472 fetch registers and its stack */
1473 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1474 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is */
1475 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1479 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
1480 struct gdb_ext_thread_info
*info
)
1482 struct remote_state
*rs
= get_remote_state ();
1486 char *limit
= pkt
+ (rs
->remote_packet_size
); /* plausable parsing limit */
1489 /* info->threadid = 0; FIXME: implement zero_threadref */
1491 info
->display
[0] = '\0';
1492 info
->shortname
[0] = '\0';
1493 info
->more_display
[0] = '\0';
1495 /* Assume the characters indicating the packet type have been stripped */
1496 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
1497 pkt
= unpack_threadid (pkt
, &ref
);
1500 warning ("Incomplete response to threadinfo request\n");
1501 if (!threadmatch (&ref
, expectedref
))
1502 { /* This is an answer to a different request */
1503 warning ("ERROR RMT Thread info mismatch\n");
1506 copy_threadref (&info
->threadid
, &ref
);
1508 /* Loop on tagged fields , try to bail if somthing goes wrong */
1510 while ((pkt
< limit
) && mask
&& *pkt
) /* packets are terminated with nulls */
1512 pkt
= unpack_int (pkt
, &tag
); /* tag */
1513 pkt
= unpack_byte (pkt
, &length
); /* length */
1514 if (!(tag
& mask
)) /* tags out of synch with mask */
1516 warning ("ERROR RMT: threadinfo tag mismatch\n");
1520 if (tag
== TAG_THREADID
)
1524 warning ("ERROR RMT: length of threadid is not 16\n");
1528 pkt
= unpack_threadid (pkt
, &ref
);
1529 mask
= mask
& ~TAG_THREADID
;
1532 if (tag
== TAG_EXISTS
)
1534 info
->active
= stub_unpack_int (pkt
, length
);
1536 mask
= mask
& ~(TAG_EXISTS
);
1539 warning ("ERROR RMT: 'exists' length too long\n");
1545 if (tag
== TAG_THREADNAME
)
1547 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
1548 mask
= mask
& ~TAG_THREADNAME
;
1551 if (tag
== TAG_DISPLAY
)
1553 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
1554 mask
= mask
& ~TAG_DISPLAY
;
1557 if (tag
== TAG_MOREDISPLAY
)
1559 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
1560 mask
= mask
& ~TAG_MOREDISPLAY
;
1563 warning ("ERROR RMT: unknown thread info tag\n");
1564 break; /* Not a tag we know about */
1570 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
1571 struct gdb_ext_thread_info
*info
)
1573 struct remote_state
*rs
= get_remote_state ();
1575 char *threadinfo_pkt
= alloca (rs
->remote_packet_size
);
1577 pack_threadinfo_request (threadinfo_pkt
, fieldset
, threadid
);
1578 putpkt (threadinfo_pkt
);
1579 getpkt (threadinfo_pkt
, (rs
->remote_packet_size
), 0);
1580 result
= remote_unpack_thread_info_response (threadinfo_pkt
+ 2, threadid
,
1585 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1588 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
1589 threadref
*nextthread
)
1591 *pkt
++ = 'q'; /* info query packet */
1592 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
1593 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
1594 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
1595 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
1600 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1603 parse_threadlist_response (char *pkt
, int result_limit
,
1604 threadref
*original_echo
, threadref
*resultlist
,
1607 struct remote_state
*rs
= get_remote_state ();
1609 int count
, resultcount
, done
;
1612 /* Assume the 'q' and 'M chars have been stripped. */
1613 limit
= pkt
+ ((rs
->remote_packet_size
) - BUF_THREAD_ID_SIZE
); /* done parse past here */
1614 pkt
= unpack_byte (pkt
, &count
); /* count field */
1615 pkt
= unpack_nibble (pkt
, &done
);
1616 /* The first threadid is the argument threadid. */
1617 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
1618 while ((count
-- > 0) && (pkt
< limit
))
1620 pkt
= unpack_threadid (pkt
, resultlist
++);
1621 if (resultcount
++ >= result_limit
)
1630 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
1631 int *done
, int *result_count
, threadref
*threadlist
)
1633 struct remote_state
*rs
= get_remote_state ();
1634 static threadref echo_nextthread
;
1635 char *threadlist_packet
= alloca (rs
->remote_packet_size
);
1636 char *t_response
= alloca (rs
->remote_packet_size
);
1639 /* Trancate result limit to be smaller than the packet size */
1640 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10) >= (rs
->remote_packet_size
))
1641 result_limit
= ((rs
->remote_packet_size
) / BUF_THREAD_ID_SIZE
) - 2;
1643 pack_threadlist_request (threadlist_packet
,
1644 startflag
, result_limit
, nextthread
);
1645 putpkt (threadlist_packet
);
1646 getpkt (t_response
, (rs
->remote_packet_size
), 0);
1649 parse_threadlist_response (t_response
+ 2, result_limit
, &echo_nextthread
,
1652 if (!threadmatch (&echo_nextthread
, nextthread
))
1654 /* FIXME: This is a good reason to drop the packet */
1655 /* Possably, there is a duplicate response */
1657 retransmit immediatly - race conditions
1658 retransmit after timeout - yes
1660 wait for packet, then exit
1662 warning ("HMM: threadlist did not echo arg thread, dropping it\n");
1663 return 0; /* I choose simply exiting */
1665 if (*result_count
<= 0)
1669 warning ("RMT ERROR : failed to get remote thread list\n");
1672 return result
; /* break; */
1674 if (*result_count
> result_limit
)
1677 warning ("RMT ERROR: threadlist response longer than requested\n");
1683 /* This is the interface between remote and threads, remotes upper interface */
1685 /* remote_find_new_threads retrieves the thread list and for each
1686 thread in the list, looks up the thread in GDB's internal list,
1687 ading the thread if it does not already exist. This involves
1688 getting partial thread lists from the remote target so, polling the
1689 quit_flag is required. */
1692 /* About this many threadisds fit in a packet. */
1694 #define MAXTHREADLISTRESULTS 32
1697 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
1700 int done
, i
, result_count
;
1704 static threadref nextthread
;
1705 static threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
1710 if (loopcount
++ > looplimit
)
1713 warning ("Remote fetch threadlist -infinite loop-\n");
1716 if (!remote_get_threadlist (startflag
, &nextthread
, MAXTHREADLISTRESULTS
,
1717 &done
, &result_count
, resultthreadlist
))
1722 /* clear for later iterations */
1724 /* Setup to resume next batch of thread references, set nextthread. */
1725 if (result_count
>= 1)
1726 copy_threadref (&nextthread
, &resultthreadlist
[result_count
- 1]);
1728 while (result_count
--)
1729 if (!(result
= (*stepfunction
) (&resultthreadlist
[i
++], context
)))
1736 remote_newthread_step (threadref
*ref
, void *context
)
1740 ptid
= pid_to_ptid (threadref_to_int (ref
));
1742 if (!in_thread_list (ptid
))
1744 return 1; /* continue iterator */
1747 #define CRAZY_MAX_THREADS 1000
1750 remote_current_thread (ptid_t oldpid
)
1752 struct remote_state
*rs
= get_remote_state ();
1753 char *buf
= alloca (rs
->remote_packet_size
);
1756 getpkt (buf
, (rs
->remote_packet_size
), 0);
1757 if (buf
[0] == 'Q' && buf
[1] == 'C')
1758 return pid_to_ptid (strtol (&buf
[2], NULL
, 16));
1763 /* Find new threads for info threads command.
1764 * Original version, using John Metzler's thread protocol.
1768 remote_find_new_threads (void)
1770 remote_threadlist_iterator (remote_newthread_step
, 0,
1772 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
) /* ack ack ack */
1773 inferior_ptid
= remote_current_thread (inferior_ptid
);
1777 * Find all threads for info threads command.
1778 * Uses new thread protocol contributed by Cisco.
1779 * Falls back and attempts to use the older method (above)
1780 * if the target doesn't respond to the new method.
1784 remote_threads_info (void)
1786 struct remote_state
*rs
= get_remote_state ();
1787 char *buf
= alloca (rs
->remote_packet_size
);
1791 if (remote_desc
== 0) /* paranoia */
1792 error ("Command can only be used when connected to the remote target.");
1794 if (use_threadinfo_query
)
1796 putpkt ("qfThreadInfo");
1798 getpkt (bufp
, (rs
->remote_packet_size
), 0);
1799 if (bufp
[0] != '\0') /* q packet recognized */
1801 while (*bufp
++ == 'm') /* reply contains one or more TID */
1805 tid
= strtol (bufp
, &bufp
, 16);
1806 if (tid
!= 0 && !in_thread_list (pid_to_ptid (tid
)))
1807 add_thread (pid_to_ptid (tid
));
1809 while (*bufp
++ == ','); /* comma-separated list */
1810 putpkt ("qsThreadInfo");
1812 getpkt (bufp
, (rs
->remote_packet_size
), 0);
1818 /* Else fall back to old method based on jmetzler protocol. */
1819 use_threadinfo_query
= 0;
1820 remote_find_new_threads ();
1825 * Collect a descriptive string about the given thread.
1826 * The target may say anything it wants to about the thread
1827 * (typically info about its blocked / runnable state, name, etc.).
1828 * This string will appear in the info threads display.
1830 * Optional: targets are not required to implement this function.
1834 remote_threads_extra_info (struct thread_info
*tp
)
1836 struct remote_state
*rs
= get_remote_state ();
1840 struct gdb_ext_thread_info threadinfo
;
1841 static char display_buf
[100]; /* arbitrary... */
1842 char *bufp
= alloca (rs
->remote_packet_size
);
1843 int n
= 0; /* position in display_buf */
1845 if (remote_desc
== 0) /* paranoia */
1846 internal_error (__FILE__
, __LINE__
,
1847 "remote_threads_extra_info");
1849 if (use_threadextra_query
)
1851 sprintf (bufp
, "qThreadExtraInfo,%x", PIDGET (tp
->ptid
));
1853 getpkt (bufp
, (rs
->remote_packet_size
), 0);
1856 n
= min (strlen (bufp
) / 2, sizeof (display_buf
));
1857 result
= hex2bin (bufp
, display_buf
, n
);
1858 display_buf
[result
] = '\0';
1863 /* If the above query fails, fall back to the old method. */
1864 use_threadextra_query
= 0;
1865 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
1866 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
1867 int_to_threadref (&id
, PIDGET (tp
->ptid
));
1868 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
1869 if (threadinfo
.active
)
1871 if (*threadinfo
.shortname
)
1872 n
+= sprintf(&display_buf
[0], " Name: %s,", threadinfo
.shortname
);
1873 if (*threadinfo
.display
)
1874 n
+= sprintf(&display_buf
[n
], " State: %s,", threadinfo
.display
);
1875 if (*threadinfo
.more_display
)
1876 n
+= sprintf(&display_buf
[n
], " Priority: %s",
1877 threadinfo
.more_display
);
1881 /* for purely cosmetic reasons, clear up trailing commas */
1882 if (',' == display_buf
[n
-1])
1883 display_buf
[n
-1] = ' ';
1892 /* Restart the remote side; this is an extended protocol operation. */
1895 extended_remote_restart (void)
1897 struct remote_state
*rs
= get_remote_state ();
1898 char *buf
= alloca (rs
->remote_packet_size
);
1900 /* Send the restart command; for reasons I don't understand the
1901 remote side really expects a number after the "R". */
1903 sprintf (&buf
[1], "%x", 0);
1906 /* Now query for status so this looks just like we restarted
1907 gdbserver from scratch. */
1909 getpkt (buf
, (rs
->remote_packet_size
), 0);
1912 /* Clean up connection to a remote debugger. */
1915 remote_close (int quitting
)
1918 serial_close (remote_desc
);
1922 /* Query the remote side for the text, data and bss offsets. */
1927 struct remote_state
*rs
= get_remote_state ();
1928 char *buf
= alloca (rs
->remote_packet_size
);
1931 CORE_ADDR text_addr
, data_addr
, bss_addr
;
1932 struct section_offsets
*offs
;
1934 putpkt ("qOffsets");
1936 getpkt (buf
, (rs
->remote_packet_size
), 0);
1938 if (buf
[0] == '\000')
1939 return; /* Return silently. Stub doesn't support
1943 warning ("Remote failure reply: %s", buf
);
1947 /* Pick up each field in turn. This used to be done with scanf, but
1948 scanf will make trouble if CORE_ADDR size doesn't match
1949 conversion directives correctly. The following code will work
1950 with any size of CORE_ADDR. */
1951 text_addr
= data_addr
= bss_addr
= 0;
1955 if (strncmp (ptr
, "Text=", 5) == 0)
1958 /* Don't use strtol, could lose on big values. */
1959 while (*ptr
&& *ptr
!= ';')
1960 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
1965 if (!lose
&& strncmp (ptr
, ";Data=", 6) == 0)
1968 while (*ptr
&& *ptr
!= ';')
1969 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
1974 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
1977 while (*ptr
&& *ptr
!= ';')
1978 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
1984 error ("Malformed response to offset query, %s", buf
);
1986 if (symfile_objfile
== NULL
)
1989 offs
= ((struct section_offsets
*)
1990 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
1991 memcpy (offs
, symfile_objfile
->section_offsets
,
1992 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
1994 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
1996 /* This is a temporary kludge to force data and bss to use the same offsets
1997 because that's what nlmconv does now. The real solution requires changes
1998 to the stub and remote.c that I don't have time to do right now. */
2000 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
2001 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
2003 objfile_relocate (symfile_objfile
, offs
);
2006 /* Stub for catch_errors. */
2009 remote_start_remote_dummy (struct ui_out
*uiout
, void *dummy
)
2011 start_remote (); /* Initialize gdb process mechanisms */
2012 /* NOTE: Return something >=0. A -ve value is reserved for
2013 catch_exceptions. */
2018 remote_start_remote (struct ui_out
*uiout
, void *dummy
)
2020 immediate_quit
++; /* Allow user to interrupt it */
2022 /* Ack any packet which the remote side has already sent. */
2023 serial_write (remote_desc
, "+", 1);
2025 /* Let the stub know that we want it to return the thread. */
2028 inferior_ptid
= remote_current_thread (inferior_ptid
);
2030 get_offsets (); /* Get text, data & bss offsets */
2032 putpkt ("?"); /* initiate a query from remote machine */
2035 /* NOTE: See comment above in remote_start_remote_dummy(). This
2036 function returns something >=0. */
2037 return remote_start_remote_dummy (uiout
, dummy
);
2040 /* Open a connection to a remote debugger.
2041 NAME is the filename used for communication. */
2044 remote_open (char *name
, int from_tty
)
2046 remote_open_1 (name
, from_tty
, &remote_ops
, 0, 0);
2049 /* Just like remote_open, but with asynchronous support. */
2051 remote_async_open (char *name
, int from_tty
)
2053 remote_open_1 (name
, from_tty
, &remote_async_ops
, 0, 1);
2056 /* Open a connection to a remote debugger using the extended
2057 remote gdb protocol. NAME is the filename used for communication. */
2060 extended_remote_open (char *name
, int from_tty
)
2062 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */,
2066 /* Just like extended_remote_open, but with asynchronous support. */
2068 extended_remote_async_open (char *name
, int from_tty
)
2070 remote_open_1 (name
, from_tty
, &extended_async_remote_ops
,
2071 1 /*extended_p */, 1 /* async_p */);
2074 /* Generic code for opening a connection to a remote target. */
2077 init_all_packet_configs (void)
2080 update_packet_config (&remote_protocol_e
);
2081 update_packet_config (&remote_protocol_E
);
2082 update_packet_config (&remote_protocol_P
);
2083 update_packet_config (&remote_protocol_qSymbol
);
2084 update_packet_config (&remote_protocol_vcont
);
2085 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2086 update_packet_config (&remote_protocol_Z
[i
]);
2087 /* Force remote_write_bytes to check whether target supports binary
2089 update_packet_config (&remote_protocol_binary_download
);
2090 update_packet_config (&remote_protocol_qPart_auxv
);
2093 /* Symbol look-up. */
2096 remote_check_symbols (struct objfile
*objfile
)
2098 struct remote_state
*rs
= get_remote_state ();
2099 char *msg
, *reply
, *tmp
;
2100 struct minimal_symbol
*sym
;
2103 if (remote_protocol_qSymbol
.support
== PACKET_DISABLE
)
2106 msg
= alloca (rs
->remote_packet_size
);
2107 reply
= alloca (rs
->remote_packet_size
);
2109 /* Invite target to request symbol lookups. */
2111 putpkt ("qSymbol::");
2112 getpkt (reply
, (rs
->remote_packet_size
), 0);
2113 packet_ok (reply
, &remote_protocol_qSymbol
);
2115 while (strncmp (reply
, "qSymbol:", 8) == 0)
2118 end
= hex2bin (tmp
, msg
, strlen (tmp
) / 2);
2120 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
2122 sprintf (msg
, "qSymbol::%s", &reply
[8]);
2124 sprintf (msg
, "qSymbol:%s:%s",
2125 paddr_nz (SYMBOL_VALUE_ADDRESS (sym
)),
2128 getpkt (reply
, (rs
->remote_packet_size
), 0);
2132 static struct serial
*
2133 remote_serial_open (char *name
)
2135 static int udp_warning
= 0;
2137 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2138 of in ser-tcp.c, because it is the remote protocol assuming that the
2139 serial connection is reliable and not the serial connection promising
2141 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
2143 warning ("The remote protocol may be unreliable over UDP.");
2144 warning ("Some events may be lost, rendering further debugging "
2149 return serial_open (name
);
2153 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
,
2154 int extended_p
, int async_p
)
2157 struct remote_state
*rs
= get_remote_state ();
2159 error ("To open a remote debug connection, you need to specify what\n"
2160 "serial device is attached to the remote system\n"
2161 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
2163 /* See FIXME above */
2165 wait_forever_enabled_p
= 1;
2167 target_preopen (from_tty
);
2169 unpush_target (target
);
2171 remote_desc
= remote_serial_open (name
);
2173 perror_with_name (name
);
2175 if (baud_rate
!= -1)
2177 if (serial_setbaudrate (remote_desc
, baud_rate
))
2179 /* The requested speed could not be set. Error out to
2180 top level after closing remote_desc. Take care to
2181 set remote_desc to NULL to avoid closing remote_desc
2183 serial_close (remote_desc
);
2185 perror_with_name (name
);
2189 serial_raw (remote_desc
);
2191 /* If there is something sitting in the buffer we might take it as a
2192 response to a command, which would be bad. */
2193 serial_flush_input (remote_desc
);
2197 puts_filtered ("Remote debugging using ");
2198 puts_filtered (name
);
2199 puts_filtered ("\n");
2201 push_target (target
); /* Switch to using remote target now */
2203 init_all_packet_configs ();
2205 general_thread
= -2;
2206 continue_thread
= -2;
2208 /* Probe for ability to use "ThreadInfo" query, as required. */
2209 use_threadinfo_query
= 1;
2210 use_threadextra_query
= 1;
2212 /* Without this, some commands which require an active target (such
2213 as kill) won't work. This variable serves (at least) double duty
2214 as both the pid of the target process (if it has such), and as a
2215 flag indicating that a target is active. These functions should
2216 be split out into seperate variables, especially since GDB will
2217 someday have a notion of debugging several processes. */
2219 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
2223 /* With this target we start out by owning the terminal. */
2224 remote_async_terminal_ours_p
= 1;
2226 /* FIXME: cagney/1999-09-23: During the initial connection it is
2227 assumed that the target is already ready and able to respond to
2228 requests. Unfortunately remote_start_remote() eventually calls
2229 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2230 around this. Eventually a mechanism that allows
2231 wait_for_inferior() to expect/get timeouts will be
2233 wait_forever_enabled_p
= 0;
2236 #ifdef SOLIB_CREATE_INFERIOR_HOOK
2237 /* First delete any symbols previously loaded from shared libraries. */
2238 no_shared_libraries (NULL
, 0);
2241 /* Start the remote connection. If error() or QUIT, discard this
2242 target (we'd otherwise be in an inconsistent state) and then
2243 propogate the error on up the exception chain. This ensures that
2244 the caller doesn't stumble along blindly assuming that the
2245 function succeeded. The CLI doesn't have this problem but other
2246 UI's, such as MI do.
2248 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2249 this function should return an error indication letting the
2250 caller restore the previous state. Unfortunately the command
2251 ``target remote'' is directly wired to this function making that
2252 impossible. On a positive note, the CLI side of this problem has
2253 been fixed - the function set_cmd_context() makes it possible for
2254 all the ``target ....'' commands to share a common callback
2255 function. See cli-dump.c. */
2256 ex
= catch_exceptions (uiout
,
2257 remote_start_remote
, NULL
,
2258 "Couldn't establish connection to remote"
2265 wait_forever_enabled_p
= 1;
2266 throw_exception (ex
);
2270 wait_forever_enabled_p
= 1;
2274 /* Tell the remote that we are using the extended protocol. */
2275 char *buf
= alloca (rs
->remote_packet_size
);
2277 getpkt (buf
, (rs
->remote_packet_size
), 0);
2279 #ifdef SOLIB_CREATE_INFERIOR_HOOK
2280 /* FIXME: need a master target_open vector from which all
2281 remote_opens can be called, so that stuff like this can
2282 go there. Failing that, the following code must be copied
2283 to the open function for any remote target that wants to
2284 support svr4 shared libraries. */
2286 /* Set up to detect and load shared libraries. */
2287 if (exec_bfd
) /* No use without an exec file. */
2289 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
2290 remote_check_symbols (symfile_objfile
);
2295 /* This takes a program previously attached to and detaches it. After
2296 this is done, GDB can be used to debug some other program. We
2297 better not have left any breakpoints in the target program or it'll
2298 die when it hits one. */
2301 remote_detach (char *args
, int from_tty
)
2303 struct remote_state
*rs
= get_remote_state ();
2304 char *buf
= alloca (rs
->remote_packet_size
);
2307 error ("Argument given to \"detach\" when remotely debugging.");
2309 /* Tell the remote target to detach. */
2311 remote_send (buf
, (rs
->remote_packet_size
));
2313 /* Unregister the file descriptor from the event loop. */
2314 if (target_is_async_p ())
2315 serial_async (remote_desc
, NULL
, 0);
2317 target_mourn_inferior ();
2319 puts_filtered ("Ending remote debugging.\n");
2322 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2325 remote_disconnect (char *args
, int from_tty
)
2327 struct remote_state
*rs
= get_remote_state ();
2328 char *buf
= alloca (rs
->remote_packet_size
);
2331 error ("Argument given to \"detach\" when remotely debugging.");
2333 /* Unregister the file descriptor from the event loop. */
2334 if (target_is_async_p ())
2335 serial_async (remote_desc
, NULL
, 0);
2337 target_mourn_inferior ();
2339 puts_filtered ("Ending remote debugging.\n");
2342 /* Convert hex digit A to a number. */
2347 if (a
>= '0' && a
<= '9')
2349 else if (a
>= 'a' && a
<= 'f')
2350 return a
- 'a' + 10;
2351 else if (a
>= 'A' && a
<= 'F')
2352 return a
- 'A' + 10;
2354 error ("Reply contains invalid hex digit %d", a
);
2358 hex2bin (const char *hex
, char *bin
, int count
)
2362 for (i
= 0; i
< count
; i
++)
2364 if (hex
[0] == 0 || hex
[1] == 0)
2366 /* Hex string is short, or of uneven length.
2367 Return the count that has been converted so far. */
2370 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
2376 /* Convert number NIB to a hex digit. */
2384 return 'a' + nib
- 10;
2388 bin2hex (const char *bin
, char *hex
, int count
)
2391 /* May use a length, or a nul-terminated string as input. */
2393 count
= strlen (bin
);
2395 for (i
= 0; i
< count
; i
++)
2397 *hex
++ = tohex ((*bin
>> 4) & 0xf);
2398 *hex
++ = tohex (*bin
++ & 0xf);
2404 /* Check for the availability of vCont. This function should also check
2408 remote_vcont_probe (struct remote_state
*rs
, char *buf
)
2410 strcpy (buf
, "vCont?");
2412 getpkt (buf
, rs
->remote_packet_size
, 0);
2414 /* Make sure that the features we assume are supported. */
2415 if (strncmp (buf
, "vCont", 5) == 0)
2418 int support_s
, support_S
, support_c
, support_C
;
2424 while (p
&& *p
== ';')
2427 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2429 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2431 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2433 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2436 p
= strchr (p
, ';');
2439 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2440 BUF will make packet_ok disable the packet. */
2441 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
2445 packet_ok (buf
, &remote_protocol_vcont
);
2448 /* Resume the remote inferior by using a "vCont" packet. The thread
2449 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2450 resumed thread should be single-stepped and/or signalled. If PTID's
2451 PID is -1, then all threads are resumed; the thread to be stepped and/or
2452 signalled is given in the global INFERIOR_PTID. This function returns
2453 non-zero iff it resumes the inferior.
2455 This function issues a strict subset of all possible vCont commands at the
2459 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2461 struct remote_state
*rs
= get_remote_state ();
2462 int pid
= PIDGET (ptid
);
2463 char *buf
= NULL
, *outbuf
;
2464 struct cleanup
*old_cleanup
;
2466 buf
= xmalloc (rs
->remote_packet_size
);
2467 old_cleanup
= make_cleanup (xfree
, buf
);
2469 if (remote_protocol_vcont
.support
== PACKET_SUPPORT_UNKNOWN
)
2470 remote_vcont_probe (rs
, buf
);
2472 if (remote_protocol_vcont
.support
== PACKET_DISABLE
)
2474 do_cleanups (old_cleanup
);
2478 /* If we could generate a wider range of packets, we'd have to worry
2479 about overflowing BUF. Should there be a generic
2480 "multi-part-packet" packet? */
2482 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
)
2484 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2485 don't have any PID numbers the inferior will understand. Make sure
2486 to only send forms that do not specify a PID. */
2487 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2488 outbuf
= xstrprintf ("vCont;S%02x", siggnal
);
2490 outbuf
= xstrprintf ("vCont;s");
2491 else if (siggnal
!= TARGET_SIGNAL_0
)
2492 outbuf
= xstrprintf ("vCont;C%02x", siggnal
);
2494 outbuf
= xstrprintf ("vCont;c");
2498 /* Resume all threads, with preference for INFERIOR_PTID. */
2499 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2500 outbuf
= xstrprintf ("vCont;S%02x:%x;c", siggnal
,
2501 PIDGET (inferior_ptid
));
2503 outbuf
= xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid
));
2504 else if (siggnal
!= TARGET_SIGNAL_0
)
2505 outbuf
= xstrprintf ("vCont;C%02x:%x;c", siggnal
,
2506 PIDGET (inferior_ptid
));
2508 outbuf
= xstrprintf ("vCont;c");
2512 /* Scheduler locking; resume only PTID. */
2513 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2514 outbuf
= xstrprintf ("vCont;S%02x:%x", siggnal
, pid
);
2516 outbuf
= xstrprintf ("vCont;s:%x", pid
);
2517 else if (siggnal
!= TARGET_SIGNAL_0
)
2518 outbuf
= xstrprintf ("vCont;C%02x:%x", siggnal
, pid
);
2520 outbuf
= xstrprintf ("vCont;c:%x", pid
);
2523 gdb_assert (outbuf
&& strlen (outbuf
) < rs
->remote_packet_size
);
2524 make_cleanup (xfree
, outbuf
);
2528 do_cleanups (old_cleanup
);
2533 /* Tell the remote machine to resume. */
2535 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
2537 static int last_sent_step
;
2540 remote_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2542 struct remote_state
*rs
= get_remote_state ();
2543 char *buf
= alloca (rs
->remote_packet_size
);
2544 int pid
= PIDGET (ptid
);
2547 last_sent_signal
= siggnal
;
2548 last_sent_step
= step
;
2550 /* A hook for when we need to do something at the last moment before
2552 if (target_resume_hook
)
2553 (*target_resume_hook
) ();
2555 /* The vCont packet doesn't need to specify threads via Hc. */
2556 if (remote_vcont_resume (ptid
, step
, siggnal
))
2559 /* All other supported resume packets do use Hc, so call set_thread. */
2561 set_thread (0, 0); /* run any thread */
2563 set_thread (pid
, 0); /* run this thread */
2565 /* The s/S/c/C packets do not return status. So if the target does
2566 not support the S or C packets, the debug agent returns an empty
2567 string which is detected in remote_wait(). This protocol defect
2568 is fixed in the e/E packets. */
2570 if (step
&& step_range_end
)
2572 /* If the target does not support the 'E' packet, we try the 'S'
2573 packet. Ideally we would fall back to the 'e' packet if that
2574 too is not supported. But that would require another copy of
2575 the code to issue the 'e' packet (and fall back to 's' if not
2576 supported) in remote_wait(). */
2578 if (siggnal
!= TARGET_SIGNAL_0
)
2580 if (remote_protocol_E
.support
!= PACKET_DISABLE
)
2584 *p
++ = tohex (((int) siggnal
>> 4) & 0xf);
2585 *p
++ = tohex (((int) siggnal
) & 0xf);
2587 p
+= hexnumstr (p
, (ULONGEST
) step_range_start
);
2589 p
+= hexnumstr (p
, (ULONGEST
) step_range_end
);
2593 getpkt (buf
, (rs
->remote_packet_size
), 0);
2595 if (packet_ok (buf
, &remote_protocol_E
) == PACKET_OK
)
2601 if (remote_protocol_e
.support
!= PACKET_DISABLE
)
2605 p
+= hexnumstr (p
, (ULONGEST
) step_range_start
);
2607 p
+= hexnumstr (p
, (ULONGEST
) step_range_end
);
2611 getpkt (buf
, (rs
->remote_packet_size
), 0);
2613 if (packet_ok (buf
, &remote_protocol_e
) == PACKET_OK
)
2619 if (siggnal
!= TARGET_SIGNAL_0
)
2621 buf
[0] = step
? 'S' : 'C';
2622 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
2623 buf
[2] = tohex (((int) siggnal
) & 0xf);
2627 strcpy (buf
, step
? "s" : "c");
2632 /* Same as remote_resume, but with async support. */
2634 remote_async_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2636 remote_resume (ptid
, step
, siggnal
);
2638 /* We are about to start executing the inferior, let's register it
2639 with the event loop. NOTE: this is the one place where all the
2640 execution commands end up. We could alternatively do this in each
2641 of the execution commands in infcmd.c.*/
2642 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2643 into infcmd.c in order to allow inferior function calls to work
2644 NOT asynchronously. */
2645 if (event_loop_p
&& target_can_async_p ())
2646 target_async (inferior_event_handler
, 0);
2647 /* Tell the world that the target is now executing. */
2648 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2649 this? Instead, should the client of target just assume (for
2650 async targets) that the target is going to start executing? Is
2651 this information already found in the continuation block? */
2652 if (target_is_async_p ())
2653 target_executing
= 1;
2657 /* Set up the signal handler for SIGINT, while the target is
2658 executing, ovewriting the 'regular' SIGINT signal handler. */
2660 initialize_sigint_signal_handler (void)
2662 sigint_remote_token
=
2663 create_async_signal_handler (async_remote_interrupt
, NULL
);
2664 signal (SIGINT
, handle_remote_sigint
);
2667 /* Signal handler for SIGINT, while the target is executing. */
2669 handle_remote_sigint (int sig
)
2671 signal (sig
, handle_remote_sigint_twice
);
2672 sigint_remote_twice_token
=
2673 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
2674 mark_async_signal_handler_wrapper (sigint_remote_token
);
2677 /* Signal handler for SIGINT, installed after SIGINT has already been
2678 sent once. It will take effect the second time that the user sends
2681 handle_remote_sigint_twice (int sig
)
2683 signal (sig
, handle_sigint
);
2684 sigint_remote_twice_token
=
2685 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
2686 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
2689 /* Perform the real interruption of the target execution, in response
2692 async_remote_interrupt (gdb_client_data arg
)
2695 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2700 /* Perform interrupt, if the first attempt did not succeed. Just give
2701 up on the target alltogether. */
2703 async_remote_interrupt_twice (gdb_client_data arg
)
2706 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
2707 /* Do something only if the target was not killed by the previous
2709 if (target_executing
)
2712 signal (SIGINT
, handle_remote_sigint
);
2716 /* Reinstall the usual SIGINT handlers, after the target has
2719 cleanup_sigint_signal_handler (void *dummy
)
2721 signal (SIGINT
, handle_sigint
);
2722 if (sigint_remote_twice_token
)
2723 delete_async_signal_handler ((struct async_signal_handler
**) & sigint_remote_twice_token
);
2724 if (sigint_remote_token
)
2725 delete_async_signal_handler ((struct async_signal_handler
**) & sigint_remote_token
);
2728 /* Send ^C to target to halt it. Target will respond, and send us a
2730 static void (*ofunc
) (int);
2732 /* The command line interface's stop routine. This function is installed
2733 as a signal handler for SIGINT. The first time a user requests a
2734 stop, we call remote_stop to send a break or ^C. If there is no
2735 response from the target (it didn't stop when the user requested it),
2736 we ask the user if he'd like to detach from the target. */
2738 remote_interrupt (int signo
)
2740 /* If this doesn't work, try more severe steps. */
2741 signal (signo
, remote_interrupt_twice
);
2744 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2749 /* The user typed ^C twice. */
2752 remote_interrupt_twice (int signo
)
2754 signal (signo
, ofunc
);
2756 signal (signo
, remote_interrupt
);
2759 /* This is the generic stop called via the target vector. When a target
2760 interrupt is requested, either by the command line or the GUI, we
2761 will eventually end up here. */
2765 /* Send a break or a ^C, depending on user preference. */
2767 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
2770 serial_send_break (remote_desc
);
2772 serial_write (remote_desc
, "\003", 1);
2775 /* Ask the user what to do when an interrupt is received. */
2778 interrupt_query (void)
2780 target_terminal_ours ();
2782 if (query ("Interrupted while waiting for the program.\n\
2783 Give up (and stop debugging it)? "))
2785 target_mourn_inferior ();
2786 throw_exception (RETURN_QUIT
);
2789 target_terminal_inferior ();
2792 /* Enable/disable target terminal ownership. Most targets can use
2793 terminal groups to control terminal ownership. Remote targets are
2794 different in that explicit transfer of ownership to/from GDB/target
2798 remote_async_terminal_inferior (void)
2800 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
2801 sync_execution here. This function should only be called when
2802 GDB is resuming the inferior in the forground. A background
2803 resume (``run&'') should leave GDB in control of the terminal and
2804 consequently should not call this code. */
2805 if (!sync_execution
)
2807 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
2808 calls target_terminal_*() idenpotent. The event-loop GDB talking
2809 to an asynchronous target with a synchronous command calls this
2810 function from both event-top.c and infrun.c/infcmd.c. Once GDB
2811 stops trying to transfer the terminal to the target when it
2812 shouldn't this guard can go away. */
2813 if (!remote_async_terminal_ours_p
)
2815 delete_file_handler (input_fd
);
2816 remote_async_terminal_ours_p
= 0;
2817 initialize_sigint_signal_handler ();
2818 /* NOTE: At this point we could also register our selves as the
2819 recipient of all input. Any characters typed could then be
2820 passed on down to the target. */
2824 remote_async_terminal_ours (void)
2826 /* See FIXME in remote_async_terminal_inferior. */
2827 if (!sync_execution
)
2829 /* See FIXME in remote_async_terminal_inferior. */
2830 if (remote_async_terminal_ours_p
)
2832 cleanup_sigint_signal_handler (NULL
);
2833 add_file_handler (input_fd
, stdin_event_handler
, 0);
2834 remote_async_terminal_ours_p
= 1;
2837 /* If nonzero, ignore the next kill. */
2842 remote_console_output (char *msg
)
2846 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
2849 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
2852 fputs_unfiltered (tb
, gdb_stdtarg
);
2854 gdb_flush (gdb_stdtarg
);
2857 /* Wait until the remote machine stops, then return,
2858 storing status in STATUS just as `wait' would.
2859 Returns "pid", which in the case of a multi-threaded
2860 remote OS, is the thread-id. */
2863 remote_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2865 struct remote_state
*rs
= get_remote_state ();
2866 unsigned char *buf
= alloca (rs
->remote_packet_size
);
2867 ULONGEST thread_num
= -1;
2870 status
->kind
= TARGET_WAITKIND_EXITED
;
2871 status
->value
.integer
= 0;
2877 ofunc
= signal (SIGINT
, remote_interrupt
);
2878 getpkt (buf
, (rs
->remote_packet_size
), 1);
2879 signal (SIGINT
, ofunc
);
2881 /* This is a hook for when we need to do something (perhaps the
2882 collection of trace data) every time the target stops. */
2883 if (target_wait_loop_hook
)
2884 (*target_wait_loop_hook
) ();
2886 remote_stopped_by_watchpoint_p
= 0;
2890 case 'E': /* Error of some sort */
2891 warning ("Remote failure reply: %s", buf
);
2893 case 'F': /* File-I/O request */
2894 remote_fileio_request (buf
);
2896 case 'T': /* Status with PC, SP, FP, ... */
2899 char regs
[MAX_REGISTER_SIZE
];
2901 /* Expedited reply, containing Signal, {regno, reg} repeat */
2902 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
2904 n... = register number
2905 r... = register contents
2907 p
= &buf
[3]; /* after Txx */
2916 /* If the packet contains a register number save it in pnum
2917 and set p1 to point to the character following it.
2918 Otherwise p1 points to p. */
2920 /* If this packet is an awatch packet, don't parse the 'a'
2921 as a register number. */
2923 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
2925 /* Read the ``P'' register number. */
2926 pnum
= strtol (p
, &p_temp
, 16);
2927 p1
= (unsigned char *) p_temp
;
2932 if (p1
== p
) /* No register number present here */
2934 p1
= (unsigned char *) strchr (p
, ':');
2936 warning ("Malformed packet(a) (missing colon): %s\n\
2939 if (strncmp (p
, "thread", p1
- p
) == 0)
2941 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
2942 record_currthread (thread_num
);
2943 p
= (unsigned char *) p_temp
;
2945 else if ((strncmp (p
, "watch", p1
- p
) == 0)
2946 || (strncmp (p
, "rwatch", p1
- p
) == 0)
2947 || (strncmp (p
, "awatch", p1
- p
) == 0))
2949 remote_stopped_by_watchpoint_p
= 1;
2950 p
= unpack_varlen_hex (++p1
, &addr
);
2951 remote_watch_data_address
= (CORE_ADDR
)addr
;
2955 /* Silently skip unknown optional info. */
2956 p_temp
= strchr (p1
+ 1, ';');
2958 p
= (unsigned char *) p_temp
;
2963 struct packet_reg
*reg
= packet_reg_from_pnum (rs
, pnum
);
2967 error ("Malformed packet(b) (missing colon): %s\nPacket: '%s'\n",
2971 error ("Remote sent bad register number %s: %s\nPacket: '%s'\n",
2972 phex_nz (pnum
, 0), p
, buf
);
2974 fieldsize
= hex2bin (p
, regs
, DEPRECATED_REGISTER_RAW_SIZE (reg
->regnum
));
2976 if (fieldsize
< DEPRECATED_REGISTER_RAW_SIZE (reg
->regnum
))
2977 warning ("Remote reply is too short: %s", buf
);
2978 supply_register (reg
->regnum
, regs
);
2982 error ("Remote register badly formatted: %s\nhere: %s", buf
, p
);
2986 case 'S': /* Old style status, just signal only */
2987 status
->kind
= TARGET_WAITKIND_STOPPED
;
2988 status
->value
.sig
= (enum target_signal
)
2989 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
2993 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
2994 record_currthread (thread_num
);
2997 case 'W': /* Target exited */
2999 /* The remote process exited. */
3000 status
->kind
= TARGET_WAITKIND_EXITED
;
3001 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3005 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3006 status
->value
.sig
= (enum target_signal
)
3007 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3011 case 'O': /* Console output */
3012 remote_console_output (buf
+ 1);
3015 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3017 /* Zero length reply means that we tried 'S' or 'C' and
3018 the remote system doesn't support it. */
3019 target_terminal_ours_for_output ();
3021 ("Can't send signals to this remote system. %s not sent.\n",
3022 target_signal_to_name (last_sent_signal
));
3023 last_sent_signal
= TARGET_SIGNAL_0
;
3024 target_terminal_inferior ();
3026 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3027 putpkt ((char *) buf
);
3030 /* else fallthrough */
3032 warning ("Invalid remote reply: %s", buf
);
3037 if (thread_num
!= -1)
3039 return pid_to_ptid (thread_num
);
3041 return inferior_ptid
;
3044 /* Async version of remote_wait. */
3046 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3048 struct remote_state
*rs
= get_remote_state ();
3049 unsigned char *buf
= alloca (rs
->remote_packet_size
);
3050 ULONGEST thread_num
= -1;
3053 status
->kind
= TARGET_WAITKIND_EXITED
;
3054 status
->value
.integer
= 0;
3056 remote_stopped_by_watchpoint_p
= 0;
3062 if (!target_is_async_p ())
3063 ofunc
= signal (SIGINT
, remote_interrupt
);
3064 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3065 _never_ wait for ever -> test on target_is_async_p().
3066 However, before we do that we need to ensure that the caller
3067 knows how to take the target into/out of async mode. */
3068 getpkt (buf
, (rs
->remote_packet_size
), wait_forever_enabled_p
);
3069 if (!target_is_async_p ())
3070 signal (SIGINT
, ofunc
);
3072 /* This is a hook for when we need to do something (perhaps the
3073 collection of trace data) every time the target stops. */
3074 if (target_wait_loop_hook
)
3075 (*target_wait_loop_hook
) ();
3079 case 'E': /* Error of some sort */
3080 warning ("Remote failure reply: %s", buf
);
3082 case 'F': /* File-I/O request */
3083 remote_fileio_request (buf
);
3085 case 'T': /* Status with PC, SP, FP, ... */
3088 char regs
[MAX_REGISTER_SIZE
];
3090 /* Expedited reply, containing Signal, {regno, reg} repeat */
3091 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3093 n... = register number
3094 r... = register contents
3096 p
= &buf
[3]; /* after Txx */
3105 /* If the packet contains a register number, save it in pnum
3106 and set p1 to point to the character following it.
3107 Otherwise p1 points to p. */
3109 /* If this packet is an awatch packet, don't parse the 'a'
3110 as a register number. */
3112 if (!strncmp (p
, "awatch", strlen ("awatch")) != 0)
3114 /* Read the register number. */
3115 pnum
= strtol (p
, &p_temp
, 16);
3116 p1
= (unsigned char *) p_temp
;
3121 if (p1
== p
) /* No register number present here */
3123 p1
= (unsigned char *) strchr (p
, ':');
3125 error ("Malformed packet(a) (missing colon): %s\nPacket: '%s'\n",
3127 if (strncmp (p
, "thread", p1
- p
) == 0)
3129 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3130 record_currthread (thread_num
);
3131 p
= (unsigned char *) p_temp
;
3133 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3134 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3135 || (strncmp (p
, "awatch", p1
- p
) == 0))
3137 remote_stopped_by_watchpoint_p
= 1;
3138 p
= unpack_varlen_hex (++p1
, &addr
);
3139 remote_watch_data_address
= (CORE_ADDR
)addr
;
3143 /* Silently skip unknown optional info. */
3144 p_temp
= (unsigned char *) strchr (p1
+ 1, ';');
3152 struct packet_reg
*reg
= packet_reg_from_pnum (rs
, pnum
);
3155 error ("Malformed packet(b) (missing colon): %s\nPacket: '%s'\n",
3159 error ("Remote sent bad register number %ld: %s\nPacket: '%s'\n",
3162 fieldsize
= hex2bin (p
, regs
, DEPRECATED_REGISTER_RAW_SIZE (reg
->regnum
));
3164 if (fieldsize
< DEPRECATED_REGISTER_RAW_SIZE (reg
->regnum
))
3165 warning ("Remote reply is too short: %s", buf
);
3166 supply_register (reg
->regnum
, regs
);
3170 error ("Remote register badly formatted: %s\nhere: %s",
3175 case 'S': /* Old style status, just signal only */
3176 status
->kind
= TARGET_WAITKIND_STOPPED
;
3177 status
->value
.sig
= (enum target_signal
)
3178 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3182 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3183 record_currthread (thread_num
);
3186 case 'W': /* Target exited */
3188 /* The remote process exited. */
3189 status
->kind
= TARGET_WAITKIND_EXITED
;
3190 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3194 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3195 status
->value
.sig
= (enum target_signal
)
3196 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3200 case 'O': /* Console output */
3201 remote_console_output (buf
+ 1);
3202 /* Return immediately to the event loop. The event loop will
3203 still be waiting on the inferior afterwards. */
3204 status
->kind
= TARGET_WAITKIND_IGNORE
;
3207 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3209 /* Zero length reply means that we tried 'S' or 'C' and
3210 the remote system doesn't support it. */
3211 target_terminal_ours_for_output ();
3213 ("Can't send signals to this remote system. %s not sent.\n",
3214 target_signal_to_name (last_sent_signal
));
3215 last_sent_signal
= TARGET_SIGNAL_0
;
3216 target_terminal_inferior ();
3218 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3219 putpkt ((char *) buf
);
3222 /* else fallthrough */
3224 warning ("Invalid remote reply: %s", buf
);
3229 if (thread_num
!= -1)
3231 return pid_to_ptid (thread_num
);
3233 return inferior_ptid
;
3236 /* Number of bytes of registers this stub implements. */
3238 static int register_bytes_found
;
3240 /* Read the remote registers into the block REGS. */
3241 /* Currently we just read all the registers, so we don't use regnum. */
3244 remote_fetch_registers (int regnum
)
3246 struct remote_state
*rs
= get_remote_state ();
3247 char *buf
= alloca (rs
->remote_packet_size
);
3250 char *regs
= alloca (rs
->sizeof_g_packet
);
3252 set_thread (PIDGET (inferior_ptid
), 1);
3256 struct packet_reg
*reg
= packet_reg_from_regnum (rs
, regnum
);
3257 gdb_assert (reg
!= NULL
);
3258 if (!reg
->in_g_packet
)
3259 internal_error (__FILE__
, __LINE__
,
3260 "Attempt to fetch a non G-packet register when this "
3261 "remote.c does not support the p-packet.");
3265 remote_send (buf
, (rs
->remote_packet_size
));
3267 /* Save the size of the packet sent to us by the target. Its used
3268 as a heuristic when determining the max size of packets that the
3269 target can safely receive. */
3270 if ((rs
->actual_register_packet_size
) == 0)
3271 (rs
->actual_register_packet_size
) = strlen (buf
);
3273 /* Unimplemented registers read as all bits zero. */
3274 memset (regs
, 0, rs
->sizeof_g_packet
);
3276 /* We can get out of synch in various cases. If the first character
3277 in the buffer is not a hex character, assume that has happened
3278 and try to fetch another packet to read. */
3279 while ((buf
[0] < '0' || buf
[0] > '9')
3280 && (buf
[0] < 'a' || buf
[0] > 'f')
3281 && buf
[0] != 'x') /* New: unavailable register value */
3284 fprintf_unfiltered (gdb_stdlog
,
3285 "Bad register packet; fetching a new packet\n");
3286 getpkt (buf
, (rs
->remote_packet_size
), 0);
3289 /* Reply describes registers byte by byte, each byte encoded as two
3290 hex characters. Suck them all up, then supply them to the
3291 register cacheing/storage mechanism. */
3294 for (i
= 0; i
< rs
->sizeof_g_packet
; i
++)
3300 warning ("Remote reply is of odd length: %s", buf
);
3301 /* Don't change register_bytes_found in this case, and don't
3302 print a second warning. */
3305 if (p
[0] == 'x' && p
[1] == 'x')
3306 regs
[i
] = 0; /* 'x' */
3308 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3312 if (i
!= register_bytes_found
)
3314 register_bytes_found
= i
;
3315 if (REGISTER_BYTES_OK_P ()
3316 && !REGISTER_BYTES_OK (i
))
3317 warning ("Remote reply is too short: %s", buf
);
3323 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
3325 struct packet_reg
*r
= &rs
->regs
[i
];
3328 if (r
->offset
* 2 >= strlen (buf
))
3329 /* A short packet that didn't include the register's
3330 value, this implies that the register is zero (and
3331 not that the register is unavailable). Supply that
3333 regcache_raw_supply (current_regcache
, r
->regnum
, NULL
);
3334 else if (buf
[r
->offset
* 2] == 'x')
3336 gdb_assert (r
->offset
* 2 < strlen (buf
));
3337 /* The register isn't available, mark it as such (at
3338 the same time setting the value to zero). */
3339 regcache_raw_supply (current_regcache
, r
->regnum
, NULL
);
3340 set_register_cached (i
, -1);
3343 regcache_raw_supply (current_regcache
, r
->regnum
,
3350 /* Prepare to store registers. Since we may send them all (using a
3351 'G' request), we have to read out the ones we don't want to change
3355 remote_prepare_to_store (void)
3357 struct remote_state
*rs
= get_remote_state ();
3359 char buf
[MAX_REGISTER_SIZE
];
3361 /* Make sure the entire registers array is valid. */
3362 switch (remote_protocol_P
.support
)
3364 case PACKET_DISABLE
:
3365 case PACKET_SUPPORT_UNKNOWN
:
3366 /* Make sure all the necessary registers are cached. */
3367 for (i
= 0; i
< NUM_REGS
; i
++)
3368 if (rs
->regs
[i
].in_g_packet
)
3369 regcache_raw_read (current_regcache
, rs
->regs
[i
].regnum
, buf
);
3376 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3377 packet was not recognized. */
3380 store_register_using_P (int regnum
)
3382 struct remote_state
*rs
= get_remote_state ();
3383 struct packet_reg
*reg
= packet_reg_from_regnum (rs
, regnum
);
3384 /* Try storing a single register. */
3385 char *buf
= alloca (rs
->remote_packet_size
);
3386 char regp
[MAX_REGISTER_SIZE
];
3390 sprintf (buf
, "P%s=", phex_nz (reg
->pnum
, 0));
3391 p
= buf
+ strlen (buf
);
3392 regcache_collect (reg
->regnum
, regp
);
3393 bin2hex (regp
, p
, DEPRECATED_REGISTER_RAW_SIZE (reg
->regnum
));
3394 remote_send (buf
, rs
->remote_packet_size
);
3396 return buf
[0] != '\0';
3400 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3401 of the register cache buffer. FIXME: ignores errors. */
3404 remote_store_registers (int regnum
)
3406 struct remote_state
*rs
= get_remote_state ();
3412 set_thread (PIDGET (inferior_ptid
), 1);
3416 switch (remote_protocol_P
.support
)
3418 case PACKET_DISABLE
:
3421 if (store_register_using_P (regnum
))
3424 error ("Protocol error: P packet not recognized by stub");
3425 case PACKET_SUPPORT_UNKNOWN
:
3426 if (store_register_using_P (regnum
))
3428 /* The stub recognized the 'P' packet. Remember this. */
3429 remote_protocol_P
.support
= PACKET_ENABLE
;
3434 /* The stub does not support the 'P' packet. Use 'G'
3435 instead, and don't try using 'P' in the future (it
3436 will just waste our time). */
3437 remote_protocol_P
.support
= PACKET_DISABLE
;
3443 /* Extract all the registers in the regcache copying them into a
3447 regs
= alloca (rs
->sizeof_g_packet
);
3448 memset (regs
, rs
->sizeof_g_packet
, 0);
3449 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
3451 struct packet_reg
*r
= &rs
->regs
[i
];
3453 regcache_collect (r
->regnum
, regs
+ r
->offset
);
3457 /* Command describes registers byte by byte,
3458 each byte encoded as two hex characters. */
3459 buf
= alloca (rs
->remote_packet_size
);
3462 /* remote_prepare_to_store insures that register_bytes_found gets set. */
3463 bin2hex (regs
, p
, register_bytes_found
);
3464 remote_send (buf
, (rs
->remote_packet_size
));
3468 /* Return the number of hex digits in num. */
3471 hexnumlen (ULONGEST num
)
3475 for (i
= 0; num
!= 0; i
++)
3481 /* Set BUF to the minimum number of hex digits representing NUM. */
3484 hexnumstr (char *buf
, ULONGEST num
)
3486 int len
= hexnumlen (num
);
3487 return hexnumnstr (buf
, num
, len
);
3491 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3494 hexnumnstr (char *buf
, ULONGEST num
, int width
)
3500 for (i
= width
- 1; i
>= 0; i
--)
3502 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
3509 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3512 remote_address_masked (CORE_ADDR addr
)
3514 if (remote_address_size
> 0
3515 && remote_address_size
< (sizeof (ULONGEST
) * 8))
3517 /* Only create a mask when that mask can safely be constructed
3518 in a ULONGEST variable. */
3520 mask
= (mask
<< remote_address_size
) - 1;
3526 /* Determine whether the remote target supports binary downloading.
3527 This is accomplished by sending a no-op memory write of zero length
3528 to the target at the specified address. It does not suffice to send
3529 the whole packet, since many stubs strip the eighth bit and subsequently
3530 compute a wrong checksum, which causes real havoc with remote_write_bytes.
3532 NOTE: This can still lose if the serial line is not eight-bit
3533 clean. In cases like this, the user should clear "remote
3537 check_binary_download (CORE_ADDR addr
)
3539 struct remote_state
*rs
= get_remote_state ();
3540 switch (remote_protocol_binary_download
.support
)
3542 case PACKET_DISABLE
:
3546 case PACKET_SUPPORT_UNKNOWN
:
3548 char *buf
= alloca (rs
->remote_packet_size
);
3553 p
+= hexnumstr (p
, (ULONGEST
) addr
);
3555 p
+= hexnumstr (p
, (ULONGEST
) 0);
3559 putpkt_binary (buf
, (int) (p
- buf
));
3560 getpkt (buf
, (rs
->remote_packet_size
), 0);
3565 fprintf_unfiltered (gdb_stdlog
,
3566 "binary downloading NOT suppported by target\n");
3567 remote_protocol_binary_download
.support
= PACKET_DISABLE
;
3572 fprintf_unfiltered (gdb_stdlog
,
3573 "binary downloading suppported by target\n");
3574 remote_protocol_binary_download
.support
= PACKET_ENABLE
;
3581 /* Write memory data directly to the remote machine.
3582 This does not inform the data cache; the data cache uses this.
3583 MEMADDR is the address in the remote memory space.
3584 MYADDR is the address of the buffer in our space.
3585 LEN is the number of bytes.
3587 Returns number of bytes transferred, or 0 (setting errno) for
3588 error. Only transfer a single packet. */
3591 remote_write_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
3595 unsigned char *plen
;
3601 unsigned char *payload_start
;
3603 /* Verify that the target can support a binary download. */
3604 check_binary_download (memaddr
);
3606 /* Compute the size, and then allocate space for the largest
3607 possible packet. Include space for an extra trailing NUL. */
3608 sizeof_buf
= get_memory_write_packet_size () + 1;
3609 buf
= alloca (sizeof_buf
);
3611 /* Compute the size of the actual payload by subtracting out the
3612 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
3613 payload_size
= (get_memory_write_packet_size () - (strlen ("$M,:#NN")
3614 + hexnumlen (memaddr
)
3615 + hexnumlen (len
)));
3617 /* Construct the packet header: "[MX]<memaddr>,<len>:". */
3619 /* Append "[XM]". Compute a best guess of the number of bytes
3620 actually transfered. */
3622 switch (remote_protocol_binary_download
.support
)
3626 /* Best guess at number of bytes that will fit. */
3627 todo
= min (len
, payload_size
);
3629 case PACKET_DISABLE
:
3631 /* num bytes that will fit */
3632 todo
= min (len
, payload_size
/ 2);
3634 case PACKET_SUPPORT_UNKNOWN
:
3635 internal_error (__FILE__
, __LINE__
,
3636 "remote_write_bytes: bad internal state");
3638 internal_error (__FILE__
, __LINE__
, "bad switch");
3641 /* Append "<memaddr>". */
3642 memaddr
= remote_address_masked (memaddr
);
3643 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
3648 /* Append <len>. Retain the location/size of <len>. It may need to
3649 be adjusted once the packet body has been created. */
3651 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
3658 /* Append the packet body. */
3660 switch (remote_protocol_binary_download
.support
)
3663 /* Binary mode. Send target system values byte by byte, in
3664 increasing byte addresses. Only escape certain critical
3667 (nr_bytes
< todo
) && (p
- payload_start
) < payload_size
;
3670 switch (myaddr
[nr_bytes
] & 0xff)
3675 /* These must be escaped */
3677 *p
++ = (myaddr
[nr_bytes
] & 0xff) ^ 0x20;
3680 *p
++ = myaddr
[nr_bytes
] & 0xff;
3684 if (nr_bytes
< todo
)
3686 /* Escape chars have filled up the buffer prematurely,
3687 and we have actually sent fewer bytes than planned.
3688 Fix-up the length field of the packet. Use the same
3689 number of characters as before. */
3690 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
3691 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
3694 case PACKET_DISABLE
:
3695 /* Normal mode: Send target system values byte by byte, in
3696 increasing byte addresses. Each byte is encoded as a two hex
3698 nr_bytes
= bin2hex (myaddr
, p
, todo
);
3701 case PACKET_SUPPORT_UNKNOWN
:
3702 internal_error (__FILE__
, __LINE__
,
3703 "remote_write_bytes: bad internal state");
3705 internal_error (__FILE__
, __LINE__
, "bad switch");
3708 putpkt_binary (buf
, (int) (p
- buf
));
3709 getpkt (buf
, sizeof_buf
, 0);
3713 /* There is no correspondance between what the remote protocol
3714 uses for errors and errno codes. We would like a cleaner way
3715 of representing errors (big enough to include errno codes,
3716 bfd_error codes, and others). But for now just return EIO. */
3721 /* Return NR_BYTES, not TODO, in case escape chars caused us to send fewer
3722 bytes than we'd planned. */
3726 /* Read memory data directly from the remote machine.
3727 This does not use the data cache; the data cache uses this.
3728 MEMADDR is the address in the remote memory space.
3729 MYADDR is the address of the buffer in our space.
3730 LEN is the number of bytes.
3732 Returns number of bytes transferred, or 0 for error. */
3734 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
3735 remote targets) shouldn't attempt to read the entire buffer.
3736 Instead it should read a single packet worth of data and then
3737 return the byte size of that packet to the caller. The caller (its
3738 caller and its callers caller ;-) already contains code for
3739 handling partial reads. */
3742 remote_read_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
3745 int max_buf_size
; /* Max size of packet output buffer */
3749 /* Create a buffer big enough for this packet. */
3750 max_buf_size
= get_memory_read_packet_size ();
3751 sizeof_buf
= max_buf_size
+ 1; /* Space for trailing NUL */
3752 buf
= alloca (sizeof_buf
);
3761 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
3763 /* construct "m"<memaddr>","<len>" */
3764 /* sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo); */
3765 memaddr
= remote_address_masked (memaddr
);
3768 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
3770 p
+= hexnumstr (p
, (ULONGEST
) todo
);
3774 getpkt (buf
, sizeof_buf
, 0);
3777 && isxdigit (buf
[1]) && isxdigit (buf
[2])
3780 /* There is no correspondance between what the remote protocol uses
3781 for errors and errno codes. We would like a cleaner way of
3782 representing errors (big enough to include errno codes, bfd_error
3783 codes, and others). But for now just return EIO. */
3788 /* Reply describes memory byte by byte,
3789 each byte encoded as two hex characters. */
3792 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
3794 /* Reply is short. This means that we were able to read
3795 only part of what we wanted to. */
3796 return i
+ (origlen
- len
);
3805 /* Read or write LEN bytes from inferior memory at MEMADDR,
3806 transferring to or from debugger address BUFFER. Write to inferior if
3807 SHOULD_WRITE is nonzero. Returns length of data written or read; 0
3808 for error. TARGET is unused. */
3811 remote_xfer_memory (CORE_ADDR mem_addr
, char *buffer
, int mem_len
,
3812 int should_write
, struct mem_attrib
*attrib
,
3813 struct target_ops
*target
)
3815 CORE_ADDR targ_addr
;
3819 /* Should this be the selected frame? */
3820 gdbarch_remote_translate_xfer_address (current_gdbarch
, current_regcache
,
3822 &targ_addr
, &targ_len
);
3827 res
= remote_write_bytes (targ_addr
, buffer
, targ_len
);
3829 res
= remote_read_bytes (targ_addr
, buffer
, targ_len
);
3835 remote_files_info (struct target_ops
*ignore
)
3837 puts_filtered ("Debugging a target over a serial line.\n");
3840 /* Stuff for dealing with the packets which are part of this protocol.
3841 See comment at top of file for details. */
3843 /* Read a single character from the remote end, masking it down to 7 bits. */
3846 readchar (int timeout
)
3850 ch
= serial_readchar (remote_desc
, timeout
);
3855 switch ((enum serial_rc
) ch
)
3858 target_mourn_inferior ();
3859 error ("Remote connection closed");
3862 perror_with_name ("Remote communication error");
3864 case SERIAL_TIMEOUT
:
3870 /* Send the command in BUF to the remote machine, and read the reply
3871 into BUF. Report an error if we get an error reply. */
3874 remote_send (char *buf
,
3878 getpkt (buf
, sizeof_buf
, 0);
3881 error ("Remote failure reply: %s", buf
);
3884 /* Display a null-terminated packet on stdout, for debugging, using C
3888 print_packet (char *buf
)
3890 puts_filtered ("\"");
3891 fputstr_filtered (buf
, '"', gdb_stdout
);
3892 puts_filtered ("\"");
3898 return putpkt_binary (buf
, strlen (buf
));
3901 /* Send a packet to the remote machine, with error checking. The data
3902 of the packet is in BUF. The string in BUF can be at most (rs->remote_packet_size) - 5
3903 to account for the $, # and checksum, and for a possible /0 if we are
3904 debugging (remote_debug) and want to print the sent packet as a string */
3907 putpkt_binary (char *buf
, int cnt
)
3909 struct remote_state
*rs
= get_remote_state ();
3911 unsigned char csum
= 0;
3912 char *buf2
= alloca (cnt
+ 6);
3913 long sizeof_junkbuf
= (rs
->remote_packet_size
);
3914 char *junkbuf
= alloca (sizeof_junkbuf
);
3920 /* Copy the packet into buffer BUF2, encapsulating it
3921 and giving it a checksum. */
3926 for (i
= 0; i
< cnt
; i
++)
3932 *p
++ = tohex ((csum
>> 4) & 0xf);
3933 *p
++ = tohex (csum
& 0xf);
3935 /* Send it over and over until we get a positive ack. */
3939 int started_error_output
= 0;
3944 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
3945 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
3946 fprintf_unfiltered (gdb_stdlog
, "...");
3947 gdb_flush (gdb_stdlog
);
3949 if (serial_write (remote_desc
, buf2
, p
- buf2
))
3950 perror_with_name ("putpkt: write failed");
3952 /* read until either a timeout occurs (-2) or '+' is read */
3955 ch
= readchar (remote_timeout
);
3963 case SERIAL_TIMEOUT
:
3965 if (started_error_output
)
3967 putchar_unfiltered ('\n');
3968 started_error_output
= 0;
3977 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
3981 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
3982 case SERIAL_TIMEOUT
:
3986 break; /* Retransmit buffer */
3990 fprintf_unfiltered (gdb_stdlog
, "Packet instead of Ack, ignoring it\n");
3991 /* It's probably an old response, and we're out of sync.
3992 Just gobble up the packet and ignore it. */
3993 read_frame (junkbuf
, sizeof_junkbuf
);
3994 continue; /* Now, go look for + */
3999 if (!started_error_output
)
4001 started_error_output
= 1;
4002 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4004 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4008 break; /* Here to retransmit */
4012 /* This is wrong. If doing a long backtrace, the user should be
4013 able to get out next time we call QUIT, without anything as
4014 violent as interrupt_query. If we want to provide a way out of
4015 here without getting to the next QUIT, it should be based on
4016 hitting ^C twice as in remote_wait. */
4026 /* Come here after finding the start of the frame. Collect the rest
4027 into BUF, verifying the checksum, length, and handling run-length
4028 compression. No more than sizeof_buf-1 characters are read so that
4029 the buffer can be NUL terminated.
4031 Returns -1 on error, number of characters in buffer (ignoring the
4032 trailing NULL) on success. (could be extended to return one of the
4033 SERIAL status indications). */
4036 read_frame (char *buf
,
4048 /* ASSERT (bc < sizeof_buf - 1) - space for trailing NUL */
4049 c
= readchar (remote_timeout
);
4052 case SERIAL_TIMEOUT
:
4054 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4058 fputs_filtered ("Saw new packet start in middle of old one\n",
4060 return -1; /* Start a new packet, count retries */
4063 unsigned char pktcsum
;
4069 check_0
= readchar (remote_timeout
);
4071 check_1
= readchar (remote_timeout
);
4073 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4076 fputs_filtered ("Timeout in checksum, retrying\n", gdb_stdlog
);
4079 else if (check_0
< 0 || check_1
< 0)
4082 fputs_filtered ("Communication error in checksum\n", gdb_stdlog
);
4086 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4087 if (csum
== pktcsum
)
4092 fprintf_filtered (gdb_stdlog
,
4093 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4095 fputs_filtered (buf
, gdb_stdlog
);
4096 fputs_filtered ("\n", gdb_stdlog
);
4098 /* Number of characters in buffer ignoring trailing
4102 case '*': /* Run length encoding */
4107 c
= readchar (remote_timeout
);
4109 repeat
= c
- ' ' + 3; /* Compute repeat count */
4111 /* The character before ``*'' is repeated. */
4113 if (repeat
> 0 && repeat
<= 255
4115 && bc
+ repeat
- 1 < sizeof_buf
- 1)
4117 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4123 printf_filtered ("Repeat count %d too large for buffer: ", repeat
);
4124 puts_filtered (buf
);
4125 puts_filtered ("\n");
4129 if (bc
< sizeof_buf
- 1)
4137 puts_filtered ("Remote packet too long: ");
4138 puts_filtered (buf
);
4139 puts_filtered ("\n");
4146 /* Read a packet from the remote machine, with error checking, and
4147 store it in BUF. If FOREVER, wait forever rather than timing out;
4148 this is used (in synchronous mode) to wait for a target that is is
4149 executing user code to stop. */
4150 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4151 don't have to change all the calls to getpkt to deal with the
4152 return value, because at the moment I don't know what the right
4153 thing to do it for those. */
4161 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
4165 /* Read a packet from the remote machine, with error checking, and
4166 store it in BUF. If FOREVER, wait forever rather than timing out;
4167 this is used (in synchronous mode) to wait for a target that is is
4168 executing user code to stop. If FOREVER == 0, this function is
4169 allowed to time out gracefully and return an indication of this to
4172 getpkt_sane (char *buf
,
4181 strcpy (buf
, "timeout");
4185 timeout
= watchdog
> 0 ? watchdog
: -1;
4189 timeout
= remote_timeout
;
4193 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
4195 /* This can loop forever if the remote side sends us characters
4196 continuously, but if it pauses, we'll get a zero from readchar
4197 because of timeout. Then we'll count that as a retry. */
4199 /* Note that we will only wait forever prior to the start of a packet.
4200 After that, we expect characters to arrive at a brisk pace. They
4201 should show up within remote_timeout intervals. */
4205 c
= readchar (timeout
);
4207 if (c
== SERIAL_TIMEOUT
)
4209 if (forever
) /* Watchdog went off? Kill the target. */
4212 target_mourn_inferior ();
4213 error ("Watchdog has expired. Target detached.\n");
4216 fputs_filtered ("Timed out.\n", gdb_stdlog
);
4222 /* We've found the start of a packet, now collect the data. */
4224 val
= read_frame (buf
, sizeof_buf
);
4230 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
4231 fputstr_unfiltered (buf
, 0, gdb_stdlog
);
4232 fprintf_unfiltered (gdb_stdlog
, "\n");
4234 serial_write (remote_desc
, "+", 1);
4238 /* Try the whole thing again. */
4240 serial_write (remote_desc
, "-", 1);
4243 /* We have tried hard enough, and just can't receive the packet. Give up. */
4245 printf_unfiltered ("Ignoring packet error, continuing...\n");
4246 serial_write (remote_desc
, "+", 1);
4253 /* For some mysterious reason, wait_for_inferior calls kill instead of
4254 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4258 target_mourn_inferior ();
4262 /* Use catch_errors so the user can quit from gdb even when we aren't on
4263 speaking terms with the remote system. */
4264 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4266 /* Don't wait for it to die. I'm not really sure it matters whether
4267 we do or not. For the existing stubs, kill is a noop. */
4268 target_mourn_inferior ();
4271 /* Async version of remote_kill. */
4273 remote_async_kill (void)
4275 /* Unregister the file descriptor from the event loop. */
4276 if (target_is_async_p ())
4277 serial_async (remote_desc
, NULL
, 0);
4279 /* For some mysterious reason, wait_for_inferior calls kill instead of
4280 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4284 target_mourn_inferior ();
4288 /* Use catch_errors so the user can quit from gdb even when we aren't on
4289 speaking terms with the remote system. */
4290 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4292 /* Don't wait for it to die. I'm not really sure it matters whether
4293 we do or not. For the existing stubs, kill is a noop. */
4294 target_mourn_inferior ();
4300 remote_mourn_1 (&remote_ops
);
4304 remote_async_mourn (void)
4306 remote_mourn_1 (&remote_async_ops
);
4310 extended_remote_mourn (void)
4312 /* We do _not_ want to mourn the target like this; this will
4313 remove the extended remote target from the target stack,
4314 and the next time the user says "run" it'll fail.
4316 FIXME: What is the right thing to do here? */
4318 remote_mourn_1 (&extended_remote_ops
);
4322 /* Worker function for remote_mourn. */
4324 remote_mourn_1 (struct target_ops
*target
)
4326 unpush_target (target
);
4327 generic_mourn_inferior ();
4330 /* In the extended protocol we want to be able to do things like
4331 "run" and have them basically work as expected. So we need
4332 a special create_inferior function.
4334 FIXME: One day add support for changing the exec file
4335 we're debugging, arguments and an environment. */
4338 extended_remote_create_inferior (char *exec_file
, char *args
, char **env
)
4340 /* Rip out the breakpoints; we'll reinsert them after restarting
4341 the remote server. */
4342 remove_breakpoints ();
4344 /* Now restart the remote server. */
4345 extended_remote_restart ();
4347 /* Now put the breakpoints back in. This way we're safe if the
4348 restart function works via a unix fork on the remote side. */
4349 insert_breakpoints ();
4351 /* Clean up from the last time we were running. */
4352 clear_proceed_status ();
4354 /* Let the remote process run. */
4355 proceed (-1, TARGET_SIGNAL_0
, 0);
4358 /* Async version of extended_remote_create_inferior. */
4360 extended_remote_async_create_inferior (char *exec_file
, char *args
, char **env
)
4362 /* Rip out the breakpoints; we'll reinsert them after restarting
4363 the remote server. */
4364 remove_breakpoints ();
4366 /* If running asynchronously, register the target file descriptor
4367 with the event loop. */
4368 if (event_loop_p
&& target_can_async_p ())
4369 target_async (inferior_event_handler
, 0);
4371 /* Now restart the remote server. */
4372 extended_remote_restart ();
4374 /* Now put the breakpoints back in. This way we're safe if the
4375 restart function works via a unix fork on the remote side. */
4376 insert_breakpoints ();
4378 /* Clean up from the last time we were running. */
4379 clear_proceed_status ();
4381 /* Let the remote process run. */
4382 proceed (-1, TARGET_SIGNAL_0
, 0);
4386 /* On some machines, e.g. 68k, we may use a different breakpoint
4387 instruction than other targets; in those use
4388 DEPRECATED_REMOTE_BREAKPOINT instead of just BREAKPOINT_FROM_PC.
4389 Also, bi-endian targets may define
4390 DEPRECATED_LITTLE_REMOTE_BREAKPOINT and
4391 DEPRECATED_BIG_REMOTE_BREAKPOINT. If none of these are defined, we
4392 just call the standard routines that are in mem-break.c. */
4394 /* NOTE: cagney/2003-06-08: This is silly. A remote and simulator
4395 target should use an identical BREAKPOINT_FROM_PC. As for native,
4396 the ARCH-OS-tdep.c code can override the default. */
4398 #if defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && defined (DEPRECATED_BIG_REMOTE_BREAKPOINT) && !defined(DEPRECATED_REMOTE_BREAKPOINT)
4399 #define DEPRECATED_REMOTE_BREAKPOINT
4402 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4404 /* If the target isn't bi-endian, just pretend it is. */
4405 #if !defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && !defined (DEPRECATED_BIG_REMOTE_BREAKPOINT)
4406 #define DEPRECATED_LITTLE_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
4407 #define DEPRECATED_BIG_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
4410 static unsigned char big_break_insn
[] = DEPRECATED_BIG_REMOTE_BREAKPOINT
;
4411 static unsigned char little_break_insn
[] = DEPRECATED_LITTLE_REMOTE_BREAKPOINT
;
4413 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4415 /* Insert a breakpoint on targets that don't have any better
4416 breakpoint support. We read the contents of the target location
4417 and stash it, then overwrite it with a breakpoint instruction.
4418 ADDR is the target location in the target machine. CONTENTS_CACHE
4419 is a pointer to memory allocated for saving the target contents.
4420 It is guaranteed by the caller to be long enough to save the number
4421 of bytes returned by BREAKPOINT_FROM_PC. */
4424 remote_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
4426 struct remote_state
*rs
= get_remote_state ();
4427 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4432 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
4433 If it succeeds, then set the support to PACKET_ENABLE. If it
4434 fails, and the user has explicitly requested the Z support then
4435 report an error, otherwise, mark it disabled and go on. */
4437 if (remote_protocol_Z
[Z_PACKET_SOFTWARE_BP
].support
!= PACKET_DISABLE
)
4439 char *buf
= alloca (rs
->remote_packet_size
);
4442 addr
= remote_address_masked (addr
);
4446 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4447 BREAKPOINT_FROM_PC (&addr
, &bp_size
);
4448 sprintf (p
, ",%d", bp_size
);
4451 getpkt (buf
, (rs
->remote_packet_size
), 0);
4453 switch (packet_ok (buf
, &remote_protocol_Z
[Z_PACKET_SOFTWARE_BP
]))
4459 case PACKET_UNKNOWN
:
4464 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4465 val
= target_read_memory (addr
, contents_cache
, sizeof big_break_insn
);
4469 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
4470 val
= target_write_memory (addr
, (char *) big_break_insn
,
4471 sizeof big_break_insn
);
4473 val
= target_write_memory (addr
, (char *) little_break_insn
,
4474 sizeof little_break_insn
);
4479 return memory_insert_breakpoint (addr
, contents_cache
);
4480 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4484 remote_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
4486 struct remote_state
*rs
= get_remote_state ();
4489 if (remote_protocol_Z
[Z_PACKET_SOFTWARE_BP
].support
!= PACKET_DISABLE
)
4491 char *buf
= alloca (rs
->remote_packet_size
);
4498 addr
= remote_address_masked (addr
);
4499 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4500 BREAKPOINT_FROM_PC (&addr
, &bp_size
);
4501 sprintf (p
, ",%d", bp_size
);
4504 getpkt (buf
, (rs
->remote_packet_size
), 0);
4506 return (buf
[0] == 'E');
4509 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4510 return target_write_memory (addr
, contents_cache
, sizeof big_break_insn
);
4512 return memory_remove_breakpoint (addr
, contents_cache
);
4513 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4517 watchpoint_to_Z_packet (int type
)
4531 internal_error (__FILE__
, __LINE__
,
4532 "hw_bp_to_z: bad watchpoint type %d", type
);
4537 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
4539 struct remote_state
*rs
= get_remote_state ();
4540 char *buf
= alloca (rs
->remote_packet_size
);
4542 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
4544 if (remote_protocol_Z
[packet
].support
== PACKET_DISABLE
)
4545 error ("Can't set hardware watchpoints without the '%s' (%s) packet\n",
4546 remote_protocol_Z
[packet
].name
,
4547 remote_protocol_Z
[packet
].title
);
4549 sprintf (buf
, "Z%x,", packet
);
4550 p
= strchr (buf
, '\0');
4551 addr
= remote_address_masked (addr
);
4552 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4553 sprintf (p
, ",%x", len
);
4556 getpkt (buf
, (rs
->remote_packet_size
), 0);
4558 switch (packet_ok (buf
, &remote_protocol_Z
[packet
]))
4561 case PACKET_UNKNOWN
:
4566 internal_error (__FILE__
, __LINE__
,
4567 "remote_insert_watchpoint: reached end of function");
4572 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
4574 struct remote_state
*rs
= get_remote_state ();
4575 char *buf
= alloca (rs
->remote_packet_size
);
4577 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
4579 if (remote_protocol_Z
[packet
].support
== PACKET_DISABLE
)
4580 error ("Can't clear hardware watchpoints without the '%s' (%s) packet\n",
4581 remote_protocol_Z
[packet
].name
,
4582 remote_protocol_Z
[packet
].title
);
4584 sprintf (buf
, "z%x,", packet
);
4585 p
= strchr (buf
, '\0');
4586 addr
= remote_address_masked (addr
);
4587 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4588 sprintf (p
, ",%x", len
);
4590 getpkt (buf
, (rs
->remote_packet_size
), 0);
4592 switch (packet_ok (buf
, &remote_protocol_Z
[packet
]))
4595 case PACKET_UNKNOWN
:
4600 internal_error (__FILE__
, __LINE__
,
4601 "remote_remove_watchpoint: reached end of function");
4605 int remote_hw_watchpoint_limit
= -1;
4606 int remote_hw_breakpoint_limit
= -1;
4609 remote_check_watch_resources (int type
, int cnt
, int ot
)
4611 if (type
== bp_hardware_breakpoint
)
4613 if (remote_hw_breakpoint_limit
== 0)
4615 else if (remote_hw_breakpoint_limit
< 0)
4617 else if (cnt
<= remote_hw_breakpoint_limit
)
4622 if (remote_hw_watchpoint_limit
== 0)
4624 else if (remote_hw_watchpoint_limit
< 0)
4628 else if (cnt
<= remote_hw_watchpoint_limit
)
4635 remote_stopped_by_watchpoint (void)
4637 return remote_stopped_by_watchpoint_p
;
4641 remote_stopped_data_address (void)
4643 if (remote_stopped_by_watchpoint ())
4644 return remote_watch_data_address
;
4645 return (CORE_ADDR
)0;
4650 remote_insert_hw_breakpoint (CORE_ADDR addr
, char *shadow
)
4653 struct remote_state
*rs
= get_remote_state ();
4654 char *buf
= alloca (rs
->remote_packet_size
);
4657 /* The length field should be set to the size of a breakpoint
4660 BREAKPOINT_FROM_PC (&addr
, &len
);
4662 if (remote_protocol_Z
[Z_PACKET_HARDWARE_BP
].support
== PACKET_DISABLE
)
4663 error ("Can't set hardware breakpoint without the '%s' (%s) packet\n",
4664 remote_protocol_Z
[Z_PACKET_HARDWARE_BP
].name
,
4665 remote_protocol_Z
[Z_PACKET_HARDWARE_BP
].title
);
4671 addr
= remote_address_masked (addr
);
4672 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4673 sprintf (p
, ",%x", len
);
4676 getpkt (buf
, (rs
->remote_packet_size
), 0);
4678 switch (packet_ok (buf
, &remote_protocol_Z
[Z_PACKET_HARDWARE_BP
]))
4681 case PACKET_UNKNOWN
:
4686 internal_error (__FILE__
, __LINE__
,
4687 "remote_insert_hw_breakpoint: reached end of function");
4692 remote_remove_hw_breakpoint (CORE_ADDR addr
, char *shadow
)
4695 struct remote_state
*rs
= get_remote_state ();
4696 char *buf
= alloca (rs
->remote_packet_size
);
4699 /* The length field should be set to the size of a breakpoint
4702 BREAKPOINT_FROM_PC (&addr
, &len
);
4704 if (remote_protocol_Z
[Z_PACKET_HARDWARE_BP
].support
== PACKET_DISABLE
)
4705 error ("Can't clear hardware breakpoint without the '%s' (%s) packet\n",
4706 remote_protocol_Z
[Z_PACKET_HARDWARE_BP
].name
,
4707 remote_protocol_Z
[Z_PACKET_HARDWARE_BP
].title
);
4713 addr
= remote_address_masked (addr
);
4714 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4715 sprintf (p
, ",%x", len
);
4718 getpkt (buf
, (rs
->remote_packet_size
), 0);
4720 switch (packet_ok (buf
, &remote_protocol_Z
[Z_PACKET_HARDWARE_BP
]))
4723 case PACKET_UNKNOWN
:
4728 internal_error (__FILE__
, __LINE__
,
4729 "remote_remove_hw_breakpoint: reached end of function");
4732 /* Some targets are only capable of doing downloads, and afterwards
4733 they switch to the remote serial protocol. This function provides
4734 a clean way to get from the download target to the remote target.
4735 It's basically just a wrapper so that we don't have to expose any
4736 of the internal workings of remote.c.
4738 Prior to calling this routine, you should shutdown the current
4739 target code, else you will get the "A program is being debugged
4740 already..." message. Usually a call to pop_target() suffices. */
4743 push_remote_target (char *name
, int from_tty
)
4745 printf_filtered ("Switching to remote protocol\n");
4746 remote_open (name
, from_tty
);
4749 /* Table used by the crc32 function to calcuate the checksum. */
4751 static unsigned long crc32_table
[256] =
4754 static unsigned long
4755 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
4757 if (!crc32_table
[1])
4759 /* Initialize the CRC table and the decoding table. */
4763 for (i
= 0; i
< 256; i
++)
4765 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
4766 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
4773 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
4779 /* compare-sections command
4781 With no arguments, compares each loadable section in the exec bfd
4782 with the same memory range on the target, and reports mismatches.
4783 Useful for verifying the image on the target against the exec file.
4784 Depends on the target understanding the new "qCRC:" request. */
4786 /* FIXME: cagney/1999-10-26: This command should be broken down into a
4787 target method (target verify memory) and generic version of the
4788 actual command. This will allow other high-level code (especially
4789 generic_load()) to make use of this target functionality. */
4792 compare_sections_command (char *args
, int from_tty
)
4794 struct remote_state
*rs
= get_remote_state ();
4796 unsigned long host_crc
, target_crc
;
4797 extern bfd
*exec_bfd
;
4798 struct cleanup
*old_chain
;
4801 const char *sectname
;
4802 char *buf
= alloca (rs
->remote_packet_size
);
4809 error ("command cannot be used without an exec file");
4810 if (!current_target
.to_shortname
||
4811 strcmp (current_target
.to_shortname
, "remote") != 0)
4812 error ("command can only be used with remote target");
4814 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4816 if (!(s
->flags
& SEC_LOAD
))
4817 continue; /* skip non-loadable section */
4819 size
= bfd_get_section_size_before_reloc (s
);
4821 continue; /* skip zero-length section */
4823 sectname
= bfd_get_section_name (exec_bfd
, s
);
4824 if (args
&& strcmp (args
, sectname
) != 0)
4825 continue; /* not the section selected by user */
4827 matched
= 1; /* do this section */
4829 /* FIXME: assumes lma can fit into long */
4830 sprintf (buf
, "qCRC:%lx,%lx", (long) lma
, (long) size
);
4833 /* be clever; compute the host_crc before waiting for target reply */
4834 sectdata
= xmalloc (size
);
4835 old_chain
= make_cleanup (xfree
, sectdata
);
4836 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
4837 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
4839 getpkt (buf
, (rs
->remote_packet_size
), 0);
4841 error ("target memory fault, section %s, range 0x%s -- 0x%s",
4842 sectname
, paddr (lma
), paddr (lma
+ size
));
4844 error ("remote target does not support this operation");
4846 for (target_crc
= 0, tmp
= &buf
[1]; *tmp
; tmp
++)
4847 target_crc
= target_crc
* 16 + fromhex (*tmp
);
4849 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
4850 sectname
, paddr (lma
), paddr (lma
+ size
));
4851 if (host_crc
== target_crc
)
4852 printf_filtered ("matched.\n");
4855 printf_filtered ("MIS-MATCHED!\n");
4859 do_cleanups (old_chain
);
4862 warning ("One or more sections of the remote executable does not match\n\
4863 the loaded file\n");
4864 if (args
&& !matched
)
4865 printf_filtered ("No loaded section named '%s'.\n", args
);
4869 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4870 const char *annex
, void *readbuf
, const void *writebuf
,
4871 ULONGEST offset
, LONGEST len
)
4873 struct remote_state
*rs
= get_remote_state ();
4875 char *buf2
= alloca (rs
->remote_packet_size
);
4876 char *p2
= &buf2
[0];
4879 /* Only handle reads. */
4880 if (writebuf
!= NULL
|| readbuf
== NULL
)
4883 /* Map pre-existing objects onto letters. DO NOT do this for new
4884 objects!!! Instead specify new query packets. */
4887 case TARGET_OBJECT_KOD
:
4890 case TARGET_OBJECT_AVR
:
4894 case TARGET_OBJECT_AUXV
:
4895 if (remote_protocol_qPart_auxv
.support
!= PACKET_DISABLE
)
4897 unsigned int total
= 0;
4900 LONGEST n
= min ((rs
->remote_packet_size
- 2) / 2, len
);
4901 snprintf (buf2
, rs
->remote_packet_size
,
4902 "qPart:auxv:read::%s,%s",
4903 phex_nz (offset
, sizeof offset
),
4904 phex_nz (n
, sizeof n
));
4907 return total
> 0 ? total
: i
;
4909 getpkt (buf2
, rs
->remote_packet_size
, 0);
4910 if (packet_ok (buf2
, &remote_protocol_qPart_auxv
) != PACKET_OK
)
4911 return total
> 0 ? total
: -1;
4912 if (buf2
[0] == 'O' && buf2
[1] == 'K' && buf2
[2] == '\0')
4913 break; /* Got EOF indicator. */
4914 /* Got some data. */
4915 i
= hex2bin (buf2
, readbuf
, len
);
4918 readbuf
= (void *) ((char *) readbuf
+ i
);
4932 /* Note: a zero OFFSET and LEN can be used to query the minimum
4934 if (offset
== 0 && len
== 0)
4935 return (rs
->remote_packet_size
);
4936 /* Minimum outbuf size is (rs->remote_packet_size) - if bufsiz is
4937 not large enough let the caller. */
4938 if (len
< (rs
->remote_packet_size
))
4940 len
= rs
->remote_packet_size
;
4942 /* except for querying the minimum buffer size, target must be open */
4944 error ("remote query is only available after target open");
4946 gdb_assert (annex
!= NULL
);
4947 gdb_assert (readbuf
!= NULL
);
4952 /* we used one buffer char for the remote protocol q command and another
4953 for the query type. As the remote protocol encapsulation uses 4 chars
4954 plus one extra in case we are debugging (remote_debug),
4955 we have PBUFZIZ - 7 left to pack the query string */
4957 while (annex
[i
] && (i
< ((rs
->remote_packet_size
) - 8)))
4959 /* Bad caller may have sent forbidden characters. */
4960 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
4965 gdb_assert (annex
[i
] == '\0');
4971 getpkt (readbuf
, len
, 0);
4973 return strlen (readbuf
);
4977 remote_rcmd (char *command
,
4978 struct ui_file
*outbuf
)
4980 struct remote_state
*rs
= get_remote_state ();
4982 char *buf
= alloca (rs
->remote_packet_size
);
4986 error ("remote rcmd is only available after target open");
4988 /* Send a NULL command across as an empty command */
4989 if (command
== NULL
)
4992 /* The query prefix */
4993 strcpy (buf
, "qRcmd,");
4994 p
= strchr (buf
, '\0');
4996 if ((strlen (buf
) + strlen (command
) * 2 + 8/*misc*/) > (rs
->remote_packet_size
))
4997 error ("\"monitor\" command ``%s'' is too long\n", command
);
4999 /* Encode the actual command */
5000 bin2hex (command
, p
, 0);
5002 if (putpkt (buf
) < 0)
5003 error ("Communication problem with target\n");
5005 /* get/display the response */
5008 /* XXX - see also tracepoint.c:remote_get_noisy_reply() */
5010 getpkt (buf
, (rs
->remote_packet_size
), 0);
5012 error ("Target does not support this command\n");
5013 if (buf
[0] == 'O' && buf
[1] != 'K')
5015 remote_console_output (buf
+ 1); /* 'O' message from stub */
5018 if (strcmp (buf
, "OK") == 0)
5020 if (strlen (buf
) == 3 && buf
[0] == 'E'
5021 && isdigit (buf
[1]) && isdigit (buf
[2]))
5023 error ("Protocol error with Rcmd");
5025 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5027 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5028 fputc_unfiltered (c
, outbuf
);
5035 packet_command (char *args
, int from_tty
)
5037 struct remote_state
*rs
= get_remote_state ();
5038 char *buf
= alloca (rs
->remote_packet_size
);
5041 error ("command can only be used with remote target");
5044 error ("remote-packet command requires packet text as argument");
5046 puts_filtered ("sending: ");
5047 print_packet (args
);
5048 puts_filtered ("\n");
5051 getpkt (buf
, (rs
->remote_packet_size
), 0);
5052 puts_filtered ("received: ");
5054 puts_filtered ("\n");
5058 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------------- */
5060 static void display_thread_info (struct gdb_ext_thread_info
*info
);
5062 static void threadset_test_cmd (char *cmd
, int tty
);
5064 static void threadalive_test (char *cmd
, int tty
);
5066 static void threadlist_test_cmd (char *cmd
, int tty
);
5068 int get_and_display_threadinfo (threadref
* ref
);
5070 static void threadinfo_test_cmd (char *cmd
, int tty
);
5072 static int thread_display_step (threadref
* ref
, void *context
);
5074 static void threadlist_update_test_cmd (char *cmd
, int tty
);
5076 static void init_remote_threadtests (void);
5078 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid */
5081 threadset_test_cmd (char *cmd
, int tty
)
5083 int sample_thread
= SAMPLE_THREAD
;
5085 printf_filtered ("Remote threadset test\n");
5086 set_thread (sample_thread
, 1);
5091 threadalive_test (char *cmd
, int tty
)
5093 int sample_thread
= SAMPLE_THREAD
;
5095 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
5096 printf_filtered ("PASS: Thread alive test\n");
5098 printf_filtered ("FAIL: Thread alive test\n");
5101 void output_threadid (char *title
, threadref
* ref
);
5104 output_threadid (char *title
, threadref
*ref
)
5108 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex */
5110 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
5114 threadlist_test_cmd (char *cmd
, int tty
)
5117 threadref nextthread
;
5118 int done
, result_count
;
5119 threadref threadlist
[3];
5121 printf_filtered ("Remote Threadlist test\n");
5122 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
5123 &result_count
, &threadlist
[0]))
5124 printf_filtered ("FAIL: threadlist test\n");
5127 threadref
*scan
= threadlist
;
5128 threadref
*limit
= scan
+ result_count
;
5130 while (scan
< limit
)
5131 output_threadid (" thread ", scan
++);
5136 display_thread_info (struct gdb_ext_thread_info
*info
)
5138 output_threadid ("Threadid: ", &info
->threadid
);
5139 printf_filtered ("Name: %s\n ", info
->shortname
);
5140 printf_filtered ("State: %s\n", info
->display
);
5141 printf_filtered ("other: %s\n\n", info
->more_display
);
5145 get_and_display_threadinfo (threadref
*ref
)
5149 struct gdb_ext_thread_info threadinfo
;
5151 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
5152 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
5153 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
5154 display_thread_info (&threadinfo
);
5159 threadinfo_test_cmd (char *cmd
, int tty
)
5161 int athread
= SAMPLE_THREAD
;
5165 int_to_threadref (&thread
, athread
);
5166 printf_filtered ("Remote Threadinfo test\n");
5167 if (!get_and_display_threadinfo (&thread
))
5168 printf_filtered ("FAIL cannot get thread info\n");
5172 thread_display_step (threadref
*ref
, void *context
)
5174 /* output_threadid(" threadstep ",ref); *//* simple test */
5175 return get_and_display_threadinfo (ref
);
5179 threadlist_update_test_cmd (char *cmd
, int tty
)
5181 printf_filtered ("Remote Threadlist update test\n");
5182 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
5186 init_remote_threadtests (void)
5188 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
5189 "Fetch and print the remote list of thread identifiers, one pkt only");
5190 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
5191 "Fetch and display info about one thread");
5192 add_com ("tset", class_obscure
, threadset_test_cmd
,
5193 "Test setting to a different thread");
5194 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
5195 "Iterate through updating all remote thread info");
5196 add_com ("talive", class_obscure
, threadalive_test
,
5197 " Remote thread alive test ");
5202 /* Convert a thread ID to a string. Returns the string in a static
5206 remote_pid_to_str (ptid_t ptid
)
5208 static char buf
[30];
5210 sprintf (buf
, "Thread %d", PIDGET (ptid
));
5215 init_remote_ops (void)
5217 remote_ops
.to_shortname
= "remote";
5218 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
5220 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5221 Specify the serial device it is connected to\n\
5222 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
5223 remote_ops
.to_open
= remote_open
;
5224 remote_ops
.to_close
= remote_close
;
5225 remote_ops
.to_detach
= remote_detach
;
5226 remote_ops
.to_disconnect
= remote_disconnect
;
5227 remote_ops
.to_resume
= remote_resume
;
5228 remote_ops
.to_wait
= remote_wait
;
5229 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
5230 remote_ops
.to_store_registers
= remote_store_registers
;
5231 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
5232 remote_ops
.to_xfer_memory
= remote_xfer_memory
;
5233 remote_ops
.to_files_info
= remote_files_info
;
5234 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
5235 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
5236 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
5237 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
5238 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
5239 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
5240 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
5241 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
5242 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
5243 remote_ops
.to_kill
= remote_kill
;
5244 remote_ops
.to_load
= generic_load
;
5245 remote_ops
.to_mourn_inferior
= remote_mourn
;
5246 remote_ops
.to_thread_alive
= remote_thread_alive
;
5247 remote_ops
.to_find_new_threads
= remote_threads_info
;
5248 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
5249 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
5250 remote_ops
.to_stop
= remote_stop
;
5251 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
5252 remote_ops
.to_rcmd
= remote_rcmd
;
5253 remote_ops
.to_stratum
= process_stratum
;
5254 remote_ops
.to_has_all_memory
= 1;
5255 remote_ops
.to_has_memory
= 1;
5256 remote_ops
.to_has_stack
= 1;
5257 remote_ops
.to_has_registers
= 1;
5258 remote_ops
.to_has_execution
= 1;
5259 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
5260 remote_ops
.to_magic
= OPS_MAGIC
;
5263 /* Set up the extended remote vector by making a copy of the standard
5264 remote vector and adding to it. */
5267 init_extended_remote_ops (void)
5269 extended_remote_ops
= remote_ops
;
5271 extended_remote_ops
.to_shortname
= "extended-remote";
5272 extended_remote_ops
.to_longname
=
5273 "Extended remote serial target in gdb-specific protocol";
5274 extended_remote_ops
.to_doc
=
5275 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5276 Specify the serial device it is connected to (e.g. /dev/ttya).",
5277 extended_remote_ops
.to_open
= extended_remote_open
;
5278 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
5279 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
5283 remote_can_async_p (void)
5285 /* We're async whenever the serial device is. */
5286 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
5290 remote_is_async_p (void)
5292 /* We're async whenever the serial device is. */
5293 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
5296 /* Pass the SERIAL event on and up to the client. One day this code
5297 will be able to delay notifying the client of an event until the
5298 point where an entire packet has been received. */
5300 static void (*async_client_callback
) (enum inferior_event_type event_type
, void *context
);
5301 static void *async_client_context
;
5302 static serial_event_ftype remote_async_serial_handler
;
5305 remote_async_serial_handler (struct serial
*scb
, void *context
)
5307 /* Don't propogate error information up to the client. Instead let
5308 the client find out about the error by querying the target. */
5309 async_client_callback (INF_REG_EVENT
, async_client_context
);
5313 remote_async (void (*callback
) (enum inferior_event_type event_type
, void *context
), void *context
)
5315 if (current_target
.to_async_mask_value
== 0)
5316 internal_error (__FILE__
, __LINE__
,
5317 "Calling remote_async when async is masked");
5319 if (callback
!= NULL
)
5321 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
5322 async_client_callback
= callback
;
5323 async_client_context
= context
;
5326 serial_async (remote_desc
, NULL
, NULL
);
5329 /* Target async and target extended-async.
5331 This are temporary targets, until it is all tested. Eventually
5332 async support will be incorporated int the usual 'remote'
5336 init_remote_async_ops (void)
5338 remote_async_ops
.to_shortname
= "async";
5339 remote_async_ops
.to_longname
= "Remote serial target in async version of the gdb-specific protocol";
5340 remote_async_ops
.to_doc
=
5341 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5342 Specify the serial device it is connected to (e.g. /dev/ttya).";
5343 remote_async_ops
.to_open
= remote_async_open
;
5344 remote_async_ops
.to_close
= remote_close
;
5345 remote_async_ops
.to_detach
= remote_detach
;
5346 remote_async_ops
.to_disconnect
= remote_disconnect
;
5347 remote_async_ops
.to_resume
= remote_async_resume
;
5348 remote_async_ops
.to_wait
= remote_async_wait
;
5349 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
5350 remote_async_ops
.to_store_registers
= remote_store_registers
;
5351 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
5352 remote_async_ops
.to_xfer_memory
= remote_xfer_memory
;
5353 remote_async_ops
.to_files_info
= remote_files_info
;
5354 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
5355 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
5356 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
5357 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
5358 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
5359 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
5360 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
5361 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
5362 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
5363 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
5364 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
5365 remote_async_ops
.to_kill
= remote_async_kill
;
5366 remote_async_ops
.to_load
= generic_load
;
5367 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
5368 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
5369 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
5370 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
5371 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
5372 remote_async_ops
.to_stop
= remote_stop
;
5373 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
5374 remote_async_ops
.to_rcmd
= remote_rcmd
;
5375 remote_async_ops
.to_stratum
= process_stratum
;
5376 remote_async_ops
.to_has_all_memory
= 1;
5377 remote_async_ops
.to_has_memory
= 1;
5378 remote_async_ops
.to_has_stack
= 1;
5379 remote_async_ops
.to_has_registers
= 1;
5380 remote_async_ops
.to_has_execution
= 1;
5381 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
5382 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
5383 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
5384 remote_async_ops
.to_async
= remote_async
;
5385 remote_async_ops
.to_async_mask_value
= 1;
5386 remote_async_ops
.to_magic
= OPS_MAGIC
;
5389 /* Set up the async extended remote vector by making a copy of the standard
5390 remote vector and adding to it. */
5393 init_extended_async_remote_ops (void)
5395 extended_async_remote_ops
= remote_async_ops
;
5397 extended_async_remote_ops
.to_shortname
= "extended-async";
5398 extended_async_remote_ops
.to_longname
=
5399 "Extended remote serial target in async gdb-specific protocol";
5400 extended_async_remote_ops
.to_doc
=
5401 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
5402 Specify the serial device it is connected to (e.g. /dev/ttya).",
5403 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
5404 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
5405 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
5409 set_remote_cmd (char *args
, int from_tty
)
5414 show_remote_cmd (char *args
, int from_tty
)
5416 /* FIXME: cagney/2002-06-15: This function should iterate over
5417 remote_show_cmdlist for a list of sub commands to show. */
5418 show_remote_protocol_Z_packet_cmd (args
, from_tty
, NULL
);
5419 show_remote_protocol_e_packet_cmd (args
, from_tty
, NULL
);
5420 show_remote_protocol_E_packet_cmd (args
, from_tty
, NULL
);
5421 show_remote_protocol_P_packet_cmd (args
, from_tty
, NULL
);
5422 show_remote_protocol_qSymbol_packet_cmd (args
, from_tty
, NULL
);
5423 show_remote_protocol_vcont_packet_cmd (args
, from_tty
, NULL
);
5424 show_remote_protocol_binary_download_cmd (args
, from_tty
, NULL
);
5425 show_remote_protocol_qPart_auxv_packet_cmd (args
, from_tty
, NULL
);
5429 build_remote_gdbarch_data (void)
5431 remote_address_size
= TARGET_ADDR_BIT
;
5434 /* Saved pointer to previous owner of the new_objfile event. */
5435 static void (*remote_new_objfile_chain
) (struct objfile
*);
5437 /* Function to be called whenever a new objfile (shlib) is detected. */
5439 remote_new_objfile (struct objfile
*objfile
)
5441 if (remote_desc
!= 0) /* Have a remote connection */
5443 remote_check_symbols (objfile
);
5445 /* Call predecessor on chain, if any. */
5446 if (remote_new_objfile_chain
!= 0 &&
5448 remote_new_objfile_chain (objfile
);
5452 _initialize_remote (void)
5454 static struct cmd_list_element
*remote_set_cmdlist
;
5455 static struct cmd_list_element
*remote_show_cmdlist
;
5456 struct cmd_list_element
*tmpcmd
;
5458 /* architecture specific data */
5459 remote_gdbarch_data_handle
= gdbarch_data_register_post_init (init_remote_state
);
5461 /* Old tacky stuff. NOTE: This comes after the remote protocol so
5462 that the remote protocol has been initialized. */
5463 DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size
);
5464 deprecated_register_gdbarch_swap (NULL
, 0, build_remote_gdbarch_data
);
5467 add_target (&remote_ops
);
5469 init_extended_remote_ops ();
5470 add_target (&extended_remote_ops
);
5472 init_remote_async_ops ();
5473 add_target (&remote_async_ops
);
5475 init_extended_async_remote_ops ();
5476 add_target (&extended_async_remote_ops
);
5478 /* Hook into new objfile notification. */
5479 remote_new_objfile_chain
= target_new_objfile_hook
;
5480 target_new_objfile_hook
= remote_new_objfile
;
5483 init_remote_threadtests ();
5486 /* set/show remote ... */
5488 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, "\
5489 Remote protocol specific variables\n\
5490 Configure various remote-protocol specific variables such as\n\
5491 the packets being used",
5492 &remote_set_cmdlist
, "set remote ",
5493 0/*allow-unknown*/, &setlist
);
5494 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, "\
5495 Remote protocol specific variables\n\
5496 Configure various remote-protocol specific variables such as\n\
5497 the packets being used",
5498 &remote_show_cmdlist
, "show remote ",
5499 0/*allow-unknown*/, &showlist
);
5501 add_cmd ("compare-sections", class_obscure
, compare_sections_command
,
5502 "Compare section data on target to the exec file.\n\
5503 Argument is a single section name (default: all loaded sections).",
5506 add_cmd ("packet", class_maintenance
, packet_command
,
5507 "Send an arbitrary packet to a remote target.\n\
5508 maintenance packet TEXT\n\
5509 If GDB is talking to an inferior via the GDB serial protocol, then\n\
5510 this command sends the string TEXT to the inferior, and displays the\n\
5511 response packet. GDB supplies the initial `$' character, and the\n\
5512 terminating `#' character and checksum.",
5515 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
,
5516 "Set whether to send break if interrupted.\n",
5517 "Show whether to send break if interrupted.\n",
5519 &setlist
, &showlist
);
5521 /* Install commands for configuring memory read/write packets. */
5523 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
,
5524 "Set the maximum number of bytes per memory write packet (deprecated).\n",
5526 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
,
5527 "Show the maximum number of bytes per memory write packet (deprecated).\n",
5529 add_cmd ("memory-write-packet-size", no_class
,
5530 set_memory_write_packet_size
,
5531 "Set the maximum number of bytes per memory-write packet.\n"
5532 "Specify the number of bytes in a packet or 0 (zero) for the\n"
5533 "default packet size. The actual limit is further reduced\n"
5534 "dependent on the target. Specify ``fixed'' to disable the\n"
5535 "further restriction and ``limit'' to enable that restriction\n",
5536 &remote_set_cmdlist
);
5537 add_cmd ("memory-read-packet-size", no_class
,
5538 set_memory_read_packet_size
,
5539 "Set the maximum number of bytes per memory-read packet.\n"
5540 "Specify the number of bytes in a packet or 0 (zero) for the\n"
5541 "default packet size. The actual limit is further reduced\n"
5542 "dependent on the target. Specify ``fixed'' to disable the\n"
5543 "further restriction and ``limit'' to enable that restriction\n",
5544 &remote_set_cmdlist
);
5545 add_cmd ("memory-write-packet-size", no_class
,
5546 show_memory_write_packet_size
,
5547 "Show the maximum number of bytes per memory-write packet.\n",
5548 &remote_show_cmdlist
);
5549 add_cmd ("memory-read-packet-size", no_class
,
5550 show_memory_read_packet_size
,
5551 "Show the maximum number of bytes per memory-read packet.\n",
5552 &remote_show_cmdlist
);
5554 add_setshow_cmd ("hardware-watchpoint-limit", no_class
,
5555 var_zinteger
, &remote_hw_watchpoint_limit
, "\
5556 Set the maximum number of target hardware watchpoints.\n\
5557 Specify a negative limit for unlimited.", "\
5558 Show the maximum number of target hardware watchpoints.\n",
5559 NULL
, NULL
, &remote_set_cmdlist
, &remote_show_cmdlist
);
5560 add_setshow_cmd ("hardware-breakpoint-limit", no_class
,
5561 var_zinteger
, &remote_hw_breakpoint_limit
, "\
5562 Set the maximum number of target hardware breakpoints.\n\
5563 Specify a negative limit for unlimited.", "\
5564 Show the maximum number of target hardware breakpoints.\n",
5565 NULL
, NULL
, &remote_set_cmdlist
, &remote_show_cmdlist
);
5568 (add_set_cmd ("remoteaddresssize", class_obscure
,
5569 var_integer
, (char *) &remote_address_size
,
5570 "Set the maximum size of the address (in bits) \
5571 in a memory packet.\n",
5575 add_packet_config_cmd (&remote_protocol_binary_download
,
5576 "X", "binary-download",
5577 set_remote_protocol_binary_download_cmd
,
5578 show_remote_protocol_binary_download_cmd
,
5579 &remote_set_cmdlist
, &remote_show_cmdlist
,
5582 /* XXXX - should ``set remotebinarydownload'' be retained for
5585 (add_set_cmd ("remotebinarydownload", no_class
,
5586 var_boolean
, (char *) &remote_binary_download
,
5587 "Set binary downloads.\n", &setlist
),
5591 add_packet_config_cmd (&remote_protocol_vcont
,
5592 "vCont", "verbose-resume",
5593 set_remote_protocol_vcont_packet_cmd
,
5594 show_remote_protocol_vcont_packet_cmd
,
5595 &remote_set_cmdlist
, &remote_show_cmdlist
,
5598 add_packet_config_cmd (&remote_protocol_qSymbol
,
5599 "qSymbol", "symbol-lookup",
5600 set_remote_protocol_qSymbol_packet_cmd
,
5601 show_remote_protocol_qSymbol_packet_cmd
,
5602 &remote_set_cmdlist
, &remote_show_cmdlist
,
5605 add_packet_config_cmd (&remote_protocol_e
,
5606 "e", "step-over-range",
5607 set_remote_protocol_e_packet_cmd
,
5608 show_remote_protocol_e_packet_cmd
,
5609 &remote_set_cmdlist
, &remote_show_cmdlist
,
5611 /* Disable by default. The ``e'' packet has nasty interactions with
5612 the threading code - it relies on global state. */
5613 remote_protocol_e
.detect
= AUTO_BOOLEAN_FALSE
;
5614 update_packet_config (&remote_protocol_e
);
5616 add_packet_config_cmd (&remote_protocol_E
,
5617 "E", "step-over-range-w-signal",
5618 set_remote_protocol_E_packet_cmd
,
5619 show_remote_protocol_E_packet_cmd
,
5620 &remote_set_cmdlist
, &remote_show_cmdlist
,
5622 /* Disable by default. The ``e'' packet has nasty interactions with
5623 the threading code - it relies on global state. */
5624 remote_protocol_E
.detect
= AUTO_BOOLEAN_FALSE
;
5625 update_packet_config (&remote_protocol_E
);
5627 add_packet_config_cmd (&remote_protocol_P
,
5628 "P", "set-register",
5629 set_remote_protocol_P_packet_cmd
,
5630 show_remote_protocol_P_packet_cmd
,
5631 &remote_set_cmdlist
, &remote_show_cmdlist
,
5634 add_packet_config_cmd (&remote_protocol_Z
[Z_PACKET_SOFTWARE_BP
],
5635 "Z0", "software-breakpoint",
5636 set_remote_protocol_Z_software_bp_packet_cmd
,
5637 show_remote_protocol_Z_software_bp_packet_cmd
,
5638 &remote_set_cmdlist
, &remote_show_cmdlist
,
5641 add_packet_config_cmd (&remote_protocol_Z
[Z_PACKET_HARDWARE_BP
],
5642 "Z1", "hardware-breakpoint",
5643 set_remote_protocol_Z_hardware_bp_packet_cmd
,
5644 show_remote_protocol_Z_hardware_bp_packet_cmd
,
5645 &remote_set_cmdlist
, &remote_show_cmdlist
,
5648 add_packet_config_cmd (&remote_protocol_Z
[Z_PACKET_WRITE_WP
],
5649 "Z2", "write-watchpoint",
5650 set_remote_protocol_Z_write_wp_packet_cmd
,
5651 show_remote_protocol_Z_write_wp_packet_cmd
,
5652 &remote_set_cmdlist
, &remote_show_cmdlist
,
5655 add_packet_config_cmd (&remote_protocol_Z
[Z_PACKET_READ_WP
],
5656 "Z3", "read-watchpoint",
5657 set_remote_protocol_Z_read_wp_packet_cmd
,
5658 show_remote_protocol_Z_read_wp_packet_cmd
,
5659 &remote_set_cmdlist
, &remote_show_cmdlist
,
5662 add_packet_config_cmd (&remote_protocol_Z
[Z_PACKET_ACCESS_WP
],
5663 "Z4", "access-watchpoint",
5664 set_remote_protocol_Z_access_wp_packet_cmd
,
5665 show_remote_protocol_Z_access_wp_packet_cmd
,
5666 &remote_set_cmdlist
, &remote_show_cmdlist
,
5669 add_packet_config_cmd (&remote_protocol_qPart_auxv
,
5670 "qPart_auxv", "read-aux-vector",
5671 set_remote_protocol_qPart_auxv_packet_cmd
,
5672 show_remote_protocol_qPart_auxv_packet_cmd
,
5673 &remote_set_cmdlist
, &remote_show_cmdlist
,
5676 /* Keep the old ``set remote Z-packet ...'' working. */
5677 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
5678 &remote_Z_packet_detect
, "\
5679 Set use of remote protocol `Z' packets",
5680 "Show use of remote protocol `Z' packets ",
5681 set_remote_protocol_Z_packet_cmd
,
5682 show_remote_protocol_Z_packet_cmd
,
5683 &remote_set_cmdlist
, &remote_show_cmdlist
);
5685 /* Eventually initialize fileio. See fileio.c */
5686 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);