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 (buf_len
> 2 * rsa
->sizeof_g_packet
)
3601 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
3603 /* Save the size of the packet sent to us by the target. It is used
3604 as a heuristic when determining the max size of packets that the
3605 target can safely receive. */
3606 if (rsa
->actual_register_packet_size
== 0)
3607 rsa
->actual_register_packet_size
= buf_len
;
3609 /* If this is smaller than we guessed the 'g' packet would be,
3610 update our records. A 'g' reply that doesn't include a register's
3611 value implies either that the register is not available, or that
3612 the 'p' packet must be used. */
3613 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
3615 rsa
->sizeof_g_packet
= buf_len
/ 2;
3617 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3619 if (rsa
->regs
[i
].pnum
== -1)
3622 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
3623 rsa
->regs
[i
].in_g_packet
= 0;
3625 rsa
->regs
[i
].in_g_packet
= 1;
3629 regs
= alloca (rsa
->sizeof_g_packet
);
3631 /* Unimplemented registers read as all bits zero. */
3632 memset (regs
, 0, rsa
->sizeof_g_packet
);
3634 /* Reply describes registers byte by byte, each byte encoded as two
3635 hex characters. Suck them all up, then supply them to the
3636 register cacheing/storage mechanism. */
3639 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3641 if (p
[0] == 0 || p
[1] == 0)
3642 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3643 internal_error (__FILE__
, __LINE__
,
3644 "unexpected end of 'g' packet reply");
3646 if (p
[0] == 'x' && p
[1] == 'x')
3647 regs
[i
] = 0; /* 'x' */
3649 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3655 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3657 struct packet_reg
*r
= &rsa
->regs
[i
];
3660 if (r
->offset
* 2 >= strlen (rs
->buf
))
3661 /* This shouldn't happen - we adjusted in_g_packet above. */
3662 internal_error (__FILE__
, __LINE__
,
3663 "unexpected end of 'g' packet reply");
3664 else if (rs
->buf
[r
->offset
* 2] == 'x')
3666 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
3667 /* The register isn't available, mark it as such (at
3668 the same time setting the value to zero). */
3669 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
3672 regcache_raw_supply (regcache
, r
->regnum
,
3680 fetch_registers_using_g (struct regcache
*regcache
)
3683 process_g_packet (regcache
);
3687 remote_fetch_registers (struct regcache
*regcache
, int regnum
)
3689 struct remote_state
*rs
= get_remote_state ();
3690 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3693 set_thread (PIDGET (inferior_ptid
), 1);
3697 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3698 gdb_assert (reg
!= NULL
);
3700 /* If this register might be in the 'g' packet, try that first -
3701 we are likely to read more than one register. If this is the
3702 first 'g' packet, we might be overly optimistic about its
3703 contents, so fall back to 'p'. */
3704 if (reg
->in_g_packet
)
3706 fetch_registers_using_g (regcache
);
3707 if (reg
->in_g_packet
)
3711 if (fetch_register_using_p (regcache
, reg
))
3714 /* This register is not available. */
3715 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3720 fetch_registers_using_g (regcache
);
3722 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3723 if (!rsa
->regs
[i
].in_g_packet
)
3724 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
3726 /* This register is not available. */
3727 regcache_raw_supply (regcache
, i
, NULL
);
3731 /* Prepare to store registers. Since we may send them all (using a
3732 'G' request), we have to read out the ones we don't want to change
3736 remote_prepare_to_store (struct regcache
*regcache
)
3738 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3740 gdb_byte buf
[MAX_REGISTER_SIZE
];
3742 /* Make sure the entire registers array is valid. */
3743 switch (remote_protocol_packets
[PACKET_P
].support
)
3745 case PACKET_DISABLE
:
3746 case PACKET_SUPPORT_UNKNOWN
:
3747 /* Make sure all the necessary registers are cached. */
3748 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3749 if (rsa
->regs
[i
].in_g_packet
)
3750 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
3757 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3758 packet was not recognized. */
3761 store_register_using_P (const struct regcache
*regcache
, struct packet_reg
*reg
)
3763 struct remote_state
*rs
= get_remote_state ();
3764 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3765 /* Try storing a single register. */
3766 char *buf
= rs
->buf
;
3767 gdb_byte regp
[MAX_REGISTER_SIZE
];
3770 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
3773 if (reg
->pnum
== -1)
3776 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
3777 p
= buf
+ strlen (buf
);
3778 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
3779 bin2hex (regp
, p
, register_size (current_gdbarch
, reg
->regnum
));
3780 remote_send (&rs
->buf
, &rs
->buf_size
);
3782 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
3787 error (_("Could not write register \"%s\""),
3788 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3789 case PACKET_UNKNOWN
:
3792 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
3796 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3797 contents of the register cache buffer. FIXME: ignores errors. */
3800 store_registers_using_G (const struct regcache
*regcache
)
3802 struct remote_state
*rs
= get_remote_state ();
3803 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3807 /* Extract all the registers in the regcache copying them into a
3811 regs
= alloca (rsa
->sizeof_g_packet
);
3812 memset (regs
, 0, rsa
->sizeof_g_packet
);
3813 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3815 struct packet_reg
*r
= &rsa
->regs
[i
];
3817 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
3821 /* Command describes registers byte by byte,
3822 each byte encoded as two hex characters. */
3825 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
3827 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
3828 remote_send (&rs
->buf
, &rs
->buf_size
);
3831 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3832 of the register cache buffer. FIXME: ignores errors. */
3835 remote_store_registers (struct regcache
*regcache
, int regnum
)
3837 struct remote_state
*rs
= get_remote_state ();
3838 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3841 set_thread (PIDGET (inferior_ptid
), 1);
3845 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3846 gdb_assert (reg
!= NULL
);
3848 /* Always prefer to store registers using the 'P' packet if
3849 possible; we often change only a small number of registers.
3850 Sometimes we change a larger number; we'd need help from a
3851 higher layer to know to use 'G'. */
3852 if (store_register_using_P (regcache
, reg
))
3855 /* For now, don't complain if we have no way to write the
3856 register. GDB loses track of unavailable registers too
3857 easily. Some day, this may be an error. We don't have
3858 any way to read the register, either... */
3859 if (!reg
->in_g_packet
)
3862 store_registers_using_G (regcache
);
3866 store_registers_using_G (regcache
);
3868 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3869 if (!rsa
->regs
[i
].in_g_packet
)
3870 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
3871 /* See above for why we do not issue an error here. */
3876 /* Return the number of hex digits in num. */
3879 hexnumlen (ULONGEST num
)
3883 for (i
= 0; num
!= 0; i
++)
3889 /* Set BUF to the minimum number of hex digits representing NUM. */
3892 hexnumstr (char *buf
, ULONGEST num
)
3894 int len
= hexnumlen (num
);
3895 return hexnumnstr (buf
, num
, len
);
3899 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3902 hexnumnstr (char *buf
, ULONGEST num
, int width
)
3908 for (i
= width
- 1; i
>= 0; i
--)
3910 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
3917 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3920 remote_address_masked (CORE_ADDR addr
)
3922 if (remote_address_size
> 0
3923 && remote_address_size
< (sizeof (ULONGEST
) * 8))
3925 /* Only create a mask when that mask can safely be constructed
3926 in a ULONGEST variable. */
3928 mask
= (mask
<< remote_address_size
) - 1;
3934 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
3935 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
3936 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
3937 (which may be more than *OUT_LEN due to escape characters). The
3938 total number of bytes in the output buffer will be at most
3942 remote_escape_output (const gdb_byte
*buffer
, int len
,
3943 gdb_byte
*out_buf
, int *out_len
,
3946 int input_index
, output_index
;
3949 for (input_index
= 0; input_index
< len
; input_index
++)
3951 gdb_byte b
= buffer
[input_index
];
3953 if (b
== '$' || b
== '#' || b
== '}')
3955 /* These must be escaped. */
3956 if (output_index
+ 2 > out_maxlen
)
3958 out_buf
[output_index
++] = '}';
3959 out_buf
[output_index
++] = b
^ 0x20;
3963 if (output_index
+ 1 > out_maxlen
)
3965 out_buf
[output_index
++] = b
;
3969 *out_len
= input_index
;
3970 return output_index
;
3973 /* Convert BUFFER, escaped data LEN bytes long, into binary data
3974 in OUT_BUF. Return the number of bytes written to OUT_BUF.
3975 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
3977 This function reverses remote_escape_output. It allows more
3978 escaped characters than that function does, in particular because
3979 '*' must be escaped to avoid the run-length encoding processing
3980 in reading packets. */
3983 remote_unescape_input (const gdb_byte
*buffer
, int len
,
3984 gdb_byte
*out_buf
, int out_maxlen
)
3986 int input_index
, output_index
;
3991 for (input_index
= 0; input_index
< len
; input_index
++)
3993 gdb_byte b
= buffer
[input_index
];
3995 if (output_index
+ 1 > out_maxlen
)
3997 warning (_("Received too much data from remote target;"
3998 " ignoring overflow."));
3999 return output_index
;
4004 out_buf
[output_index
++] = b
^ 0x20;
4010 out_buf
[output_index
++] = b
;
4014 error (_("Unmatched escape character in target response."));
4016 return output_index
;
4019 /* Determine whether the remote target supports binary downloading.
4020 This is accomplished by sending a no-op memory write of zero length
4021 to the target at the specified address. It does not suffice to send
4022 the whole packet, since many stubs strip the eighth bit and
4023 subsequently compute a wrong checksum, which causes real havoc with
4026 NOTE: This can still lose if the serial line is not eight-bit
4027 clean. In cases like this, the user should clear "remote
4031 check_binary_download (CORE_ADDR addr
)
4033 struct remote_state
*rs
= get_remote_state ();
4035 switch (remote_protocol_packets
[PACKET_X
].support
)
4037 case PACKET_DISABLE
:
4041 case PACKET_SUPPORT_UNKNOWN
:
4047 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4049 p
+= hexnumstr (p
, (ULONGEST
) 0);
4053 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4054 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4056 if (rs
->buf
[0] == '\0')
4059 fprintf_unfiltered (gdb_stdlog
,
4060 "binary downloading NOT suppported by target\n");
4061 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
4066 fprintf_unfiltered (gdb_stdlog
,
4067 "binary downloading suppported by target\n");
4068 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
4075 /* Write memory data directly to the remote machine.
4076 This does not inform the data cache; the data cache uses this.
4077 HEADER is the starting part of the packet.
4078 MEMADDR is the address in the remote memory space.
4079 MYADDR is the address of the buffer in our space.
4080 LEN is the number of bytes.
4081 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4082 should send data as binary ('X'), or hex-encoded ('M').
4084 The function creates packet of the form
4085 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4087 where encoding of <DATA> is termined by PACKET_FORMAT.
4089 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4092 Returns the number of bytes transferred, or 0 (setting errno) for
4093 error. Only transfer a single packet. */
4096 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
4097 const gdb_byte
*myaddr
, int len
,
4098 char packet_format
, int use_length
)
4100 struct remote_state
*rs
= get_remote_state ();
4110 if (packet_format
!= 'X' && packet_format
!= 'M')
4111 internal_error (__FILE__
, __LINE__
,
4112 "remote_write_bytes_aux: bad packet format");
4117 payload_size
= get_memory_write_packet_size ();
4119 /* The packet buffer will be large enough for the payload;
4120 get_memory_packet_size ensures this. */
4123 /* Compute the size of the actual payload by subtracting out the
4124 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4126 payload_size
-= strlen ("$,:#NN");
4128 /* The comma won't be used. */
4130 header_length
= strlen (header
);
4131 payload_size
-= header_length
;
4132 payload_size
-= hexnumlen (memaddr
);
4134 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4136 strcat (rs
->buf
, header
);
4137 p
= rs
->buf
+ strlen (header
);
4139 /* Compute a best guess of the number of bytes actually transfered. */
4140 if (packet_format
== 'X')
4142 /* Best guess at number of bytes that will fit. */
4143 todo
= min (len
, payload_size
);
4145 payload_size
-= hexnumlen (todo
);
4146 todo
= min (todo
, payload_size
);
4150 /* Num bytes that will fit. */
4151 todo
= min (len
, payload_size
/ 2);
4153 payload_size
-= hexnumlen (todo
);
4154 todo
= min (todo
, payload_size
/ 2);
4158 internal_error (__FILE__
, __LINE__
,
4159 _("minumum packet size too small to write data"));
4161 /* If we already need another packet, then try to align the end
4162 of this packet to a useful boundary. */
4163 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
4164 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
4166 /* Append "<memaddr>". */
4167 memaddr
= remote_address_masked (memaddr
);
4168 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4175 /* Append <len>. Retain the location/size of <len>. It may need to
4176 be adjusted once the packet body has been created. */
4178 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
4186 /* Append the packet body. */
4187 if (packet_format
== 'X')
4189 /* Binary mode. Send target system values byte by byte, in
4190 increasing byte addresses. Only escape certain critical
4192 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
4195 /* If not all TODO bytes fit, then we'll need another packet. Make
4196 a second try to keep the end of the packet aligned. Don't do
4197 this if the packet is tiny. */
4198 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
4202 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
4204 if (new_nr_bytes
!= nr_bytes
)
4205 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
4210 p
+= payload_length
;
4211 if (use_length
&& nr_bytes
< todo
)
4213 /* Escape chars have filled up the buffer prematurely,
4214 and we have actually sent fewer bytes than planned.
4215 Fix-up the length field of the packet. Use the same
4216 number of characters as before. */
4217 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
4218 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
4223 /* Normal mode: Send target system values byte by byte, in
4224 increasing byte addresses. Each byte is encoded as a two hex
4226 nr_bytes
= bin2hex (myaddr
, p
, todo
);
4230 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4231 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4233 if (rs
->buf
[0] == 'E')
4235 /* There is no correspondance between what the remote protocol
4236 uses for errors and errno codes. We would like a cleaner way
4237 of representing errors (big enough to include errno codes,
4238 bfd_error codes, and others). But for now just return EIO. */
4243 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4244 fewer bytes than we'd planned. */
4248 /* Write memory data directly to the remote machine.
4249 This does not inform the data cache; the data cache uses this.
4250 MEMADDR is the address in the remote memory space.
4251 MYADDR is the address of the buffer in our space.
4252 LEN is the number of bytes.
4254 Returns number of bytes transferred, or 0 (setting errno) for
4255 error. Only transfer a single packet. */
4258 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
4260 char *packet_format
= 0;
4262 /* Check whether the target supports binary download. */
4263 check_binary_download (memaddr
);
4265 switch (remote_protocol_packets
[PACKET_X
].support
)
4268 packet_format
= "X";
4270 case PACKET_DISABLE
:
4271 packet_format
= "M";
4273 case PACKET_SUPPORT_UNKNOWN
:
4274 internal_error (__FILE__
, __LINE__
,
4275 _("remote_write_bytes: bad internal state"));
4277 internal_error (__FILE__
, __LINE__
, _("bad switch"));
4280 return remote_write_bytes_aux (packet_format
,
4281 memaddr
, myaddr
, len
, packet_format
[0], 1);
4284 /* Read memory data directly from the remote machine.
4285 This does not use the data cache; the data cache uses this.
4286 MEMADDR is the address in the remote memory space.
4287 MYADDR is the address of the buffer in our space.
4288 LEN is the number of bytes.
4290 Returns number of bytes transferred, or 0 for error. */
4292 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4293 remote targets) shouldn't attempt to read the entire buffer.
4294 Instead it should read a single packet worth of data and then
4295 return the byte size of that packet to the caller. The caller (its
4296 caller and its callers caller ;-) already contains code for
4297 handling partial reads. */
4300 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
4302 struct remote_state
*rs
= get_remote_state ();
4303 int max_buf_size
; /* Max size of packet output buffer. */
4309 max_buf_size
= get_memory_read_packet_size ();
4310 /* The packet buffer will be large enough for the payload;
4311 get_memory_packet_size ensures this. */
4320 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
4322 /* construct "m"<memaddr>","<len>" */
4323 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4324 memaddr
= remote_address_masked (memaddr
);
4327 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4329 p
+= hexnumstr (p
, (ULONGEST
) todo
);
4333 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4335 if (rs
->buf
[0] == 'E'
4336 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
4337 && rs
->buf
[3] == '\0')
4339 /* There is no correspondance between what the remote
4340 protocol uses for errors and errno codes. We would like
4341 a cleaner way of representing errors (big enough to
4342 include errno codes, bfd_error codes, and others). But
4343 for now just return EIO. */
4348 /* Reply describes memory byte by byte,
4349 each byte encoded as two hex characters. */
4352 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
4354 /* Reply is short. This means that we were able to read
4355 only part of what we wanted to. */
4356 return i
+ (origlen
- len
);
4365 /* Read or write LEN bytes from inferior memory at MEMADDR,
4366 transferring to or from debugger address BUFFER. Write to inferior
4367 if SHOULD_WRITE is nonzero. Returns length of data written or
4368 read; 0 for error. TARGET is unused. */
4371 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
4372 int should_write
, struct mem_attrib
*attrib
,
4373 struct target_ops
*target
)
4378 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
4380 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
4385 /* Sends a packet with content determined by the printf format string
4386 FORMAT and the remaining arguments, then gets the reply. Returns
4387 whether the packet was a success, a failure, or unknown. */
4390 remote_send_printf (const char *format
, ...)
4392 struct remote_state
*rs
= get_remote_state ();
4393 int max_size
= get_remote_packet_size ();
4396 va_start (ap
, format
);
4399 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
4400 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
4402 if (putpkt (rs
->buf
) < 0)
4403 error (_("Communication problem with target."));
4406 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4408 return packet_check_result (rs
->buf
);
4412 restore_remote_timeout (void *p
)
4414 int value
= *(int *)p
;
4415 remote_timeout
= value
;
4418 /* Flash writing can take quite some time. We'll set
4419 effectively infinite timeout for flash operations.
4420 In future, we'll need to decide on a better approach. */
4421 static const int remote_flash_timeout
= 1000;
4424 remote_flash_erase (struct target_ops
*ops
,
4425 ULONGEST address
, LONGEST length
)
4427 int saved_remote_timeout
= remote_timeout
;
4428 enum packet_result ret
;
4430 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4431 &saved_remote_timeout
);
4432 remote_timeout
= remote_flash_timeout
;
4434 ret
= remote_send_printf ("vFlashErase:%s,%s",
4439 case PACKET_UNKNOWN
:
4440 error (_("Remote target does not support flash erase"));
4442 error (_("Error erasing flash with vFlashErase packet"));
4447 do_cleanups (back_to
);
4451 remote_flash_write (struct target_ops
*ops
,
4452 ULONGEST address
, LONGEST length
,
4453 const gdb_byte
*data
)
4455 int saved_remote_timeout
= remote_timeout
;
4457 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4458 &saved_remote_timeout
);
4460 remote_timeout
= remote_flash_timeout
;
4461 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
4462 do_cleanups (back_to
);
4468 remote_flash_done (struct target_ops
*ops
)
4470 int saved_remote_timeout
= remote_timeout
;
4472 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4473 &saved_remote_timeout
);
4475 remote_timeout
= remote_flash_timeout
;
4476 ret
= remote_send_printf ("vFlashDone");
4477 do_cleanups (back_to
);
4481 case PACKET_UNKNOWN
:
4482 error (_("Remote target does not support vFlashDone"));
4484 error (_("Error finishing flash operation"));
4491 remote_files_info (struct target_ops
*ignore
)
4493 puts_filtered ("Debugging a target over a serial line.\n");
4496 /* Stuff for dealing with the packets which are part of this protocol.
4497 See comment at top of file for details. */
4499 /* Read a single character from the remote end. */
4502 readchar (int timeout
)
4506 ch
= serial_readchar (remote_desc
, timeout
);
4511 switch ((enum serial_rc
) ch
)
4514 target_mourn_inferior ();
4515 error (_("Remote connection closed"));
4518 perror_with_name (_("Remote communication error"));
4520 case SERIAL_TIMEOUT
:
4526 /* Send the command in *BUF to the remote machine, and read the reply
4527 into *BUF. Report an error if we get an error reply. Resize
4528 *BUF using xrealloc if necessary to hold the result, and update
4532 remote_send (char **buf
,
4536 getpkt (buf
, sizeof_buf
, 0);
4538 if ((*buf
)[0] == 'E')
4539 error (_("Remote failure reply: %s"), *buf
);
4542 /* Display a null-terminated packet on stdout, for debugging, using C
4546 print_packet (char *buf
)
4548 puts_filtered ("\"");
4549 fputstr_filtered (buf
, '"', gdb_stdout
);
4550 puts_filtered ("\"");
4556 return putpkt_binary (buf
, strlen (buf
));
4559 /* Send a packet to the remote machine, with error checking. The data
4560 of the packet is in BUF. The string in BUF can be at most
4561 get_remote_packet_size () - 5 to account for the $, # and checksum,
4562 and for a possible /0 if we are debugging (remote_debug) and want
4563 to print the sent packet as a string. */
4566 putpkt_binary (char *buf
, int cnt
)
4569 unsigned char csum
= 0;
4570 char *buf2
= alloca (cnt
+ 6);
4576 /* Copy the packet into buffer BUF2, encapsulating it
4577 and giving it a checksum. */
4582 for (i
= 0; i
< cnt
; i
++)
4588 *p
++ = tohex ((csum
>> 4) & 0xf);
4589 *p
++ = tohex (csum
& 0xf);
4591 /* Send it over and over until we get a positive ack. */
4595 int started_error_output
= 0;
4600 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
4601 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
4602 fprintf_unfiltered (gdb_stdlog
, "...");
4603 gdb_flush (gdb_stdlog
);
4605 if (serial_write (remote_desc
, buf2
, p
- buf2
))
4606 perror_with_name (_("putpkt: write failed"));
4608 /* Read until either a timeout occurs (-2) or '+' is read. */
4611 ch
= readchar (remote_timeout
);
4619 case SERIAL_TIMEOUT
:
4621 if (started_error_output
)
4623 putchar_unfiltered ('\n');
4624 started_error_output
= 0;
4633 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
4637 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
4638 case SERIAL_TIMEOUT
:
4642 break; /* Retransmit buffer. */
4646 fprintf_unfiltered (gdb_stdlog
,
4647 "Packet instead of Ack, ignoring it\n");
4648 /* It's probably an old response sent because an ACK
4649 was lost. Gobble up the packet and ack it so it
4650 doesn't get retransmitted when we resend this
4653 serial_write (remote_desc
, "+", 1);
4654 continue; /* Now, go look for +. */
4659 if (!started_error_output
)
4661 started_error_output
= 1;
4662 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4664 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4668 break; /* Here to retransmit. */
4672 /* This is wrong. If doing a long backtrace, the user should be
4673 able to get out next time we call QUIT, without anything as
4674 violent as interrupt_query. If we want to provide a way out of
4675 here without getting to the next QUIT, it should be based on
4676 hitting ^C twice as in remote_wait. */
4686 /* Come here after finding the start of a frame when we expected an
4687 ack. Do our best to discard the rest of this packet. */
4696 c
= readchar (remote_timeout
);
4699 case SERIAL_TIMEOUT
:
4700 /* Nothing we can do. */
4703 /* Discard the two bytes of checksum and stop. */
4704 c
= readchar (remote_timeout
);
4706 c
= readchar (remote_timeout
);
4709 case '*': /* Run length encoding. */
4710 /* Discard the repeat count. */
4711 c
= readchar (remote_timeout
);
4716 /* A regular character. */
4722 /* Come here after finding the start of the frame. Collect the rest
4723 into *BUF, verifying the checksum, length, and handling run-length
4724 compression. NUL terminate the buffer. If there is not enough room,
4725 expand *BUF using xrealloc.
4727 Returns -1 on error, number of characters in buffer (ignoring the
4728 trailing NULL) on success. (could be extended to return one of the
4729 SERIAL status indications). */
4732 read_frame (char **buf_p
,
4745 c
= readchar (remote_timeout
);
4748 case SERIAL_TIMEOUT
:
4750 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4754 fputs_filtered ("Saw new packet start in middle of old one\n",
4756 return -1; /* Start a new packet, count retries. */
4759 unsigned char pktcsum
;
4765 check_0
= readchar (remote_timeout
);
4767 check_1
= readchar (remote_timeout
);
4769 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4772 fputs_filtered ("Timeout in checksum, retrying\n",
4776 else if (check_0
< 0 || check_1
< 0)
4779 fputs_filtered ("Communication error in checksum\n",
4784 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4785 if (csum
== pktcsum
)
4790 fprintf_filtered (gdb_stdlog
,
4791 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4793 fputstrn_filtered (buf
, bc
, 0, gdb_stdlog
);
4794 fputs_filtered ("\n", gdb_stdlog
);
4796 /* Number of characters in buffer ignoring trailing
4800 case '*': /* Run length encoding. */
4805 c
= readchar (remote_timeout
);
4807 repeat
= c
- ' ' + 3; /* Compute repeat count. */
4809 /* The character before ``*'' is repeated. */
4811 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
4813 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
4815 /* Make some more room in the buffer. */
4816 *sizeof_buf
+= repeat
;
4817 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4821 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4827 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
4831 if (bc
>= *sizeof_buf
- 1)
4833 /* Make some more room in the buffer. */
4835 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4846 /* Read a packet from the remote machine, with error checking, and
4847 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4848 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4849 rather than timing out; this is used (in synchronous mode) to wait
4850 for a target that is is executing user code to stop. */
4851 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4852 don't have to change all the calls to getpkt to deal with the
4853 return value, because at the moment I don't know what the right
4854 thing to do it for those. */
4862 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
4866 /* Read a packet from the remote machine, with error checking, and
4867 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4868 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4869 rather than timing out; this is used (in synchronous mode) to wait
4870 for a target that is is executing user code to stop. If FOREVER ==
4871 0, this function is allowed to time out gracefully and return an
4872 indication of this to the caller. Otherwise return the number
4875 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
4882 strcpy (*buf
, "timeout");
4886 timeout
= watchdog
> 0 ? watchdog
: -1;
4890 timeout
= remote_timeout
;
4894 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
4896 /* This can loop forever if the remote side sends us characters
4897 continuously, but if it pauses, we'll get a zero from
4898 readchar because of timeout. Then we'll count that as a
4901 /* Note that we will only wait forever prior to the start of a
4902 packet. After that, we expect characters to arrive at a
4903 brisk pace. They should show up within remote_timeout
4908 c
= readchar (timeout
);
4910 if (c
== SERIAL_TIMEOUT
)
4912 if (forever
) /* Watchdog went off? Kill the target. */
4915 target_mourn_inferior ();
4916 error (_("Watchdog has expired. Target detached."));
4919 fputs_filtered ("Timed out.\n", gdb_stdlog
);
4925 /* We've found the start of a packet, now collect the data. */
4927 val
= read_frame (buf
, sizeof_buf
);
4933 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
4934 fputstrn_unfiltered (*buf
, val
, 0, gdb_stdlog
);
4935 fprintf_unfiltered (gdb_stdlog
, "\n");
4937 serial_write (remote_desc
, "+", 1);
4941 /* Try the whole thing again. */
4943 serial_write (remote_desc
, "-", 1);
4946 /* We have tried hard enough, and just can't receive the packet.
4949 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
4950 serial_write (remote_desc
, "+", 1);
4957 /* For some mysterious reason, wait_for_inferior calls kill instead of
4958 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4962 target_mourn_inferior ();
4966 /* Use catch_errors so the user can quit from gdb even when we aren't on
4967 speaking terms with the remote system. */
4968 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4970 /* Don't wait for it to die. I'm not really sure it matters whether
4971 we do or not. For the existing stubs, kill is a noop. */
4972 target_mourn_inferior ();
4975 /* Async version of remote_kill. */
4977 remote_async_kill (void)
4979 /* Unregister the file descriptor from the event loop. */
4980 if (target_is_async_p ())
4981 serial_async (remote_desc
, NULL
, 0);
4983 /* For some mysterious reason, wait_for_inferior calls kill instead of
4984 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4988 target_mourn_inferior ();
4992 /* Use catch_errors so the user can quit from gdb even when we
4993 aren't on speaking terms with the remote system. */
4994 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4996 /* Don't wait for it to die. I'm not really sure it matters whether
4997 we do or not. For the existing stubs, kill is a noop. */
4998 target_mourn_inferior ();
5004 remote_mourn_1 (&remote_ops
);
5008 remote_async_mourn (void)
5010 remote_mourn_1 (&remote_async_ops
);
5014 extended_remote_mourn (void)
5016 /* We do _not_ want to mourn the target like this; this will
5017 remove the extended remote target from the target stack,
5018 and the next time the user says "run" it'll fail.
5020 FIXME: What is the right thing to do here? */
5022 remote_mourn_1 (&extended_remote_ops
);
5026 /* Worker function for remote_mourn. */
5028 remote_mourn_1 (struct target_ops
*target
)
5030 unpush_target (target
);
5031 generic_mourn_inferior ();
5034 /* In the extended protocol we want to be able to do things like
5035 "run" and have them basically work as expected. So we need
5036 a special create_inferior function.
5038 FIXME: One day add support for changing the exec file
5039 we're debugging, arguments and an environment. */
5042 extended_remote_create_inferior (char *exec_file
, char *args
,
5043 char **env
, int from_tty
)
5045 /* Rip out the breakpoints; we'll reinsert them after restarting
5046 the remote server. */
5047 remove_breakpoints ();
5049 /* Now restart the remote server. */
5050 extended_remote_restart ();
5052 /* NOTE: We don't need to recheck for a target description here; but
5053 if we gain the ability to switch the remote executable we may
5054 need to, if for instance we are running a process which requested
5055 different emulated hardware from the operating system. A
5056 concrete example of this is ARM GNU/Linux, where some binaries
5057 will have a legacy FPA coprocessor emulated and others may have
5058 access to a hardware VFP unit. */
5060 /* Now put the breakpoints back in. This way we're safe if the
5061 restart function works via a unix fork on the remote side. */
5062 insert_breakpoints ();
5064 /* Clean up from the last time we were running. */
5065 clear_proceed_status ();
5068 /* Async version of extended_remote_create_inferior. */
5070 extended_remote_async_create_inferior (char *exec_file
, char *args
,
5071 char **env
, int from_tty
)
5073 /* Rip out the breakpoints; we'll reinsert them after restarting
5074 the remote server. */
5075 remove_breakpoints ();
5077 /* If running asynchronously, register the target file descriptor
5078 with the event loop. */
5079 if (target_can_async_p ())
5080 target_async (inferior_event_handler
, 0);
5082 /* Now restart the remote server. */
5083 extended_remote_restart ();
5085 /* NOTE: We don't need to recheck for a target description here; but
5086 if we gain the ability to switch the remote executable we may
5087 need to, if for instance we are running a process which requested
5088 different emulated hardware from the operating system. A
5089 concrete example of this is ARM GNU/Linux, where some binaries
5090 will have a legacy FPA coprocessor emulated and others may have
5091 access to a hardware VFP unit. */
5093 /* Now put the breakpoints back in. This way we're safe if the
5094 restart function works via a unix fork on the remote side. */
5095 insert_breakpoints ();
5097 /* Clean up from the last time we were running. */
5098 clear_proceed_status ();
5102 /* Insert a breakpoint. On targets that have software breakpoint
5103 support, we ask the remote target to do the work; on targets
5104 which don't, we insert a traditional memory breakpoint. */
5107 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
5109 CORE_ADDR addr
= bp_tgt
->placed_address
;
5110 struct remote_state
*rs
= get_remote_state ();
5112 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5113 If it succeeds, then set the support to PACKET_ENABLE. If it
5114 fails, and the user has explicitly requested the Z support then
5115 report an error, otherwise, mark it disabled and go on. */
5117 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5124 BREAKPOINT_FROM_PC (&bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5125 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5126 p
+= hexnumstr (p
, addr
);
5127 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5130 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5132 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
5138 case PACKET_UNKNOWN
:
5143 return memory_insert_breakpoint (bp_tgt
);
5147 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
5149 CORE_ADDR addr
= bp_tgt
->placed_address
;
5150 struct remote_state
*rs
= get_remote_state ();
5153 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5161 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5162 p
+= hexnumstr (p
, addr
);
5163 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5166 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5168 return (rs
->buf
[0] == 'E');
5171 return memory_remove_breakpoint (bp_tgt
);
5175 watchpoint_to_Z_packet (int type
)
5180 return Z_PACKET_WRITE_WP
;
5183 return Z_PACKET_READ_WP
;
5186 return Z_PACKET_ACCESS_WP
;
5189 internal_error (__FILE__
, __LINE__
,
5190 _("hw_bp_to_z: bad watchpoint type %d"), type
);
5195 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
5197 struct remote_state
*rs
= get_remote_state ();
5199 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5201 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5204 sprintf (rs
->buf
, "Z%x,", packet
);
5205 p
= strchr (rs
->buf
, '\0');
5206 addr
= remote_address_masked (addr
);
5207 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5208 sprintf (p
, ",%x", len
);
5211 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5213 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5216 case PACKET_UNKNOWN
:
5221 internal_error (__FILE__
, __LINE__
,
5222 _("remote_insert_watchpoint: reached end of function"));
5227 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
5229 struct remote_state
*rs
= get_remote_state ();
5231 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5233 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5236 sprintf (rs
->buf
, "z%x,", packet
);
5237 p
= strchr (rs
->buf
, '\0');
5238 addr
= remote_address_masked (addr
);
5239 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5240 sprintf (p
, ",%x", len
);
5242 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5244 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5247 case PACKET_UNKNOWN
:
5252 internal_error (__FILE__
, __LINE__
,
5253 _("remote_remove_watchpoint: reached end of function"));
5257 int remote_hw_watchpoint_limit
= -1;
5258 int remote_hw_breakpoint_limit
= -1;
5261 remote_check_watch_resources (int type
, int cnt
, int ot
)
5263 if (type
== bp_hardware_breakpoint
)
5265 if (remote_hw_breakpoint_limit
== 0)
5267 else if (remote_hw_breakpoint_limit
< 0)
5269 else if (cnt
<= remote_hw_breakpoint_limit
)
5274 if (remote_hw_watchpoint_limit
== 0)
5276 else if (remote_hw_watchpoint_limit
< 0)
5280 else if (cnt
<= remote_hw_watchpoint_limit
)
5287 remote_stopped_by_watchpoint (void)
5289 return remote_stopped_by_watchpoint_p
;
5292 extern int stepped_after_stopped_by_watchpoint
;
5295 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
5298 if (remote_stopped_by_watchpoint ()
5299 || stepped_after_stopped_by_watchpoint
)
5301 *addr_p
= remote_watch_data_address
;
5310 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5313 struct remote_state
*rs
= get_remote_state ();
5316 /* The length field should be set to the size of a breakpoint
5317 instruction, even though we aren't inserting one ourselves. */
5319 BREAKPOINT_FROM_PC (&bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5321 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5328 addr
= remote_address_masked (bp_tgt
->placed_address
);
5329 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5330 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5333 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5335 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5338 case PACKET_UNKNOWN
:
5343 internal_error (__FILE__
, __LINE__
,
5344 _("remote_insert_hw_breakpoint: reached end of function"));
5349 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5352 struct remote_state
*rs
= get_remote_state ();
5355 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5362 addr
= remote_address_masked (bp_tgt
->placed_address
);
5363 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5364 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5367 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5369 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5372 case PACKET_UNKNOWN
:
5377 internal_error (__FILE__
, __LINE__
,
5378 _("remote_remove_hw_breakpoint: reached end of function"));
5381 /* Some targets are only capable of doing downloads, and afterwards
5382 they switch to the remote serial protocol. This function provides
5383 a clean way to get from the download target to the remote target.
5384 It's basically just a wrapper so that we don't have to expose any
5385 of the internal workings of remote.c.
5387 Prior to calling this routine, you should shutdown the current
5388 target code, else you will get the "A program is being debugged
5389 already..." message. Usually a call to pop_target() suffices. */
5392 push_remote_target (char *name
, int from_tty
)
5394 printf_filtered (_("Switching to remote protocol\n"));
5395 remote_open (name
, from_tty
);
5398 /* Table used by the crc32 function to calcuate the checksum. */
5400 static unsigned long crc32_table
[256] =
5403 static unsigned long
5404 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
5406 if (!crc32_table
[1])
5408 /* Initialize the CRC table and the decoding table. */
5412 for (i
= 0; i
< 256; i
++)
5414 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
5415 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
5422 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
5428 /* compare-sections command
5430 With no arguments, compares each loadable section in the exec bfd
5431 with the same memory range on the target, and reports mismatches.
5432 Useful for verifying the image on the target against the exec file.
5433 Depends on the target understanding the new "qCRC:" request. */
5435 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5436 target method (target verify memory) and generic version of the
5437 actual command. This will allow other high-level code (especially
5438 generic_load()) to make use of this target functionality. */
5441 compare_sections_command (char *args
, int from_tty
)
5443 struct remote_state
*rs
= get_remote_state ();
5445 unsigned long host_crc
, target_crc
;
5446 extern bfd
*exec_bfd
;
5447 struct cleanup
*old_chain
;
5450 const char *sectname
;
5457 error (_("command cannot be used without an exec file"));
5458 if (!current_target
.to_shortname
||
5459 strcmp (current_target
.to_shortname
, "remote") != 0)
5460 error (_("command can only be used with remote target"));
5462 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5464 if (!(s
->flags
& SEC_LOAD
))
5465 continue; /* skip non-loadable section */
5467 size
= bfd_get_section_size (s
);
5469 continue; /* skip zero-length section */
5471 sectname
= bfd_get_section_name (exec_bfd
, s
);
5472 if (args
&& strcmp (args
, sectname
) != 0)
5473 continue; /* not the section selected by user */
5475 matched
= 1; /* do this section */
5477 /* FIXME: assumes lma can fit into long. */
5478 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
5479 (long) lma
, (long) size
);
5482 /* Be clever; compute the host_crc before waiting for target
5484 sectdata
= xmalloc (size
);
5485 old_chain
= make_cleanup (xfree
, sectdata
);
5486 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
5487 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
5489 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5490 if (rs
->buf
[0] == 'E')
5491 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5492 sectname
, paddr (lma
), paddr (lma
+ size
));
5493 if (rs
->buf
[0] != 'C')
5494 error (_("remote target does not support this operation"));
5496 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
5497 target_crc
= target_crc
* 16 + fromhex (*tmp
);
5499 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5500 sectname
, paddr (lma
), paddr (lma
+ size
));
5501 if (host_crc
== target_crc
)
5502 printf_filtered ("matched.\n");
5505 printf_filtered ("MIS-MATCHED!\n");
5509 do_cleanups (old_chain
);
5512 warning (_("One or more sections of the remote executable does not match\n\
5513 the loaded file\n"));
5514 if (args
&& !matched
)
5515 printf_filtered (_("No loaded section named '%s'.\n"), args
);
5518 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5519 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5520 number of bytes read is returned, or 0 for EOF, or -1 for error.
5521 The number of bytes read may be less than LEN without indicating an
5522 EOF. PACKET is checked and updated to indicate whether the remote
5523 target supports this object. */
5526 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
5528 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
5529 struct packet_config
*packet
)
5531 static char *finished_object
;
5532 static char *finished_annex
;
5533 static ULONGEST finished_offset
;
5535 struct remote_state
*rs
= get_remote_state ();
5536 unsigned int total
= 0;
5537 LONGEST i
, n
, packet_len
;
5539 if (packet
->support
== PACKET_DISABLE
)
5542 /* Check whether we've cached an end-of-object packet that matches
5544 if (finished_object
)
5546 if (strcmp (object_name
, finished_object
) == 0
5547 && strcmp (annex
? annex
: "", finished_annex
) == 0
5548 && offset
== finished_offset
)
5551 /* Otherwise, we're now reading something different. Discard
5553 xfree (finished_object
);
5554 xfree (finished_annex
);
5555 finished_object
= NULL
;
5556 finished_annex
= NULL
;
5559 /* Request only enough to fit in a single packet. The actual data
5560 may not, since we don't know how much of it will need to be escaped;
5561 the target is free to respond with slightly less data. We subtract
5562 five to account for the response type and the protocol frame. */
5563 n
= min (get_remote_packet_size () - 5, len
);
5564 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5565 object_name
, annex
? annex
: "",
5566 phex_nz (offset
, sizeof offset
),
5567 phex_nz (n
, sizeof n
));
5568 i
= putpkt (rs
->buf
);
5573 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
5574 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5577 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
5578 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
5580 /* 'm' means there is (or at least might be) more data after this
5581 batch. That does not make sense unless there's at least one byte
5582 of data in this reply. */
5583 if (rs
->buf
[0] == 'm' && packet_len
== 1)
5584 error (_("Remote qXfer reply contained no data."));
5586 /* Got some data. */
5587 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
5589 /* 'l' is an EOF marker, possibly including a final block of data,
5590 or possibly empty. Record it to bypass the next read, if one is
5592 if (rs
->buf
[0] == 'l')
5594 finished_object
= xstrdup (object_name
);
5595 finished_annex
= xstrdup (annex
? annex
: "");
5596 finished_offset
= offset
+ i
;
5603 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5604 const char *annex
, gdb_byte
*readbuf
,
5605 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5607 struct remote_state
*rs
= get_remote_state ();
5612 /* Handle memory using the standard memory routines. */
5613 if (object
== TARGET_OBJECT_MEMORY
)
5618 if (writebuf
!= NULL
)
5619 xfered
= remote_write_bytes (offset
, writebuf
, len
);
5621 xfered
= remote_read_bytes (offset
, readbuf
, len
);
5625 else if (xfered
== 0 && errno
== 0)
5631 /* Only handle flash writes. */
5632 if (writebuf
!= NULL
)
5638 case TARGET_OBJECT_FLASH
:
5639 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
5643 else if (xfered
== 0 && errno
== 0)
5653 /* Map pre-existing objects onto letters. DO NOT do this for new
5654 objects!!! Instead specify new query packets. */
5657 case TARGET_OBJECT_AVR
:
5661 case TARGET_OBJECT_AUXV
:
5662 gdb_assert (annex
== NULL
);
5663 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
5664 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
5666 case TARGET_OBJECT_AVAILABLE_FEATURES
:
5667 return remote_read_qxfer
5668 (ops
, "features", annex
, readbuf
, offset
, len
,
5669 &remote_protocol_packets
[PACKET_qXfer_features
]);
5671 case TARGET_OBJECT_MEMORY_MAP
:
5672 gdb_assert (annex
== NULL
);
5673 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
5674 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
5680 /* Note: a zero OFFSET and LEN can be used to query the minimum
5682 if (offset
== 0 && len
== 0)
5683 return (get_remote_packet_size ());
5684 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5685 large enough let the caller deal with it. */
5686 if (len
< get_remote_packet_size ())
5688 len
= get_remote_packet_size ();
5690 /* Except for querying the minimum buffer size, target must be open. */
5692 error (_("remote query is only available after target open"));
5694 gdb_assert (annex
!= NULL
);
5695 gdb_assert (readbuf
!= NULL
);
5701 /* We used one buffer char for the remote protocol q command and
5702 another for the query type. As the remote protocol encapsulation
5703 uses 4 chars plus one extra in case we are debugging
5704 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5707 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
5709 /* Bad caller may have sent forbidden characters. */
5710 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
5715 gdb_assert (annex
[i
] == '\0');
5717 i
= putpkt (rs
->buf
);
5721 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5722 strcpy ((char *) readbuf
, rs
->buf
);
5724 return strlen ((char *) readbuf
);
5728 remote_rcmd (char *command
,
5729 struct ui_file
*outbuf
)
5731 struct remote_state
*rs
= get_remote_state ();
5735 error (_("remote rcmd is only available after target open"));
5737 /* Send a NULL command across as an empty command. */
5738 if (command
== NULL
)
5741 /* The query prefix. */
5742 strcpy (rs
->buf
, "qRcmd,");
5743 p
= strchr (rs
->buf
, '\0');
5745 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
5746 error (_("\"monitor\" command ``%s'' is too long."), command
);
5748 /* Encode the actual command. */
5749 bin2hex ((gdb_byte
*) command
, p
, 0);
5751 if (putpkt (rs
->buf
) < 0)
5752 error (_("Communication problem with target."));
5754 /* get/display the response */
5759 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5761 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5764 error (_("Target does not support this command."));
5765 if (buf
[0] == 'O' && buf
[1] != 'K')
5767 remote_console_output (buf
+ 1); /* 'O' message from stub. */
5770 if (strcmp (buf
, "OK") == 0)
5772 if (strlen (buf
) == 3 && buf
[0] == 'E'
5773 && isdigit (buf
[1]) && isdigit (buf
[2]))
5775 error (_("Protocol error with Rcmd"));
5777 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5779 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5780 fputc_unfiltered (c
, outbuf
);
5786 static VEC(mem_region_s
) *
5787 remote_memory_map (struct target_ops
*ops
)
5789 VEC(mem_region_s
) *result
= NULL
;
5790 char *text
= target_read_stralloc (¤t_target
,
5791 TARGET_OBJECT_MEMORY_MAP
, NULL
);
5795 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
5796 result
= parse_memory_map (text
);
5797 do_cleanups (back_to
);
5804 packet_command (char *args
, int from_tty
)
5806 struct remote_state
*rs
= get_remote_state ();
5809 error (_("command can only be used with remote target"));
5812 error (_("remote-packet command requires packet text as argument"));
5814 puts_filtered ("sending: ");
5815 print_packet (args
);
5816 puts_filtered ("\n");
5819 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5820 puts_filtered ("received: ");
5821 print_packet (rs
->buf
);
5822 puts_filtered ("\n");
5826 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
5828 static void display_thread_info (struct gdb_ext_thread_info
*info
);
5830 static void threadset_test_cmd (char *cmd
, int tty
);
5832 static void threadalive_test (char *cmd
, int tty
);
5834 static void threadlist_test_cmd (char *cmd
, int tty
);
5836 int get_and_display_threadinfo (threadref
*ref
);
5838 static void threadinfo_test_cmd (char *cmd
, int tty
);
5840 static int thread_display_step (threadref
*ref
, void *context
);
5842 static void threadlist_update_test_cmd (char *cmd
, int tty
);
5844 static void init_remote_threadtests (void);
5846 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
5849 threadset_test_cmd (char *cmd
, int tty
)
5851 int sample_thread
= SAMPLE_THREAD
;
5853 printf_filtered (_("Remote threadset test\n"));
5854 set_thread (sample_thread
, 1);
5859 threadalive_test (char *cmd
, int tty
)
5861 int sample_thread
= SAMPLE_THREAD
;
5863 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
5864 printf_filtered ("PASS: Thread alive test\n");
5866 printf_filtered ("FAIL: Thread alive test\n");
5869 void output_threadid (char *title
, threadref
*ref
);
5872 output_threadid (char *title
, threadref
*ref
)
5876 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
5878 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
5882 threadlist_test_cmd (char *cmd
, int tty
)
5885 threadref nextthread
;
5886 int done
, result_count
;
5887 threadref threadlist
[3];
5889 printf_filtered ("Remote Threadlist test\n");
5890 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
5891 &result_count
, &threadlist
[0]))
5892 printf_filtered ("FAIL: threadlist test\n");
5895 threadref
*scan
= threadlist
;
5896 threadref
*limit
= scan
+ result_count
;
5898 while (scan
< limit
)
5899 output_threadid (" thread ", scan
++);
5904 display_thread_info (struct gdb_ext_thread_info
*info
)
5906 output_threadid ("Threadid: ", &info
->threadid
);
5907 printf_filtered ("Name: %s\n ", info
->shortname
);
5908 printf_filtered ("State: %s\n", info
->display
);
5909 printf_filtered ("other: %s\n\n", info
->more_display
);
5913 get_and_display_threadinfo (threadref
*ref
)
5917 struct gdb_ext_thread_info threadinfo
;
5919 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
5920 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
5921 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
5922 display_thread_info (&threadinfo
);
5927 threadinfo_test_cmd (char *cmd
, int tty
)
5929 int athread
= SAMPLE_THREAD
;
5933 int_to_threadref (&thread
, athread
);
5934 printf_filtered ("Remote Threadinfo test\n");
5935 if (!get_and_display_threadinfo (&thread
))
5936 printf_filtered ("FAIL cannot get thread info\n");
5940 thread_display_step (threadref
*ref
, void *context
)
5942 /* output_threadid(" threadstep ",ref); *//* simple test */
5943 return get_and_display_threadinfo (ref
);
5947 threadlist_update_test_cmd (char *cmd
, int tty
)
5949 printf_filtered ("Remote Threadlist update test\n");
5950 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
5954 init_remote_threadtests (void)
5956 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
5957 Fetch and print the remote list of thread identifiers, one pkt only"));
5958 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
5959 _("Fetch and display info about one thread"));
5960 add_com ("tset", class_obscure
, threadset_test_cmd
,
5961 _("Test setting to a different thread"));
5962 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
5963 _("Iterate through updating all remote thread info"));
5964 add_com ("talive", class_obscure
, threadalive_test
,
5965 _(" Remote thread alive test "));
5970 /* Convert a thread ID to a string. Returns the string in a static
5974 remote_pid_to_str (ptid_t ptid
)
5976 static char buf
[32];
5978 xsnprintf (buf
, sizeof buf
, "Thread %d", ptid_get_pid (ptid
));
5982 /* Get the address of the thread local variable in OBJFILE which is
5983 stored at OFFSET within the thread local storage for thread PTID. */
5986 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
5988 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
5990 struct remote_state
*rs
= get_remote_state ();
5992 enum packet_result result
;
5994 strcpy (p
, "qGetTLSAddr:");
5996 p
+= hexnumstr (p
, PIDGET (ptid
));
5998 p
+= hexnumstr (p
, offset
);
6000 p
+= hexnumstr (p
, lm
);
6004 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6005 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
6006 if (result
== PACKET_OK
)
6010 unpack_varlen_hex (rs
->buf
, &result
);
6013 else if (result
== PACKET_UNKNOWN
)
6014 throw_error (TLS_GENERIC_ERROR
,
6015 _("Remote target doesn't support qGetTLSAddr packet"));
6017 throw_error (TLS_GENERIC_ERROR
,
6018 _("Remote target failed to process qGetTLSAddr request"));
6021 throw_error (TLS_GENERIC_ERROR
,
6022 _("TLS not supported or disabled on this target"));
6027 /* Support for inferring a target description based on the current
6028 architecture and the size of a 'g' packet. While the 'g' packet
6029 can have any size (since optional registers can be left off the
6030 end), some sizes are easily recognizable given knowledge of the
6031 approximate architecture. */
6033 struct remote_g_packet_guess
6036 const struct target_desc
*tdesc
;
6038 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
6039 DEF_VEC_O(remote_g_packet_guess_s
);
6041 struct remote_g_packet_data
6043 VEC(remote_g_packet_guess_s
) *guesses
;
6046 static struct gdbarch_data
*remote_g_packet_data_handle
;
6049 remote_g_packet_data_init (struct obstack
*obstack
)
6051 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
6055 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
6056 const struct target_desc
*tdesc
)
6058 struct remote_g_packet_data
*data
6059 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
6060 struct remote_g_packet_guess new_guess
, *guess
;
6063 gdb_assert (tdesc
!= NULL
);
6066 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6068 if (guess
->bytes
== bytes
)
6069 internal_error (__FILE__
, __LINE__
,
6070 "Duplicate g packet description added for size %d",
6073 new_guess
.bytes
= bytes
;
6074 new_guess
.tdesc
= tdesc
;
6075 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
6078 static const struct target_desc
*
6079 remote_read_description (struct target_ops
*target
)
6081 struct remote_g_packet_data
*data
6082 = gdbarch_data (current_gdbarch
, remote_g_packet_data_handle
);
6084 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
6086 struct remote_g_packet_guess
*guess
;
6088 int bytes
= send_g_packet ();
6091 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6093 if (guess
->bytes
== bytes
)
6094 return guess
->tdesc
;
6096 /* We discard the g packet. A minor optimization would be to
6097 hold on to it, and fill the register cache once we have selected
6098 an architecture, but it's too tricky to do safely. */
6105 init_remote_ops (void)
6107 remote_ops
.to_shortname
= "remote";
6108 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
6110 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6111 Specify the serial device it is connected to\n\
6112 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
6113 remote_ops
.to_open
= remote_open
;
6114 remote_ops
.to_close
= remote_close
;
6115 remote_ops
.to_detach
= remote_detach
;
6116 remote_ops
.to_disconnect
= remote_disconnect
;
6117 remote_ops
.to_resume
= remote_resume
;
6118 remote_ops
.to_wait
= remote_wait
;
6119 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
6120 remote_ops
.to_store_registers
= remote_store_registers
;
6121 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6122 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6123 remote_ops
.to_files_info
= remote_files_info
;
6124 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6125 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6126 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6127 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6128 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6129 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6130 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6131 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6132 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6133 remote_ops
.to_kill
= remote_kill
;
6134 remote_ops
.to_load
= generic_load
;
6135 remote_ops
.to_mourn_inferior
= remote_mourn
;
6136 remote_ops
.to_thread_alive
= remote_thread_alive
;
6137 remote_ops
.to_find_new_threads
= remote_threads_info
;
6138 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
6139 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6140 remote_ops
.to_stop
= remote_stop
;
6141 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
6142 remote_ops
.to_rcmd
= remote_rcmd
;
6143 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
6144 remote_ops
.to_stratum
= process_stratum
;
6145 remote_ops
.to_has_all_memory
= 1;
6146 remote_ops
.to_has_memory
= 1;
6147 remote_ops
.to_has_stack
= 1;
6148 remote_ops
.to_has_registers
= 1;
6149 remote_ops
.to_has_execution
= 1;
6150 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6151 remote_ops
.to_magic
= OPS_MAGIC
;
6152 remote_ops
.to_memory_map
= remote_memory_map
;
6153 remote_ops
.to_flash_erase
= remote_flash_erase
;
6154 remote_ops
.to_flash_done
= remote_flash_done
;
6155 remote_ops
.to_read_description
= remote_read_description
;
6158 /* Set up the extended remote vector by making a copy of the standard
6159 remote vector and adding to it. */
6162 init_extended_remote_ops (void)
6164 extended_remote_ops
= remote_ops
;
6166 extended_remote_ops
.to_shortname
= "extended-remote";
6167 extended_remote_ops
.to_longname
=
6168 "Extended remote serial target in gdb-specific protocol";
6169 extended_remote_ops
.to_doc
=
6170 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6171 Specify the serial device it is connected to (e.g. /dev/ttya).",
6172 extended_remote_ops
.to_open
= extended_remote_open
;
6173 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
6174 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6178 remote_can_async_p (void)
6180 /* We're async whenever the serial device is. */
6181 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
6185 remote_is_async_p (void)
6187 /* We're async whenever the serial device is. */
6188 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
6191 /* Pass the SERIAL event on and up to the client. One day this code
6192 will be able to delay notifying the client of an event until the
6193 point where an entire packet has been received. */
6195 static void (*async_client_callback
) (enum inferior_event_type event_type
,
6197 static void *async_client_context
;
6198 static serial_event_ftype remote_async_serial_handler
;
6201 remote_async_serial_handler (struct serial
*scb
, void *context
)
6203 /* Don't propogate error information up to the client. Instead let
6204 the client find out about the error by querying the target. */
6205 async_client_callback (INF_REG_EVENT
, async_client_context
);
6209 remote_async (void (*callback
) (enum inferior_event_type event_type
,
6210 void *context
), void *context
)
6212 if (current_target
.to_async_mask_value
== 0)
6213 internal_error (__FILE__
, __LINE__
,
6214 _("Calling remote_async when async is masked"));
6216 if (callback
!= NULL
)
6218 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
6219 async_client_callback
= callback
;
6220 async_client_context
= context
;
6223 serial_async (remote_desc
, NULL
, NULL
);
6226 /* Target async and target extended-async.
6228 This are temporary targets, until it is all tested. Eventually
6229 async support will be incorporated int the usual 'remote'
6233 init_remote_async_ops (void)
6235 remote_async_ops
.to_shortname
= "async";
6236 remote_async_ops
.to_longname
=
6237 "Remote serial target in async version of the gdb-specific protocol";
6238 remote_async_ops
.to_doc
=
6239 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6240 Specify the serial device it is connected to (e.g. /dev/ttya).";
6241 remote_async_ops
.to_open
= remote_async_open
;
6242 remote_async_ops
.to_close
= remote_close
;
6243 remote_async_ops
.to_detach
= remote_detach
;
6244 remote_async_ops
.to_disconnect
= remote_disconnect
;
6245 remote_async_ops
.to_resume
= remote_async_resume
;
6246 remote_async_ops
.to_wait
= remote_async_wait
;
6247 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
6248 remote_async_ops
.to_store_registers
= remote_store_registers
;
6249 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6250 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6251 remote_async_ops
.to_files_info
= remote_files_info
;
6252 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6253 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6254 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6255 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6256 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6257 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6258 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6259 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6260 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6261 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
6262 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
6263 remote_async_ops
.to_kill
= remote_async_kill
;
6264 remote_async_ops
.to_load
= generic_load
;
6265 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
6266 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
6267 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
6268 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
6269 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6270 remote_async_ops
.to_stop
= remote_stop
;
6271 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
6272 remote_async_ops
.to_rcmd
= remote_rcmd
;
6273 remote_async_ops
.to_stratum
= process_stratum
;
6274 remote_async_ops
.to_has_all_memory
= 1;
6275 remote_async_ops
.to_has_memory
= 1;
6276 remote_async_ops
.to_has_stack
= 1;
6277 remote_async_ops
.to_has_registers
= 1;
6278 remote_async_ops
.to_has_execution
= 1;
6279 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6280 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
6281 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
6282 remote_async_ops
.to_async
= remote_async
;
6283 remote_async_ops
.to_async_mask_value
= 1;
6284 remote_async_ops
.to_magic
= OPS_MAGIC
;
6285 remote_async_ops
.to_memory_map
= remote_memory_map
;
6286 remote_async_ops
.to_flash_erase
= remote_flash_erase
;
6287 remote_async_ops
.to_flash_done
= remote_flash_done
;
6288 remote_ops
.to_read_description
= remote_read_description
;
6291 /* Set up the async extended remote vector by making a copy of the standard
6292 remote vector and adding to it. */
6295 init_extended_async_remote_ops (void)
6297 extended_async_remote_ops
= remote_async_ops
;
6299 extended_async_remote_ops
.to_shortname
= "extended-async";
6300 extended_async_remote_ops
.to_longname
=
6301 "Extended remote serial target in async gdb-specific protocol";
6302 extended_async_remote_ops
.to_doc
=
6303 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
6304 Specify the serial device it is connected to (e.g. /dev/ttya).",
6305 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
6306 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
6307 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6311 set_remote_cmd (char *args
, int from_tty
)
6313 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
6317 show_remote_cmd (char *args
, int from_tty
)
6319 /* We can't just use cmd_show_list here, because we want to skip
6320 the redundant "show remote Z-packet" and the legacy aliases. */
6321 struct cleanup
*showlist_chain
;
6322 struct cmd_list_element
*list
= remote_show_cmdlist
;
6324 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
6325 for (; list
!= NULL
; list
= list
->next
)
6326 if (strcmp (list
->name
, "Z-packet") == 0)
6328 else if (list
->type
== not_set_cmd
)
6329 /* Alias commands are exactly like the original, except they
6330 don't have the normal type. */
6334 struct cleanup
*option_chain
6335 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
6336 ui_out_field_string (uiout
, "name", list
->name
);
6337 ui_out_text (uiout
, ": ");
6338 if (list
->type
== show_cmd
)
6339 do_setshow_command ((char *) NULL
, from_tty
, list
);
6341 cmd_func (list
, NULL
, from_tty
);
6342 /* Close the tuple. */
6343 do_cleanups (option_chain
);
6346 /* Close the tuple. */
6347 do_cleanups (showlist_chain
);
6351 build_remote_gdbarch_data (void)
6353 remote_address_size
= TARGET_ADDR_BIT
;
6356 /* Function to be called whenever a new objfile (shlib) is detected. */
6358 remote_new_objfile (struct objfile
*objfile
)
6360 if (remote_desc
!= 0) /* Have a remote connection. */
6361 remote_check_symbols (objfile
);
6365 _initialize_remote (void)
6367 struct remote_state
*rs
;
6369 /* architecture specific data */
6370 remote_gdbarch_data_handle
=
6371 gdbarch_data_register_post_init (init_remote_state
);
6372 remote_g_packet_data_handle
=
6373 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
6375 /* Old tacky stuff. NOTE: This comes after the remote protocol so
6376 that the remote protocol has been initialized. */
6377 DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size
);
6378 deprecated_register_gdbarch_swap (NULL
, 0, build_remote_gdbarch_data
);
6380 /* Initialize the per-target state. At the moment there is only one
6381 of these, not one per target. Only one target is active at a
6382 time. The default buffer size is unimportant; it will be expanded
6383 whenever a larger buffer is needed. */
6384 rs
= get_remote_state_raw ();
6386 rs
->buf
= xmalloc (rs
->buf_size
);
6389 add_target (&remote_ops
);
6391 init_extended_remote_ops ();
6392 add_target (&extended_remote_ops
);
6394 init_remote_async_ops ();
6395 add_target (&remote_async_ops
);
6397 init_extended_async_remote_ops ();
6398 add_target (&extended_async_remote_ops
);
6400 /* Hook into new objfile notification. */
6401 observer_attach_new_objfile (remote_new_objfile
);
6404 init_remote_threadtests ();
6407 /* set/show remote ... */
6409 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
6410 Remote protocol specific variables\n\
6411 Configure various remote-protocol specific variables such as\n\
6412 the packets being used"),
6413 &remote_set_cmdlist
, "set remote ",
6414 0 /* allow-unknown */, &setlist
);
6415 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
6416 Remote protocol specific variables\n\
6417 Configure various remote-protocol specific variables such as\n\
6418 the packets being used"),
6419 &remote_show_cmdlist
, "show remote ",
6420 0 /* allow-unknown */, &showlist
);
6422 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
6423 Compare section data on target to the exec file.\n\
6424 Argument is a single section name (default: all loaded sections)."),
6427 add_cmd ("packet", class_maintenance
, packet_command
, _("\
6428 Send an arbitrary packet to a remote target.\n\
6429 maintenance packet TEXT\n\
6430 If GDB is talking to an inferior via the GDB serial protocol, then\n\
6431 this command sends the string TEXT to the inferior, and displays the\n\
6432 response packet. GDB supplies the initial `$' character, and the\n\
6433 terminating `#' character and checksum."),
6436 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
6437 Set whether to send break if interrupted."), _("\
6438 Show whether to send break if interrupted."), _("\
6439 If set, a break, instead of a cntrl-c, is sent to the remote target."),
6440 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
6441 &setlist
, &showlist
);
6443 /* Install commands for configuring memory read/write packets. */
6445 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
6446 Set the maximum number of bytes per memory write packet (deprecated)."),
6448 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
6449 Show the maximum number of bytes per memory write packet (deprecated)."),
6451 add_cmd ("memory-write-packet-size", no_class
,
6452 set_memory_write_packet_size
, _("\
6453 Set the maximum number of bytes per memory-write packet.\n\
6454 Specify the number of bytes in a packet or 0 (zero) for the\n\
6455 default packet size. The actual limit is further reduced\n\
6456 dependent on the target. Specify ``fixed'' to disable the\n\
6457 further restriction and ``limit'' to enable that restriction."),
6458 &remote_set_cmdlist
);
6459 add_cmd ("memory-read-packet-size", no_class
,
6460 set_memory_read_packet_size
, _("\
6461 Set the maximum number of bytes per memory-read packet.\n\
6462 Specify the number of bytes in a packet or 0 (zero) for the\n\
6463 default packet size. The actual limit is further reduced\n\
6464 dependent on the target. Specify ``fixed'' to disable the\n\
6465 further restriction and ``limit'' to enable that restriction."),
6466 &remote_set_cmdlist
);
6467 add_cmd ("memory-write-packet-size", no_class
,
6468 show_memory_write_packet_size
,
6469 _("Show the maximum number of bytes per memory-write packet."),
6470 &remote_show_cmdlist
);
6471 add_cmd ("memory-read-packet-size", no_class
,
6472 show_memory_read_packet_size
,
6473 _("Show the maximum number of bytes per memory-read packet."),
6474 &remote_show_cmdlist
);
6476 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
6477 &remote_hw_watchpoint_limit
, _("\
6478 Set the maximum number of target hardware watchpoints."), _("\
6479 Show the maximum number of target hardware watchpoints."), _("\
6480 Specify a negative limit for unlimited."),
6481 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
6482 &remote_set_cmdlist
, &remote_show_cmdlist
);
6483 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
6484 &remote_hw_breakpoint_limit
, _("\
6485 Set the maximum number of target hardware breakpoints."), _("\
6486 Show the maximum number of target hardware breakpoints."), _("\
6487 Specify a negative limit for unlimited."),
6488 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
6489 &remote_set_cmdlist
, &remote_show_cmdlist
);
6491 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
6492 &remote_address_size
, _("\
6493 Set the maximum size of the address (in bits) in a memory packet."), _("\
6494 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
6496 NULL
, /* FIXME: i18n: */
6497 &setlist
, &showlist
);
6499 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
6500 "X", "binary-download", 1);
6502 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
6503 "vCont", "verbose-resume", 0);
6505 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
6506 "QPassSignals", "pass-signals", 0);
6508 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
6509 "qSymbol", "symbol-lookup", 0);
6511 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
6512 "P", "set-register", 1);
6514 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
6515 "p", "fetch-register", 1);
6517 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
6518 "Z0", "software-breakpoint", 0);
6520 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
6521 "Z1", "hardware-breakpoint", 0);
6523 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
6524 "Z2", "write-watchpoint", 0);
6526 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
6527 "Z3", "read-watchpoint", 0);
6529 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
6530 "Z4", "access-watchpoint", 0);
6532 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
6533 "qXfer:auxv:read", "read-aux-vector", 0);
6535 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
6536 "qXfer:features:read", "target-features", 0);
6538 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
6539 "qXfer:memory-map:read", "memory-map", 0);
6541 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
6542 "qGetTLSAddr", "get-thread-local-storage-address",
6545 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
6546 "qSupported", "supported-packets", 0);
6548 /* Keep the old ``set remote Z-packet ...'' working. Each individual
6549 Z sub-packet has its own set and show commands, but users may
6550 have sets to this variable in their .gdbinit files (or in their
6552 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
6553 &remote_Z_packet_detect
, _("\
6554 Set use of remote protocol `Z' packets"), _("\
6555 Show use of remote protocol `Z' packets "), _("\
6556 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
6558 set_remote_protocol_Z_packet_cmd
,
6559 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
6560 &remote_set_cmdlist
, &remote_show_cmdlist
);
6562 /* Eventually initialize fileio. See fileio.c */
6563 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);