1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
24 /* See the GDB User Guide for details of the GDB remote protocol. */
27 #include "gdb_string.h"
33 #include "exceptions.h"
35 /*#include "terminal.h" */
38 #include "gdb-stabs.h"
39 #include "gdbthread.h"
43 #include "gdb_assert.h"
46 #include "cli/cli-decode.h"
47 #include "cli/cli-setshow.h"
48 #include "target-descriptions.h"
53 #include "event-loop.h"
54 #include "event-top.h"
60 #include "gdbcore.h" /* for exec_bfd */
62 #include "remote-fileio.h"
64 #include "memory-map.h"
66 /* The size to align memory write packets, when practical. The protocol
67 does not guarantee any alignment, and gdb will generate short
68 writes and unaligned writes, but even as a best-effort attempt this
69 can improve bulk transfers. For instance, if a write is misaligned
70 relative to the target's data bus, the stub may need to make an extra
71 round trip fetching data from the target. This doesn't make a
72 huge difference, but it's easy to do, so we try to be helpful.
74 The alignment chosen is arbitrary; usually data bus width is
75 important here, not the possibly larger cache line size. */
76 enum { REMOTE_ALIGN_WRITES
= 16 };
78 /* Prototypes for local functions. */
79 static void cleanup_sigint_signal_handler (void *dummy
);
80 static void initialize_sigint_signal_handler (void);
81 static int getpkt_sane (char **buf
, long *sizeof_buf
, int forever
);
83 static void handle_remote_sigint (int);
84 static void handle_remote_sigint_twice (int);
85 static void async_remote_interrupt (gdb_client_data
);
86 void async_remote_interrupt_twice (gdb_client_data
);
88 static void build_remote_gdbarch_data (void);
90 static void remote_files_info (struct target_ops
*ignore
);
92 static void remote_prepare_to_store (struct regcache
*regcache
);
94 static void remote_fetch_registers (struct regcache
*regcache
, int regno
);
96 static void remote_resume (ptid_t ptid
, int step
,
97 enum target_signal siggnal
);
98 static void remote_async_resume (ptid_t ptid
, int step
,
99 enum target_signal siggnal
);
100 static void remote_open (char *name
, int from_tty
);
101 static void remote_async_open (char *name
, int from_tty
);
103 static void extended_remote_open (char *name
, int from_tty
);
104 static void extended_remote_async_open (char *name
, int from_tty
);
106 static void remote_open_1 (char *, int, struct target_ops
*, int extended_p
,
109 static void remote_close (int quitting
);
111 static void remote_store_registers (struct regcache
*regcache
, int regno
);
113 static void remote_mourn (void);
114 static void remote_async_mourn (void);
116 static void extended_remote_restart (void);
118 static void extended_remote_mourn (void);
120 static void remote_mourn_1 (struct target_ops
*);
122 static void remote_send (char **buf
, long *sizeof_buf_p
);
124 static int readchar (int timeout
);
126 static ptid_t
remote_wait (ptid_t ptid
,
127 struct target_waitstatus
*status
);
128 static ptid_t
remote_async_wait (ptid_t ptid
,
129 struct target_waitstatus
*status
);
131 static void remote_kill (void);
132 static void remote_async_kill (void);
134 static int tohex (int nib
);
136 static void remote_detach (char *args
, int from_tty
);
138 static void remote_interrupt (int signo
);
140 static void remote_interrupt_twice (int signo
);
142 static void interrupt_query (void);
144 static void set_thread (int, int);
146 static int remote_thread_alive (ptid_t
);
148 static void get_offsets (void);
150 static void skip_frame (void);
152 static long read_frame (char **buf_p
, long *sizeof_buf
);
154 static int hexnumlen (ULONGEST num
);
156 static void init_remote_ops (void);
158 static void init_extended_remote_ops (void);
160 static void remote_stop (void);
162 static int ishex (int ch
, int *val
);
164 static int stubhex (int ch
);
166 static int hexnumstr (char *, ULONGEST
);
168 static int hexnumnstr (char *, ULONGEST
, int);
170 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
172 static void print_packet (char *);
174 static unsigned long crc32 (unsigned char *, int, unsigned int);
176 static void compare_sections_command (char *, int);
178 static void packet_command (char *, int);
180 static int stub_unpack_int (char *buff
, int fieldlength
);
182 static ptid_t
remote_current_thread (ptid_t oldptid
);
184 static void remote_find_new_threads (void);
186 static void record_currthread (int currthread
);
188 static int fromhex (int a
);
190 static int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
192 static int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
194 static int putpkt_binary (char *buf
, int cnt
);
196 static void check_binary_download (CORE_ADDR addr
);
198 struct packet_config
;
200 static void show_packet_config_cmd (struct packet_config
*config
);
202 static void update_packet_config (struct packet_config
*config
);
204 static void set_remote_protocol_packet_cmd (char *args
, int from_tty
,
205 struct cmd_list_element
*c
);
207 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
209 struct cmd_list_element
*c
,
212 void _initialize_remote (void);
214 /* For "set remote" and "show remote". */
216 static struct cmd_list_element
*remote_set_cmdlist
;
217 static struct cmd_list_element
*remote_show_cmdlist
;
219 /* Description of the remote protocol state for the currently
220 connected target. This is per-target state, and independent of the
221 selected architecture. */
225 /* A buffer to use for incoming packets, and its current size. The
226 buffer is grown dynamically for larger incoming packets.
227 Outgoing packets may also be constructed in this buffer.
228 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
229 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
234 /* If we negotiated packet size explicitly (and thus can bypass
235 heuristics for the largest packet size that will not overflow
236 a buffer in the stub), this will be set to that packet size.
237 Otherwise zero, meaning to use the guessed size. */
238 long explicit_packet_size
;
241 /* This data could be associated with a target, but we do not always
242 have access to the current target when we need it, so for now it is
243 static. This will be fine for as long as only one target is in use
245 static struct remote_state remote_state
;
247 static struct remote_state
*
248 get_remote_state_raw (void)
250 return &remote_state
;
253 /* Description of the remote protocol for a given architecture. */
257 long offset
; /* Offset into G packet. */
258 long regnum
; /* GDB's internal register number. */
259 LONGEST pnum
; /* Remote protocol register number. */
260 int in_g_packet
; /* Always part of G packet. */
261 /* long size in bytes; == register_size (current_gdbarch, regnum);
263 /* char *name; == REGISTER_NAME (regnum); at present. */
266 struct remote_arch_state
268 /* Description of the remote protocol registers. */
269 long sizeof_g_packet
;
271 /* Description of the remote protocol registers indexed by REGNUM
272 (making an array gdbarch_num_regs in size). */
273 struct packet_reg
*regs
;
275 /* This is the size (in chars) of the first response to the ``g''
276 packet. It is used as a heuristic when determining the maximum
277 size of memory-read and memory-write packets. A target will
278 typically only reserve a buffer large enough to hold the ``g''
279 packet. The size does not include packet overhead (headers and
281 long actual_register_packet_size
;
283 /* This is the maximum size (in chars) of a non read/write packet.
284 It is also used as a cap on the size of read/write packets. */
285 long remote_packet_size
;
289 /* Handle for retreving the remote protocol data from gdbarch. */
290 static struct gdbarch_data
*remote_gdbarch_data_handle
;
292 static struct remote_arch_state
*
293 get_remote_arch_state (void)
295 return gdbarch_data (current_gdbarch
, remote_gdbarch_data_handle
);
298 /* Fetch the global remote target state. */
300 static struct remote_state
*
301 get_remote_state (void)
303 /* Make sure that the remote architecture state has been
304 initialized, because doing so might reallocate rs->buf. Any
305 function which calls getpkt also needs to be mindful of changes
306 to rs->buf, but this call limits the number of places which run
308 get_remote_arch_state ();
310 return get_remote_state_raw ();
314 compare_pnums (const void *lhs_
, const void *rhs_
)
316 const struct packet_reg
* const *lhs
= lhs_
;
317 const struct packet_reg
* const *rhs
= rhs_
;
319 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
321 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
328 init_remote_state (struct gdbarch
*gdbarch
)
330 int regnum
, num_remote_regs
, offset
;
331 struct remote_state
*rs
= get_remote_state_raw ();
332 struct remote_arch_state
*rsa
;
333 struct packet_reg
**remote_regs
;
335 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
337 /* Use the architecture to build a regnum<->pnum table, which will be
338 1:1 unless a feature set specifies otherwise. */
339 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
,
340 gdbarch_num_regs (current_gdbarch
),
342 for (regnum
= 0; regnum
< gdbarch_num_regs (current_gdbarch
); regnum
++)
344 struct packet_reg
*r
= &rsa
->regs
[regnum
];
346 if (register_size (current_gdbarch
, regnum
) == 0)
347 /* Do not try to fetch zero-sized (placeholder) registers. */
350 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
355 /* Define the g/G packet format as the contents of each register
356 with a remote protocol number, in order of ascending protocol
359 remote_regs
= alloca (gdbarch_num_regs (current_gdbarch
)
360 * sizeof (struct packet_reg
*));
361 for (num_remote_regs
= 0, regnum
= 0;
362 regnum
< gdbarch_num_regs (current_gdbarch
);
364 if (rsa
->regs
[regnum
].pnum
!= -1)
365 remote_regs
[num_remote_regs
++] = &rsa
->regs
[regnum
];
367 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
370 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
372 remote_regs
[regnum
]->in_g_packet
= 1;
373 remote_regs
[regnum
]->offset
= offset
;
374 offset
+= register_size (current_gdbarch
, remote_regs
[regnum
]->regnum
);
377 /* Record the maximum possible size of the g packet - it may turn out
379 rsa
->sizeof_g_packet
= offset
;
381 /* Default maximum number of characters in a packet body. Many
382 remote stubs have a hardwired buffer size of 400 bytes
383 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
384 as the maximum packet-size to ensure that the packet and an extra
385 NUL character can always fit in the buffer. This stops GDB
386 trashing stubs that try to squeeze an extra NUL into what is
387 already a full buffer (As of 1999-12-04 that was most stubs). */
388 rsa
->remote_packet_size
= 400 - 1;
390 /* This one is filled in when a ``g'' packet is received. */
391 rsa
->actual_register_packet_size
= 0;
393 /* Should rsa->sizeof_g_packet needs more space than the
394 default, adjust the size accordingly. Remember that each byte is
395 encoded as two characters. 32 is the overhead for the packet
396 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
397 (``$NN:G...#NN'') is a better guess, the below has been padded a
399 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
400 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
402 /* Make sure that the packet buffer is plenty big enough for
403 this architecture. */
404 if (rs
->buf_size
< rsa
->remote_packet_size
)
406 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
407 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
413 /* Return the current allowed size of a remote packet. This is
414 inferred from the current architecture, and should be used to
415 limit the length of outgoing packets. */
417 get_remote_packet_size (void)
419 struct remote_state
*rs
= get_remote_state ();
420 struct remote_arch_state
*rsa
= get_remote_arch_state ();
422 if (rs
->explicit_packet_size
)
423 return rs
->explicit_packet_size
;
425 return rsa
->remote_packet_size
;
428 static struct packet_reg
*
429 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
431 if (regnum
< 0 && regnum
>= gdbarch_num_regs (current_gdbarch
))
435 struct packet_reg
*r
= &rsa
->regs
[regnum
];
436 gdb_assert (r
->regnum
== regnum
);
441 static struct packet_reg
*
442 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
445 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
447 struct packet_reg
*r
= &rsa
->regs
[i
];
454 /* FIXME: graces/2002-08-08: These variables should eventually be
455 bound to an instance of the target object (as in gdbarch-tdep()),
456 when such a thing exists. */
458 /* This is set to the data address of the access causing the target
459 to stop for a watchpoint. */
460 static CORE_ADDR remote_watch_data_address
;
462 /* This is non-zero if target stopped for a watchpoint. */
463 static int remote_stopped_by_watchpoint_p
;
465 static struct target_ops remote_ops
;
467 static struct target_ops extended_remote_ops
;
469 /* Temporary target ops. Just like the remote_ops and
470 extended_remote_ops, but with asynchronous support. */
471 static struct target_ops remote_async_ops
;
473 static struct target_ops extended_async_remote_ops
;
475 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
476 ``forever'' still use the normal timeout mechanism. This is
477 currently used by the ASYNC code to guarentee that target reads
478 during the initial connect always time-out. Once getpkt has been
479 modified to return a timeout indication and, in turn
480 remote_wait()/wait_for_inferior() have gained a timeout parameter
482 static int wait_forever_enabled_p
= 1;
485 /* This variable chooses whether to send a ^C or a break when the user
486 requests program interruption. Although ^C is usually what remote
487 systems expect, and that is the default here, sometimes a break is
488 preferable instead. */
490 static int remote_break
;
492 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
493 remote_open knows that we don't have a file open when the program
495 static struct serial
*remote_desc
= NULL
;
497 /* This variable sets the number of bits in an address that are to be
498 sent in a memory ("M" or "m") packet. Normally, after stripping
499 leading zeros, the entire address would be sent. This variable
500 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
501 initial implementation of remote.c restricted the address sent in
502 memory packets to ``host::sizeof long'' bytes - (typically 32
503 bits). Consequently, for 64 bit targets, the upper 32 bits of an
504 address was never sent. Since fixing this bug may cause a break in
505 some remote targets this variable is principly provided to
506 facilitate backward compatibility. */
508 static int remote_address_size
;
510 /* Tempoary to track who currently owns the terminal. See
511 target_async_terminal_* for more details. */
513 static int remote_async_terminal_ours_p
;
516 /* User configurable variables for the number of characters in a
517 memory read/write packet. MIN (rsa->remote_packet_size,
518 rsa->sizeof_g_packet) is the default. Some targets need smaller
519 values (fifo overruns, et.al.) and some users need larger values
520 (speed up transfers). The variables ``preferred_*'' (the user
521 request), ``current_*'' (what was actually set) and ``forced_*''
522 (Positive - a soft limit, negative - a hard limit). */
524 struct memory_packet_config
531 /* Compute the current size of a read/write packet. Since this makes
532 use of ``actual_register_packet_size'' the computation is dynamic. */
535 get_memory_packet_size (struct memory_packet_config
*config
)
537 struct remote_state
*rs
= get_remote_state ();
538 struct remote_arch_state
*rsa
= get_remote_arch_state ();
540 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
541 law?) that some hosts don't cope very well with large alloca()
542 calls. Eventually the alloca() code will be replaced by calls to
543 xmalloc() and make_cleanups() allowing this restriction to either
544 be lifted or removed. */
545 #ifndef MAX_REMOTE_PACKET_SIZE
546 #define MAX_REMOTE_PACKET_SIZE 16384
548 /* NOTE: 20 ensures we can write at least one byte. */
549 #ifndef MIN_REMOTE_PACKET_SIZE
550 #define MIN_REMOTE_PACKET_SIZE 20
555 if (config
->size
<= 0)
556 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
558 what_they_get
= config
->size
;
562 what_they_get
= get_remote_packet_size ();
563 /* Limit the packet to the size specified by the user. */
565 && what_they_get
> config
->size
)
566 what_they_get
= config
->size
;
568 /* Limit it to the size of the targets ``g'' response unless we have
569 permission from the stub to use a larger packet size. */
570 if (rs
->explicit_packet_size
== 0
571 && rsa
->actual_register_packet_size
> 0
572 && what_they_get
> rsa
->actual_register_packet_size
)
573 what_they_get
= rsa
->actual_register_packet_size
;
575 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
576 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
577 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
578 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
580 /* Make sure there is room in the global buffer for this packet
581 (including its trailing NUL byte). */
582 if (rs
->buf_size
< what_they_get
+ 1)
584 rs
->buf_size
= 2 * what_they_get
;
585 rs
->buf
= xrealloc (rs
->buf
, 2 * what_they_get
);
588 return what_they_get
;
591 /* Update the size of a read/write packet. If they user wants
592 something really big then do a sanity check. */
595 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
597 int fixed_p
= config
->fixed_p
;
598 long size
= config
->size
;
600 error (_("Argument required (integer, `fixed' or `limited')."));
601 else if (strcmp (args
, "hard") == 0
602 || strcmp (args
, "fixed") == 0)
604 else if (strcmp (args
, "soft") == 0
605 || strcmp (args
, "limit") == 0)
610 size
= strtoul (args
, &end
, 0);
612 error (_("Invalid %s (bad syntax)."), config
->name
);
614 /* Instead of explicitly capping the size of a packet to
615 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
616 instead allowed to set the size to something arbitrarily
618 if (size
> MAX_REMOTE_PACKET_SIZE
)
619 error (_("Invalid %s (too large)."), config
->name
);
623 if (fixed_p
&& !config
->fixed_p
)
625 if (! query (_("The target may not be able to correctly handle a %s\n"
626 "of %ld bytes. Change the packet size? "),
628 error (_("Packet size not changed."));
630 /* Update the config. */
631 config
->fixed_p
= fixed_p
;
636 show_memory_packet_size (struct memory_packet_config
*config
)
638 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
640 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
641 get_memory_packet_size (config
));
643 printf_filtered (_("Packets are limited to %ld bytes.\n"),
644 get_memory_packet_size (config
));
647 static struct memory_packet_config memory_write_packet_config
=
649 "memory-write-packet-size",
653 set_memory_write_packet_size (char *args
, int from_tty
)
655 set_memory_packet_size (args
, &memory_write_packet_config
);
659 show_memory_write_packet_size (char *args
, int from_tty
)
661 show_memory_packet_size (&memory_write_packet_config
);
665 get_memory_write_packet_size (void)
667 return get_memory_packet_size (&memory_write_packet_config
);
670 static struct memory_packet_config memory_read_packet_config
=
672 "memory-read-packet-size",
676 set_memory_read_packet_size (char *args
, int from_tty
)
678 set_memory_packet_size (args
, &memory_read_packet_config
);
682 show_memory_read_packet_size (char *args
, int from_tty
)
684 show_memory_packet_size (&memory_read_packet_config
);
688 get_memory_read_packet_size (void)
690 long size
= get_memory_packet_size (&memory_read_packet_config
);
691 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
692 extra buffer size argument before the memory read size can be
693 increased beyond this. */
694 if (size
> get_remote_packet_size ())
695 size
= get_remote_packet_size ();
700 /* Generic configuration support for packets the stub optionally
701 supports. Allows the user to specify the use of the packet as well
702 as allowing GDB to auto-detect support in the remote stub. */
706 PACKET_SUPPORT_UNKNOWN
= 0,
715 enum auto_boolean detect
;
716 enum packet_support support
;
719 /* Analyze a packet's return value and update the packet config
730 update_packet_config (struct packet_config
*config
)
732 switch (config
->detect
)
734 case AUTO_BOOLEAN_TRUE
:
735 config
->support
= PACKET_ENABLE
;
737 case AUTO_BOOLEAN_FALSE
:
738 config
->support
= PACKET_DISABLE
;
740 case AUTO_BOOLEAN_AUTO
:
741 config
->support
= PACKET_SUPPORT_UNKNOWN
;
747 show_packet_config_cmd (struct packet_config
*config
)
749 char *support
= "internal-error";
750 switch (config
->support
)
756 support
= "disabled";
758 case PACKET_SUPPORT_UNKNOWN
:
762 switch (config
->detect
)
764 case AUTO_BOOLEAN_AUTO
:
765 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
766 config
->name
, support
);
768 case AUTO_BOOLEAN_TRUE
:
769 case AUTO_BOOLEAN_FALSE
:
770 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
771 config
->name
, support
);
777 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
778 const char *title
, int legacy
)
785 config
->title
= title
;
786 config
->detect
= AUTO_BOOLEAN_AUTO
;
787 config
->support
= PACKET_SUPPORT_UNKNOWN
;
788 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
790 show_doc
= xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
792 /* set/show TITLE-packet {auto,on,off} */
793 cmd_name
= xstrprintf ("%s-packet", title
);
794 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
795 &config
->detect
, set_doc
, show_doc
, NULL
, /* help_doc */
796 set_remote_protocol_packet_cmd
,
797 show_remote_protocol_packet_cmd
,
798 &remote_set_cmdlist
, &remote_show_cmdlist
);
799 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
803 legacy_name
= xstrprintf ("%s-packet", name
);
804 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
805 &remote_set_cmdlist
);
806 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
807 &remote_show_cmdlist
);
811 static enum packet_result
812 packet_check_result (const char *buf
)
816 /* The stub recognized the packet request. Check that the
817 operation succeeded. */
819 && isxdigit (buf
[1]) && isxdigit (buf
[2])
821 /* "Enn" - definitly an error. */
824 /* Always treat "E." as an error. This will be used for
825 more verbose error messages, such as E.memtypes. */
826 if (buf
[0] == 'E' && buf
[1] == '.')
829 /* The packet may or may not be OK. Just assume it is. */
833 /* The stub does not support the packet. */
834 return PACKET_UNKNOWN
;
837 static enum packet_result
838 packet_ok (const char *buf
, struct packet_config
*config
)
840 enum packet_result result
;
842 result
= packet_check_result (buf
);
847 /* The stub recognized the packet request. */
848 switch (config
->support
)
850 case PACKET_SUPPORT_UNKNOWN
:
852 fprintf_unfiltered (gdb_stdlog
,
853 "Packet %s (%s) is supported\n",
854 config
->name
, config
->title
);
855 config
->support
= PACKET_ENABLE
;
858 internal_error (__FILE__
, __LINE__
,
859 _("packet_ok: attempt to use a disabled packet"));
866 /* The stub does not support the packet. */
867 switch (config
->support
)
870 if (config
->detect
== AUTO_BOOLEAN_AUTO
)
871 /* If the stub previously indicated that the packet was
872 supported then there is a protocol error.. */
873 error (_("Protocol error: %s (%s) conflicting enabled responses."),
874 config
->name
, config
->title
);
876 /* The user set it wrong. */
877 error (_("Enabled packet %s (%s) not recognized by stub"),
878 config
->name
, config
->title
);
880 case PACKET_SUPPORT_UNKNOWN
:
882 fprintf_unfiltered (gdb_stdlog
,
883 "Packet %s (%s) is NOT supported\n",
884 config
->name
, config
->title
);
885 config
->support
= PACKET_DISABLE
;
908 PACKET_qXfer_features
,
909 PACKET_qXfer_memory_map
,
916 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
919 set_remote_protocol_packet_cmd (char *args
, int from_tty
,
920 struct cmd_list_element
*c
)
922 struct packet_config
*packet
;
924 for (packet
= remote_protocol_packets
;
925 packet
< &remote_protocol_packets
[PACKET_MAX
];
928 if (&packet
->detect
== c
->var
)
930 update_packet_config (packet
);
934 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
939 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
940 struct cmd_list_element
*c
,
943 struct packet_config
*packet
;
945 for (packet
= remote_protocol_packets
;
946 packet
< &remote_protocol_packets
[PACKET_MAX
];
949 if (&packet
->detect
== c
->var
)
951 show_packet_config_cmd (packet
);
955 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
959 /* Should we try one of the 'Z' requests? */
963 Z_PACKET_SOFTWARE_BP
,
964 Z_PACKET_HARDWARE_BP
,
971 /* For compatibility with older distributions. Provide a ``set remote
972 Z-packet ...'' command that updates all the Z packet types. */
974 static enum auto_boolean remote_Z_packet_detect
;
977 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
978 struct cmd_list_element
*c
)
981 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
983 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
984 update_packet_config (&remote_protocol_packets
[PACKET_Z0
+ i
]);
989 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
990 struct cmd_list_element
*c
,
994 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
996 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1000 /* Should we try the 'ThreadInfo' query packet?
1002 This variable (NOT available to the user: auto-detect only!)
1003 determines whether GDB will use the new, simpler "ThreadInfo"
1004 query or the older, more complex syntax for thread queries.
1005 This is an auto-detect variable (set to true at each connect,
1006 and set to false when the target fails to recognize it). */
1008 static int use_threadinfo_query
;
1009 static int use_threadextra_query
;
1011 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1012 static struct async_signal_handler
*sigint_remote_twice_token
;
1013 static struct async_signal_handler
*sigint_remote_token
;
1015 /* These are pointers to hook functions that may be set in order to
1016 modify resume/wait behavior for a particular architecture. */
1018 void (*deprecated_target_resume_hook
) (void);
1019 void (*deprecated_target_wait_loop_hook
) (void);
1023 /* These are the threads which we last sent to the remote system.
1024 -1 for all or -2 for not sent yet. */
1025 static int general_thread
;
1026 static int continue_thread
;
1028 /* Call this function as a result of
1029 1) A halt indication (T packet) containing a thread id
1030 2) A direct query of currthread
1031 3) Successful execution of set thread
1035 record_currthread (int currthread
)
1037 general_thread
= currthread
;
1039 /* If this is a new thread, add it to GDB's thread list.
1040 If we leave it up to WFI to do this, bad things will happen. */
1041 if (!in_thread_list (pid_to_ptid (currthread
)))
1043 add_thread (pid_to_ptid (currthread
));
1044 ui_out_text (uiout
, "[New ");
1045 ui_out_text (uiout
, target_pid_to_str (pid_to_ptid (currthread
)));
1046 ui_out_text (uiout
, "]\n");
1050 static char *last_pass_packet
;
1052 /* If 'QPassSignals' is supported, tell the remote stub what signals
1053 it can simply pass through to the inferior without reporting. */
1056 remote_pass_signals (void)
1058 if (remote_protocol_packets
[PACKET_QPassSignals
].support
!= PACKET_DISABLE
)
1060 char *pass_packet
, *p
;
1061 int numsigs
= (int) TARGET_SIGNAL_LAST
;
1064 gdb_assert (numsigs
< 256);
1065 for (i
= 0; i
< numsigs
; i
++)
1067 if (signal_stop_state (i
) == 0
1068 && signal_print_state (i
) == 0
1069 && signal_pass_state (i
) == 1)
1072 pass_packet
= xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
1073 strcpy (pass_packet
, "QPassSignals:");
1074 p
= pass_packet
+ strlen (pass_packet
);
1075 for (i
= 0; i
< numsigs
; i
++)
1077 if (signal_stop_state (i
) == 0
1078 && signal_print_state (i
) == 0
1079 && signal_pass_state (i
) == 1)
1082 *p
++ = tohex (i
>> 4);
1083 *p
++ = tohex (i
& 15);
1092 if (!last_pass_packet
|| strcmp (last_pass_packet
, pass_packet
))
1094 struct remote_state
*rs
= get_remote_state ();
1095 char *buf
= rs
->buf
;
1097 putpkt (pass_packet
);
1098 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1099 packet_ok (buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
1100 if (last_pass_packet
)
1101 xfree (last_pass_packet
);
1102 last_pass_packet
= pass_packet
;
1105 xfree (pass_packet
);
1109 #define MAGIC_NULL_PID 42000
1112 set_thread (int th
, int gen
)
1114 struct remote_state
*rs
= get_remote_state ();
1115 char *buf
= rs
->buf
;
1116 int state
= gen
? general_thread
: continue_thread
;
1122 buf
[1] = gen
? 'g' : 'c';
1123 if (th
== MAGIC_NULL_PID
)
1129 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "-%x", -th
);
1131 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "%x", th
);
1133 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1135 general_thread
= th
;
1137 continue_thread
= th
;
1140 /* Return nonzero if the thread TH is still alive on the remote system. */
1143 remote_thread_alive (ptid_t ptid
)
1145 struct remote_state
*rs
= get_remote_state ();
1146 int tid
= PIDGET (ptid
);
1149 xsnprintf (rs
->buf
, get_remote_packet_size (), "T-%08x", -tid
);
1151 xsnprintf (rs
->buf
, get_remote_packet_size (), "T%08x", tid
);
1153 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1154 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
1157 /* About these extended threadlist and threadinfo packets. They are
1158 variable length packets but, the fields within them are often fixed
1159 length. They are redundent enough to send over UDP as is the
1160 remote protocol in general. There is a matching unit test module
1163 #define OPAQUETHREADBYTES 8
1165 /* a 64 bit opaque identifier */
1166 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
1168 /* WARNING: This threadref data structure comes from the remote O.S.,
1169 libstub protocol encoding, and remote.c. it is not particularly
1172 /* Right now, the internal structure is int. We want it to be bigger.
1176 typedef int gdb_threadref
; /* Internal GDB thread reference. */
1178 /* gdb_ext_thread_info is an internal GDB data structure which is
1179 equivalent to the reply of the remote threadinfo packet. */
1181 struct gdb_ext_thread_info
1183 threadref threadid
; /* External form of thread reference. */
1184 int active
; /* Has state interesting to GDB?
1186 char display
[256]; /* Brief state display, name,
1187 blocked/suspended. */
1188 char shortname
[32]; /* To be used to name threads. */
1189 char more_display
[256]; /* Long info, statistics, queue depth,
1193 /* The volume of remote transfers can be limited by submitting
1194 a mask containing bits specifying the desired information.
1195 Use a union of these values as the 'selection' parameter to
1196 get_thread_info. FIXME: Make these TAG names more thread specific.
1199 #define TAG_THREADID 1
1200 #define TAG_EXISTS 2
1201 #define TAG_DISPLAY 4
1202 #define TAG_THREADNAME 8
1203 #define TAG_MOREDISPLAY 16
1205 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1207 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1209 static char *unpack_nibble (char *buf
, int *val
);
1211 static char *pack_nibble (char *buf
, int nibble
);
1213 static char *pack_hex_byte (char *pkt
, int /* unsigned char */ byte
);
1215 static char *unpack_byte (char *buf
, int *value
);
1217 static char *pack_int (char *buf
, int value
);
1219 static char *unpack_int (char *buf
, int *value
);
1221 static char *unpack_string (char *src
, char *dest
, int length
);
1223 static char *pack_threadid (char *pkt
, threadref
*id
);
1225 static char *unpack_threadid (char *inbuf
, threadref
*id
);
1227 void int_to_threadref (threadref
*id
, int value
);
1229 static int threadref_to_int (threadref
*ref
);
1231 static void copy_threadref (threadref
*dest
, threadref
*src
);
1233 static int threadmatch (threadref
*dest
, threadref
*src
);
1235 static char *pack_threadinfo_request (char *pkt
, int mode
,
1238 static int remote_unpack_thread_info_response (char *pkt
,
1239 threadref
*expectedref
,
1240 struct gdb_ext_thread_info
1244 static int remote_get_threadinfo (threadref
*threadid
,
1245 int fieldset
, /*TAG mask */
1246 struct gdb_ext_thread_info
*info
);
1248 static char *pack_threadlist_request (char *pkt
, int startflag
,
1250 threadref
*nextthread
);
1252 static int parse_threadlist_response (char *pkt
,
1254 threadref
*original_echo
,
1255 threadref
*resultlist
,
1258 static int remote_get_threadlist (int startflag
,
1259 threadref
*nextthread
,
1263 threadref
*threadlist
);
1265 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
1267 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
1268 void *context
, int looplimit
);
1270 static int remote_newthread_step (threadref
*ref
, void *context
);
1272 /* Encode 64 bits in 16 chars of hex. */
1274 static const char hexchars
[] = "0123456789abcdef";
1277 ishex (int ch
, int *val
)
1279 if ((ch
>= 'a') && (ch
<= 'f'))
1281 *val
= ch
- 'a' + 10;
1284 if ((ch
>= 'A') && (ch
<= 'F'))
1286 *val
= ch
- 'A' + 10;
1289 if ((ch
>= '0') && (ch
<= '9'))
1300 if (ch
>= 'a' && ch
<= 'f')
1301 return ch
- 'a' + 10;
1302 if (ch
>= '0' && ch
<= '9')
1304 if (ch
>= 'A' && ch
<= 'F')
1305 return ch
- 'A' + 10;
1310 stub_unpack_int (char *buff
, int fieldlength
)
1317 nibble
= stubhex (*buff
++);
1321 retval
= retval
<< 4;
1327 unpack_varlen_hex (char *buff
, /* packet to parse */
1331 ULONGEST retval
= 0;
1333 while (ishex (*buff
, &nibble
))
1336 retval
= retval
<< 4;
1337 retval
|= nibble
& 0x0f;
1344 unpack_nibble (char *buf
, int *val
)
1346 ishex (*buf
++, val
);
1351 pack_nibble (char *buf
, int nibble
)
1353 *buf
++ = hexchars
[(nibble
& 0x0f)];
1358 pack_hex_byte (char *pkt
, int byte
)
1360 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
1361 *pkt
++ = hexchars
[(byte
& 0xf)];
1366 unpack_byte (char *buf
, int *value
)
1368 *value
= stub_unpack_int (buf
, 2);
1373 pack_int (char *buf
, int value
)
1375 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
1376 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
1377 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
1378 buf
= pack_hex_byte (buf
, (value
& 0xff));
1383 unpack_int (char *buf
, int *value
)
1385 *value
= stub_unpack_int (buf
, 8);
1389 #if 0 /* Currently unused, uncomment when needed. */
1390 static char *pack_string (char *pkt
, char *string
);
1393 pack_string (char *pkt
, char *string
)
1398 len
= strlen (string
);
1400 len
= 200; /* Bigger than most GDB packets, junk??? */
1401 pkt
= pack_hex_byte (pkt
, len
);
1405 if ((ch
== '\0') || (ch
== '#'))
1406 ch
= '*'; /* Protect encapsulation. */
1411 #endif /* 0 (unused) */
1414 unpack_string (char *src
, char *dest
, int length
)
1423 pack_threadid (char *pkt
, threadref
*id
)
1426 unsigned char *altid
;
1428 altid
= (unsigned char *) id
;
1429 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
1431 pkt
= pack_hex_byte (pkt
, *altid
++);
1437 unpack_threadid (char *inbuf
, threadref
*id
)
1440 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
1443 altref
= (char *) id
;
1445 while (inbuf
< limit
)
1447 x
= stubhex (*inbuf
++);
1448 y
= stubhex (*inbuf
++);
1449 *altref
++ = (x
<< 4) | y
;
1454 /* Externally, threadrefs are 64 bits but internally, they are still
1455 ints. This is due to a mismatch of specifications. We would like
1456 to use 64bit thread references internally. This is an adapter
1460 int_to_threadref (threadref
*id
, int value
)
1462 unsigned char *scan
;
1464 scan
= (unsigned char *) id
;
1470 *scan
++ = (value
>> 24) & 0xff;
1471 *scan
++ = (value
>> 16) & 0xff;
1472 *scan
++ = (value
>> 8) & 0xff;
1473 *scan
++ = (value
& 0xff);
1477 threadref_to_int (threadref
*ref
)
1480 unsigned char *scan
;
1486 value
= (value
<< 8) | ((*scan
++) & 0xff);
1491 copy_threadref (threadref
*dest
, threadref
*src
)
1494 unsigned char *csrc
, *cdest
;
1496 csrc
= (unsigned char *) src
;
1497 cdest
= (unsigned char *) dest
;
1504 threadmatch (threadref
*dest
, threadref
*src
)
1506 /* Things are broken right now, so just assume we got a match. */
1508 unsigned char *srcp
, *destp
;
1510 srcp
= (char *) src
;
1511 destp
= (char *) dest
;
1515 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
1522 threadid:1, # always request threadid
1529 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1532 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
1534 *pkt
++ = 'q'; /* Info Query */
1535 *pkt
++ = 'P'; /* process or thread info */
1536 pkt
= pack_int (pkt
, mode
); /* mode */
1537 pkt
= pack_threadid (pkt
, id
); /* threadid */
1538 *pkt
= '\0'; /* terminate */
1542 /* These values tag the fields in a thread info response packet. */
1543 /* Tagging the fields allows us to request specific fields and to
1544 add more fields as time goes by. */
1546 #define TAG_THREADID 1 /* Echo the thread identifier. */
1547 #define TAG_EXISTS 2 /* Is this process defined enough to
1548 fetch registers and its stack? */
1549 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1550 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1551 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1555 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
1556 struct gdb_ext_thread_info
*info
)
1558 struct remote_state
*rs
= get_remote_state ();
1562 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
1565 /* info->threadid = 0; FIXME: implement zero_threadref. */
1567 info
->display
[0] = '\0';
1568 info
->shortname
[0] = '\0';
1569 info
->more_display
[0] = '\0';
1571 /* Assume the characters indicating the packet type have been
1573 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
1574 pkt
= unpack_threadid (pkt
, &ref
);
1577 warning (_("Incomplete response to threadinfo request."));
1578 if (!threadmatch (&ref
, expectedref
))
1579 { /* This is an answer to a different request. */
1580 warning (_("ERROR RMT Thread info mismatch."));
1583 copy_threadref (&info
->threadid
, &ref
);
1585 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1587 /* Packets are terminated with nulls. */
1588 while ((pkt
< limit
) && mask
&& *pkt
)
1590 pkt
= unpack_int (pkt
, &tag
); /* tag */
1591 pkt
= unpack_byte (pkt
, &length
); /* length */
1592 if (!(tag
& mask
)) /* Tags out of synch with mask. */
1594 warning (_("ERROR RMT: threadinfo tag mismatch."));
1598 if (tag
== TAG_THREADID
)
1602 warning (_("ERROR RMT: length of threadid is not 16."));
1606 pkt
= unpack_threadid (pkt
, &ref
);
1607 mask
= mask
& ~TAG_THREADID
;
1610 if (tag
== TAG_EXISTS
)
1612 info
->active
= stub_unpack_int (pkt
, length
);
1614 mask
= mask
& ~(TAG_EXISTS
);
1617 warning (_("ERROR RMT: 'exists' length too long."));
1623 if (tag
== TAG_THREADNAME
)
1625 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
1626 mask
= mask
& ~TAG_THREADNAME
;
1629 if (tag
== TAG_DISPLAY
)
1631 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
1632 mask
= mask
& ~TAG_DISPLAY
;
1635 if (tag
== TAG_MOREDISPLAY
)
1637 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
1638 mask
= mask
& ~TAG_MOREDISPLAY
;
1641 warning (_("ERROR RMT: unknown thread info tag."));
1642 break; /* Not a tag we know about. */
1648 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
1649 struct gdb_ext_thread_info
*info
)
1651 struct remote_state
*rs
= get_remote_state ();
1654 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
1656 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1657 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
1662 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1665 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
1666 threadref
*nextthread
)
1668 *pkt
++ = 'q'; /* info query packet */
1669 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
1670 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
1671 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
1672 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
1677 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1680 parse_threadlist_response (char *pkt
, int result_limit
,
1681 threadref
*original_echo
, threadref
*resultlist
,
1684 struct remote_state
*rs
= get_remote_state ();
1686 int count
, resultcount
, done
;
1689 /* Assume the 'q' and 'M chars have been stripped. */
1690 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
1691 /* done parse past here */
1692 pkt
= unpack_byte (pkt
, &count
); /* count field */
1693 pkt
= unpack_nibble (pkt
, &done
);
1694 /* The first threadid is the argument threadid. */
1695 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
1696 while ((count
-- > 0) && (pkt
< limit
))
1698 pkt
= unpack_threadid (pkt
, resultlist
++);
1699 if (resultcount
++ >= result_limit
)
1708 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
1709 int *done
, int *result_count
, threadref
*threadlist
)
1711 struct remote_state
*rs
= get_remote_state ();
1712 static threadref echo_nextthread
;
1715 /* Trancate result limit to be smaller than the packet size. */
1716 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10) >= get_remote_packet_size ())
1717 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
1719 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
1721 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1724 parse_threadlist_response (rs
->buf
+ 2, result_limit
, &echo_nextthread
,
1727 if (!threadmatch (&echo_nextthread
, nextthread
))
1729 /* FIXME: This is a good reason to drop the packet. */
1730 /* Possably, there is a duplicate response. */
1732 retransmit immediatly - race conditions
1733 retransmit after timeout - yes
1735 wait for packet, then exit
1737 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1738 return 0; /* I choose simply exiting. */
1740 if (*result_count
<= 0)
1744 warning (_("RMT ERROR : failed to get remote thread list."));
1747 return result
; /* break; */
1749 if (*result_count
> result_limit
)
1752 warning (_("RMT ERROR: threadlist response longer than requested."));
1758 /* This is the interface between remote and threads, remotes upper
1761 /* remote_find_new_threads retrieves the thread list and for each
1762 thread in the list, looks up the thread in GDB's internal list,
1763 ading the thread if it does not already exist. This involves
1764 getting partial thread lists from the remote target so, polling the
1765 quit_flag is required. */
1768 /* About this many threadisds fit in a packet. */
1770 #define MAXTHREADLISTRESULTS 32
1773 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
1776 int done
, i
, result_count
;
1780 static threadref nextthread
;
1781 static threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
1786 if (loopcount
++ > looplimit
)
1789 warning (_("Remote fetch threadlist -infinite loop-."));
1792 if (!remote_get_threadlist (startflag
, &nextthread
, MAXTHREADLISTRESULTS
,
1793 &done
, &result_count
, resultthreadlist
))
1798 /* Clear for later iterations. */
1800 /* Setup to resume next batch of thread references, set nextthread. */
1801 if (result_count
>= 1)
1802 copy_threadref (&nextthread
, &resultthreadlist
[result_count
- 1]);
1804 while (result_count
--)
1805 if (!(result
= (*stepfunction
) (&resultthreadlist
[i
++], context
)))
1812 remote_newthread_step (threadref
*ref
, void *context
)
1816 ptid
= pid_to_ptid (threadref_to_int (ref
));
1818 if (!in_thread_list (ptid
))
1820 return 1; /* continue iterator */
1823 #define CRAZY_MAX_THREADS 1000
1826 remote_current_thread (ptid_t oldpid
)
1828 struct remote_state
*rs
= get_remote_state ();
1831 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1832 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
1833 /* Use strtoul here, so we'll correctly parse values whose highest
1834 bit is set. The protocol carries them as a simple series of
1835 hex digits; in the absence of a sign, strtol will see such
1836 values as positive numbers out of range for signed 'long', and
1837 return LONG_MAX to indicate an overflow. */
1838 return pid_to_ptid (strtoul (&rs
->buf
[2], NULL
, 16));
1843 /* Find new threads for info threads command.
1844 * Original version, using John Metzler's thread protocol.
1848 remote_find_new_threads (void)
1850 remote_threadlist_iterator (remote_newthread_step
, 0,
1852 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
) /* ack ack ack */
1853 inferior_ptid
= remote_current_thread (inferior_ptid
);
1857 * Find all threads for info threads command.
1858 * Uses new thread protocol contributed by Cisco.
1859 * Falls back and attempts to use the older method (above)
1860 * if the target doesn't respond to the new method.
1864 remote_threads_info (void)
1866 struct remote_state
*rs
= get_remote_state ();
1870 if (remote_desc
== 0) /* paranoia */
1871 error (_("Command can only be used when connected to the remote target."));
1873 if (use_threadinfo_query
)
1875 putpkt ("qfThreadInfo");
1876 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1878 if (bufp
[0] != '\0') /* q packet recognized */
1880 while (*bufp
++ == 'm') /* reply contains one or more TID */
1884 /* Use strtoul here, so we'll correctly parse values
1885 whose highest bit is set. The protocol carries
1886 them as a simple series of hex digits; in the
1887 absence of a sign, strtol will see such values as
1888 positive numbers out of range for signed 'long',
1889 and return LONG_MAX to indicate an overflow. */
1890 tid
= strtoul (bufp
, &bufp
, 16);
1891 if (tid
!= 0 && !in_thread_list (pid_to_ptid (tid
)))
1892 add_thread (pid_to_ptid (tid
));
1894 while (*bufp
++ == ','); /* comma-separated list */
1895 putpkt ("qsThreadInfo");
1896 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1903 /* Else fall back to old method based on jmetzler protocol. */
1904 use_threadinfo_query
= 0;
1905 remote_find_new_threads ();
1910 * Collect a descriptive string about the given thread.
1911 * The target may say anything it wants to about the thread
1912 * (typically info about its blocked / runnable state, name, etc.).
1913 * This string will appear in the info threads display.
1915 * Optional: targets are not required to implement this function.
1919 remote_threads_extra_info (struct thread_info
*tp
)
1921 struct remote_state
*rs
= get_remote_state ();
1925 struct gdb_ext_thread_info threadinfo
;
1926 static char display_buf
[100]; /* arbitrary... */
1927 int n
= 0; /* position in display_buf */
1929 if (remote_desc
== 0) /* paranoia */
1930 internal_error (__FILE__
, __LINE__
,
1931 _("remote_threads_extra_info"));
1933 if (use_threadextra_query
)
1935 xsnprintf (rs
->buf
, get_remote_packet_size (), "qThreadExtraInfo,%x",
1938 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1939 if (rs
->buf
[0] != 0)
1941 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
1942 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
1943 display_buf
[result
] = '\0';
1948 /* If the above query fails, fall back to the old method. */
1949 use_threadextra_query
= 0;
1950 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
1951 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
1952 int_to_threadref (&id
, PIDGET (tp
->ptid
));
1953 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
1954 if (threadinfo
.active
)
1956 if (*threadinfo
.shortname
)
1957 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
1958 " Name: %s,", threadinfo
.shortname
);
1959 if (*threadinfo
.display
)
1960 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1961 " State: %s,", threadinfo
.display
);
1962 if (*threadinfo
.more_display
)
1963 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1964 " Priority: %s", threadinfo
.more_display
);
1968 /* For purely cosmetic reasons, clear up trailing commas. */
1969 if (',' == display_buf
[n
-1])
1970 display_buf
[n
-1] = ' ';
1978 /* Restart the remote side; this is an extended protocol operation. */
1981 extended_remote_restart (void)
1983 struct remote_state
*rs
= get_remote_state ();
1985 /* Send the restart command; for reasons I don't understand the
1986 remote side really expects a number after the "R". */
1987 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
1990 remote_fileio_reset ();
1992 /* Now query for status so this looks just like we restarted
1993 gdbserver from scratch. */
1995 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1998 /* Clean up connection to a remote debugger. */
2001 remote_close (int quitting
)
2004 serial_close (remote_desc
);
2008 /* Query the remote side for the text, data and bss offsets. */
2013 struct remote_state
*rs
= get_remote_state ();
2017 CORE_ADDR text_addr
, data_addr
, bss_addr
;
2018 struct section_offsets
*offs
;
2020 putpkt ("qOffsets");
2021 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2024 if (buf
[0] == '\000')
2025 return; /* Return silently. Stub doesn't support
2029 warning (_("Remote failure reply: %s"), buf
);
2033 /* Pick up each field in turn. This used to be done with scanf, but
2034 scanf will make trouble if CORE_ADDR size doesn't match
2035 conversion directives correctly. The following code will work
2036 with any size of CORE_ADDR. */
2037 text_addr
= data_addr
= bss_addr
= 0;
2041 if (strncmp (ptr
, "Text=", 5) == 0)
2044 /* Don't use strtol, could lose on big values. */
2045 while (*ptr
&& *ptr
!= ';')
2046 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2051 if (!lose
&& strncmp (ptr
, ";Data=", 6) == 0)
2054 while (*ptr
&& *ptr
!= ';')
2055 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2060 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
2063 while (*ptr
&& *ptr
!= ';')
2064 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
2070 error (_("Malformed response to offset query, %s"), buf
);
2072 if (symfile_objfile
== NULL
)
2075 offs
= ((struct section_offsets
*)
2076 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
2077 memcpy (offs
, symfile_objfile
->section_offsets
,
2078 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
2080 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
2082 /* This is a temporary kludge to force data and bss to use the same offsets
2083 because that's what nlmconv does now. The real solution requires changes
2084 to the stub and remote.c that I don't have time to do right now. */
2086 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
2087 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
2089 objfile_relocate (symfile_objfile
, offs
);
2092 /* Stub for catch_exception. */
2095 remote_start_remote (struct ui_out
*uiout
, void *from_tty_p
)
2097 int from_tty
= * (int *) from_tty_p
;
2099 immediate_quit
++; /* Allow user to interrupt it. */
2101 /* Ack any packet which the remote side has already sent. */
2102 serial_write (remote_desc
, "+", 1);
2104 /* Let the stub know that we want it to return the thread. */
2107 inferior_ptid
= remote_current_thread (inferior_ptid
);
2109 get_offsets (); /* Get text, data & bss offsets. */
2111 putpkt ("?"); /* Initiate a query from remote machine. */
2114 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
2117 /* Open a connection to a remote debugger.
2118 NAME is the filename used for communication. */
2121 remote_open (char *name
, int from_tty
)
2123 remote_open_1 (name
, from_tty
, &remote_ops
, 0, 0);
2126 /* Just like remote_open, but with asynchronous support. */
2128 remote_async_open (char *name
, int from_tty
)
2130 remote_open_1 (name
, from_tty
, &remote_async_ops
, 0, 1);
2133 /* Open a connection to a remote debugger using the extended
2134 remote gdb protocol. NAME is the filename used for communication. */
2137 extended_remote_open (char *name
, int from_tty
)
2139 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */,
2143 /* Just like extended_remote_open, but with asynchronous support. */
2145 extended_remote_async_open (char *name
, int from_tty
)
2147 remote_open_1 (name
, from_tty
, &extended_async_remote_ops
,
2148 1 /*extended_p */, 1 /* async_p */);
2151 /* Generic code for opening a connection to a remote target. */
2154 init_all_packet_configs (void)
2157 for (i
= 0; i
< PACKET_MAX
; i
++)
2158 update_packet_config (&remote_protocol_packets
[i
]);
2161 /* Symbol look-up. */
2164 remote_check_symbols (struct objfile
*objfile
)
2166 struct remote_state
*rs
= get_remote_state ();
2167 char *msg
, *reply
, *tmp
;
2168 struct minimal_symbol
*sym
;
2171 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
2174 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2175 because we need both at the same time. */
2176 msg
= alloca (get_remote_packet_size ());
2178 /* Invite target to request symbol lookups. */
2180 putpkt ("qSymbol::");
2181 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2182 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
2185 while (strncmp (reply
, "qSymbol:", 8) == 0)
2188 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
2190 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
2192 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
2194 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
2195 paddr_nz (SYMBOL_VALUE_ADDRESS (sym
)),
2198 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2203 static struct serial
*
2204 remote_serial_open (char *name
)
2206 static int udp_warning
= 0;
2208 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2209 of in ser-tcp.c, because it is the remote protocol assuming that the
2210 serial connection is reliable and not the serial connection promising
2212 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
2215 The remote protocol may be unreliable over UDP.\n\
2216 Some events may be lost, rendering further debugging impossible."));
2220 return serial_open (name
);
2223 /* This type describes each known response to the qSupported
2225 struct protocol_feature
2227 /* The name of this protocol feature. */
2230 /* The default for this protocol feature. */
2231 enum packet_support default_support
;
2233 /* The function to call when this feature is reported, or after
2234 qSupported processing if the feature is not supported.
2235 The first argument points to this structure. The second
2236 argument indicates whether the packet requested support be
2237 enabled, disabled, or probed (or the default, if this function
2238 is being called at the end of processing and this feature was
2239 not reported). The third argument may be NULL; if not NULL, it
2240 is a NUL-terminated string taken from the packet following
2241 this feature's name and an equals sign. */
2242 void (*func
) (const struct protocol_feature
*, enum packet_support
,
2245 /* The corresponding packet for this feature. Only used if
2246 FUNC is remote_supported_packet. */
2251 remote_supported_packet (const struct protocol_feature
*feature
,
2252 enum packet_support support
,
2253 const char *argument
)
2257 warning (_("Remote qSupported response supplied an unexpected value for"
2258 " \"%s\"."), feature
->name
);
2262 if (remote_protocol_packets
[feature
->packet
].support
2263 == PACKET_SUPPORT_UNKNOWN
)
2264 remote_protocol_packets
[feature
->packet
].support
= support
;
2268 remote_packet_size (const struct protocol_feature
*feature
,
2269 enum packet_support support
, const char *value
)
2271 struct remote_state
*rs
= get_remote_state ();
2276 if (support
!= PACKET_ENABLE
)
2279 if (value
== NULL
|| *value
== '\0')
2281 warning (_("Remote target reported \"%s\" without a size."),
2287 packet_size
= strtol (value
, &value_end
, 16);
2288 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
2290 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2291 feature
->name
, value
);
2295 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
2297 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2298 packet_size
, MAX_REMOTE_PACKET_SIZE
);
2299 packet_size
= MAX_REMOTE_PACKET_SIZE
;
2302 /* Record the new maximum packet size. */
2303 rs
->explicit_packet_size
= packet_size
;
2306 static struct protocol_feature remote_protocol_features
[] = {
2307 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
2308 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
2309 PACKET_qXfer_auxv
},
2310 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
2311 PACKET_qXfer_features
},
2312 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
2313 PACKET_qXfer_memory_map
},
2314 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
2315 PACKET_QPassSignals
},
2319 remote_query_supported (void)
2321 struct remote_state
*rs
= get_remote_state ();
2324 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
2326 /* The packet support flags are handled differently for this packet
2327 than for most others. We treat an error, a disabled packet, and
2328 an empty response identically: any features which must be reported
2329 to be used will be automatically disabled. An empty buffer
2330 accomplishes this, since that is also the representation for a list
2331 containing no features. */
2334 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
2336 putpkt ("qSupported");
2337 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2339 /* If an error occured, warn, but do not return - just reset the
2340 buffer to empty and go on to disable features. */
2341 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
2344 warning (_("Remote failure reply: %s"), rs
->buf
);
2349 memset (seen
, 0, sizeof (seen
));
2354 enum packet_support is_supported
;
2355 char *p
, *end
, *name_end
, *value
;
2357 /* First separate out this item from the rest of the packet. If
2358 there's another item after this, we overwrite the separator
2359 (terminated strings are much easier to work with). */
2361 end
= strchr (p
, ';');
2364 end
= p
+ strlen (p
);
2374 warning (_("empty item in \"qSupported\" response"));
2379 name_end
= strchr (p
, '=');
2382 /* This is a name=value entry. */
2383 is_supported
= PACKET_ENABLE
;
2384 value
= name_end
+ 1;
2393 is_supported
= PACKET_ENABLE
;
2397 is_supported
= PACKET_DISABLE
;
2401 is_supported
= PACKET_SUPPORT_UNKNOWN
;
2405 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p
);
2411 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2412 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
2414 const struct protocol_feature
*feature
;
2417 feature
= &remote_protocol_features
[i
];
2418 feature
->func (feature
, is_supported
, value
);
2423 /* If we increased the packet size, make sure to increase the global
2424 buffer size also. We delay this until after parsing the entire
2425 qSupported packet, because this is the same buffer we were
2427 if (rs
->buf_size
< rs
->explicit_packet_size
)
2429 rs
->buf_size
= rs
->explicit_packet_size
;
2430 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
2433 /* Handle the defaults for unmentioned features. */
2434 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2437 const struct protocol_feature
*feature
;
2439 feature
= &remote_protocol_features
[i
];
2440 feature
->func (feature
, feature
->default_support
, NULL
);
2446 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
,
2447 int extended_p
, int async_p
)
2449 struct remote_state
*rs
= get_remote_state ();
2451 error (_("To open a remote debug connection, you need to specify what\n"
2452 "serial device is attached to the remote system\n"
2453 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2455 /* See FIXME above. */
2457 wait_forever_enabled_p
= 1;
2459 target_preopen (from_tty
);
2461 unpush_target (target
);
2463 /* Make sure we send the passed signals list the next time we resume. */
2464 xfree (last_pass_packet
);
2465 last_pass_packet
= NULL
;
2467 remote_fileio_reset ();
2468 reopen_exec_file ();
2471 remote_desc
= remote_serial_open (name
);
2473 perror_with_name (name
);
2475 if (baud_rate
!= -1)
2477 if (serial_setbaudrate (remote_desc
, baud_rate
))
2479 /* The requested speed could not be set. Error out to
2480 top level after closing remote_desc. Take care to
2481 set remote_desc to NULL to avoid closing remote_desc
2483 serial_close (remote_desc
);
2485 perror_with_name (name
);
2489 serial_raw (remote_desc
);
2491 /* If there is something sitting in the buffer we might take it as a
2492 response to a command, which would be bad. */
2493 serial_flush_input (remote_desc
);
2497 puts_filtered ("Remote debugging using ");
2498 puts_filtered (name
);
2499 puts_filtered ("\n");
2501 push_target (target
); /* Switch to using remote target now. */
2503 /* Reset the target state; these things will be queried either by
2504 remote_query_supported or as they are needed. */
2505 init_all_packet_configs ();
2506 rs
->explicit_packet_size
= 0;
2508 general_thread
= -2;
2509 continue_thread
= -2;
2511 /* Probe for ability to use "ThreadInfo" query, as required. */
2512 use_threadinfo_query
= 1;
2513 use_threadextra_query
= 1;
2515 /* The first packet we send to the target is the optional "supported
2516 packets" request. If the target can answer this, it will tell us
2517 which later probes to skip. */
2518 remote_query_supported ();
2520 /* Next, if the target can specify a description, read it. We do
2521 this before anything involving memory or registers. */
2522 target_find_description ();
2524 /* Without this, some commands which require an active target (such
2525 as kill) won't work. This variable serves (at least) double duty
2526 as both the pid of the target process (if it has such), and as a
2527 flag indicating that a target is active. These functions should
2528 be split out into seperate variables, especially since GDB will
2529 someday have a notion of debugging several processes. */
2531 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
2535 /* With this target we start out by owning the terminal. */
2536 remote_async_terminal_ours_p
= 1;
2538 /* FIXME: cagney/1999-09-23: During the initial connection it is
2539 assumed that the target is already ready and able to respond to
2540 requests. Unfortunately remote_start_remote() eventually calls
2541 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2542 around this. Eventually a mechanism that allows
2543 wait_for_inferior() to expect/get timeouts will be
2545 wait_forever_enabled_p
= 0;
2548 /* First delete any symbols previously loaded from shared libraries. */
2549 no_shared_libraries (NULL
, 0);
2551 /* Start the remote connection. If error() or QUIT, discard this
2552 target (we'd otherwise be in an inconsistent state) and then
2553 propogate the error on up the exception chain. This ensures that
2554 the caller doesn't stumble along blindly assuming that the
2555 function succeeded. The CLI doesn't have this problem but other
2556 UI's, such as MI do.
2558 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2559 this function should return an error indication letting the
2560 caller restore the previous state. Unfortunately the command
2561 ``target remote'' is directly wired to this function making that
2562 impossible. On a positive note, the CLI side of this problem has
2563 been fixed - the function set_cmd_context() makes it possible for
2564 all the ``target ....'' commands to share a common callback
2565 function. See cli-dump.c. */
2567 struct gdb_exception ex
2568 = catch_exception (uiout
, remote_start_remote
, &from_tty
,
2574 wait_forever_enabled_p
= 1;
2575 throw_exception (ex
);
2580 wait_forever_enabled_p
= 1;
2584 /* Tell the remote that we are using the extended protocol. */
2586 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2589 if (exec_bfd
) /* No use without an exec file. */
2590 remote_check_symbols (symfile_objfile
);
2593 /* This takes a program previously attached to and detaches it. After
2594 this is done, GDB can be used to debug some other program. We
2595 better not have left any breakpoints in the target program or it'll
2596 die when it hits one. */
2599 remote_detach (char *args
, int from_tty
)
2601 struct remote_state
*rs
= get_remote_state ();
2604 error (_("Argument given to \"detach\" when remotely debugging."));
2606 /* Tell the remote target to detach. */
2607 strcpy (rs
->buf
, "D");
2609 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2611 if (rs
->buf
[0] == 'E')
2612 error (_("Can't detach process."));
2614 /* Unregister the file descriptor from the event loop. */
2615 if (target_is_async_p ())
2616 serial_async (remote_desc
, NULL
, 0);
2618 target_mourn_inferior ();
2620 puts_filtered ("Ending remote debugging.\n");
2623 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2626 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
2629 error (_("Argument given to \"detach\" when remotely debugging."));
2631 /* Unregister the file descriptor from the event loop. */
2632 if (target_is_async_p ())
2633 serial_async (remote_desc
, NULL
, 0);
2635 target_mourn_inferior ();
2637 puts_filtered ("Ending remote debugging.\n");
2640 /* Convert hex digit A to a number. */
2645 if (a
>= '0' && a
<= '9')
2647 else if (a
>= 'a' && a
<= 'f')
2648 return a
- 'a' + 10;
2649 else if (a
>= 'A' && a
<= 'F')
2650 return a
- 'A' + 10;
2652 error (_("Reply contains invalid hex digit %d"), a
);
2656 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
2660 for (i
= 0; i
< count
; i
++)
2662 if (hex
[0] == 0 || hex
[1] == 0)
2664 /* Hex string is short, or of uneven length.
2665 Return the count that has been converted so far. */
2668 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
2674 /* Convert number NIB to a hex digit. */
2682 return 'a' + nib
- 10;
2686 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
2689 /* May use a length, or a nul-terminated string as input. */
2691 count
= strlen ((char *) bin
);
2693 for (i
= 0; i
< count
; i
++)
2695 *hex
++ = tohex ((*bin
>> 4) & 0xf);
2696 *hex
++ = tohex (*bin
++ & 0xf);
2702 /* Check for the availability of vCont. This function should also check
2706 remote_vcont_probe (struct remote_state
*rs
)
2710 strcpy (rs
->buf
, "vCont?");
2712 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2715 /* Make sure that the features we assume are supported. */
2716 if (strncmp (buf
, "vCont", 5) == 0)
2719 int support_s
, support_S
, support_c
, support_C
;
2725 while (p
&& *p
== ';')
2728 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2730 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2732 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2734 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2737 p
= strchr (p
, ';');
2740 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2741 BUF will make packet_ok disable the packet. */
2742 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
2746 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
2749 /* Resume the remote inferior by using a "vCont" packet. The thread
2750 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2751 resumed thread should be single-stepped and/or signalled. If PTID's
2752 PID is -1, then all threads are resumed; the thread to be stepped and/or
2753 signalled is given in the global INFERIOR_PTID. This function returns
2754 non-zero iff it resumes the inferior.
2756 This function issues a strict subset of all possible vCont commands at the
2760 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2762 struct remote_state
*rs
= get_remote_state ();
2763 int pid
= PIDGET (ptid
);
2764 char *buf
= NULL
, *outbuf
;
2765 struct cleanup
*old_cleanup
;
2767 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
2768 remote_vcont_probe (rs
);
2770 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
2773 /* If we could generate a wider range of packets, we'd have to worry
2774 about overflowing BUF. Should there be a generic
2775 "multi-part-packet" packet? */
2777 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
)
2779 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2780 don't have any PID numbers the inferior will understand. Make sure
2781 to only send forms that do not specify a PID. */
2782 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2783 outbuf
= xstrprintf ("vCont;S%02x", siggnal
);
2785 outbuf
= xstrprintf ("vCont;s");
2786 else if (siggnal
!= TARGET_SIGNAL_0
)
2787 outbuf
= xstrprintf ("vCont;C%02x", siggnal
);
2789 outbuf
= xstrprintf ("vCont;c");
2793 /* Resume all threads, with preference for INFERIOR_PTID. */
2794 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2795 outbuf
= xstrprintf ("vCont;S%02x:%x;c", siggnal
,
2796 PIDGET (inferior_ptid
));
2798 outbuf
= xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid
));
2799 else if (siggnal
!= TARGET_SIGNAL_0
)
2800 outbuf
= xstrprintf ("vCont;C%02x:%x;c", siggnal
,
2801 PIDGET (inferior_ptid
));
2803 outbuf
= xstrprintf ("vCont;c");
2807 /* Scheduler locking; resume only PTID. */
2808 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2809 outbuf
= xstrprintf ("vCont;S%02x:%x", siggnal
, pid
);
2811 outbuf
= xstrprintf ("vCont;s:%x", pid
);
2812 else if (siggnal
!= TARGET_SIGNAL_0
)
2813 outbuf
= xstrprintf ("vCont;C%02x:%x", siggnal
, pid
);
2815 outbuf
= xstrprintf ("vCont;c:%x", pid
);
2818 gdb_assert (outbuf
&& strlen (outbuf
) < get_remote_packet_size ());
2819 old_cleanup
= make_cleanup (xfree
, outbuf
);
2823 do_cleanups (old_cleanup
);
2828 /* Tell the remote machine to resume. */
2830 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
2832 static int last_sent_step
;
2835 remote_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2837 struct remote_state
*rs
= get_remote_state ();
2839 int pid
= PIDGET (ptid
);
2841 last_sent_signal
= siggnal
;
2842 last_sent_step
= step
;
2844 /* A hook for when we need to do something at the last moment before
2846 if (deprecated_target_resume_hook
)
2847 (*deprecated_target_resume_hook
) ();
2849 /* Update the inferior on signals to silently pass, if they've changed. */
2850 remote_pass_signals ();
2852 /* The vCont packet doesn't need to specify threads via Hc. */
2853 if (remote_vcont_resume (ptid
, step
, siggnal
))
2856 /* All other supported resume packets do use Hc, so call set_thread. */
2858 set_thread (0, 0); /* Run any thread. */
2860 set_thread (pid
, 0); /* Run this thread. */
2863 if (siggnal
!= TARGET_SIGNAL_0
)
2865 buf
[0] = step
? 'S' : 'C';
2866 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
2867 buf
[2] = tohex (((int) siggnal
) & 0xf);
2871 strcpy (buf
, step
? "s" : "c");
2876 /* Same as remote_resume, but with async support. */
2878 remote_async_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2880 remote_resume (ptid
, step
, siggnal
);
2882 /* We are about to start executing the inferior, let's register it
2883 with the event loop. NOTE: this is the one place where all the
2884 execution commands end up. We could alternatively do this in each
2885 of the execution commands in infcmd.c. */
2886 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2887 into infcmd.c in order to allow inferior function calls to work
2888 NOT asynchronously. */
2889 if (target_can_async_p ())
2890 target_async (inferior_event_handler
, 0);
2891 /* Tell the world that the target is now executing. */
2892 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2893 this? Instead, should the client of target just assume (for
2894 async targets) that the target is going to start executing? Is
2895 this information already found in the continuation block? */
2896 if (target_is_async_p ())
2897 target_executing
= 1;
2901 /* Set up the signal handler for SIGINT, while the target is
2902 executing, ovewriting the 'regular' SIGINT signal handler. */
2904 initialize_sigint_signal_handler (void)
2906 sigint_remote_token
=
2907 create_async_signal_handler (async_remote_interrupt
, NULL
);
2908 signal (SIGINT
, handle_remote_sigint
);
2911 /* Signal handler for SIGINT, while the target is executing. */
2913 handle_remote_sigint (int sig
)
2915 signal (sig
, handle_remote_sigint_twice
);
2916 sigint_remote_twice_token
=
2917 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
2918 mark_async_signal_handler_wrapper (sigint_remote_token
);
2921 /* Signal handler for SIGINT, installed after SIGINT has already been
2922 sent once. It will take effect the second time that the user sends
2925 handle_remote_sigint_twice (int sig
)
2927 signal (sig
, handle_sigint
);
2928 sigint_remote_twice_token
=
2929 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
2930 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
2933 /* Perform the real interruption of the target execution, in response
2936 async_remote_interrupt (gdb_client_data arg
)
2939 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2944 /* Perform interrupt, if the first attempt did not succeed. Just give
2945 up on the target alltogether. */
2947 async_remote_interrupt_twice (gdb_client_data arg
)
2950 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
2951 /* Do something only if the target was not killed by the previous
2953 if (target_executing
)
2956 signal (SIGINT
, handle_remote_sigint
);
2960 /* Reinstall the usual SIGINT handlers, after the target has
2963 cleanup_sigint_signal_handler (void *dummy
)
2965 signal (SIGINT
, handle_sigint
);
2966 if (sigint_remote_twice_token
)
2967 delete_async_signal_handler (&sigint_remote_twice_token
);
2968 if (sigint_remote_token
)
2969 delete_async_signal_handler (&sigint_remote_token
);
2972 /* Send ^C to target to halt it. Target will respond, and send us a
2974 static void (*ofunc
) (int);
2976 /* The command line interface's stop routine. This function is installed
2977 as a signal handler for SIGINT. The first time a user requests a
2978 stop, we call remote_stop to send a break or ^C. If there is no
2979 response from the target (it didn't stop when the user requested it),
2980 we ask the user if he'd like to detach from the target. */
2982 remote_interrupt (int signo
)
2984 /* If this doesn't work, try more severe steps. */
2985 signal (signo
, remote_interrupt_twice
);
2988 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2993 /* The user typed ^C twice. */
2996 remote_interrupt_twice (int signo
)
2998 signal (signo
, ofunc
);
3000 signal (signo
, remote_interrupt
);
3003 /* This is the generic stop called via the target vector. When a target
3004 interrupt is requested, either by the command line or the GUI, we
3005 will eventually end up here. */
3009 /* Send a break or a ^C, depending on user preference. */
3011 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
3014 serial_send_break (remote_desc
);
3016 serial_write (remote_desc
, "\003", 1);
3019 /* Ask the user what to do when an interrupt is received. */
3022 interrupt_query (void)
3024 target_terminal_ours ();
3026 if (query ("Interrupted while waiting for the program.\n\
3027 Give up (and stop debugging it)? "))
3029 target_mourn_inferior ();
3030 deprecated_throw_reason (RETURN_QUIT
);
3033 target_terminal_inferior ();
3036 /* Enable/disable target terminal ownership. Most targets can use
3037 terminal groups to control terminal ownership. Remote targets are
3038 different in that explicit transfer of ownership to/from GDB/target
3042 remote_async_terminal_inferior (void)
3044 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
3045 sync_execution here. This function should only be called when
3046 GDB is resuming the inferior in the forground. A background
3047 resume (``run&'') should leave GDB in control of the terminal and
3048 consequently should not call this code. */
3049 if (!sync_execution
)
3051 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
3052 calls target_terminal_*() idenpotent. The event-loop GDB talking
3053 to an asynchronous target with a synchronous command calls this
3054 function from both event-top.c and infrun.c/infcmd.c. Once GDB
3055 stops trying to transfer the terminal to the target when it
3056 shouldn't this guard can go away. */
3057 if (!remote_async_terminal_ours_p
)
3059 delete_file_handler (input_fd
);
3060 remote_async_terminal_ours_p
= 0;
3061 initialize_sigint_signal_handler ();
3062 /* NOTE: At this point we could also register our selves as the
3063 recipient of all input. Any characters typed could then be
3064 passed on down to the target. */
3068 remote_async_terminal_ours (void)
3070 /* See FIXME in remote_async_terminal_inferior. */
3071 if (!sync_execution
)
3073 /* See FIXME in remote_async_terminal_inferior. */
3074 if (remote_async_terminal_ours_p
)
3076 cleanup_sigint_signal_handler (NULL
);
3077 add_file_handler (input_fd
, stdin_event_handler
, 0);
3078 remote_async_terminal_ours_p
= 1;
3081 /* If nonzero, ignore the next kill. */
3086 remote_console_output (char *msg
)
3090 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
3093 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
3096 fputs_unfiltered (tb
, gdb_stdtarg
);
3098 gdb_flush (gdb_stdtarg
);
3101 /* Wait until the remote machine stops, then return,
3102 storing status in STATUS just as `wait' would.
3103 Returns "pid", which in the case of a multi-threaded
3104 remote OS, is the thread-id. */
3107 remote_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3109 struct remote_state
*rs
= get_remote_state ();
3110 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3111 ULONGEST thread_num
= -1;
3114 status
->kind
= TARGET_WAITKIND_EXITED
;
3115 status
->value
.integer
= 0;
3121 ofunc
= signal (SIGINT
, remote_interrupt
);
3122 getpkt (&rs
->buf
, &rs
->buf_size
, 1);
3123 signal (SIGINT
, ofunc
);
3127 /* This is a hook for when we need to do something (perhaps the
3128 collection of trace data) every time the target stops. */
3129 if (deprecated_target_wait_loop_hook
)
3130 (*deprecated_target_wait_loop_hook
) ();
3132 remote_stopped_by_watchpoint_p
= 0;
3136 case 'E': /* Error of some sort. */
3137 warning (_("Remote failure reply: %s"), buf
);
3139 case 'F': /* File-I/O request. */
3140 remote_fileio_request (buf
);
3142 case 'T': /* Status with PC, SP, FP, ... */
3144 gdb_byte regs
[MAX_REGISTER_SIZE
];
3146 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3147 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3149 n... = register number
3150 r... = register contents
3152 p
= &buf
[3]; /* after Txx */
3161 /* If the packet contains a register number save it in
3162 pnum and set p1 to point to the character following
3163 it. Otherwise p1 points to p. */
3165 /* If this packet is an awatch packet, don't parse the
3166 'a' as a register number. */
3168 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3170 /* Read the ``P'' register number. */
3171 pnum
= strtol (p
, &p_temp
, 16);
3177 if (p1
== p
) /* No register number present here. */
3179 p1
= strchr (p
, ':');
3181 error (_("Malformed packet(a) (missing colon): %s\n\
3184 if (strncmp (p
, "thread", p1
- p
) == 0)
3186 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3187 record_currthread (thread_num
);
3190 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3191 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3192 || (strncmp (p
, "awatch", p1
- p
) == 0))
3194 remote_stopped_by_watchpoint_p
= 1;
3195 p
= unpack_varlen_hex (++p1
, &addr
);
3196 remote_watch_data_address
= (CORE_ADDR
)addr
;
3200 /* Silently skip unknown optional info. */
3201 p_temp
= strchr (p1
+ 1, ';');
3208 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3212 error (_("Malformed packet(b) (missing colon): %s\n\
3217 error (_("Remote sent bad register number %s: %s\n\
3219 phex_nz (pnum
, 0), p
, buf
);
3221 fieldsize
= hex2bin (p
, regs
,
3222 register_size (current_gdbarch
,
3225 if (fieldsize
< register_size (current_gdbarch
,
3227 warning (_("Remote reply is too short: %s"), buf
);
3228 regcache_raw_supply (current_regcache
,
3233 error (_("Remote register badly formatted: %s\nhere: %s"),
3238 case 'S': /* Old style status, just signal only. */
3239 status
->kind
= TARGET_WAITKIND_STOPPED
;
3240 status
->value
.sig
= (enum target_signal
)
3241 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3245 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3246 record_currthread (thread_num
);
3249 case 'W': /* Target exited. */
3251 /* The remote process exited. */
3252 status
->kind
= TARGET_WAITKIND_EXITED
;
3253 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3257 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3258 status
->value
.sig
= (enum target_signal
)
3259 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3263 case 'O': /* Console output. */
3264 remote_console_output (buf
+ 1);
3267 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3269 /* Zero length reply means that we tried 'S' or 'C' and
3270 the remote system doesn't support it. */
3271 target_terminal_ours_for_output ();
3273 ("Can't send signals to this remote system. %s not sent.\n",
3274 target_signal_to_name (last_sent_signal
));
3275 last_sent_signal
= TARGET_SIGNAL_0
;
3276 target_terminal_inferior ();
3278 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3279 putpkt ((char *) buf
);
3282 /* else fallthrough */
3284 warning (_("Invalid remote reply: %s"), buf
);
3289 if (thread_num
!= -1)
3291 return pid_to_ptid (thread_num
);
3293 return inferior_ptid
;
3296 /* Async version of remote_wait. */
3298 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3300 struct remote_state
*rs
= get_remote_state ();
3301 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3302 ULONGEST thread_num
= -1;
3305 status
->kind
= TARGET_WAITKIND_EXITED
;
3306 status
->value
.integer
= 0;
3308 remote_stopped_by_watchpoint_p
= 0;
3314 if (!target_is_async_p ())
3315 ofunc
= signal (SIGINT
, remote_interrupt
);
3316 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3317 _never_ wait for ever -> test on target_is_async_p().
3318 However, before we do that we need to ensure that the caller
3319 knows how to take the target into/out of async mode. */
3320 getpkt (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
3321 if (!target_is_async_p ())
3322 signal (SIGINT
, ofunc
);
3326 /* This is a hook for when we need to do something (perhaps the
3327 collection of trace data) every time the target stops. */
3328 if (deprecated_target_wait_loop_hook
)
3329 (*deprecated_target_wait_loop_hook
) ();
3333 case 'E': /* Error of some sort. */
3334 warning (_("Remote failure reply: %s"), buf
);
3336 case 'F': /* File-I/O request. */
3337 remote_fileio_request (buf
);
3339 case 'T': /* Status with PC, SP, FP, ... */
3341 gdb_byte regs
[MAX_REGISTER_SIZE
];
3343 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3344 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3346 n... = register number
3347 r... = register contents
3349 p
= &buf
[3]; /* after Txx */
3358 /* If the packet contains a register number, save it
3359 in pnum and set p1 to point to the character
3360 following it. Otherwise p1 points to p. */
3362 /* If this packet is an awatch packet, don't parse the 'a'
3363 as a register number. */
3365 if (!strncmp (p
, "awatch", strlen ("awatch")) != 0)
3367 /* Read the register number. */
3368 pnum
= strtol (p
, &p_temp
, 16);
3374 if (p1
== p
) /* No register number present here. */
3376 p1
= strchr (p
, ':');
3378 error (_("Malformed packet(a) (missing colon): %s\n\
3381 if (strncmp (p
, "thread", p1
- p
) == 0)
3383 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3384 record_currthread (thread_num
);
3387 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3388 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3389 || (strncmp (p
, "awatch", p1
- p
) == 0))
3391 remote_stopped_by_watchpoint_p
= 1;
3392 p
= unpack_varlen_hex (++p1
, &addr
);
3393 remote_watch_data_address
= (CORE_ADDR
)addr
;
3397 /* Silently skip unknown optional info. */
3398 p_temp
= strchr (p1
+ 1, ';');
3406 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3409 error (_("Malformed packet(b) (missing colon): %s\n\
3414 error (_("Remote sent bad register number %ld: %s\n\
3418 fieldsize
= hex2bin (p
, regs
,
3419 register_size (current_gdbarch
,
3422 if (fieldsize
< register_size (current_gdbarch
,
3424 warning (_("Remote reply is too short: %s"), buf
);
3425 regcache_raw_supply (current_regcache
, reg
->regnum
, regs
);
3429 error (_("Remote register badly formatted: %s\nhere: %s"),
3434 case 'S': /* Old style status, just signal only. */
3435 status
->kind
= TARGET_WAITKIND_STOPPED
;
3436 status
->value
.sig
= (enum target_signal
)
3437 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3441 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3442 record_currthread (thread_num
);
3445 case 'W': /* Target exited. */
3447 /* The remote process exited. */
3448 status
->kind
= TARGET_WAITKIND_EXITED
;
3449 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3453 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3454 status
->value
.sig
= (enum target_signal
)
3455 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3459 case 'O': /* Console output. */
3460 remote_console_output (buf
+ 1);
3461 /* Return immediately to the event loop. The event loop will
3462 still be waiting on the inferior afterwards. */
3463 status
->kind
= TARGET_WAITKIND_IGNORE
;
3466 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3468 /* Zero length reply means that we tried 'S' or 'C' and
3469 the remote system doesn't support it. */
3470 target_terminal_ours_for_output ();
3472 ("Can't send signals to this remote system. %s not sent.\n",
3473 target_signal_to_name (last_sent_signal
));
3474 last_sent_signal
= TARGET_SIGNAL_0
;
3475 target_terminal_inferior ();
3477 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3478 putpkt ((char *) buf
);
3481 /* else fallthrough */
3483 warning (_("Invalid remote reply: %s"), buf
);
3488 if (thread_num
!= -1)
3490 return pid_to_ptid (thread_num
);
3492 return inferior_ptid
;
3495 /* Fetch a single register using a 'p' packet. */
3498 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
3500 struct remote_state
*rs
= get_remote_state ();
3502 char regp
[MAX_REGISTER_SIZE
];
3505 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
3508 if (reg
->pnum
== -1)
3513 p
+= hexnumstr (p
, reg
->pnum
);
3515 remote_send (&rs
->buf
, &rs
->buf_size
);
3519 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
3523 case PACKET_UNKNOWN
:
3526 error (_("Could not fetch register \"%s\""),
3527 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3530 /* If this register is unfetchable, tell the regcache. */
3533 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3537 /* Otherwise, parse and supply the value. */
3543 error (_("fetch_register_using_p: early buf termination"));
3545 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3548 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
3552 /* Fetch the registers included in the target's 'g' packet. */
3555 send_g_packet (void)
3557 struct remote_state
*rs
= get_remote_state ();
3562 sprintf (rs
->buf
, "g");
3563 remote_send (&rs
->buf
, &rs
->buf_size
);
3565 /* We can get out of synch in various cases. If the first character
3566 in the buffer is not a hex character, assume that has happened
3567 and try to fetch another packet to read. */
3568 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
3569 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
3570 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
3571 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
3574 fprintf_unfiltered (gdb_stdlog
,
3575 "Bad register packet; fetching a new packet\n");
3576 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3579 buf_len
= strlen (rs
->buf
);
3581 /* Sanity check the received packet. */
3582 if (buf_len
% 2 != 0)
3583 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
3589 process_g_packet (struct regcache
*regcache
)
3591 struct remote_state
*rs
= get_remote_state ();
3592 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3597 buf_len
= strlen (rs
->buf
);
3599 /* Further sanity checks, with knowledge of the architecture. */
3600 if (REGISTER_BYTES_OK_P () && !REGISTER_BYTES_OK (buf_len
/ 2))
3601 error (_("Remote 'g' packet reply is wrong length: %s"), rs
->buf
);
3602 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
3603 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
3605 /* Save the size of the packet sent to us by the target. It is used
3606 as a heuristic when determining the max size of packets that the
3607 target can safely receive. */
3608 if (rsa
->actual_register_packet_size
== 0)
3609 rsa
->actual_register_packet_size
= buf_len
;
3611 /* If this is smaller than we guessed the 'g' packet would be,
3612 update our records. A 'g' reply that doesn't include a register's
3613 value implies either that the register is not available, or that
3614 the 'p' packet must be used. */
3615 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
3617 rsa
->sizeof_g_packet
= buf_len
/ 2;
3619 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3621 if (rsa
->regs
[i
].pnum
== -1)
3624 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
3625 rsa
->regs
[i
].in_g_packet
= 0;
3627 rsa
->regs
[i
].in_g_packet
= 1;
3631 regs
= alloca (rsa
->sizeof_g_packet
);
3633 /* Unimplemented registers read as all bits zero. */
3634 memset (regs
, 0, rsa
->sizeof_g_packet
);
3636 /* Reply describes registers byte by byte, each byte encoded as two
3637 hex characters. Suck them all up, then supply them to the
3638 register cacheing/storage mechanism. */
3641 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3643 if (p
[0] == 0 || p
[1] == 0)
3644 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3645 internal_error (__FILE__
, __LINE__
,
3646 "unexpected end of 'g' packet reply");
3648 if (p
[0] == 'x' && p
[1] == 'x')
3649 regs
[i
] = 0; /* 'x' */
3651 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3657 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3659 struct packet_reg
*r
= &rsa
->regs
[i
];
3662 if (r
->offset
* 2 >= strlen (rs
->buf
))
3663 /* This shouldn't happen - we adjusted in_g_packet above. */
3664 internal_error (__FILE__
, __LINE__
,
3665 "unexpected end of 'g' packet reply");
3666 else if (rs
->buf
[r
->offset
* 2] == 'x')
3668 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
3669 /* The register isn't available, mark it as such (at
3670 the same time setting the value to zero). */
3671 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
3674 regcache_raw_supply (regcache
, r
->regnum
,
3682 fetch_registers_using_g (struct regcache
*regcache
)
3685 process_g_packet (regcache
);
3689 remote_fetch_registers (struct regcache
*regcache
, int regnum
)
3691 struct remote_state
*rs
= get_remote_state ();
3692 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3695 set_thread (PIDGET (inferior_ptid
), 1);
3699 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3700 gdb_assert (reg
!= NULL
);
3702 /* If this register might be in the 'g' packet, try that first -
3703 we are likely to read more than one register. If this is the
3704 first 'g' packet, we might be overly optimistic about its
3705 contents, so fall back to 'p'. */
3706 if (reg
->in_g_packet
)
3708 fetch_registers_using_g (regcache
);
3709 if (reg
->in_g_packet
)
3713 if (fetch_register_using_p (regcache
, reg
))
3716 /* This register is not available. */
3717 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3722 fetch_registers_using_g (regcache
);
3724 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3725 if (!rsa
->regs
[i
].in_g_packet
)
3726 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
3728 /* This register is not available. */
3729 regcache_raw_supply (regcache
, i
, NULL
);
3733 /* Prepare to store registers. Since we may send them all (using a
3734 'G' request), we have to read out the ones we don't want to change
3738 remote_prepare_to_store (struct regcache
*regcache
)
3740 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3742 gdb_byte buf
[MAX_REGISTER_SIZE
];
3744 /* Make sure the entire registers array is valid. */
3745 switch (remote_protocol_packets
[PACKET_P
].support
)
3747 case PACKET_DISABLE
:
3748 case PACKET_SUPPORT_UNKNOWN
:
3749 /* Make sure all the necessary registers are cached. */
3750 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3751 if (rsa
->regs
[i
].in_g_packet
)
3752 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
3759 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3760 packet was not recognized. */
3763 store_register_using_P (const struct regcache
*regcache
, struct packet_reg
*reg
)
3765 struct remote_state
*rs
= get_remote_state ();
3766 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3767 /* Try storing a single register. */
3768 char *buf
= rs
->buf
;
3769 gdb_byte regp
[MAX_REGISTER_SIZE
];
3772 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
3775 if (reg
->pnum
== -1)
3778 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
3779 p
= buf
+ strlen (buf
);
3780 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
3781 bin2hex (regp
, p
, register_size (current_gdbarch
, reg
->regnum
));
3782 remote_send (&rs
->buf
, &rs
->buf_size
);
3784 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
3789 error (_("Could not write register \"%s\""),
3790 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3791 case PACKET_UNKNOWN
:
3794 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
3798 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3799 contents of the register cache buffer. FIXME: ignores errors. */
3802 store_registers_using_G (const struct regcache
*regcache
)
3804 struct remote_state
*rs
= get_remote_state ();
3805 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3809 /* Extract all the registers in the regcache copying them into a
3813 regs
= alloca (rsa
->sizeof_g_packet
);
3814 memset (regs
, 0, rsa
->sizeof_g_packet
);
3815 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3817 struct packet_reg
*r
= &rsa
->regs
[i
];
3819 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
3823 /* Command describes registers byte by byte,
3824 each byte encoded as two hex characters. */
3827 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
3829 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
3830 remote_send (&rs
->buf
, &rs
->buf_size
);
3833 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3834 of the register cache buffer. FIXME: ignores errors. */
3837 remote_store_registers (struct regcache
*regcache
, int regnum
)
3839 struct remote_state
*rs
= get_remote_state ();
3840 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3843 set_thread (PIDGET (inferior_ptid
), 1);
3847 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3848 gdb_assert (reg
!= NULL
);
3850 /* Always prefer to store registers using the 'P' packet if
3851 possible; we often change only a small number of registers.
3852 Sometimes we change a larger number; we'd need help from a
3853 higher layer to know to use 'G'. */
3854 if (store_register_using_P (regcache
, reg
))
3857 /* For now, don't complain if we have no way to write the
3858 register. GDB loses track of unavailable registers too
3859 easily. Some day, this may be an error. We don't have
3860 any way to read the register, either... */
3861 if (!reg
->in_g_packet
)
3864 store_registers_using_G (regcache
);
3868 store_registers_using_G (regcache
);
3870 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3871 if (!rsa
->regs
[i
].in_g_packet
)
3872 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
3873 /* See above for why we do not issue an error here. */
3878 /* Return the number of hex digits in num. */
3881 hexnumlen (ULONGEST num
)
3885 for (i
= 0; num
!= 0; i
++)
3891 /* Set BUF to the minimum number of hex digits representing NUM. */
3894 hexnumstr (char *buf
, ULONGEST num
)
3896 int len
= hexnumlen (num
);
3897 return hexnumnstr (buf
, num
, len
);
3901 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3904 hexnumnstr (char *buf
, ULONGEST num
, int width
)
3910 for (i
= width
- 1; i
>= 0; i
--)
3912 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
3919 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3922 remote_address_masked (CORE_ADDR addr
)
3924 if (remote_address_size
> 0
3925 && remote_address_size
< (sizeof (ULONGEST
) * 8))
3927 /* Only create a mask when that mask can safely be constructed
3928 in a ULONGEST variable. */
3930 mask
= (mask
<< remote_address_size
) - 1;
3936 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
3937 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
3938 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
3939 (which may be more than *OUT_LEN due to escape characters). The
3940 total number of bytes in the output buffer will be at most
3944 remote_escape_output (const gdb_byte
*buffer
, int len
,
3945 gdb_byte
*out_buf
, int *out_len
,
3948 int input_index
, output_index
;
3951 for (input_index
= 0; input_index
< len
; input_index
++)
3953 gdb_byte b
= buffer
[input_index
];
3955 if (b
== '$' || b
== '#' || b
== '}')
3957 /* These must be escaped. */
3958 if (output_index
+ 2 > out_maxlen
)
3960 out_buf
[output_index
++] = '}';
3961 out_buf
[output_index
++] = b
^ 0x20;
3965 if (output_index
+ 1 > out_maxlen
)
3967 out_buf
[output_index
++] = b
;
3971 *out_len
= input_index
;
3972 return output_index
;
3975 /* Convert BUFFER, escaped data LEN bytes long, into binary data
3976 in OUT_BUF. Return the number of bytes written to OUT_BUF.
3977 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
3979 This function reverses remote_escape_output. It allows more
3980 escaped characters than that function does, in particular because
3981 '*' must be escaped to avoid the run-length encoding processing
3982 in reading packets. */
3985 remote_unescape_input (const gdb_byte
*buffer
, int len
,
3986 gdb_byte
*out_buf
, int out_maxlen
)
3988 int input_index
, output_index
;
3993 for (input_index
= 0; input_index
< len
; input_index
++)
3995 gdb_byte b
= buffer
[input_index
];
3997 if (output_index
+ 1 > out_maxlen
)
3999 warning (_("Received too much data from remote target;"
4000 " ignoring overflow."));
4001 return output_index
;
4006 out_buf
[output_index
++] = b
^ 0x20;
4012 out_buf
[output_index
++] = b
;
4016 error (_("Unmatched escape character in target response."));
4018 return output_index
;
4021 /* Determine whether the remote target supports binary downloading.
4022 This is accomplished by sending a no-op memory write of zero length
4023 to the target at the specified address. It does not suffice to send
4024 the whole packet, since many stubs strip the eighth bit and
4025 subsequently compute a wrong checksum, which causes real havoc with
4028 NOTE: This can still lose if the serial line is not eight-bit
4029 clean. In cases like this, the user should clear "remote
4033 check_binary_download (CORE_ADDR addr
)
4035 struct remote_state
*rs
= get_remote_state ();
4037 switch (remote_protocol_packets
[PACKET_X
].support
)
4039 case PACKET_DISABLE
:
4043 case PACKET_SUPPORT_UNKNOWN
:
4049 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4051 p
+= hexnumstr (p
, (ULONGEST
) 0);
4055 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4056 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4058 if (rs
->buf
[0] == '\0')
4061 fprintf_unfiltered (gdb_stdlog
,
4062 "binary downloading NOT suppported by target\n");
4063 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
4068 fprintf_unfiltered (gdb_stdlog
,
4069 "binary downloading suppported by target\n");
4070 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
4077 /* Write memory data directly to the remote machine.
4078 This does not inform the data cache; the data cache uses this.
4079 HEADER is the starting part of the packet.
4080 MEMADDR is the address in the remote memory space.
4081 MYADDR is the address of the buffer in our space.
4082 LEN is the number of bytes.
4083 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4084 should send data as binary ('X'), or hex-encoded ('M').
4086 The function creates packet of the form
4087 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4089 where encoding of <DATA> is termined by PACKET_FORMAT.
4091 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4094 Returns the number of bytes transferred, or 0 (setting errno) for
4095 error. Only transfer a single packet. */
4098 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
4099 const gdb_byte
*myaddr
, int len
,
4100 char packet_format
, int use_length
)
4102 struct remote_state
*rs
= get_remote_state ();
4112 if (packet_format
!= 'X' && packet_format
!= 'M')
4113 internal_error (__FILE__
, __LINE__
,
4114 "remote_write_bytes_aux: bad packet format");
4119 payload_size
= get_memory_write_packet_size ();
4121 /* The packet buffer will be large enough for the payload;
4122 get_memory_packet_size ensures this. */
4125 /* Compute the size of the actual payload by subtracting out the
4126 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4128 payload_size
-= strlen ("$,:#NN");
4130 /* The comma won't be used. */
4132 header_length
= strlen (header
);
4133 payload_size
-= header_length
;
4134 payload_size
-= hexnumlen (memaddr
);
4136 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4138 strcat (rs
->buf
, header
);
4139 p
= rs
->buf
+ strlen (header
);
4141 /* Compute a best guess of the number of bytes actually transfered. */
4142 if (packet_format
== 'X')
4144 /* Best guess at number of bytes that will fit. */
4145 todo
= min (len
, payload_size
);
4147 payload_size
-= hexnumlen (todo
);
4148 todo
= min (todo
, payload_size
);
4152 /* Num bytes that will fit. */
4153 todo
= min (len
, payload_size
/ 2);
4155 payload_size
-= hexnumlen (todo
);
4156 todo
= min (todo
, payload_size
/ 2);
4160 internal_error (__FILE__
, __LINE__
,
4161 _("minumum packet size too small to write data"));
4163 /* If we already need another packet, then try to align the end
4164 of this packet to a useful boundary. */
4165 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
4166 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
4168 /* Append "<memaddr>". */
4169 memaddr
= remote_address_masked (memaddr
);
4170 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4177 /* Append <len>. Retain the location/size of <len>. It may need to
4178 be adjusted once the packet body has been created. */
4180 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
4188 /* Append the packet body. */
4189 if (packet_format
== 'X')
4191 /* Binary mode. Send target system values byte by byte, in
4192 increasing byte addresses. Only escape certain critical
4194 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
4197 /* If not all TODO bytes fit, then we'll need another packet. Make
4198 a second try to keep the end of the packet aligned. Don't do
4199 this if the packet is tiny. */
4200 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
4204 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
4206 if (new_nr_bytes
!= nr_bytes
)
4207 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
4212 p
+= payload_length
;
4213 if (use_length
&& nr_bytes
< todo
)
4215 /* Escape chars have filled up the buffer prematurely,
4216 and we have actually sent fewer bytes than planned.
4217 Fix-up the length field of the packet. Use the same
4218 number of characters as before. */
4219 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
4220 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
4225 /* Normal mode: Send target system values byte by byte, in
4226 increasing byte addresses. Each byte is encoded as a two hex
4228 nr_bytes
= bin2hex (myaddr
, p
, todo
);
4232 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4233 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4235 if (rs
->buf
[0] == 'E')
4237 /* There is no correspondance between what the remote protocol
4238 uses for errors and errno codes. We would like a cleaner way
4239 of representing errors (big enough to include errno codes,
4240 bfd_error codes, and others). But for now just return EIO. */
4245 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4246 fewer bytes than we'd planned. */
4250 /* Write memory data directly to the remote machine.
4251 This does not inform the data cache; the data cache uses this.
4252 MEMADDR is the address in the remote memory space.
4253 MYADDR is the address of the buffer in our space.
4254 LEN is the number of bytes.
4256 Returns number of bytes transferred, or 0 (setting errno) for
4257 error. Only transfer a single packet. */
4260 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
4262 char *packet_format
= 0;
4264 /* Check whether the target supports binary download. */
4265 check_binary_download (memaddr
);
4267 switch (remote_protocol_packets
[PACKET_X
].support
)
4270 packet_format
= "X";
4272 case PACKET_DISABLE
:
4273 packet_format
= "M";
4275 case PACKET_SUPPORT_UNKNOWN
:
4276 internal_error (__FILE__
, __LINE__
,
4277 _("remote_write_bytes: bad internal state"));
4279 internal_error (__FILE__
, __LINE__
, _("bad switch"));
4282 return remote_write_bytes_aux (packet_format
,
4283 memaddr
, myaddr
, len
, packet_format
[0], 1);
4286 /* Read memory data directly from the remote machine.
4287 This does not use the data cache; the data cache uses this.
4288 MEMADDR is the address in the remote memory space.
4289 MYADDR is the address of the buffer in our space.
4290 LEN is the number of bytes.
4292 Returns number of bytes transferred, or 0 for error. */
4294 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4295 remote targets) shouldn't attempt to read the entire buffer.
4296 Instead it should read a single packet worth of data and then
4297 return the byte size of that packet to the caller. The caller (its
4298 caller and its callers caller ;-) already contains code for
4299 handling partial reads. */
4302 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
4304 struct remote_state
*rs
= get_remote_state ();
4305 int max_buf_size
; /* Max size of packet output buffer. */
4311 max_buf_size
= get_memory_read_packet_size ();
4312 /* The packet buffer will be large enough for the payload;
4313 get_memory_packet_size ensures this. */
4322 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
4324 /* construct "m"<memaddr>","<len>" */
4325 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4326 memaddr
= remote_address_masked (memaddr
);
4329 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4331 p
+= hexnumstr (p
, (ULONGEST
) todo
);
4335 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4337 if (rs
->buf
[0] == 'E'
4338 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
4339 && rs
->buf
[3] == '\0')
4341 /* There is no correspondance between what the remote
4342 protocol uses for errors and errno codes. We would like
4343 a cleaner way of representing errors (big enough to
4344 include errno codes, bfd_error codes, and others). But
4345 for now just return EIO. */
4350 /* Reply describes memory byte by byte,
4351 each byte encoded as two hex characters. */
4354 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
4356 /* Reply is short. This means that we were able to read
4357 only part of what we wanted to. */
4358 return i
+ (origlen
- len
);
4367 /* Read or write LEN bytes from inferior memory at MEMADDR,
4368 transferring to or from debugger address BUFFER. Write to inferior
4369 if SHOULD_WRITE is nonzero. Returns length of data written or
4370 read; 0 for error. TARGET is unused. */
4373 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
4374 int should_write
, struct mem_attrib
*attrib
,
4375 struct target_ops
*target
)
4380 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
4382 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
4387 /* Sends a packet with content determined by the printf format string
4388 FORMAT and the remaining arguments, then gets the reply. Returns
4389 whether the packet was a success, a failure, or unknown. */
4392 remote_send_printf (const char *format
, ...)
4394 struct remote_state
*rs
= get_remote_state ();
4395 int max_size
= get_remote_packet_size ();
4398 va_start (ap
, format
);
4401 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
4402 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
4404 if (putpkt (rs
->buf
) < 0)
4405 error (_("Communication problem with target."));
4408 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4410 return packet_check_result (rs
->buf
);
4414 restore_remote_timeout (void *p
)
4416 int value
= *(int *)p
;
4417 remote_timeout
= value
;
4420 /* Flash writing can take quite some time. We'll set
4421 effectively infinite timeout for flash operations.
4422 In future, we'll need to decide on a better approach. */
4423 static const int remote_flash_timeout
= 1000;
4426 remote_flash_erase (struct target_ops
*ops
,
4427 ULONGEST address
, LONGEST length
)
4429 int saved_remote_timeout
= remote_timeout
;
4430 enum packet_result ret
;
4432 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4433 &saved_remote_timeout
);
4434 remote_timeout
= remote_flash_timeout
;
4436 ret
= remote_send_printf ("vFlashErase:%s,%s",
4441 case PACKET_UNKNOWN
:
4442 error (_("Remote target does not support flash erase"));
4444 error (_("Error erasing flash with vFlashErase packet"));
4449 do_cleanups (back_to
);
4453 remote_flash_write (struct target_ops
*ops
,
4454 ULONGEST address
, LONGEST length
,
4455 const gdb_byte
*data
)
4457 int saved_remote_timeout
= remote_timeout
;
4459 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4460 &saved_remote_timeout
);
4462 remote_timeout
= remote_flash_timeout
;
4463 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
4464 do_cleanups (back_to
);
4470 remote_flash_done (struct target_ops
*ops
)
4472 int saved_remote_timeout
= remote_timeout
;
4474 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4475 &saved_remote_timeout
);
4477 remote_timeout
= remote_flash_timeout
;
4478 ret
= remote_send_printf ("vFlashDone");
4479 do_cleanups (back_to
);
4483 case PACKET_UNKNOWN
:
4484 error (_("Remote target does not support vFlashDone"));
4486 error (_("Error finishing flash operation"));
4493 remote_files_info (struct target_ops
*ignore
)
4495 puts_filtered ("Debugging a target over a serial line.\n");
4498 /* Stuff for dealing with the packets which are part of this protocol.
4499 See comment at top of file for details. */
4501 /* Read a single character from the remote end. */
4504 readchar (int timeout
)
4508 ch
= serial_readchar (remote_desc
, timeout
);
4513 switch ((enum serial_rc
) ch
)
4516 target_mourn_inferior ();
4517 error (_("Remote connection closed"));
4520 perror_with_name (_("Remote communication error"));
4522 case SERIAL_TIMEOUT
:
4528 /* Send the command in *BUF to the remote machine, and read the reply
4529 into *BUF. Report an error if we get an error reply. Resize
4530 *BUF using xrealloc if necessary to hold the result, and update
4534 remote_send (char **buf
,
4538 getpkt (buf
, sizeof_buf
, 0);
4540 if ((*buf
)[0] == 'E')
4541 error (_("Remote failure reply: %s"), *buf
);
4544 /* Display a null-terminated packet on stdout, for debugging, using C
4548 print_packet (char *buf
)
4550 puts_filtered ("\"");
4551 fputstr_filtered (buf
, '"', gdb_stdout
);
4552 puts_filtered ("\"");
4558 return putpkt_binary (buf
, strlen (buf
));
4561 /* Send a packet to the remote machine, with error checking. The data
4562 of the packet is in BUF. The string in BUF can be at most
4563 get_remote_packet_size () - 5 to account for the $, # and checksum,
4564 and for a possible /0 if we are debugging (remote_debug) and want
4565 to print the sent packet as a string. */
4568 putpkt_binary (char *buf
, int cnt
)
4571 unsigned char csum
= 0;
4572 char *buf2
= alloca (cnt
+ 6);
4578 /* Copy the packet into buffer BUF2, encapsulating it
4579 and giving it a checksum. */
4584 for (i
= 0; i
< cnt
; i
++)
4590 *p
++ = tohex ((csum
>> 4) & 0xf);
4591 *p
++ = tohex (csum
& 0xf);
4593 /* Send it over and over until we get a positive ack. */
4597 int started_error_output
= 0;
4602 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
4603 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
4604 fprintf_unfiltered (gdb_stdlog
, "...");
4605 gdb_flush (gdb_stdlog
);
4607 if (serial_write (remote_desc
, buf2
, p
- buf2
))
4608 perror_with_name (_("putpkt: write failed"));
4610 /* Read until either a timeout occurs (-2) or '+' is read. */
4613 ch
= readchar (remote_timeout
);
4621 case SERIAL_TIMEOUT
:
4623 if (started_error_output
)
4625 putchar_unfiltered ('\n');
4626 started_error_output
= 0;
4635 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
4639 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
4640 case SERIAL_TIMEOUT
:
4644 break; /* Retransmit buffer. */
4648 fprintf_unfiltered (gdb_stdlog
,
4649 "Packet instead of Ack, ignoring it\n");
4650 /* It's probably an old response sent because an ACK
4651 was lost. Gobble up the packet and ack it so it
4652 doesn't get retransmitted when we resend this
4655 serial_write (remote_desc
, "+", 1);
4656 continue; /* Now, go look for +. */
4661 if (!started_error_output
)
4663 started_error_output
= 1;
4664 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4666 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4670 break; /* Here to retransmit. */
4674 /* This is wrong. If doing a long backtrace, the user should be
4675 able to get out next time we call QUIT, without anything as
4676 violent as interrupt_query. If we want to provide a way out of
4677 here without getting to the next QUIT, it should be based on
4678 hitting ^C twice as in remote_wait. */
4688 /* Come here after finding the start of a frame when we expected an
4689 ack. Do our best to discard the rest of this packet. */
4698 c
= readchar (remote_timeout
);
4701 case SERIAL_TIMEOUT
:
4702 /* Nothing we can do. */
4705 /* Discard the two bytes of checksum and stop. */
4706 c
= readchar (remote_timeout
);
4708 c
= readchar (remote_timeout
);
4711 case '*': /* Run length encoding. */
4712 /* Discard the repeat count. */
4713 c
= readchar (remote_timeout
);
4718 /* A regular character. */
4724 /* Come here after finding the start of the frame. Collect the rest
4725 into *BUF, verifying the checksum, length, and handling run-length
4726 compression. NUL terminate the buffer. If there is not enough room,
4727 expand *BUF using xrealloc.
4729 Returns -1 on error, number of characters in buffer (ignoring the
4730 trailing NULL) on success. (could be extended to return one of the
4731 SERIAL status indications). */
4734 read_frame (char **buf_p
,
4747 c
= readchar (remote_timeout
);
4750 case SERIAL_TIMEOUT
:
4752 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4756 fputs_filtered ("Saw new packet start in middle of old one\n",
4758 return -1; /* Start a new packet, count retries. */
4761 unsigned char pktcsum
;
4767 check_0
= readchar (remote_timeout
);
4769 check_1
= readchar (remote_timeout
);
4771 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4774 fputs_filtered ("Timeout in checksum, retrying\n",
4778 else if (check_0
< 0 || check_1
< 0)
4781 fputs_filtered ("Communication error in checksum\n",
4786 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4787 if (csum
== pktcsum
)
4792 fprintf_filtered (gdb_stdlog
,
4793 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4795 fputstrn_filtered (buf
, bc
, 0, gdb_stdlog
);
4796 fputs_filtered ("\n", gdb_stdlog
);
4798 /* Number of characters in buffer ignoring trailing
4802 case '*': /* Run length encoding. */
4807 c
= readchar (remote_timeout
);
4809 repeat
= c
- ' ' + 3; /* Compute repeat count. */
4811 /* The character before ``*'' is repeated. */
4813 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
4815 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
4817 /* Make some more room in the buffer. */
4818 *sizeof_buf
+= repeat
;
4819 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4823 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4829 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
4833 if (bc
>= *sizeof_buf
- 1)
4835 /* Make some more room in the buffer. */
4837 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4848 /* Read a packet from the remote machine, with error checking, and
4849 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4850 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4851 rather than timing out; this is used (in synchronous mode) to wait
4852 for a target that is is executing user code to stop. */
4853 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4854 don't have to change all the calls to getpkt to deal with the
4855 return value, because at the moment I don't know what the right
4856 thing to do it for those. */
4864 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
4868 /* Read a packet from the remote machine, with error checking, and
4869 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4870 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4871 rather than timing out; this is used (in synchronous mode) to wait
4872 for a target that is is executing user code to stop. If FOREVER ==
4873 0, this function is allowed to time out gracefully and return an
4874 indication of this to the caller. Otherwise return the number
4877 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
4884 strcpy (*buf
, "timeout");
4888 timeout
= watchdog
> 0 ? watchdog
: -1;
4892 timeout
= remote_timeout
;
4896 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
4898 /* This can loop forever if the remote side sends us characters
4899 continuously, but if it pauses, we'll get a zero from
4900 readchar because of timeout. Then we'll count that as a
4903 /* Note that we will only wait forever prior to the start of a
4904 packet. After that, we expect characters to arrive at a
4905 brisk pace. They should show up within remote_timeout
4910 c
= readchar (timeout
);
4912 if (c
== SERIAL_TIMEOUT
)
4914 if (forever
) /* Watchdog went off? Kill the target. */
4917 target_mourn_inferior ();
4918 error (_("Watchdog has expired. Target detached."));
4921 fputs_filtered ("Timed out.\n", gdb_stdlog
);
4927 /* We've found the start of a packet, now collect the data. */
4929 val
= read_frame (buf
, sizeof_buf
);
4935 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
4936 fputstrn_unfiltered (*buf
, val
, 0, gdb_stdlog
);
4937 fprintf_unfiltered (gdb_stdlog
, "\n");
4939 serial_write (remote_desc
, "+", 1);
4943 /* Try the whole thing again. */
4945 serial_write (remote_desc
, "-", 1);
4948 /* We have tried hard enough, and just can't receive the packet.
4951 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
4952 serial_write (remote_desc
, "+", 1);
4959 /* For some mysterious reason, wait_for_inferior calls kill instead of
4960 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4964 target_mourn_inferior ();
4968 /* Use catch_errors so the user can quit from gdb even when we aren't on
4969 speaking terms with the remote system. */
4970 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4972 /* Don't wait for it to die. I'm not really sure it matters whether
4973 we do or not. For the existing stubs, kill is a noop. */
4974 target_mourn_inferior ();
4977 /* Async version of remote_kill. */
4979 remote_async_kill (void)
4981 /* Unregister the file descriptor from the event loop. */
4982 if (target_is_async_p ())
4983 serial_async (remote_desc
, NULL
, 0);
4985 /* For some mysterious reason, wait_for_inferior calls kill instead of
4986 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4990 target_mourn_inferior ();
4994 /* Use catch_errors so the user can quit from gdb even when we
4995 aren't on speaking terms with the remote system. */
4996 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4998 /* Don't wait for it to die. I'm not really sure it matters whether
4999 we do or not. For the existing stubs, kill is a noop. */
5000 target_mourn_inferior ();
5006 remote_mourn_1 (&remote_ops
);
5010 remote_async_mourn (void)
5012 remote_mourn_1 (&remote_async_ops
);
5016 extended_remote_mourn (void)
5018 /* We do _not_ want to mourn the target like this; this will
5019 remove the extended remote target from the target stack,
5020 and the next time the user says "run" it'll fail.
5022 FIXME: What is the right thing to do here? */
5024 remote_mourn_1 (&extended_remote_ops
);
5028 /* Worker function for remote_mourn. */
5030 remote_mourn_1 (struct target_ops
*target
)
5032 unpush_target (target
);
5033 generic_mourn_inferior ();
5036 /* In the extended protocol we want to be able to do things like
5037 "run" and have them basically work as expected. So we need
5038 a special create_inferior function.
5040 FIXME: One day add support for changing the exec file
5041 we're debugging, arguments and an environment. */
5044 extended_remote_create_inferior (char *exec_file
, char *args
,
5045 char **env
, int from_tty
)
5047 /* Rip out the breakpoints; we'll reinsert them after restarting
5048 the remote server. */
5049 remove_breakpoints ();
5051 /* Now restart the remote server. */
5052 extended_remote_restart ();
5054 /* NOTE: We don't need to recheck for a target description here; but
5055 if we gain the ability to switch the remote executable we may
5056 need to, if for instance we are running a process which requested
5057 different emulated hardware from the operating system. A
5058 concrete example of this is ARM GNU/Linux, where some binaries
5059 will have a legacy FPA coprocessor emulated and others may have
5060 access to a hardware VFP unit. */
5062 /* Now put the breakpoints back in. This way we're safe if the
5063 restart function works via a unix fork on the remote side. */
5064 insert_breakpoints ();
5066 /* Clean up from the last time we were running. */
5067 clear_proceed_status ();
5070 /* Async version of extended_remote_create_inferior. */
5072 extended_remote_async_create_inferior (char *exec_file
, char *args
,
5073 char **env
, int from_tty
)
5075 /* Rip out the breakpoints; we'll reinsert them after restarting
5076 the remote server. */
5077 remove_breakpoints ();
5079 /* If running asynchronously, register the target file descriptor
5080 with the event loop. */
5081 if (target_can_async_p ())
5082 target_async (inferior_event_handler
, 0);
5084 /* Now restart the remote server. */
5085 extended_remote_restart ();
5087 /* NOTE: We don't need to recheck for a target description here; but
5088 if we gain the ability to switch the remote executable we may
5089 need to, if for instance we are running a process which requested
5090 different emulated hardware from the operating system. A
5091 concrete example of this is ARM GNU/Linux, where some binaries
5092 will have a legacy FPA coprocessor emulated and others may have
5093 access to a hardware VFP unit. */
5095 /* Now put the breakpoints back in. This way we're safe if the
5096 restart function works via a unix fork on the remote side. */
5097 insert_breakpoints ();
5099 /* Clean up from the last time we were running. */
5100 clear_proceed_status ();
5104 /* Insert a breakpoint. On targets that have software breakpoint
5105 support, we ask the remote target to do the work; on targets
5106 which don't, we insert a traditional memory breakpoint. */
5109 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
5111 CORE_ADDR addr
= bp_tgt
->placed_address
;
5112 struct remote_state
*rs
= get_remote_state ();
5114 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5115 If it succeeds, then set the support to PACKET_ENABLE. If it
5116 fails, and the user has explicitly requested the Z support then
5117 report an error, otherwise, mark it disabled and go on. */
5119 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5126 BREAKPOINT_FROM_PC (&bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5127 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5128 p
+= hexnumstr (p
, addr
);
5129 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5132 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5134 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
5140 case PACKET_UNKNOWN
:
5145 return memory_insert_breakpoint (bp_tgt
);
5149 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
5151 CORE_ADDR addr
= bp_tgt
->placed_address
;
5152 struct remote_state
*rs
= get_remote_state ();
5155 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5163 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5164 p
+= hexnumstr (p
, addr
);
5165 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5168 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5170 return (rs
->buf
[0] == 'E');
5173 return memory_remove_breakpoint (bp_tgt
);
5177 watchpoint_to_Z_packet (int type
)
5182 return Z_PACKET_WRITE_WP
;
5185 return Z_PACKET_READ_WP
;
5188 return Z_PACKET_ACCESS_WP
;
5191 internal_error (__FILE__
, __LINE__
,
5192 _("hw_bp_to_z: bad watchpoint type %d"), type
);
5197 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
5199 struct remote_state
*rs
= get_remote_state ();
5201 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5203 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5206 sprintf (rs
->buf
, "Z%x,", packet
);
5207 p
= strchr (rs
->buf
, '\0');
5208 addr
= remote_address_masked (addr
);
5209 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5210 sprintf (p
, ",%x", len
);
5213 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5215 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5218 case PACKET_UNKNOWN
:
5223 internal_error (__FILE__
, __LINE__
,
5224 _("remote_insert_watchpoint: reached end of function"));
5229 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
5231 struct remote_state
*rs
= get_remote_state ();
5233 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5235 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5238 sprintf (rs
->buf
, "z%x,", packet
);
5239 p
= strchr (rs
->buf
, '\0');
5240 addr
= remote_address_masked (addr
);
5241 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5242 sprintf (p
, ",%x", len
);
5244 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5246 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5249 case PACKET_UNKNOWN
:
5254 internal_error (__FILE__
, __LINE__
,
5255 _("remote_remove_watchpoint: reached end of function"));
5259 int remote_hw_watchpoint_limit
= -1;
5260 int remote_hw_breakpoint_limit
= -1;
5263 remote_check_watch_resources (int type
, int cnt
, int ot
)
5265 if (type
== bp_hardware_breakpoint
)
5267 if (remote_hw_breakpoint_limit
== 0)
5269 else if (remote_hw_breakpoint_limit
< 0)
5271 else if (cnt
<= remote_hw_breakpoint_limit
)
5276 if (remote_hw_watchpoint_limit
== 0)
5278 else if (remote_hw_watchpoint_limit
< 0)
5282 else if (cnt
<= remote_hw_watchpoint_limit
)
5289 remote_stopped_by_watchpoint (void)
5291 return remote_stopped_by_watchpoint_p
;
5294 extern int stepped_after_stopped_by_watchpoint
;
5297 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
5300 if (remote_stopped_by_watchpoint ()
5301 || stepped_after_stopped_by_watchpoint
)
5303 *addr_p
= remote_watch_data_address
;
5312 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5315 struct remote_state
*rs
= get_remote_state ();
5318 /* The length field should be set to the size of a breakpoint
5319 instruction, even though we aren't inserting one ourselves. */
5321 BREAKPOINT_FROM_PC (&bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5323 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5330 addr
= remote_address_masked (bp_tgt
->placed_address
);
5331 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5332 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5335 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5337 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5340 case PACKET_UNKNOWN
:
5345 internal_error (__FILE__
, __LINE__
,
5346 _("remote_insert_hw_breakpoint: reached end of function"));
5351 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5354 struct remote_state
*rs
= get_remote_state ();
5357 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5364 addr
= remote_address_masked (bp_tgt
->placed_address
);
5365 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5366 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5369 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5371 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5374 case PACKET_UNKNOWN
:
5379 internal_error (__FILE__
, __LINE__
,
5380 _("remote_remove_hw_breakpoint: reached end of function"));
5383 /* Some targets are only capable of doing downloads, and afterwards
5384 they switch to the remote serial protocol. This function provides
5385 a clean way to get from the download target to the remote target.
5386 It's basically just a wrapper so that we don't have to expose any
5387 of the internal workings of remote.c.
5389 Prior to calling this routine, you should shutdown the current
5390 target code, else you will get the "A program is being debugged
5391 already..." message. Usually a call to pop_target() suffices. */
5394 push_remote_target (char *name
, int from_tty
)
5396 printf_filtered (_("Switching to remote protocol\n"));
5397 remote_open (name
, from_tty
);
5400 /* Table used by the crc32 function to calcuate the checksum. */
5402 static unsigned long crc32_table
[256] =
5405 static unsigned long
5406 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
5408 if (!crc32_table
[1])
5410 /* Initialize the CRC table and the decoding table. */
5414 for (i
= 0; i
< 256; i
++)
5416 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
5417 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
5424 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
5430 /* compare-sections command
5432 With no arguments, compares each loadable section in the exec bfd
5433 with the same memory range on the target, and reports mismatches.
5434 Useful for verifying the image on the target against the exec file.
5435 Depends on the target understanding the new "qCRC:" request. */
5437 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5438 target method (target verify memory) and generic version of the
5439 actual command. This will allow other high-level code (especially
5440 generic_load()) to make use of this target functionality. */
5443 compare_sections_command (char *args
, int from_tty
)
5445 struct remote_state
*rs
= get_remote_state ();
5447 unsigned long host_crc
, target_crc
;
5448 extern bfd
*exec_bfd
;
5449 struct cleanup
*old_chain
;
5452 const char *sectname
;
5459 error (_("command cannot be used without an exec file"));
5460 if (!current_target
.to_shortname
||
5461 strcmp (current_target
.to_shortname
, "remote") != 0)
5462 error (_("command can only be used with remote target"));
5464 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5466 if (!(s
->flags
& SEC_LOAD
))
5467 continue; /* skip non-loadable section */
5469 size
= bfd_get_section_size (s
);
5471 continue; /* skip zero-length section */
5473 sectname
= bfd_get_section_name (exec_bfd
, s
);
5474 if (args
&& strcmp (args
, sectname
) != 0)
5475 continue; /* not the section selected by user */
5477 matched
= 1; /* do this section */
5479 /* FIXME: assumes lma can fit into long. */
5480 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
5481 (long) lma
, (long) size
);
5484 /* Be clever; compute the host_crc before waiting for target
5486 sectdata
= xmalloc (size
);
5487 old_chain
= make_cleanup (xfree
, sectdata
);
5488 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
5489 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
5491 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5492 if (rs
->buf
[0] == 'E')
5493 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5494 sectname
, paddr (lma
), paddr (lma
+ size
));
5495 if (rs
->buf
[0] != 'C')
5496 error (_("remote target does not support this operation"));
5498 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
5499 target_crc
= target_crc
* 16 + fromhex (*tmp
);
5501 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5502 sectname
, paddr (lma
), paddr (lma
+ size
));
5503 if (host_crc
== target_crc
)
5504 printf_filtered ("matched.\n");
5507 printf_filtered ("MIS-MATCHED!\n");
5511 do_cleanups (old_chain
);
5514 warning (_("One or more sections of the remote executable does not match\n\
5515 the loaded file\n"));
5516 if (args
&& !matched
)
5517 printf_filtered (_("No loaded section named '%s'.\n"), args
);
5520 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5521 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5522 number of bytes read is returned, or 0 for EOF, or -1 for error.
5523 The number of bytes read may be less than LEN without indicating an
5524 EOF. PACKET is checked and updated to indicate whether the remote
5525 target supports this object. */
5528 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
5530 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
5531 struct packet_config
*packet
)
5533 static char *finished_object
;
5534 static char *finished_annex
;
5535 static ULONGEST finished_offset
;
5537 struct remote_state
*rs
= get_remote_state ();
5538 unsigned int total
= 0;
5539 LONGEST i
, n
, packet_len
;
5541 if (packet
->support
== PACKET_DISABLE
)
5544 /* Check whether we've cached an end-of-object packet that matches
5546 if (finished_object
)
5548 if (strcmp (object_name
, finished_object
) == 0
5549 && strcmp (annex
? annex
: "", finished_annex
) == 0
5550 && offset
== finished_offset
)
5553 /* Otherwise, we're now reading something different. Discard
5555 xfree (finished_object
);
5556 xfree (finished_annex
);
5557 finished_object
= NULL
;
5558 finished_annex
= NULL
;
5561 /* Request only enough to fit in a single packet. The actual data
5562 may not, since we don't know how much of it will need to be escaped;
5563 the target is free to respond with slightly less data. We subtract
5564 five to account for the response type and the protocol frame. */
5565 n
= min (get_remote_packet_size () - 5, len
);
5566 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5567 object_name
, annex
? annex
: "",
5568 phex_nz (offset
, sizeof offset
),
5569 phex_nz (n
, sizeof n
));
5570 i
= putpkt (rs
->buf
);
5575 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
5576 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5579 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
5580 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
5582 /* 'm' means there is (or at least might be) more data after this
5583 batch. That does not make sense unless there's at least one byte
5584 of data in this reply. */
5585 if (rs
->buf
[0] == 'm' && packet_len
== 1)
5586 error (_("Remote qXfer reply contained no data."));
5588 /* Got some data. */
5589 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
5591 /* 'l' is an EOF marker, possibly including a final block of data,
5592 or possibly empty. Record it to bypass the next read, if one is
5594 if (rs
->buf
[0] == 'l')
5596 finished_object
= xstrdup (object_name
);
5597 finished_annex
= xstrdup (annex
? annex
: "");
5598 finished_offset
= offset
+ i
;
5605 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5606 const char *annex
, gdb_byte
*readbuf
,
5607 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5609 struct remote_state
*rs
= get_remote_state ();
5614 /* Handle memory using the standard memory routines. */
5615 if (object
== TARGET_OBJECT_MEMORY
)
5620 if (writebuf
!= NULL
)
5621 xfered
= remote_write_bytes (offset
, writebuf
, len
);
5623 xfered
= remote_read_bytes (offset
, readbuf
, len
);
5627 else if (xfered
== 0 && errno
== 0)
5633 /* Only handle flash writes. */
5634 if (writebuf
!= NULL
)
5640 case TARGET_OBJECT_FLASH
:
5641 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
5645 else if (xfered
== 0 && errno
== 0)
5655 /* Map pre-existing objects onto letters. DO NOT do this for new
5656 objects!!! Instead specify new query packets. */
5659 case TARGET_OBJECT_AVR
:
5663 case TARGET_OBJECT_AUXV
:
5664 gdb_assert (annex
== NULL
);
5665 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
5666 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
5668 case TARGET_OBJECT_AVAILABLE_FEATURES
:
5669 return remote_read_qxfer
5670 (ops
, "features", annex
, readbuf
, offset
, len
,
5671 &remote_protocol_packets
[PACKET_qXfer_features
]);
5673 case TARGET_OBJECT_MEMORY_MAP
:
5674 gdb_assert (annex
== NULL
);
5675 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
5676 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
5682 /* Note: a zero OFFSET and LEN can be used to query the minimum
5684 if (offset
== 0 && len
== 0)
5685 return (get_remote_packet_size ());
5686 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5687 large enough let the caller deal with it. */
5688 if (len
< get_remote_packet_size ())
5690 len
= get_remote_packet_size ();
5692 /* Except for querying the minimum buffer size, target must be open. */
5694 error (_("remote query is only available after target open"));
5696 gdb_assert (annex
!= NULL
);
5697 gdb_assert (readbuf
!= NULL
);
5703 /* We used one buffer char for the remote protocol q command and
5704 another for the query type. As the remote protocol encapsulation
5705 uses 4 chars plus one extra in case we are debugging
5706 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5709 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
5711 /* Bad caller may have sent forbidden characters. */
5712 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
5717 gdb_assert (annex
[i
] == '\0');
5719 i
= putpkt (rs
->buf
);
5723 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5724 strcpy ((char *) readbuf
, rs
->buf
);
5726 return strlen ((char *) readbuf
);
5730 remote_rcmd (char *command
,
5731 struct ui_file
*outbuf
)
5733 struct remote_state
*rs
= get_remote_state ();
5737 error (_("remote rcmd is only available after target open"));
5739 /* Send a NULL command across as an empty command. */
5740 if (command
== NULL
)
5743 /* The query prefix. */
5744 strcpy (rs
->buf
, "qRcmd,");
5745 p
= strchr (rs
->buf
, '\0');
5747 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
5748 error (_("\"monitor\" command ``%s'' is too long."), command
);
5750 /* Encode the actual command. */
5751 bin2hex ((gdb_byte
*) command
, p
, 0);
5753 if (putpkt (rs
->buf
) < 0)
5754 error (_("Communication problem with target."));
5756 /* get/display the response */
5761 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5763 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5766 error (_("Target does not support this command."));
5767 if (buf
[0] == 'O' && buf
[1] != 'K')
5769 remote_console_output (buf
+ 1); /* 'O' message from stub. */
5772 if (strcmp (buf
, "OK") == 0)
5774 if (strlen (buf
) == 3 && buf
[0] == 'E'
5775 && isdigit (buf
[1]) && isdigit (buf
[2]))
5777 error (_("Protocol error with Rcmd"));
5779 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5781 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5782 fputc_unfiltered (c
, outbuf
);
5788 static VEC(mem_region_s
) *
5789 remote_memory_map (struct target_ops
*ops
)
5791 VEC(mem_region_s
) *result
= NULL
;
5792 char *text
= target_read_stralloc (¤t_target
,
5793 TARGET_OBJECT_MEMORY_MAP
, NULL
);
5797 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
5798 result
= parse_memory_map (text
);
5799 do_cleanups (back_to
);
5806 packet_command (char *args
, int from_tty
)
5808 struct remote_state
*rs
= get_remote_state ();
5811 error (_("command can only be used with remote target"));
5814 error (_("remote-packet command requires packet text as argument"));
5816 puts_filtered ("sending: ");
5817 print_packet (args
);
5818 puts_filtered ("\n");
5821 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5822 puts_filtered ("received: ");
5823 print_packet (rs
->buf
);
5824 puts_filtered ("\n");
5828 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
5830 static void display_thread_info (struct gdb_ext_thread_info
*info
);
5832 static void threadset_test_cmd (char *cmd
, int tty
);
5834 static void threadalive_test (char *cmd
, int tty
);
5836 static void threadlist_test_cmd (char *cmd
, int tty
);
5838 int get_and_display_threadinfo (threadref
*ref
);
5840 static void threadinfo_test_cmd (char *cmd
, int tty
);
5842 static int thread_display_step (threadref
*ref
, void *context
);
5844 static void threadlist_update_test_cmd (char *cmd
, int tty
);
5846 static void init_remote_threadtests (void);
5848 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
5851 threadset_test_cmd (char *cmd
, int tty
)
5853 int sample_thread
= SAMPLE_THREAD
;
5855 printf_filtered (_("Remote threadset test\n"));
5856 set_thread (sample_thread
, 1);
5861 threadalive_test (char *cmd
, int tty
)
5863 int sample_thread
= SAMPLE_THREAD
;
5865 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
5866 printf_filtered ("PASS: Thread alive test\n");
5868 printf_filtered ("FAIL: Thread alive test\n");
5871 void output_threadid (char *title
, threadref
*ref
);
5874 output_threadid (char *title
, threadref
*ref
)
5878 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
5880 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
5884 threadlist_test_cmd (char *cmd
, int tty
)
5887 threadref nextthread
;
5888 int done
, result_count
;
5889 threadref threadlist
[3];
5891 printf_filtered ("Remote Threadlist test\n");
5892 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
5893 &result_count
, &threadlist
[0]))
5894 printf_filtered ("FAIL: threadlist test\n");
5897 threadref
*scan
= threadlist
;
5898 threadref
*limit
= scan
+ result_count
;
5900 while (scan
< limit
)
5901 output_threadid (" thread ", scan
++);
5906 display_thread_info (struct gdb_ext_thread_info
*info
)
5908 output_threadid ("Threadid: ", &info
->threadid
);
5909 printf_filtered ("Name: %s\n ", info
->shortname
);
5910 printf_filtered ("State: %s\n", info
->display
);
5911 printf_filtered ("other: %s\n\n", info
->more_display
);
5915 get_and_display_threadinfo (threadref
*ref
)
5919 struct gdb_ext_thread_info threadinfo
;
5921 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
5922 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
5923 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
5924 display_thread_info (&threadinfo
);
5929 threadinfo_test_cmd (char *cmd
, int tty
)
5931 int athread
= SAMPLE_THREAD
;
5935 int_to_threadref (&thread
, athread
);
5936 printf_filtered ("Remote Threadinfo test\n");
5937 if (!get_and_display_threadinfo (&thread
))
5938 printf_filtered ("FAIL cannot get thread info\n");
5942 thread_display_step (threadref
*ref
, void *context
)
5944 /* output_threadid(" threadstep ",ref); *//* simple test */
5945 return get_and_display_threadinfo (ref
);
5949 threadlist_update_test_cmd (char *cmd
, int tty
)
5951 printf_filtered ("Remote Threadlist update test\n");
5952 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
5956 init_remote_threadtests (void)
5958 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
5959 Fetch and print the remote list of thread identifiers, one pkt only"));
5960 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
5961 _("Fetch and display info about one thread"));
5962 add_com ("tset", class_obscure
, threadset_test_cmd
,
5963 _("Test setting to a different thread"));
5964 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
5965 _("Iterate through updating all remote thread info"));
5966 add_com ("talive", class_obscure
, threadalive_test
,
5967 _(" Remote thread alive test "));
5972 /* Convert a thread ID to a string. Returns the string in a static
5976 remote_pid_to_str (ptid_t ptid
)
5978 static char buf
[32];
5980 xsnprintf (buf
, sizeof buf
, "Thread %d", ptid_get_pid (ptid
));
5984 /* Get the address of the thread local variable in OBJFILE which is
5985 stored at OFFSET within the thread local storage for thread PTID. */
5988 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
5990 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
5992 struct remote_state
*rs
= get_remote_state ();
5994 enum packet_result result
;
5996 strcpy (p
, "qGetTLSAddr:");
5998 p
+= hexnumstr (p
, PIDGET (ptid
));
6000 p
+= hexnumstr (p
, offset
);
6002 p
+= hexnumstr (p
, lm
);
6006 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6007 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
6008 if (result
== PACKET_OK
)
6012 unpack_varlen_hex (rs
->buf
, &result
);
6015 else if (result
== PACKET_UNKNOWN
)
6016 throw_error (TLS_GENERIC_ERROR
,
6017 _("Remote target doesn't support qGetTLSAddr packet"));
6019 throw_error (TLS_GENERIC_ERROR
,
6020 _("Remote target failed to process qGetTLSAddr request"));
6023 throw_error (TLS_GENERIC_ERROR
,
6024 _("TLS not supported or disabled on this target"));
6029 /* Support for inferring a target description based on the current
6030 architecture and the size of a 'g' packet. While the 'g' packet
6031 can have any size (since optional registers can be left off the
6032 end), some sizes are easily recognizable given knowledge of the
6033 approximate architecture. */
6035 struct remote_g_packet_guess
6038 const struct target_desc
*tdesc
;
6040 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
6041 DEF_VEC_O(remote_g_packet_guess_s
);
6043 struct remote_g_packet_data
6045 VEC(remote_g_packet_guess_s
) *guesses
;
6048 static struct gdbarch_data
*remote_g_packet_data_handle
;
6051 remote_g_packet_data_init (struct obstack
*obstack
)
6053 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
6057 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
6058 const struct target_desc
*tdesc
)
6060 struct remote_g_packet_data
*data
6061 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
6062 struct remote_g_packet_guess new_guess
, *guess
;
6065 gdb_assert (tdesc
!= NULL
);
6068 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6070 if (guess
->bytes
== bytes
)
6071 internal_error (__FILE__
, __LINE__
,
6072 "Duplicate g packet description added for size %d",
6075 new_guess
.bytes
= bytes
;
6076 new_guess
.tdesc
= tdesc
;
6077 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
6080 static const struct target_desc
*
6081 remote_read_description (struct target_ops
*target
)
6083 struct remote_g_packet_data
*data
6084 = gdbarch_data (current_gdbarch
, remote_g_packet_data_handle
);
6086 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
6088 struct remote_g_packet_guess
*guess
;
6090 int bytes
= send_g_packet ();
6093 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6095 if (guess
->bytes
== bytes
)
6096 return guess
->tdesc
;
6098 /* We discard the g packet. A minor optimization would be to
6099 hold on to it, and fill the register cache once we have selected
6100 an architecture, but it's too tricky to do safely. */
6107 init_remote_ops (void)
6109 remote_ops
.to_shortname
= "remote";
6110 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
6112 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6113 Specify the serial device it is connected to\n\
6114 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
6115 remote_ops
.to_open
= remote_open
;
6116 remote_ops
.to_close
= remote_close
;
6117 remote_ops
.to_detach
= remote_detach
;
6118 remote_ops
.to_disconnect
= remote_disconnect
;
6119 remote_ops
.to_resume
= remote_resume
;
6120 remote_ops
.to_wait
= remote_wait
;
6121 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
6122 remote_ops
.to_store_registers
= remote_store_registers
;
6123 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6124 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6125 remote_ops
.to_files_info
= remote_files_info
;
6126 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6127 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6128 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6129 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6130 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6131 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6132 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6133 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6134 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6135 remote_ops
.to_kill
= remote_kill
;
6136 remote_ops
.to_load
= generic_load
;
6137 remote_ops
.to_mourn_inferior
= remote_mourn
;
6138 remote_ops
.to_thread_alive
= remote_thread_alive
;
6139 remote_ops
.to_find_new_threads
= remote_threads_info
;
6140 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
6141 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6142 remote_ops
.to_stop
= remote_stop
;
6143 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
6144 remote_ops
.to_rcmd
= remote_rcmd
;
6145 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
6146 remote_ops
.to_stratum
= process_stratum
;
6147 remote_ops
.to_has_all_memory
= 1;
6148 remote_ops
.to_has_memory
= 1;
6149 remote_ops
.to_has_stack
= 1;
6150 remote_ops
.to_has_registers
= 1;
6151 remote_ops
.to_has_execution
= 1;
6152 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6153 remote_ops
.to_magic
= OPS_MAGIC
;
6154 remote_ops
.to_memory_map
= remote_memory_map
;
6155 remote_ops
.to_flash_erase
= remote_flash_erase
;
6156 remote_ops
.to_flash_done
= remote_flash_done
;
6157 remote_ops
.to_read_description
= remote_read_description
;
6160 /* Set up the extended remote vector by making a copy of the standard
6161 remote vector and adding to it. */
6164 init_extended_remote_ops (void)
6166 extended_remote_ops
= remote_ops
;
6168 extended_remote_ops
.to_shortname
= "extended-remote";
6169 extended_remote_ops
.to_longname
=
6170 "Extended remote serial target in gdb-specific protocol";
6171 extended_remote_ops
.to_doc
=
6172 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6173 Specify the serial device it is connected to (e.g. /dev/ttya).",
6174 extended_remote_ops
.to_open
= extended_remote_open
;
6175 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
6176 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6180 remote_can_async_p (void)
6182 /* We're async whenever the serial device is. */
6183 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
6187 remote_is_async_p (void)
6189 /* We're async whenever the serial device is. */
6190 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
6193 /* Pass the SERIAL event on and up to the client. One day this code
6194 will be able to delay notifying the client of an event until the
6195 point where an entire packet has been received. */
6197 static void (*async_client_callback
) (enum inferior_event_type event_type
,
6199 static void *async_client_context
;
6200 static serial_event_ftype remote_async_serial_handler
;
6203 remote_async_serial_handler (struct serial
*scb
, void *context
)
6205 /* Don't propogate error information up to the client. Instead let
6206 the client find out about the error by querying the target. */
6207 async_client_callback (INF_REG_EVENT
, async_client_context
);
6211 remote_async (void (*callback
) (enum inferior_event_type event_type
,
6212 void *context
), void *context
)
6214 if (current_target
.to_async_mask_value
== 0)
6215 internal_error (__FILE__
, __LINE__
,
6216 _("Calling remote_async when async is masked"));
6218 if (callback
!= NULL
)
6220 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
6221 async_client_callback
= callback
;
6222 async_client_context
= context
;
6225 serial_async (remote_desc
, NULL
, NULL
);
6228 /* Target async and target extended-async.
6230 This are temporary targets, until it is all tested. Eventually
6231 async support will be incorporated int the usual 'remote'
6235 init_remote_async_ops (void)
6237 remote_async_ops
.to_shortname
= "async";
6238 remote_async_ops
.to_longname
=
6239 "Remote serial target in async version of the gdb-specific protocol";
6240 remote_async_ops
.to_doc
=
6241 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6242 Specify the serial device it is connected to (e.g. /dev/ttya).";
6243 remote_async_ops
.to_open
= remote_async_open
;
6244 remote_async_ops
.to_close
= remote_close
;
6245 remote_async_ops
.to_detach
= remote_detach
;
6246 remote_async_ops
.to_disconnect
= remote_disconnect
;
6247 remote_async_ops
.to_resume
= remote_async_resume
;
6248 remote_async_ops
.to_wait
= remote_async_wait
;
6249 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
6250 remote_async_ops
.to_store_registers
= remote_store_registers
;
6251 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6252 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6253 remote_async_ops
.to_files_info
= remote_files_info
;
6254 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6255 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6256 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6257 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6258 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6259 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6260 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6261 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6262 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6263 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
6264 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
6265 remote_async_ops
.to_kill
= remote_async_kill
;
6266 remote_async_ops
.to_load
= generic_load
;
6267 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
6268 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
6269 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
6270 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
6271 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6272 remote_async_ops
.to_stop
= remote_stop
;
6273 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
6274 remote_async_ops
.to_rcmd
= remote_rcmd
;
6275 remote_async_ops
.to_stratum
= process_stratum
;
6276 remote_async_ops
.to_has_all_memory
= 1;
6277 remote_async_ops
.to_has_memory
= 1;
6278 remote_async_ops
.to_has_stack
= 1;
6279 remote_async_ops
.to_has_registers
= 1;
6280 remote_async_ops
.to_has_execution
= 1;
6281 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6282 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
6283 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
6284 remote_async_ops
.to_async
= remote_async
;
6285 remote_async_ops
.to_async_mask_value
= 1;
6286 remote_async_ops
.to_magic
= OPS_MAGIC
;
6287 remote_async_ops
.to_memory_map
= remote_memory_map
;
6288 remote_async_ops
.to_flash_erase
= remote_flash_erase
;
6289 remote_async_ops
.to_flash_done
= remote_flash_done
;
6290 remote_ops
.to_read_description
= remote_read_description
;
6293 /* Set up the async extended remote vector by making a copy of the standard
6294 remote vector and adding to it. */
6297 init_extended_async_remote_ops (void)
6299 extended_async_remote_ops
= remote_async_ops
;
6301 extended_async_remote_ops
.to_shortname
= "extended-async";
6302 extended_async_remote_ops
.to_longname
=
6303 "Extended remote serial target in async gdb-specific protocol";
6304 extended_async_remote_ops
.to_doc
=
6305 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
6306 Specify the serial device it is connected to (e.g. /dev/ttya).",
6307 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
6308 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
6309 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6313 set_remote_cmd (char *args
, int from_tty
)
6315 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
6319 show_remote_cmd (char *args
, int from_tty
)
6321 /* We can't just use cmd_show_list here, because we want to skip
6322 the redundant "show remote Z-packet" and the legacy aliases. */
6323 struct cleanup
*showlist_chain
;
6324 struct cmd_list_element
*list
= remote_show_cmdlist
;
6326 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
6327 for (; list
!= NULL
; list
= list
->next
)
6328 if (strcmp (list
->name
, "Z-packet") == 0)
6330 else if (list
->type
== not_set_cmd
)
6331 /* Alias commands are exactly like the original, except they
6332 don't have the normal type. */
6336 struct cleanup
*option_chain
6337 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
6338 ui_out_field_string (uiout
, "name", list
->name
);
6339 ui_out_text (uiout
, ": ");
6340 if (list
->type
== show_cmd
)
6341 do_setshow_command ((char *) NULL
, from_tty
, list
);
6343 cmd_func (list
, NULL
, from_tty
);
6344 /* Close the tuple. */
6345 do_cleanups (option_chain
);
6348 /* Close the tuple. */
6349 do_cleanups (showlist_chain
);
6353 build_remote_gdbarch_data (void)
6355 remote_address_size
= TARGET_ADDR_BIT
;
6358 /* Function to be called whenever a new objfile (shlib) is detected. */
6360 remote_new_objfile (struct objfile
*objfile
)
6362 if (remote_desc
!= 0) /* Have a remote connection. */
6363 remote_check_symbols (objfile
);
6367 _initialize_remote (void)
6369 struct remote_state
*rs
;
6371 /* architecture specific data */
6372 remote_gdbarch_data_handle
=
6373 gdbarch_data_register_post_init (init_remote_state
);
6374 remote_g_packet_data_handle
=
6375 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
6377 /* Old tacky stuff. NOTE: This comes after the remote protocol so
6378 that the remote protocol has been initialized. */
6379 DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size
);
6380 deprecated_register_gdbarch_swap (NULL
, 0, build_remote_gdbarch_data
);
6382 /* Initialize the per-target state. At the moment there is only one
6383 of these, not one per target. Only one target is active at a
6384 time. The default buffer size is unimportant; it will be expanded
6385 whenever a larger buffer is needed. */
6386 rs
= get_remote_state_raw ();
6388 rs
->buf
= xmalloc (rs
->buf_size
);
6391 add_target (&remote_ops
);
6393 init_extended_remote_ops ();
6394 add_target (&extended_remote_ops
);
6396 init_remote_async_ops ();
6397 add_target (&remote_async_ops
);
6399 init_extended_async_remote_ops ();
6400 add_target (&extended_async_remote_ops
);
6402 /* Hook into new objfile notification. */
6403 observer_attach_new_objfile (remote_new_objfile
);
6406 init_remote_threadtests ();
6409 /* set/show remote ... */
6411 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
6412 Remote protocol specific variables\n\
6413 Configure various remote-protocol specific variables such as\n\
6414 the packets being used"),
6415 &remote_set_cmdlist
, "set remote ",
6416 0 /* allow-unknown */, &setlist
);
6417 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
6418 Remote protocol specific variables\n\
6419 Configure various remote-protocol specific variables such as\n\
6420 the packets being used"),
6421 &remote_show_cmdlist
, "show remote ",
6422 0 /* allow-unknown */, &showlist
);
6424 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
6425 Compare section data on target to the exec file.\n\
6426 Argument is a single section name (default: all loaded sections)."),
6429 add_cmd ("packet", class_maintenance
, packet_command
, _("\
6430 Send an arbitrary packet to a remote target.\n\
6431 maintenance packet TEXT\n\
6432 If GDB is talking to an inferior via the GDB serial protocol, then\n\
6433 this command sends the string TEXT to the inferior, and displays the\n\
6434 response packet. GDB supplies the initial `$' character, and the\n\
6435 terminating `#' character and checksum."),
6438 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
6439 Set whether to send break if interrupted."), _("\
6440 Show whether to send break if interrupted."), _("\
6441 If set, a break, instead of a cntrl-c, is sent to the remote target."),
6442 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
6443 &setlist
, &showlist
);
6445 /* Install commands for configuring memory read/write packets. */
6447 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
6448 Set the maximum number of bytes per memory write packet (deprecated)."),
6450 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
6451 Show the maximum number of bytes per memory write packet (deprecated)."),
6453 add_cmd ("memory-write-packet-size", no_class
,
6454 set_memory_write_packet_size
, _("\
6455 Set the maximum number of bytes per memory-write packet.\n\
6456 Specify the number of bytes in a packet or 0 (zero) for the\n\
6457 default packet size. The actual limit is further reduced\n\
6458 dependent on the target. Specify ``fixed'' to disable the\n\
6459 further restriction and ``limit'' to enable that restriction."),
6460 &remote_set_cmdlist
);
6461 add_cmd ("memory-read-packet-size", no_class
,
6462 set_memory_read_packet_size
, _("\
6463 Set the maximum number of bytes per memory-read packet.\n\
6464 Specify the number of bytes in a packet or 0 (zero) for the\n\
6465 default packet size. The actual limit is further reduced\n\
6466 dependent on the target. Specify ``fixed'' to disable the\n\
6467 further restriction and ``limit'' to enable that restriction."),
6468 &remote_set_cmdlist
);
6469 add_cmd ("memory-write-packet-size", no_class
,
6470 show_memory_write_packet_size
,
6471 _("Show the maximum number of bytes per memory-write packet."),
6472 &remote_show_cmdlist
);
6473 add_cmd ("memory-read-packet-size", no_class
,
6474 show_memory_read_packet_size
,
6475 _("Show the maximum number of bytes per memory-read packet."),
6476 &remote_show_cmdlist
);
6478 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
6479 &remote_hw_watchpoint_limit
, _("\
6480 Set the maximum number of target hardware watchpoints."), _("\
6481 Show the maximum number of target hardware watchpoints."), _("\
6482 Specify a negative limit for unlimited."),
6483 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
6484 &remote_set_cmdlist
, &remote_show_cmdlist
);
6485 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
6486 &remote_hw_breakpoint_limit
, _("\
6487 Set the maximum number of target hardware breakpoints."), _("\
6488 Show the maximum number of target hardware breakpoints."), _("\
6489 Specify a negative limit for unlimited."),
6490 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
6491 &remote_set_cmdlist
, &remote_show_cmdlist
);
6493 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
6494 &remote_address_size
, _("\
6495 Set the maximum size of the address (in bits) in a memory packet."), _("\
6496 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
6498 NULL
, /* FIXME: i18n: */
6499 &setlist
, &showlist
);
6501 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
6502 "X", "binary-download", 1);
6504 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
6505 "vCont", "verbose-resume", 0);
6507 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
6508 "QPassSignals", "pass-signals", 0);
6510 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
6511 "qSymbol", "symbol-lookup", 0);
6513 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
6514 "P", "set-register", 1);
6516 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
6517 "p", "fetch-register", 1);
6519 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
6520 "Z0", "software-breakpoint", 0);
6522 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
6523 "Z1", "hardware-breakpoint", 0);
6525 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
6526 "Z2", "write-watchpoint", 0);
6528 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
6529 "Z3", "read-watchpoint", 0);
6531 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
6532 "Z4", "access-watchpoint", 0);
6534 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
6535 "qXfer:auxv:read", "read-aux-vector", 0);
6537 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
6538 "qXfer:features:read", "target-features", 0);
6540 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
6541 "qXfer:memory-map:read", "memory-map", 0);
6543 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
6544 "qGetTLSAddr", "get-thread-local-storage-address",
6547 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
6548 "qSupported", "supported-packets", 0);
6550 /* Keep the old ``set remote Z-packet ...'' working. Each individual
6551 Z sub-packet has its own set and show commands, but users may
6552 have sets to this variable in their .gdbinit files (or in their
6554 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
6555 &remote_Z_packet_detect
, _("\
6556 Set use of remote protocol `Z' packets"), _("\
6557 Show use of remote protocol `Z' packets "), _("\
6558 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
6560 set_remote_protocol_Z_packet_cmd
,
6561 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
6562 &remote_set_cmdlist
, &remote_show_cmdlist
);
6564 /* Eventually initialize fileio. See fileio.c */
6565 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);