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, 2008, 2009,
5 2010 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 3 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, see <http://www.gnu.org/licenses/>. */
22 /* See the GDB User Guide for details of the GDB remote protocol. */
25 #include "gdb_string.h"
31 #include "exceptions.h"
33 /*#include "terminal.h" */
36 #include "gdb-stabs.h"
37 #include "gdbthread.h"
41 #include "gdb_assert.h"
44 #include "cli/cli-decode.h"
45 #include "cli/cli-setshow.h"
46 #include "target-descriptions.h"
51 #include "event-loop.h"
52 #include "event-top.h"
58 #include "gdbcore.h" /* for exec_bfd */
60 #include "remote-fileio.h"
61 #include "gdb/fileio.h"
63 #include "xml-support.h"
65 #include "memory-map.h"
67 #include "tracepoint.h"
71 /* temp hacks for tracepoint encoding migration */
72 static char *target_buf
;
73 static long target_buf_size
;
75 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
76 char ***tdp_actions
, char ***stepping_actions
);
78 /* The size to align memory write packets, when practical. The protocol
79 does not guarantee any alignment, and gdb will generate short
80 writes and unaligned writes, but even as a best-effort attempt this
81 can improve bulk transfers. For instance, if a write is misaligned
82 relative to the target's data bus, the stub may need to make an extra
83 round trip fetching data from the target. This doesn't make a
84 huge difference, but it's easy to do, so we try to be helpful.
86 The alignment chosen is arbitrary; usually data bus width is
87 important here, not the possibly larger cache line size. */
88 enum { REMOTE_ALIGN_WRITES
= 16 };
90 /* Prototypes for local functions. */
91 static void cleanup_sigint_signal_handler (void *dummy
);
92 static void initialize_sigint_signal_handler (void);
93 static int getpkt_sane (char **buf
, long *sizeof_buf
, int forever
);
94 static int getpkt_or_notif_sane (char **buf
, long *sizeof_buf
,
97 static void handle_remote_sigint (int);
98 static void handle_remote_sigint_twice (int);
99 static void async_remote_interrupt (gdb_client_data
);
100 void async_remote_interrupt_twice (gdb_client_data
);
102 static void remote_files_info (struct target_ops
*ignore
);
104 static void remote_prepare_to_store (struct regcache
*regcache
);
106 static void remote_open (char *name
, int from_tty
);
108 static void extended_remote_open (char *name
, int from_tty
);
110 static void remote_open_1 (char *, int, struct target_ops
*, int extended_p
);
112 static void remote_close (int quitting
);
114 static void remote_mourn (struct target_ops
*ops
);
116 static void extended_remote_restart (void);
118 static void extended_remote_mourn (struct target_ops
*);
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 void remote_kill (struct target_ops
*ops
);
128 static int tohex (int nib
);
130 static int remote_can_async_p (void);
132 static int remote_is_async_p (void);
134 static void remote_async (void (*callback
) (enum inferior_event_type event_type
,
135 void *context
), void *context
);
137 static int remote_async_mask (int new_mask
);
139 static void remote_detach (struct target_ops
*ops
, char *args
, int from_tty
);
141 static void remote_interrupt (int signo
);
143 static void remote_interrupt_twice (int signo
);
145 static void interrupt_query (void);
147 static void set_general_thread (struct ptid ptid
);
148 static void set_continue_thread (struct ptid ptid
);
150 static void get_offsets (void);
152 static void skip_frame (void);
154 static long read_frame (char **buf_p
, long *sizeof_buf
);
156 static int hexnumlen (ULONGEST num
);
158 static void init_remote_ops (void);
160 static void init_extended_remote_ops (void);
162 static void remote_stop (ptid_t
);
164 static int ishex (int ch
, int *val
);
166 static int stubhex (int ch
);
168 static int hexnumstr (char *, ULONGEST
);
170 static int hexnumnstr (char *, ULONGEST
, int);
172 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
174 static void print_packet (char *);
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 (ptid_t currthread
);
188 static int fromhex (int a
);
190 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
192 extern 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 static char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
213 static ptid_t
read_ptid (char *buf
, char **obuf
);
216 static int remote_get_trace_status (struct trace_status
*ts
);
218 static int remote_upload_tracepoints (struct uploaded_tp
**utpp
);
220 static int remote_upload_trace_state_variables (struct uploaded_tsv
**utsvp
);
222 static void remote_query_supported (void);
224 static void remote_check_symbols (struct objfile
*objfile
);
226 void _initialize_remote (void);
229 static struct stop_reply
*stop_reply_xmalloc (void);
230 static void stop_reply_xfree (struct stop_reply
*);
231 static void do_stop_reply_xfree (void *arg
);
232 static void remote_parse_stop_reply (char *buf
, struct stop_reply
*);
233 static void push_stop_reply (struct stop_reply
*);
234 static void remote_get_pending_stop_replies (void);
235 static void discard_pending_stop_replies (int pid
);
236 static int peek_stop_reply (ptid_t ptid
);
238 static void remote_async_inferior_event_handler (gdb_client_data
);
239 static void remote_async_get_pending_events_handler (gdb_client_data
);
241 static void remote_terminal_ours (void);
243 static int remote_read_description_p (struct target_ops
*target
);
245 /* The non-stop remote protocol provisions for one pending stop reply.
246 This is where we keep it until it is acknowledged. */
248 static struct stop_reply
*pending_stop_reply
= NULL
;
252 static struct cmd_list_element
*remote_cmdlist
;
254 /* For "set remote" and "show remote". */
256 static struct cmd_list_element
*remote_set_cmdlist
;
257 static struct cmd_list_element
*remote_show_cmdlist
;
259 /* Description of the remote protocol state for the currently
260 connected target. This is per-target state, and independent of the
261 selected architecture. */
265 /* A buffer to use for incoming packets, and its current size. The
266 buffer is grown dynamically for larger incoming packets.
267 Outgoing packets may also be constructed in this buffer.
268 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
269 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
274 /* If we negotiated packet size explicitly (and thus can bypass
275 heuristics for the largest packet size that will not overflow
276 a buffer in the stub), this will be set to that packet size.
277 Otherwise zero, meaning to use the guessed size. */
278 long explicit_packet_size
;
280 /* remote_wait is normally called when the target is running and
281 waits for a stop reply packet. But sometimes we need to call it
282 when the target is already stopped. We can send a "?" packet
283 and have remote_wait read the response. Or, if we already have
284 the response, we can stash it in BUF and tell remote_wait to
285 skip calling getpkt. This flag is set when BUF contains a
286 stop reply packet and the target is not waiting. */
287 int cached_wait_status
;
289 /* True, if in no ack mode. That is, neither GDB nor the stub will
290 expect acks from each other. The connection is assumed to be
294 /* True if we're connected in extended remote mode. */
297 /* True if the stub reported support for multi-process
299 int multi_process_aware
;
301 /* True if we resumed the target and we're waiting for the target to
302 stop. In the mean time, we can't start another command/query.
303 The remote server wouldn't be ready to process it, so we'd
304 timeout waiting for a reply that would never come and eventually
305 we'd close the connection. This can happen in asynchronous mode
306 because we allow GDB commands while the target is running. */
307 int waiting_for_stop_reply
;
309 /* True if the stub reports support for non-stop mode. */
312 /* True if the stub reports support for vCont;t. */
315 /* True if the stub reports support for conditional tracepoints. */
316 int cond_tracepoints
;
318 /* True if the stub reports support for fast tracepoints. */
319 int fast_tracepoints
;
321 /* True if the stub can continue running a trace while GDB is
323 int disconnected_tracing
;
325 /* Nonzero if the user has pressed Ctrl-C, but the target hasn't
326 responded to that. */
330 /* Private data that we'll store in (struct thread_info)->private. */
331 struct private_thread_info
338 free_private_thread_info (struct private_thread_info
*info
)
344 /* Returns true if the multi-process extensions are in effect. */
346 remote_multi_process_p (struct remote_state
*rs
)
348 return rs
->extended
&& rs
->multi_process_aware
;
351 /* This data could be associated with a target, but we do not always
352 have access to the current target when we need it, so for now it is
353 static. This will be fine for as long as only one target is in use
355 static struct remote_state remote_state
;
357 static struct remote_state
*
358 get_remote_state_raw (void)
360 return &remote_state
;
363 /* Description of the remote protocol for a given architecture. */
367 long offset
; /* Offset into G packet. */
368 long regnum
; /* GDB's internal register number. */
369 LONGEST pnum
; /* Remote protocol register number. */
370 int in_g_packet
; /* Always part of G packet. */
371 /* long size in bytes; == register_size (target_gdbarch, regnum);
373 /* char *name; == gdbarch_register_name (target_gdbarch, regnum);
377 struct remote_arch_state
379 /* Description of the remote protocol registers. */
380 long sizeof_g_packet
;
382 /* Description of the remote protocol registers indexed by REGNUM
383 (making an array gdbarch_num_regs in size). */
384 struct packet_reg
*regs
;
386 /* This is the size (in chars) of the first response to the ``g''
387 packet. It is used as a heuristic when determining the maximum
388 size of memory-read and memory-write packets. A target will
389 typically only reserve a buffer large enough to hold the ``g''
390 packet. The size does not include packet overhead (headers and
392 long actual_register_packet_size
;
394 /* This is the maximum size (in chars) of a non read/write packet.
395 It is also used as a cap on the size of read/write packets. */
396 long remote_packet_size
;
399 long sizeof_pkt
= 2000;
401 /* Utility: generate error from an incoming stub packet. */
403 trace_error (char *buf
)
406 return; /* not an error msg */
409 case '1': /* malformed packet error */
410 if (*++buf
== '0') /* general case: */
411 error (_("remote.c: error in outgoing packet."));
413 error (_("remote.c: error in outgoing packet at field #%ld."),
414 strtol (buf
, NULL
, 16));
416 error (_("trace API error 0x%s."), ++buf
);
418 error (_("Target returns error code '%s'."), buf
);
422 /* Utility: wait for reply from stub, while accepting "O" packets. */
424 remote_get_noisy_reply (char **buf_p
,
427 do /* Loop on reply from remote stub. */
430 QUIT
; /* allow user to bail out with ^C */
431 getpkt (buf_p
, sizeof_buf
, 0);
435 else if (buf
[0] == 'O' && buf
[1] != 'K')
436 remote_console_output (buf
+ 1); /* 'O' message from stub */
438 return buf
; /* here's the actual reply */
443 /* Handle for retreving the remote protocol data from gdbarch. */
444 static struct gdbarch_data
*remote_gdbarch_data_handle
;
446 static struct remote_arch_state
*
447 get_remote_arch_state (void)
449 return gdbarch_data (target_gdbarch
, remote_gdbarch_data_handle
);
452 /* Fetch the global remote target state. */
454 static struct remote_state
*
455 get_remote_state (void)
457 /* Make sure that the remote architecture state has been
458 initialized, because doing so might reallocate rs->buf. Any
459 function which calls getpkt also needs to be mindful of changes
460 to rs->buf, but this call limits the number of places which run
462 get_remote_arch_state ();
464 return get_remote_state_raw ();
468 compare_pnums (const void *lhs_
, const void *rhs_
)
470 const struct packet_reg
* const *lhs
= lhs_
;
471 const struct packet_reg
* const *rhs
= rhs_
;
473 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
475 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
482 init_remote_state (struct gdbarch
*gdbarch
)
484 int regnum
, num_remote_regs
, offset
;
485 struct remote_state
*rs
= get_remote_state_raw ();
486 struct remote_arch_state
*rsa
;
487 struct packet_reg
**remote_regs
;
489 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
491 /* Use the architecture to build a regnum<->pnum table, which will be
492 1:1 unless a feature set specifies otherwise. */
493 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
,
494 gdbarch_num_regs (gdbarch
),
496 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
498 struct packet_reg
*r
= &rsa
->regs
[regnum
];
500 if (register_size (gdbarch
, regnum
) == 0)
501 /* Do not try to fetch zero-sized (placeholder) registers. */
504 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
509 /* Define the g/G packet format as the contents of each register
510 with a remote protocol number, in order of ascending protocol
513 remote_regs
= alloca (gdbarch_num_regs (gdbarch
)
514 * sizeof (struct packet_reg
*));
515 for (num_remote_regs
= 0, regnum
= 0;
516 regnum
< gdbarch_num_regs (gdbarch
);
518 if (rsa
->regs
[regnum
].pnum
!= -1)
519 remote_regs
[num_remote_regs
++] = &rsa
->regs
[regnum
];
521 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
524 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
526 remote_regs
[regnum
]->in_g_packet
= 1;
527 remote_regs
[regnum
]->offset
= offset
;
528 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
531 /* Record the maximum possible size of the g packet - it may turn out
533 rsa
->sizeof_g_packet
= offset
;
535 /* Default maximum number of characters in a packet body. Many
536 remote stubs have a hardwired buffer size of 400 bytes
537 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
538 as the maximum packet-size to ensure that the packet and an extra
539 NUL character can always fit in the buffer. This stops GDB
540 trashing stubs that try to squeeze an extra NUL into what is
541 already a full buffer (As of 1999-12-04 that was most stubs). */
542 rsa
->remote_packet_size
= 400 - 1;
544 /* This one is filled in when a ``g'' packet is received. */
545 rsa
->actual_register_packet_size
= 0;
547 /* Should rsa->sizeof_g_packet needs more space than the
548 default, adjust the size accordingly. Remember that each byte is
549 encoded as two characters. 32 is the overhead for the packet
550 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
551 (``$NN:G...#NN'') is a better guess, the below has been padded a
553 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
554 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
556 /* Make sure that the packet buffer is plenty big enough for
557 this architecture. */
558 if (rs
->buf_size
< rsa
->remote_packet_size
)
560 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
561 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
567 /* Return the current allowed size of a remote packet. This is
568 inferred from the current architecture, and should be used to
569 limit the length of outgoing packets. */
571 get_remote_packet_size (void)
573 struct remote_state
*rs
= get_remote_state ();
574 struct remote_arch_state
*rsa
= get_remote_arch_state ();
576 if (rs
->explicit_packet_size
)
577 return rs
->explicit_packet_size
;
579 return rsa
->remote_packet_size
;
582 static struct packet_reg
*
583 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
585 if (regnum
< 0 && regnum
>= gdbarch_num_regs (target_gdbarch
))
589 struct packet_reg
*r
= &rsa
->regs
[regnum
];
590 gdb_assert (r
->regnum
== regnum
);
595 static struct packet_reg
*
596 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
599 for (i
= 0; i
< gdbarch_num_regs (target_gdbarch
); i
++)
601 struct packet_reg
*r
= &rsa
->regs
[i
];
608 /* FIXME: graces/2002-08-08: These variables should eventually be
609 bound to an instance of the target object (as in gdbarch-tdep()),
610 when such a thing exists. */
612 /* This is set to the data address of the access causing the target
613 to stop for a watchpoint. */
614 static CORE_ADDR remote_watch_data_address
;
616 /* This is non-zero if target stopped for a watchpoint. */
617 static int remote_stopped_by_watchpoint_p
;
619 static struct target_ops remote_ops
;
621 static struct target_ops extended_remote_ops
;
623 static int remote_async_mask_value
= 1;
625 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
626 ``forever'' still use the normal timeout mechanism. This is
627 currently used by the ASYNC code to guarentee that target reads
628 during the initial connect always time-out. Once getpkt has been
629 modified to return a timeout indication and, in turn
630 remote_wait()/wait_for_inferior() have gained a timeout parameter
632 static int wait_forever_enabled_p
= 1;
634 /* Allow the user to specify what sequence to send to the remote
635 when he requests a program interruption: Although ^C is usually
636 what remote systems expect (this is the default, here), it is
637 sometimes preferable to send a break. On other systems such
638 as the Linux kernel, a break followed by g, which is Magic SysRq g
639 is required in order to interrupt the execution. */
640 const char interrupt_sequence_control_c
[] = "Ctrl-C";
641 const char interrupt_sequence_break
[] = "BREAK";
642 const char interrupt_sequence_break_g
[] = "BREAK-g";
643 static const char *interrupt_sequence_modes
[] =
645 interrupt_sequence_control_c
,
646 interrupt_sequence_break
,
647 interrupt_sequence_break_g
,
650 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
653 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
654 struct cmd_list_element
*c
,
657 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
658 fprintf_filtered (file
,
659 _("Send the ASCII ETX character (Ctrl-c) "
660 "to the remote target to interrupt the "
661 "execution of the program.\n"));
662 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
663 fprintf_filtered (file
,
664 _("send a break signal to the remote target "
665 "to interrupt the execution of the program.\n"));
666 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
667 fprintf_filtered (file
,
668 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
669 "the remote target to interrupt the execution "
670 "of Linux kernel.\n"));
672 internal_error (__FILE__
, __LINE__
,
673 _("Invalid value for interrupt_sequence_mode: %s."),
674 interrupt_sequence_mode
);
677 /* This boolean variable specifies whether interrupt_sequence is sent
678 to the remote target when gdb connects to it.
679 This is mostly needed when you debug the Linux kernel: The Linux kernel
680 expects BREAK g which is Magic SysRq g for connecting gdb. */
681 static int interrupt_on_connect
= 0;
683 /* This variable is used to implement the "set/show remotebreak" commands.
684 Since these commands are now deprecated in favor of "set/show remote
685 interrupt-sequence", it no longer has any effect on the code. */
686 static int remote_break
;
689 set_remotebreak (char *args
, int from_tty
, struct cmd_list_element
*c
)
692 interrupt_sequence_mode
= interrupt_sequence_break
;
694 interrupt_sequence_mode
= interrupt_sequence_control_c
;
698 show_remotebreak (struct ui_file
*file
, int from_tty
,
699 struct cmd_list_element
*c
,
704 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
705 remote_open knows that we don't have a file open when the program
707 static struct serial
*remote_desc
= NULL
;
709 /* This variable sets the number of bits in an address that are to be
710 sent in a memory ("M" or "m") packet. Normally, after stripping
711 leading zeros, the entire address would be sent. This variable
712 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
713 initial implementation of remote.c restricted the address sent in
714 memory packets to ``host::sizeof long'' bytes - (typically 32
715 bits). Consequently, for 64 bit targets, the upper 32 bits of an
716 address was never sent. Since fixing this bug may cause a break in
717 some remote targets this variable is principly provided to
718 facilitate backward compatibility. */
720 static int remote_address_size
;
722 /* Temporary to track who currently owns the terminal. See
723 remote_terminal_* for more details. */
725 static int remote_async_terminal_ours_p
;
727 /* The executable file to use for "run" on the remote side. */
729 static char *remote_exec_file
= "";
732 /* User configurable variables for the number of characters in a
733 memory read/write packet. MIN (rsa->remote_packet_size,
734 rsa->sizeof_g_packet) is the default. Some targets need smaller
735 values (fifo overruns, et.al.) and some users need larger values
736 (speed up transfers). The variables ``preferred_*'' (the user
737 request), ``current_*'' (what was actually set) and ``forced_*''
738 (Positive - a soft limit, negative - a hard limit). */
740 struct memory_packet_config
747 /* Compute the current size of a read/write packet. Since this makes
748 use of ``actual_register_packet_size'' the computation is dynamic. */
751 get_memory_packet_size (struct memory_packet_config
*config
)
753 struct remote_state
*rs
= get_remote_state ();
754 struct remote_arch_state
*rsa
= get_remote_arch_state ();
756 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
757 law?) that some hosts don't cope very well with large alloca()
758 calls. Eventually the alloca() code will be replaced by calls to
759 xmalloc() and make_cleanups() allowing this restriction to either
760 be lifted or removed. */
761 #ifndef MAX_REMOTE_PACKET_SIZE
762 #define MAX_REMOTE_PACKET_SIZE 16384
764 /* NOTE: 20 ensures we can write at least one byte. */
765 #ifndef MIN_REMOTE_PACKET_SIZE
766 #define MIN_REMOTE_PACKET_SIZE 20
771 if (config
->size
<= 0)
772 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
774 what_they_get
= config
->size
;
778 what_they_get
= get_remote_packet_size ();
779 /* Limit the packet to the size specified by the user. */
781 && what_they_get
> config
->size
)
782 what_they_get
= config
->size
;
784 /* Limit it to the size of the targets ``g'' response unless we have
785 permission from the stub to use a larger packet size. */
786 if (rs
->explicit_packet_size
== 0
787 && rsa
->actual_register_packet_size
> 0
788 && what_they_get
> rsa
->actual_register_packet_size
)
789 what_they_get
= rsa
->actual_register_packet_size
;
791 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
792 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
793 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
794 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
796 /* Make sure there is room in the global buffer for this packet
797 (including its trailing NUL byte). */
798 if (rs
->buf_size
< what_they_get
+ 1)
800 rs
->buf_size
= 2 * what_they_get
;
801 rs
->buf
= xrealloc (rs
->buf
, 2 * what_they_get
);
804 return what_they_get
;
807 /* Update the size of a read/write packet. If they user wants
808 something really big then do a sanity check. */
811 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
813 int fixed_p
= config
->fixed_p
;
814 long size
= config
->size
;
816 error (_("Argument required (integer, `fixed' or `limited')."));
817 else if (strcmp (args
, "hard") == 0
818 || strcmp (args
, "fixed") == 0)
820 else if (strcmp (args
, "soft") == 0
821 || strcmp (args
, "limit") == 0)
826 size
= strtoul (args
, &end
, 0);
828 error (_("Invalid %s (bad syntax)."), config
->name
);
830 /* Instead of explicitly capping the size of a packet to
831 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
832 instead allowed to set the size to something arbitrarily
834 if (size
> MAX_REMOTE_PACKET_SIZE
)
835 error (_("Invalid %s (too large)."), config
->name
);
839 if (fixed_p
&& !config
->fixed_p
)
841 if (! query (_("The target may not be able to correctly handle a %s\n"
842 "of %ld bytes. Change the packet size? "),
844 error (_("Packet size not changed."));
846 /* Update the config. */
847 config
->fixed_p
= fixed_p
;
852 show_memory_packet_size (struct memory_packet_config
*config
)
854 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
856 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
857 get_memory_packet_size (config
));
859 printf_filtered (_("Packets are limited to %ld bytes.\n"),
860 get_memory_packet_size (config
));
863 static struct memory_packet_config memory_write_packet_config
=
865 "memory-write-packet-size",
869 set_memory_write_packet_size (char *args
, int from_tty
)
871 set_memory_packet_size (args
, &memory_write_packet_config
);
875 show_memory_write_packet_size (char *args
, int from_tty
)
877 show_memory_packet_size (&memory_write_packet_config
);
881 get_memory_write_packet_size (void)
883 return get_memory_packet_size (&memory_write_packet_config
);
886 static struct memory_packet_config memory_read_packet_config
=
888 "memory-read-packet-size",
892 set_memory_read_packet_size (char *args
, int from_tty
)
894 set_memory_packet_size (args
, &memory_read_packet_config
);
898 show_memory_read_packet_size (char *args
, int from_tty
)
900 show_memory_packet_size (&memory_read_packet_config
);
904 get_memory_read_packet_size (void)
906 long size
= get_memory_packet_size (&memory_read_packet_config
);
907 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
908 extra buffer size argument before the memory read size can be
909 increased beyond this. */
910 if (size
> get_remote_packet_size ())
911 size
= get_remote_packet_size ();
916 /* Generic configuration support for packets the stub optionally
917 supports. Allows the user to specify the use of the packet as well
918 as allowing GDB to auto-detect support in the remote stub. */
922 PACKET_SUPPORT_UNKNOWN
= 0,
931 enum auto_boolean detect
;
932 enum packet_support support
;
935 /* Analyze a packet's return value and update the packet config
946 update_packet_config (struct packet_config
*config
)
948 switch (config
->detect
)
950 case AUTO_BOOLEAN_TRUE
:
951 config
->support
= PACKET_ENABLE
;
953 case AUTO_BOOLEAN_FALSE
:
954 config
->support
= PACKET_DISABLE
;
956 case AUTO_BOOLEAN_AUTO
:
957 config
->support
= PACKET_SUPPORT_UNKNOWN
;
963 show_packet_config_cmd (struct packet_config
*config
)
965 char *support
= "internal-error";
966 switch (config
->support
)
972 support
= "disabled";
974 case PACKET_SUPPORT_UNKNOWN
:
978 switch (config
->detect
)
980 case AUTO_BOOLEAN_AUTO
:
981 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
982 config
->name
, support
);
984 case AUTO_BOOLEAN_TRUE
:
985 case AUTO_BOOLEAN_FALSE
:
986 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
987 config
->name
, support
);
993 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
994 const char *title
, int legacy
)
1000 config
->name
= name
;
1001 config
->title
= title
;
1002 config
->detect
= AUTO_BOOLEAN_AUTO
;
1003 config
->support
= PACKET_SUPPORT_UNKNOWN
;
1004 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
1006 show_doc
= xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
1008 /* set/show TITLE-packet {auto,on,off} */
1009 cmd_name
= xstrprintf ("%s-packet", title
);
1010 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1011 &config
->detect
, set_doc
, show_doc
, NULL
, /* help_doc */
1012 set_remote_protocol_packet_cmd
,
1013 show_remote_protocol_packet_cmd
,
1014 &remote_set_cmdlist
, &remote_show_cmdlist
);
1015 /* The command code copies the documentation strings. */
1018 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1022 legacy_name
= xstrprintf ("%s-packet", name
);
1023 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1024 &remote_set_cmdlist
);
1025 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1026 &remote_show_cmdlist
);
1030 static enum packet_result
1031 packet_check_result (const char *buf
)
1035 /* The stub recognized the packet request. Check that the
1036 operation succeeded. */
1038 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1040 /* "Enn" - definitly an error. */
1041 return PACKET_ERROR
;
1043 /* Always treat "E." as an error. This will be used for
1044 more verbose error messages, such as E.memtypes. */
1045 if (buf
[0] == 'E' && buf
[1] == '.')
1046 return PACKET_ERROR
;
1048 /* The packet may or may not be OK. Just assume it is. */
1052 /* The stub does not support the packet. */
1053 return PACKET_UNKNOWN
;
1056 static enum packet_result
1057 packet_ok (const char *buf
, struct packet_config
*config
)
1059 enum packet_result result
;
1061 result
= packet_check_result (buf
);
1066 /* The stub recognized the packet request. */
1067 switch (config
->support
)
1069 case PACKET_SUPPORT_UNKNOWN
:
1071 fprintf_unfiltered (gdb_stdlog
,
1072 "Packet %s (%s) is supported\n",
1073 config
->name
, config
->title
);
1074 config
->support
= PACKET_ENABLE
;
1076 case PACKET_DISABLE
:
1077 internal_error (__FILE__
, __LINE__
,
1078 _("packet_ok: attempt to use a disabled packet"));
1084 case PACKET_UNKNOWN
:
1085 /* The stub does not support the packet. */
1086 switch (config
->support
)
1089 if (config
->detect
== AUTO_BOOLEAN_AUTO
)
1090 /* If the stub previously indicated that the packet was
1091 supported then there is a protocol error.. */
1092 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1093 config
->name
, config
->title
);
1095 /* The user set it wrong. */
1096 error (_("Enabled packet %s (%s) not recognized by stub"),
1097 config
->name
, config
->title
);
1099 case PACKET_SUPPORT_UNKNOWN
:
1101 fprintf_unfiltered (gdb_stdlog
,
1102 "Packet %s (%s) is NOT supported\n",
1103 config
->name
, config
->title
);
1104 config
->support
= PACKET_DISABLE
;
1106 case PACKET_DISABLE
:
1128 PACKET_vFile_pwrite
,
1130 PACKET_vFile_unlink
,
1132 PACKET_qXfer_features
,
1133 PACKET_qXfer_libraries
,
1134 PACKET_qXfer_memory_map
,
1135 PACKET_qXfer_spu_read
,
1136 PACKET_qXfer_spu_write
,
1137 PACKET_qXfer_osdata
,
1138 PACKET_qXfer_threads
,
1142 PACKET_QPassSignals
,
1143 PACKET_qSearch_memory
,
1146 PACKET_QStartNoAckMode
,
1148 PACKET_qXfer_siginfo_read
,
1149 PACKET_qXfer_siginfo_write
,
1151 PACKET_ConditionalTracepoints
,
1152 PACKET_FastTracepoints
,
1155 PACKET_TracepointSource
,
1159 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
1162 set_remote_protocol_packet_cmd (char *args
, int from_tty
,
1163 struct cmd_list_element
*c
)
1165 struct packet_config
*packet
;
1167 for (packet
= remote_protocol_packets
;
1168 packet
< &remote_protocol_packets
[PACKET_MAX
];
1171 if (&packet
->detect
== c
->var
)
1173 update_packet_config (packet
);
1177 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
1182 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
1183 struct cmd_list_element
*c
,
1186 struct packet_config
*packet
;
1188 for (packet
= remote_protocol_packets
;
1189 packet
< &remote_protocol_packets
[PACKET_MAX
];
1192 if (&packet
->detect
== c
->var
)
1194 show_packet_config_cmd (packet
);
1198 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
1202 /* Should we try one of the 'Z' requests? */
1206 Z_PACKET_SOFTWARE_BP
,
1207 Z_PACKET_HARDWARE_BP
,
1214 /* For compatibility with older distributions. Provide a ``set remote
1215 Z-packet ...'' command that updates all the Z packet types. */
1217 static enum auto_boolean remote_Z_packet_detect
;
1220 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
1221 struct cmd_list_element
*c
)
1224 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1226 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
1227 update_packet_config (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1232 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
1233 struct cmd_list_element
*c
,
1237 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1239 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1243 /* Should we try the 'ThreadInfo' query packet?
1245 This variable (NOT available to the user: auto-detect only!)
1246 determines whether GDB will use the new, simpler "ThreadInfo"
1247 query or the older, more complex syntax for thread queries.
1248 This is an auto-detect variable (set to true at each connect,
1249 and set to false when the target fails to recognize it). */
1251 static int use_threadinfo_query
;
1252 static int use_threadextra_query
;
1254 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1255 static struct async_signal_handler
*sigint_remote_twice_token
;
1256 static struct async_signal_handler
*sigint_remote_token
;
1259 /* Asynchronous signal handle registered as event loop source for
1260 when we have pending events ready to be passed to the core. */
1262 static struct async_event_handler
*remote_async_inferior_event_token
;
1264 /* Asynchronous signal handle registered as event loop source for when
1265 the remote sent us a %Stop notification. The registered callback
1266 will do a vStopped sequence to pull the rest of the events out of
1267 the remote side into our event queue. */
1269 static struct async_event_handler
*remote_async_get_pending_events_token
;
1272 static ptid_t magic_null_ptid
;
1273 static ptid_t not_sent_ptid
;
1274 static ptid_t any_thread_ptid
;
1276 /* These are the threads which we last sent to the remote system. The
1277 TID member will be -1 for all or -2 for not sent yet. */
1279 static ptid_t general_thread
;
1280 static ptid_t continue_thread
;
1282 /* Find out if the stub attached to PID (and hence GDB should offer to
1283 detach instead of killing it when bailing out). */
1286 remote_query_attached (int pid
)
1288 struct remote_state
*rs
= get_remote_state ();
1290 if (remote_protocol_packets
[PACKET_qAttached
].support
== PACKET_DISABLE
)
1293 if (remote_multi_process_p (rs
))
1294 sprintf (rs
->buf
, "qAttached:%x", pid
);
1296 sprintf (rs
->buf
, "qAttached");
1299 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1301 switch (packet_ok (rs
->buf
,
1302 &remote_protocol_packets
[PACKET_qAttached
]))
1305 if (strcmp (rs
->buf
, "1") == 0)
1309 warning (_("Remote failure reply: %s"), rs
->buf
);
1311 case PACKET_UNKNOWN
:
1318 /* Add PID to GDB's inferior table. Since we can be connected to a
1319 remote system before before knowing about any inferior, mark the
1320 target with execution when we find the first inferior. If ATTACHED
1321 is 1, then we had just attached to this inferior. If it is 0, then
1322 we just created this inferior. If it is -1, then try querying the
1323 remote stub to find out if it had attached to the inferior or
1326 static struct inferior
*
1327 remote_add_inferior (int pid
, int attached
)
1329 struct inferior
*inf
;
1331 /* Check whether this process we're learning about is to be
1332 considered attached, or if is to be considered to have been
1333 spawned by the stub. */
1335 attached
= remote_query_attached (pid
);
1337 if (gdbarch_has_global_solist (target_gdbarch
))
1339 /* If the target shares code across all inferiors, then every
1340 attach adds a new inferior. */
1341 inf
= add_inferior (pid
);
1343 /* ... and every inferior is bound to the same program space.
1344 However, each inferior may still have its own address
1346 inf
->aspace
= maybe_new_address_space ();
1347 inf
->pspace
= current_program_space
;
1351 /* In the traditional debugging scenario, there's a 1-1 match
1352 between program/address spaces. We simply bind the inferior
1353 to the program space's address space. */
1354 inf
= current_inferior ();
1355 inferior_appeared (inf
, pid
);
1358 inf
->attach_flag
= attached
;
1363 /* Add thread PTID to GDB's thread list. Tag it as executing/running
1364 according to RUNNING. */
1367 remote_add_thread (ptid_t ptid
, int running
)
1371 set_executing (ptid
, running
);
1372 set_running (ptid
, running
);
1375 /* Come here when we learn about a thread id from the remote target.
1376 It may be the first time we hear about such thread, so take the
1377 opportunity to add it to GDB's thread list. In case this is the
1378 first time we're noticing its corresponding inferior, add it to
1379 GDB's inferior list as well. */
1382 remote_notice_new_inferior (ptid_t currthread
, int running
)
1384 /* If this is a new thread, add it to GDB's thread list.
1385 If we leave it up to WFI to do this, bad things will happen. */
1387 if (in_thread_list (currthread
) && is_exited (currthread
))
1389 /* We're seeing an event on a thread id we knew had exited.
1390 This has to be a new thread reusing the old id. Add it. */
1391 remote_add_thread (currthread
, running
);
1395 if (!in_thread_list (currthread
))
1397 struct inferior
*inf
= NULL
;
1398 int pid
= ptid_get_pid (currthread
);
1400 if (ptid_is_pid (inferior_ptid
)
1401 && pid
== ptid_get_pid (inferior_ptid
))
1403 /* inferior_ptid has no thread member yet. This can happen
1404 with the vAttach -> remote_wait,"TAAthread:" path if the
1405 stub doesn't support qC. This is the first stop reported
1406 after an attach, so this is the main thread. Update the
1407 ptid in the thread list. */
1408 if (in_thread_list (pid_to_ptid (pid
)))
1409 thread_change_ptid (inferior_ptid
, currthread
);
1412 remote_add_thread (currthread
, running
);
1413 inferior_ptid
= currthread
;
1418 if (ptid_equal (magic_null_ptid
, inferior_ptid
))
1420 /* inferior_ptid is not set yet. This can happen with the
1421 vRun -> remote_wait,"TAAthread:" path if the stub
1422 doesn't support qC. This is the first stop reported
1423 after an attach, so this is the main thread. Update the
1424 ptid in the thread list. */
1425 thread_change_ptid (inferior_ptid
, currthread
);
1429 /* When connecting to a target remote, or to a target
1430 extended-remote which already was debugging an inferior, we
1431 may not know about it yet. Add it before adding its child
1432 thread, so notifications are emitted in a sensible order. */
1433 if (!in_inferior_list (ptid_get_pid (currthread
)))
1434 inf
= remote_add_inferior (ptid_get_pid (currthread
), -1);
1436 /* This is really a new thread. Add it. */
1437 remote_add_thread (currthread
, running
);
1439 /* If we found a new inferior, let the common code do whatever
1440 it needs to with it (e.g., read shared libraries, insert
1443 notice_new_inferior (currthread
, running
, 0);
1447 /* Return the private thread data, creating it if necessary. */
1449 struct private_thread_info
*
1450 demand_private_info (ptid_t ptid
)
1452 struct thread_info
*info
= find_thread_ptid (ptid
);
1458 info
->private = xmalloc (sizeof (*(info
->private)));
1459 info
->private_dtor
= free_private_thread_info
;
1460 info
->private->core
= -1;
1461 info
->private->extra
= 0;
1464 return info
->private;
1467 /* Call this function as a result of
1468 1) A halt indication (T packet) containing a thread id
1469 2) A direct query of currthread
1470 3) Successful execution of set thread
1474 record_currthread (ptid_t currthread
)
1476 general_thread
= currthread
;
1479 static char *last_pass_packet
;
1481 /* If 'QPassSignals' is supported, tell the remote stub what signals
1482 it can simply pass through to the inferior without reporting. */
1485 remote_pass_signals (void)
1487 if (remote_protocol_packets
[PACKET_QPassSignals
].support
!= PACKET_DISABLE
)
1489 char *pass_packet
, *p
;
1490 int numsigs
= (int) TARGET_SIGNAL_LAST
;
1493 gdb_assert (numsigs
< 256);
1494 for (i
= 0; i
< numsigs
; i
++)
1496 if (signal_stop_state (i
) == 0
1497 && signal_print_state (i
) == 0
1498 && signal_pass_state (i
) == 1)
1501 pass_packet
= xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
1502 strcpy (pass_packet
, "QPassSignals:");
1503 p
= pass_packet
+ strlen (pass_packet
);
1504 for (i
= 0; i
< numsigs
; i
++)
1506 if (signal_stop_state (i
) == 0
1507 && signal_print_state (i
) == 0
1508 && signal_pass_state (i
) == 1)
1511 *p
++ = tohex (i
>> 4);
1512 *p
++ = tohex (i
& 15);
1521 if (!last_pass_packet
|| strcmp (last_pass_packet
, pass_packet
))
1523 struct remote_state
*rs
= get_remote_state ();
1524 char *buf
= rs
->buf
;
1526 putpkt (pass_packet
);
1527 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1528 packet_ok (buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
1529 if (last_pass_packet
)
1530 xfree (last_pass_packet
);
1531 last_pass_packet
= pass_packet
;
1534 xfree (pass_packet
);
1539 remote_notice_signals (ptid_t ptid
)
1541 /* Update the remote on signals to silently pass, if they've
1543 remote_pass_signals ();
1546 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
1547 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
1548 thread. If GEN is set, set the general thread, if not, then set
1549 the step/continue thread. */
1551 set_thread (struct ptid ptid
, int gen
)
1553 struct remote_state
*rs
= get_remote_state ();
1554 ptid_t state
= gen
? general_thread
: continue_thread
;
1555 char *buf
= rs
->buf
;
1556 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
1558 if (ptid_equal (state
, ptid
))
1562 *buf
++ = gen
? 'g' : 'c';
1563 if (ptid_equal (ptid
, magic_null_ptid
))
1564 xsnprintf (buf
, endbuf
- buf
, "0");
1565 else if (ptid_equal (ptid
, any_thread_ptid
))
1566 xsnprintf (buf
, endbuf
- buf
, "0");
1567 else if (ptid_equal (ptid
, minus_one_ptid
))
1568 xsnprintf (buf
, endbuf
- buf
, "-1");
1570 write_ptid (buf
, endbuf
, ptid
);
1572 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1574 general_thread
= ptid
;
1576 continue_thread
= ptid
;
1580 set_general_thread (struct ptid ptid
)
1582 set_thread (ptid
, 1);
1586 set_continue_thread (struct ptid ptid
)
1588 set_thread (ptid
, 0);
1591 /* Change the remote current process. Which thread within the process
1592 ends up selected isn't important, as long as it is the same process
1593 as what INFERIOR_PTID points to.
1595 This comes from that fact that there is no explicit notion of
1596 "selected process" in the protocol. The selected process for
1597 general operations is the process the selected general thread
1601 set_general_process (void)
1603 struct remote_state
*rs
= get_remote_state ();
1605 /* If the remote can't handle multiple processes, don't bother. */
1606 if (!remote_multi_process_p (rs
))
1609 /* We only need to change the remote current thread if it's pointing
1610 at some other process. */
1611 if (ptid_get_pid (general_thread
) != ptid_get_pid (inferior_ptid
))
1612 set_general_thread (inferior_ptid
);
1616 /* Return nonzero if the thread PTID is still alive on the remote
1620 remote_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1622 struct remote_state
*rs
= get_remote_state ();
1625 if (ptid_equal (ptid
, magic_null_ptid
))
1626 /* The main thread is always alive. */
1629 if (ptid_get_pid (ptid
) != 0 && ptid_get_tid (ptid
) == 0)
1630 /* The main thread is always alive. This can happen after a
1631 vAttach, if the remote side doesn't support
1636 endp
= rs
->buf
+ get_remote_packet_size ();
1639 write_ptid (p
, endp
, ptid
);
1642 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1643 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
1646 /* About these extended threadlist and threadinfo packets. They are
1647 variable length packets but, the fields within them are often fixed
1648 length. They are redundent enough to send over UDP as is the
1649 remote protocol in general. There is a matching unit test module
1652 #define OPAQUETHREADBYTES 8
1654 /* a 64 bit opaque identifier */
1655 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
1657 /* WARNING: This threadref data structure comes from the remote O.S.,
1658 libstub protocol encoding, and remote.c. it is not particularly
1661 /* Right now, the internal structure is int. We want it to be bigger.
1665 typedef int gdb_threadref
; /* Internal GDB thread reference. */
1667 /* gdb_ext_thread_info is an internal GDB data structure which is
1668 equivalent to the reply of the remote threadinfo packet. */
1670 struct gdb_ext_thread_info
1672 threadref threadid
; /* External form of thread reference. */
1673 int active
; /* Has state interesting to GDB?
1675 char display
[256]; /* Brief state display, name,
1676 blocked/suspended. */
1677 char shortname
[32]; /* To be used to name threads. */
1678 char more_display
[256]; /* Long info, statistics, queue depth,
1682 /* The volume of remote transfers can be limited by submitting
1683 a mask containing bits specifying the desired information.
1684 Use a union of these values as the 'selection' parameter to
1685 get_thread_info. FIXME: Make these TAG names more thread specific.
1688 #define TAG_THREADID 1
1689 #define TAG_EXISTS 2
1690 #define TAG_DISPLAY 4
1691 #define TAG_THREADNAME 8
1692 #define TAG_MOREDISPLAY 16
1694 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1696 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1698 static char *unpack_nibble (char *buf
, int *val
);
1700 static char *pack_nibble (char *buf
, int nibble
);
1702 static char *pack_hex_byte (char *pkt
, int /* unsigned char */ byte
);
1704 static char *unpack_byte (char *buf
, int *value
);
1706 static char *pack_int (char *buf
, int value
);
1708 static char *unpack_int (char *buf
, int *value
);
1710 static char *unpack_string (char *src
, char *dest
, int length
);
1712 static char *pack_threadid (char *pkt
, threadref
*id
);
1714 static char *unpack_threadid (char *inbuf
, threadref
*id
);
1716 void int_to_threadref (threadref
*id
, int value
);
1718 static int threadref_to_int (threadref
*ref
);
1720 static void copy_threadref (threadref
*dest
, threadref
*src
);
1722 static int threadmatch (threadref
*dest
, threadref
*src
);
1724 static char *pack_threadinfo_request (char *pkt
, int mode
,
1727 static int remote_unpack_thread_info_response (char *pkt
,
1728 threadref
*expectedref
,
1729 struct gdb_ext_thread_info
1733 static int remote_get_threadinfo (threadref
*threadid
,
1734 int fieldset
, /*TAG mask */
1735 struct gdb_ext_thread_info
*info
);
1737 static char *pack_threadlist_request (char *pkt
, int startflag
,
1739 threadref
*nextthread
);
1741 static int parse_threadlist_response (char *pkt
,
1743 threadref
*original_echo
,
1744 threadref
*resultlist
,
1747 static int remote_get_threadlist (int startflag
,
1748 threadref
*nextthread
,
1752 threadref
*threadlist
);
1754 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
1756 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
1757 void *context
, int looplimit
);
1759 static int remote_newthread_step (threadref
*ref
, void *context
);
1762 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
1763 buffer we're allowed to write to. Returns
1764 BUF+CHARACTERS_WRITTEN. */
1767 write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
1770 struct remote_state
*rs
= get_remote_state ();
1772 if (remote_multi_process_p (rs
))
1774 pid
= ptid_get_pid (ptid
);
1776 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
1778 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
1780 tid
= ptid_get_tid (ptid
);
1782 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
1784 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
1789 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
1790 passed the last parsed char. Returns null_ptid on error. */
1793 read_ptid (char *buf
, char **obuf
)
1797 ULONGEST pid
= 0, tid
= 0;
1801 /* Multi-process ptid. */
1802 pp
= unpack_varlen_hex (p
+ 1, &pid
);
1804 error (_("invalid remote ptid: %s\n"), p
);
1807 pp
= unpack_varlen_hex (p
+ 1, &tid
);
1810 return ptid_build (pid
, 0, tid
);
1813 /* No multi-process. Just a tid. */
1814 pp
= unpack_varlen_hex (p
, &tid
);
1816 /* Since the stub is not sending a process id, then default to
1817 what's in inferior_ptid, unless it's null at this point. If so,
1818 then since there's no way to know the pid of the reported
1819 threads, use the magic number. */
1820 if (ptid_equal (inferior_ptid
, null_ptid
))
1821 pid
= ptid_get_pid (magic_null_ptid
);
1823 pid
= ptid_get_pid (inferior_ptid
);
1827 return ptid_build (pid
, 0, tid
);
1830 /* Encode 64 bits in 16 chars of hex. */
1832 static const char hexchars
[] = "0123456789abcdef";
1835 ishex (int ch
, int *val
)
1837 if ((ch
>= 'a') && (ch
<= 'f'))
1839 *val
= ch
- 'a' + 10;
1842 if ((ch
>= 'A') && (ch
<= 'F'))
1844 *val
= ch
- 'A' + 10;
1847 if ((ch
>= '0') && (ch
<= '9'))
1858 if (ch
>= 'a' && ch
<= 'f')
1859 return ch
- 'a' + 10;
1860 if (ch
>= '0' && ch
<= '9')
1862 if (ch
>= 'A' && ch
<= 'F')
1863 return ch
- 'A' + 10;
1868 stub_unpack_int (char *buff
, int fieldlength
)
1875 nibble
= stubhex (*buff
++);
1879 retval
= retval
<< 4;
1885 unpack_varlen_hex (char *buff
, /* packet to parse */
1889 ULONGEST retval
= 0;
1891 while (ishex (*buff
, &nibble
))
1894 retval
= retval
<< 4;
1895 retval
|= nibble
& 0x0f;
1902 unpack_nibble (char *buf
, int *val
)
1904 *val
= fromhex (*buf
++);
1909 pack_nibble (char *buf
, int nibble
)
1911 *buf
++ = hexchars
[(nibble
& 0x0f)];
1916 pack_hex_byte (char *pkt
, int byte
)
1918 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
1919 *pkt
++ = hexchars
[(byte
& 0xf)];
1924 unpack_byte (char *buf
, int *value
)
1926 *value
= stub_unpack_int (buf
, 2);
1931 pack_int (char *buf
, int value
)
1933 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
1934 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
1935 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
1936 buf
= pack_hex_byte (buf
, (value
& 0xff));
1941 unpack_int (char *buf
, int *value
)
1943 *value
= stub_unpack_int (buf
, 8);
1947 #if 0 /* Currently unused, uncomment when needed. */
1948 static char *pack_string (char *pkt
, char *string
);
1951 pack_string (char *pkt
, char *string
)
1956 len
= strlen (string
);
1958 len
= 200; /* Bigger than most GDB packets, junk??? */
1959 pkt
= pack_hex_byte (pkt
, len
);
1963 if ((ch
== '\0') || (ch
== '#'))
1964 ch
= '*'; /* Protect encapsulation. */
1969 #endif /* 0 (unused) */
1972 unpack_string (char *src
, char *dest
, int length
)
1981 pack_threadid (char *pkt
, threadref
*id
)
1984 unsigned char *altid
;
1986 altid
= (unsigned char *) id
;
1987 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
1989 pkt
= pack_hex_byte (pkt
, *altid
++);
1995 unpack_threadid (char *inbuf
, threadref
*id
)
1998 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
2001 altref
= (char *) id
;
2003 while (inbuf
< limit
)
2005 x
= stubhex (*inbuf
++);
2006 y
= stubhex (*inbuf
++);
2007 *altref
++ = (x
<< 4) | y
;
2012 /* Externally, threadrefs are 64 bits but internally, they are still
2013 ints. This is due to a mismatch of specifications. We would like
2014 to use 64bit thread references internally. This is an adapter
2018 int_to_threadref (threadref
*id
, int value
)
2020 unsigned char *scan
;
2022 scan
= (unsigned char *) id
;
2028 *scan
++ = (value
>> 24) & 0xff;
2029 *scan
++ = (value
>> 16) & 0xff;
2030 *scan
++ = (value
>> 8) & 0xff;
2031 *scan
++ = (value
& 0xff);
2035 threadref_to_int (threadref
*ref
)
2038 unsigned char *scan
;
2044 value
= (value
<< 8) | ((*scan
++) & 0xff);
2049 copy_threadref (threadref
*dest
, threadref
*src
)
2052 unsigned char *csrc
, *cdest
;
2054 csrc
= (unsigned char *) src
;
2055 cdest
= (unsigned char *) dest
;
2062 threadmatch (threadref
*dest
, threadref
*src
)
2064 /* Things are broken right now, so just assume we got a match. */
2066 unsigned char *srcp
, *destp
;
2068 srcp
= (char *) src
;
2069 destp
= (char *) dest
;
2073 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
2080 threadid:1, # always request threadid
2087 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
2090 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
2092 *pkt
++ = 'q'; /* Info Query */
2093 *pkt
++ = 'P'; /* process or thread info */
2094 pkt
= pack_int (pkt
, mode
); /* mode */
2095 pkt
= pack_threadid (pkt
, id
); /* threadid */
2096 *pkt
= '\0'; /* terminate */
2100 /* These values tag the fields in a thread info response packet. */
2101 /* Tagging the fields allows us to request specific fields and to
2102 add more fields as time goes by. */
2104 #define TAG_THREADID 1 /* Echo the thread identifier. */
2105 #define TAG_EXISTS 2 /* Is this process defined enough to
2106 fetch registers and its stack? */
2107 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
2108 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
2109 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
2113 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
2114 struct gdb_ext_thread_info
*info
)
2116 struct remote_state
*rs
= get_remote_state ();
2120 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
2123 /* info->threadid = 0; FIXME: implement zero_threadref. */
2125 info
->display
[0] = '\0';
2126 info
->shortname
[0] = '\0';
2127 info
->more_display
[0] = '\0';
2129 /* Assume the characters indicating the packet type have been
2131 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
2132 pkt
= unpack_threadid (pkt
, &ref
);
2135 warning (_("Incomplete response to threadinfo request."));
2136 if (!threadmatch (&ref
, expectedref
))
2137 { /* This is an answer to a different request. */
2138 warning (_("ERROR RMT Thread info mismatch."));
2141 copy_threadref (&info
->threadid
, &ref
);
2143 /* Loop on tagged fields , try to bail if somthing goes wrong. */
2145 /* Packets are terminated with nulls. */
2146 while ((pkt
< limit
) && mask
&& *pkt
)
2148 pkt
= unpack_int (pkt
, &tag
); /* tag */
2149 pkt
= unpack_byte (pkt
, &length
); /* length */
2150 if (!(tag
& mask
)) /* Tags out of synch with mask. */
2152 warning (_("ERROR RMT: threadinfo tag mismatch."));
2156 if (tag
== TAG_THREADID
)
2160 warning (_("ERROR RMT: length of threadid is not 16."));
2164 pkt
= unpack_threadid (pkt
, &ref
);
2165 mask
= mask
& ~TAG_THREADID
;
2168 if (tag
== TAG_EXISTS
)
2170 info
->active
= stub_unpack_int (pkt
, length
);
2172 mask
= mask
& ~(TAG_EXISTS
);
2175 warning (_("ERROR RMT: 'exists' length too long."));
2181 if (tag
== TAG_THREADNAME
)
2183 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
2184 mask
= mask
& ~TAG_THREADNAME
;
2187 if (tag
== TAG_DISPLAY
)
2189 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
2190 mask
= mask
& ~TAG_DISPLAY
;
2193 if (tag
== TAG_MOREDISPLAY
)
2195 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
2196 mask
= mask
& ~TAG_MOREDISPLAY
;
2199 warning (_("ERROR RMT: unknown thread info tag."));
2200 break; /* Not a tag we know about. */
2206 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
2207 struct gdb_ext_thread_info
*info
)
2209 struct remote_state
*rs
= get_remote_state ();
2212 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
2214 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2216 if (rs
->buf
[0] == '\0')
2219 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
2224 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
2227 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
2228 threadref
*nextthread
)
2230 *pkt
++ = 'q'; /* info query packet */
2231 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
2232 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
2233 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
2234 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
2239 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
2242 parse_threadlist_response (char *pkt
, int result_limit
,
2243 threadref
*original_echo
, threadref
*resultlist
,
2246 struct remote_state
*rs
= get_remote_state ();
2248 int count
, resultcount
, done
;
2251 /* Assume the 'q' and 'M chars have been stripped. */
2252 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
2253 /* done parse past here */
2254 pkt
= unpack_byte (pkt
, &count
); /* count field */
2255 pkt
= unpack_nibble (pkt
, &done
);
2256 /* The first threadid is the argument threadid. */
2257 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
2258 while ((count
-- > 0) && (pkt
< limit
))
2260 pkt
= unpack_threadid (pkt
, resultlist
++);
2261 if (resultcount
++ >= result_limit
)
2270 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
2271 int *done
, int *result_count
, threadref
*threadlist
)
2273 struct remote_state
*rs
= get_remote_state ();
2274 static threadref echo_nextthread
;
2277 /* Trancate result limit to be smaller than the packet size. */
2278 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10) >= get_remote_packet_size ())
2279 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
2281 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
2283 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2285 if (*rs
->buf
== '\0')
2289 parse_threadlist_response (rs
->buf
+ 2, result_limit
, &echo_nextthread
,
2292 if (!threadmatch (&echo_nextthread
, nextthread
))
2294 /* FIXME: This is a good reason to drop the packet. */
2295 /* Possably, there is a duplicate response. */
2297 retransmit immediatly - race conditions
2298 retransmit after timeout - yes
2300 wait for packet, then exit
2302 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
2303 return 0; /* I choose simply exiting. */
2305 if (*result_count
<= 0)
2309 warning (_("RMT ERROR : failed to get remote thread list."));
2312 return result
; /* break; */
2314 if (*result_count
> result_limit
)
2317 warning (_("RMT ERROR: threadlist response longer than requested."));
2323 /* This is the interface between remote and threads, remotes upper
2326 /* remote_find_new_threads retrieves the thread list and for each
2327 thread in the list, looks up the thread in GDB's internal list,
2328 adding the thread if it does not already exist. This involves
2329 getting partial thread lists from the remote target so, polling the
2330 quit_flag is required. */
2333 /* About this many threadisds fit in a packet. */
2335 #define MAXTHREADLISTRESULTS 32
2338 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
2341 int done
, i
, result_count
;
2345 static threadref nextthread
;
2346 static threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
2351 if (loopcount
++ > looplimit
)
2354 warning (_("Remote fetch threadlist -infinite loop-."));
2357 if (!remote_get_threadlist (startflag
, &nextthread
, MAXTHREADLISTRESULTS
,
2358 &done
, &result_count
, resultthreadlist
))
2363 /* Clear for later iterations. */
2365 /* Setup to resume next batch of thread references, set nextthread. */
2366 if (result_count
>= 1)
2367 copy_threadref (&nextthread
, &resultthreadlist
[result_count
- 1]);
2369 while (result_count
--)
2370 if (!(result
= (*stepfunction
) (&resultthreadlist
[i
++], context
)))
2377 remote_newthread_step (threadref
*ref
, void *context
)
2379 int pid
= ptid_get_pid (inferior_ptid
);
2380 ptid_t ptid
= ptid_build (pid
, 0, threadref_to_int (ref
));
2382 if (!in_thread_list (ptid
))
2384 return 1; /* continue iterator */
2387 #define CRAZY_MAX_THREADS 1000
2390 remote_current_thread (ptid_t oldpid
)
2392 struct remote_state
*rs
= get_remote_state ();
2395 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2396 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
2397 return read_ptid (&rs
->buf
[2], NULL
);
2402 /* Find new threads for info threads command.
2403 * Original version, using John Metzler's thread protocol.
2407 remote_find_new_threads (void)
2409 remote_threadlist_iterator (remote_newthread_step
, 0,
2413 #if defined(HAVE_LIBEXPAT)
2415 typedef struct thread_item
2421 DEF_VEC_O(thread_item_t
);
2423 struct threads_parsing_context
2425 VEC (thread_item_t
) *items
;
2429 start_thread (struct gdb_xml_parser
*parser
,
2430 const struct gdb_xml_element
*element
,
2431 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
2433 struct threads_parsing_context
*data
= user_data
;
2435 struct thread_item item
;
2438 id
= VEC_index (gdb_xml_value_s
, attributes
, 0)->value
;
2439 item
.ptid
= read_ptid (id
, NULL
);
2441 if (VEC_length (gdb_xml_value_s
, attributes
) > 1)
2442 item
.core
= *(ULONGEST
*) VEC_index (gdb_xml_value_s
, attributes
, 1)->value
;
2448 VEC_safe_push (thread_item_t
, data
->items
, &item
);
2452 end_thread (struct gdb_xml_parser
*parser
,
2453 const struct gdb_xml_element
*element
,
2454 void *user_data
, const char *body_text
)
2456 struct threads_parsing_context
*data
= user_data
;
2458 if (body_text
&& *body_text
)
2459 VEC_last (thread_item_t
, data
->items
)->extra
= xstrdup (body_text
);
2462 const struct gdb_xml_attribute thread_attributes
[] = {
2463 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
2464 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
2465 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2468 const struct gdb_xml_element thread_children
[] = {
2469 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2472 const struct gdb_xml_element threads_children
[] = {
2473 { "thread", thread_attributes
, thread_children
,
2474 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
2475 start_thread
, end_thread
},
2476 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2479 const struct gdb_xml_element threads_elements
[] = {
2480 { "threads", NULL
, threads_children
,
2481 GDB_XML_EF_NONE
, NULL
, NULL
},
2482 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2485 /* Discard the contents of the constructed thread info context. */
2488 clear_threads_parsing_context (void *p
)
2490 struct threads_parsing_context
*context
= p
;
2492 struct thread_item
*item
;
2494 for (i
= 0; VEC_iterate (thread_item_t
, context
->items
, i
, item
); ++i
)
2495 xfree (item
->extra
);
2497 VEC_free (thread_item_t
, context
->items
);
2503 * Find all threads for info threads command.
2504 * Uses new thread protocol contributed by Cisco.
2505 * Falls back and attempts to use the older method (above)
2506 * if the target doesn't respond to the new method.
2510 remote_threads_info (struct target_ops
*ops
)
2512 struct remote_state
*rs
= get_remote_state ();
2516 if (remote_desc
== 0) /* paranoia */
2517 error (_("Command can only be used when connected to the remote target."));
2519 #if defined(HAVE_LIBEXPAT)
2520 if (remote_protocol_packets
[PACKET_qXfer_threads
].support
== PACKET_ENABLE
)
2522 char *xml
= target_read_stralloc (¤t_target
,
2523 TARGET_OBJECT_THREADS
, NULL
);
2525 struct cleanup
*back_to
= make_cleanup (xfree
, xml
);
2528 struct gdb_xml_parser
*parser
;
2529 struct threads_parsing_context context
;
2530 struct cleanup
*clear_parsing_context
;
2533 /* Note: this parser cleanup is already guarded by BACK_TO
2535 parser
= gdb_xml_create_parser_and_cleanup (_("threads"),
2539 gdb_xml_use_dtd (parser
, "threads.dtd");
2541 clear_parsing_context
2542 = make_cleanup (clear_threads_parsing_context
, &context
);
2544 if (gdb_xml_parse (parser
, xml
) == 0)
2547 struct thread_item
*item
;
2549 for (i
= 0; VEC_iterate (thread_item_t
, context
.items
, i
, item
); ++i
)
2551 if (!ptid_equal (item
->ptid
, null_ptid
))
2553 struct private_thread_info
*info
;
2554 /* In non-stop mode, we assume new found threads
2555 are running until proven otherwise with a
2556 stop reply. In all-stop, we can only get
2557 here if all threads are stopped. */
2558 int running
= non_stop
? 1 : 0;
2560 remote_notice_new_inferior (item
->ptid
, running
);
2562 info
= demand_private_info (item
->ptid
);
2563 info
->core
= item
->core
;
2564 info
->extra
= item
->extra
;
2570 do_cleanups (clear_parsing_context
);
2573 do_cleanups (back_to
);
2578 if (use_threadinfo_query
)
2580 putpkt ("qfThreadInfo");
2581 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2583 if (bufp
[0] != '\0') /* q packet recognized */
2585 while (*bufp
++ == 'm') /* reply contains one or more TID */
2589 new_thread
= read_ptid (bufp
, &bufp
);
2590 if (!ptid_equal (new_thread
, null_ptid
))
2592 /* In non-stop mode, we assume new found threads
2593 are running until proven otherwise with a
2594 stop reply. In all-stop, we can only get
2595 here if all threads are stopped. */
2596 int running
= non_stop
? 1 : 0;
2598 remote_notice_new_inferior (new_thread
, running
);
2601 while (*bufp
++ == ','); /* comma-separated list */
2602 putpkt ("qsThreadInfo");
2603 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2610 /* Only qfThreadInfo is supported in non-stop mode. */
2614 /* Else fall back to old method based on jmetzler protocol. */
2615 use_threadinfo_query
= 0;
2616 remote_find_new_threads ();
2621 * Collect a descriptive string about the given thread.
2622 * The target may say anything it wants to about the thread
2623 * (typically info about its blocked / runnable state, name, etc.).
2624 * This string will appear in the info threads display.
2626 * Optional: targets are not required to implement this function.
2630 remote_threads_extra_info (struct thread_info
*tp
)
2632 struct remote_state
*rs
= get_remote_state ();
2636 struct gdb_ext_thread_info threadinfo
;
2637 static char display_buf
[100]; /* arbitrary... */
2638 int n
= 0; /* position in display_buf */
2640 if (remote_desc
== 0) /* paranoia */
2641 internal_error (__FILE__
, __LINE__
,
2642 _("remote_threads_extra_info"));
2644 if (ptid_equal (tp
->ptid
, magic_null_ptid
)
2645 || (ptid_get_pid (tp
->ptid
) != 0 && ptid_get_tid (tp
->ptid
) == 0))
2646 /* This is the main thread which was added by GDB. The remote
2647 server doesn't know about it. */
2650 if (remote_protocol_packets
[PACKET_qXfer_threads
].support
== PACKET_ENABLE
)
2652 struct thread_info
*info
= find_thread_ptid (tp
->ptid
);
2653 if (info
&& info
->private)
2654 return info
->private->extra
;
2659 if (use_threadextra_query
)
2662 char *endb
= rs
->buf
+ get_remote_packet_size ();
2664 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
2666 write_ptid (b
, endb
, tp
->ptid
);
2669 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2670 if (rs
->buf
[0] != 0)
2672 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
2673 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
2674 display_buf
[result
] = '\0';
2679 /* If the above query fails, fall back to the old method. */
2680 use_threadextra_query
= 0;
2681 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
2682 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
2683 int_to_threadref (&id
, ptid_get_tid (tp
->ptid
));
2684 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
2685 if (threadinfo
.active
)
2687 if (*threadinfo
.shortname
)
2688 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
2689 " Name: %s,", threadinfo
.shortname
);
2690 if (*threadinfo
.display
)
2691 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
2692 " State: %s,", threadinfo
.display
);
2693 if (*threadinfo
.more_display
)
2694 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
2695 " Priority: %s", threadinfo
.more_display
);
2699 /* For purely cosmetic reasons, clear up trailing commas. */
2700 if (',' == display_buf
[n
-1])
2701 display_buf
[n
-1] = ' ';
2709 /* Implement the to_get_ada_task_ptid function for the remote targets. */
2712 remote_get_ada_task_ptid (long lwp
, long thread
)
2714 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2718 /* Restart the remote side; this is an extended protocol operation. */
2721 extended_remote_restart (void)
2723 struct remote_state
*rs
= get_remote_state ();
2725 /* Send the restart command; for reasons I don't understand the
2726 remote side really expects a number after the "R". */
2727 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
2730 remote_fileio_reset ();
2733 /* Clean up connection to a remote debugger. */
2736 remote_close (int quitting
)
2738 if (remote_desc
== NULL
)
2739 return; /* already closed */
2741 /* Make sure we leave stdin registered in the event loop, and we
2742 don't leave the async SIGINT signal handler installed. */
2743 remote_terminal_ours ();
2745 serial_close (remote_desc
);
2748 /* We don't have a connection to the remote stub anymore. Get rid
2749 of all the inferiors and their threads we were controlling. */
2750 discard_all_inferiors ();
2752 /* We're no longer interested in any of these events. */
2753 discard_pending_stop_replies (-1);
2755 if (remote_async_inferior_event_token
)
2756 delete_async_event_handler (&remote_async_inferior_event_token
);
2757 if (remote_async_get_pending_events_token
)
2758 delete_async_event_handler (&remote_async_get_pending_events_token
);
2761 /* Query the remote side for the text, data and bss offsets. */
2766 struct remote_state
*rs
= get_remote_state ();
2769 int lose
, num_segments
= 0, do_sections
, do_segments
;
2770 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
2771 struct section_offsets
*offs
;
2772 struct symfile_segment_data
*data
;
2774 if (symfile_objfile
== NULL
)
2777 putpkt ("qOffsets");
2778 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2781 if (buf
[0] == '\000')
2782 return; /* Return silently. Stub doesn't support
2786 warning (_("Remote failure reply: %s"), buf
);
2790 /* Pick up each field in turn. This used to be done with scanf, but
2791 scanf will make trouble if CORE_ADDR size doesn't match
2792 conversion directives correctly. The following code will work
2793 with any size of CORE_ADDR. */
2794 text_addr
= data_addr
= bss_addr
= 0;
2798 if (strncmp (ptr
, "Text=", 5) == 0)
2801 /* Don't use strtol, could lose on big values. */
2802 while (*ptr
&& *ptr
!= ';')
2803 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2805 if (strncmp (ptr
, ";Data=", 6) == 0)
2808 while (*ptr
&& *ptr
!= ';')
2809 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2814 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
2817 while (*ptr
&& *ptr
!= ';')
2818 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
2820 if (bss_addr
!= data_addr
)
2821 warning (_("Target reported unsupported offsets: %s"), buf
);
2826 else if (strncmp (ptr
, "TextSeg=", 8) == 0)
2829 /* Don't use strtol, could lose on big values. */
2830 while (*ptr
&& *ptr
!= ';')
2831 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2834 if (strncmp (ptr
, ";DataSeg=", 9) == 0)
2837 while (*ptr
&& *ptr
!= ';')
2838 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2846 error (_("Malformed response to offset query, %s"), buf
);
2847 else if (*ptr
!= '\0')
2848 warning (_("Target reported unsupported offsets: %s"), buf
);
2850 offs
= ((struct section_offsets
*)
2851 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
2852 memcpy (offs
, symfile_objfile
->section_offsets
,
2853 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
2855 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
2856 do_segments
= (data
!= NULL
);
2857 do_sections
= num_segments
== 0;
2859 if (num_segments
> 0)
2861 segments
[0] = text_addr
;
2862 segments
[1] = data_addr
;
2864 /* If we have two segments, we can still try to relocate everything
2865 by assuming that the .text and .data offsets apply to the whole
2866 text and data segments. Convert the offsets given in the packet
2867 to base addresses for symfile_map_offsets_to_segments. */
2868 else if (data
&& data
->num_segments
== 2)
2870 segments
[0] = data
->segment_bases
[0] + text_addr
;
2871 segments
[1] = data
->segment_bases
[1] + data_addr
;
2874 /* If the object file has only one segment, assume that it is text
2875 rather than data; main programs with no writable data are rare,
2876 but programs with no code are useless. Of course the code might
2877 have ended up in the data segment... to detect that we would need
2878 the permissions here. */
2879 else if (data
&& data
->num_segments
== 1)
2881 segments
[0] = data
->segment_bases
[0] + text_addr
;
2884 /* There's no way to relocate by segment. */
2890 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
2891 offs
, num_segments
, segments
);
2893 if (ret
== 0 && !do_sections
)
2894 error (_("Can not handle qOffsets TextSeg response with this symbol file"));
2901 free_symfile_segment_data (data
);
2905 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
2907 /* This is a temporary kludge to force data and bss to use the same offsets
2908 because that's what nlmconv does now. The real solution requires changes
2909 to the stub and remote.c that I don't have time to do right now. */
2911 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
2912 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
2915 objfile_relocate (symfile_objfile
, offs
);
2918 /* Callback for iterate_over_threads. Set the STOP_REQUESTED flags in
2919 threads we know are stopped already. This is used during the
2920 initial remote connection in non-stop mode --- threads that are
2921 reported as already being stopped are left stopped. */
2924 set_stop_requested_callback (struct thread_info
*thread
, void *data
)
2926 /* If we have a stop reply for this thread, it must be stopped. */
2927 if (peek_stop_reply (thread
->ptid
))
2928 set_stop_requested (thread
->ptid
, 1);
2933 /* Stub for catch_exception. */
2935 struct start_remote_args
2939 /* The current target. */
2940 struct target_ops
*target
;
2942 /* Non-zero if this is an extended-remote target. */
2946 /* Send interrupt_sequence to remote target. */
2948 send_interrupt_sequence ()
2950 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
2951 serial_write (remote_desc
, "\x03", 1);
2952 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
2953 serial_send_break (remote_desc
);
2954 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
2956 serial_send_break (remote_desc
);
2957 serial_write (remote_desc
, "g", 1);
2960 internal_error (__FILE__
, __LINE__
,
2961 _("Invalid value for interrupt_sequence_mode: %s."),
2962 interrupt_sequence_mode
);
2966 remote_start_remote (struct ui_out
*uiout
, void *opaque
)
2968 struct start_remote_args
*args
= opaque
;
2969 struct remote_state
*rs
= get_remote_state ();
2970 struct packet_config
*noack_config
;
2971 char *wait_status
= NULL
;
2973 immediate_quit
++; /* Allow user to interrupt it. */
2975 /* Ack any packet which the remote side has already sent. */
2976 serial_write (remote_desc
, "+", 1);
2978 if (interrupt_on_connect
)
2979 send_interrupt_sequence ();
2981 /* The first packet we send to the target is the optional "supported
2982 packets" request. If the target can answer this, it will tell us
2983 which later probes to skip. */
2984 remote_query_supported ();
2986 /* Next, we possibly activate noack mode.
2988 If the QStartNoAckMode packet configuration is set to AUTO,
2989 enable noack mode if the stub reported a wish for it with
2992 If set to TRUE, then enable noack mode even if the stub didn't
2993 report it in qSupported. If the stub doesn't reply OK, the
2994 session ends with an error.
2996 If FALSE, then don't activate noack mode, regardless of what the
2997 stub claimed should be the default with qSupported. */
2999 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
3001 if (noack_config
->detect
== AUTO_BOOLEAN_TRUE
3002 || (noack_config
->detect
== AUTO_BOOLEAN_AUTO
3003 && noack_config
->support
== PACKET_ENABLE
))
3005 putpkt ("QStartNoAckMode");
3006 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3007 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
3011 if (args
->extended_p
)
3013 /* Tell the remote that we are using the extended protocol. */
3015 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3018 /* Next, if the target can specify a description, read it. We do
3019 this before anything involving memory or registers. */
3020 target_find_description ();
3022 /* Next, now that we know something about the target, update the
3023 address spaces in the program spaces. */
3024 update_address_spaces ();
3026 /* On OSs where the list of libraries is global to all
3027 processes, we fetch them early. */
3028 if (gdbarch_has_global_solist (target_gdbarch
))
3029 solib_add (NULL
, args
->from_tty
, args
->target
, auto_solib_add
);
3033 if (!rs
->non_stop_aware
)
3034 error (_("Non-stop mode requested, but remote does not support non-stop"));
3036 putpkt ("QNonStop:1");
3037 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3039 if (strcmp (rs
->buf
, "OK") != 0)
3040 error ("Remote refused setting non-stop mode with: %s", rs
->buf
);
3042 /* Find about threads and processes the stub is already
3043 controlling. We default to adding them in the running state.
3044 The '?' query below will then tell us about which threads are
3046 remote_threads_info (args
->target
);
3048 else if (rs
->non_stop_aware
)
3050 /* Don't assume that the stub can operate in all-stop mode.
3051 Request it explicitely. */
3052 putpkt ("QNonStop:0");
3053 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3055 if (strcmp (rs
->buf
, "OK") != 0)
3056 error ("Remote refused setting all-stop mode with: %s", rs
->buf
);
3059 /* Check whether the target is running now. */
3061 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3065 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
3067 if (!args
->extended_p
)
3068 error (_("The target is not running (try extended-remote?)"));
3070 /* We're connected, but not running. Drop out before we
3071 call start_remote. */
3076 /* Save the reply for later. */
3077 wait_status
= alloca (strlen (rs
->buf
) + 1);
3078 strcpy (wait_status
, rs
->buf
);
3081 /* Let the stub know that we want it to return the thread. */
3082 set_continue_thread (minus_one_ptid
);
3084 /* Without this, some commands which require an active target
3085 (such as kill) won't work. This variable serves (at least)
3086 double duty as both the pid of the target process (if it has
3087 such), and as a flag indicating that a target is active.
3088 These functions should be split out into seperate variables,
3089 especially since GDB will someday have a notion of debugging
3090 several processes. */
3091 inferior_ptid
= magic_null_ptid
;
3093 /* Now, if we have thread information, update inferior_ptid. */
3094 inferior_ptid
= remote_current_thread (inferior_ptid
);
3096 remote_add_inferior (ptid_get_pid (inferior_ptid
), -1);
3098 /* Always add the main thread. */
3099 add_thread_silent (inferior_ptid
);
3101 get_offsets (); /* Get text, data & bss offsets. */
3103 /* If we could not find a description using qXfer, and we know
3104 how to do it some other way, try again. This is not
3105 supported for non-stop; it could be, but it is tricky if
3106 there are no stopped threads when we connect. */
3107 if (remote_read_description_p (args
->target
)
3108 && gdbarch_target_desc (target_gdbarch
) == NULL
)
3110 target_clear_description ();
3111 target_find_description ();
3114 /* Use the previously fetched status. */
3115 gdb_assert (wait_status
!= NULL
);
3116 strcpy (rs
->buf
, wait_status
);
3117 rs
->cached_wait_status
= 1;
3120 start_remote (args
->from_tty
); /* Initialize gdb process mechanisms. */
3124 /* Clear WFI global state. Do this before finding about new
3125 threads and inferiors, and setting the current inferior.
3126 Otherwise we would clear the proceed status of the current
3127 inferior when we want its stop_soon state to be preserved
3128 (see notice_new_inferior). */
3129 init_wait_for_inferior ();
3131 /* In non-stop, we will either get an "OK", meaning that there
3132 are no stopped threads at this time; or, a regular stop
3133 reply. In the latter case, there may be more than one thread
3134 stopped --- we pull them all out using the vStopped
3136 if (strcmp (rs
->buf
, "OK") != 0)
3138 struct stop_reply
*stop_reply
;
3139 struct cleanup
*old_chain
;
3141 stop_reply
= stop_reply_xmalloc ();
3142 old_chain
= make_cleanup (do_stop_reply_xfree
, stop_reply
);
3144 remote_parse_stop_reply (rs
->buf
, stop_reply
);
3145 discard_cleanups (old_chain
);
3147 /* get_pending_stop_replies acks this one, and gets the rest
3149 pending_stop_reply
= stop_reply
;
3150 remote_get_pending_stop_replies ();
3152 /* Make sure that threads that were stopped remain
3154 iterate_over_threads (set_stop_requested_callback
, NULL
);
3157 if (target_can_async_p ())
3158 target_async (inferior_event_handler
, 0);
3160 if (thread_count () == 0)
3162 if (!args
->extended_p
)
3163 error (_("The target is not running (try extended-remote?)"));
3165 /* We're connected, but not running. Drop out before we
3166 call start_remote. */
3170 /* Let the stub know that we want it to return the thread. */
3172 /* Force the stub to choose a thread. */
3173 set_general_thread (null_ptid
);
3176 inferior_ptid
= remote_current_thread (minus_one_ptid
);
3177 if (ptid_equal (inferior_ptid
, minus_one_ptid
))
3178 error (_("remote didn't report the current thread in non-stop mode"));
3180 get_offsets (); /* Get text, data & bss offsets. */
3182 /* In non-stop mode, any cached wait status will be stored in
3183 the stop reply queue. */
3184 gdb_assert (wait_status
== NULL
);
3186 /* Update the remote on signals to silently pass, or more
3187 importantly, which to not ignore, in case a previous session
3188 had set some different set of signals to be ignored. */
3189 remote_pass_signals ();
3192 /* If we connected to a live target, do some additional setup. */
3193 if (target_has_execution
)
3195 if (exec_bfd
) /* No use without an exec file. */
3196 remote_check_symbols (symfile_objfile
);
3199 /* Possibly the target has been engaged in a trace run started
3200 previously; find out where things are at. */
3201 if (remote_get_trace_status (current_trace_status ()) != -1)
3203 struct uploaded_tp
*uploaded_tps
= NULL
;
3204 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3206 if (current_trace_status ()->running
)
3207 printf_filtered (_("Trace is already running on the target.\n"));
3209 /* Get trace state variables first, they may be checked when
3210 parsing uploaded commands. */
3212 remote_upload_trace_state_variables (&uploaded_tsvs
);
3214 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3216 remote_upload_tracepoints (&uploaded_tps
);
3218 merge_uploaded_tracepoints (&uploaded_tps
);
3221 /* If breakpoints are global, insert them now. */
3222 if (gdbarch_has_global_breakpoints (target_gdbarch
)
3223 && breakpoints_always_inserted_mode ())
3224 insert_breakpoints ();
3227 /* Open a connection to a remote debugger.
3228 NAME is the filename used for communication. */
3231 remote_open (char *name
, int from_tty
)
3233 remote_open_1 (name
, from_tty
, &remote_ops
, 0);
3236 /* Open a connection to a remote debugger using the extended
3237 remote gdb protocol. NAME is the filename used for communication. */
3240 extended_remote_open (char *name
, int from_tty
)
3242 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */);
3245 /* Generic code for opening a connection to a remote target. */
3248 init_all_packet_configs (void)
3251 for (i
= 0; i
< PACKET_MAX
; i
++)
3252 update_packet_config (&remote_protocol_packets
[i
]);
3255 /* Symbol look-up. */
3258 remote_check_symbols (struct objfile
*objfile
)
3260 struct remote_state
*rs
= get_remote_state ();
3261 char *msg
, *reply
, *tmp
;
3262 struct minimal_symbol
*sym
;
3265 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
3268 /* Make sure the remote is pointing at the right process. */
3269 set_general_process ();
3271 /* Allocate a message buffer. We can't reuse the input buffer in RS,
3272 because we need both at the same time. */
3273 msg
= alloca (get_remote_packet_size ());
3275 /* Invite target to request symbol lookups. */
3277 putpkt ("qSymbol::");
3278 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3279 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
3282 while (strncmp (reply
, "qSymbol:", 8) == 0)
3285 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
3287 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
3289 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
3292 int addr_size
= gdbarch_addr_bit (target_gdbarch
) / 8;
3293 CORE_ADDR sym_addr
= SYMBOL_VALUE_ADDRESS (sym
);
3295 /* If this is a function address, return the start of code
3296 instead of any data function descriptor. */
3297 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch
,
3301 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
3302 phex_nz (sym_addr
, addr_size
), &reply
[8]);
3306 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3311 static struct serial
*
3312 remote_serial_open (char *name
)
3314 static int udp_warning
= 0;
3316 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
3317 of in ser-tcp.c, because it is the remote protocol assuming that the
3318 serial connection is reliable and not the serial connection promising
3320 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
3323 The remote protocol may be unreliable over UDP.\n\
3324 Some events may be lost, rendering further debugging impossible."));
3328 return serial_open (name
);
3331 /* This type describes each known response to the qSupported
3333 struct protocol_feature
3335 /* The name of this protocol feature. */
3338 /* The default for this protocol feature. */
3339 enum packet_support default_support
;
3341 /* The function to call when this feature is reported, or after
3342 qSupported processing if the feature is not supported.
3343 The first argument points to this structure. The second
3344 argument indicates whether the packet requested support be
3345 enabled, disabled, or probed (or the default, if this function
3346 is being called at the end of processing and this feature was
3347 not reported). The third argument may be NULL; if not NULL, it
3348 is a NUL-terminated string taken from the packet following
3349 this feature's name and an equals sign. */
3350 void (*func
) (const struct protocol_feature
*, enum packet_support
,
3353 /* The corresponding packet for this feature. Only used if
3354 FUNC is remote_supported_packet. */
3359 remote_supported_packet (const struct protocol_feature
*feature
,
3360 enum packet_support support
,
3361 const char *argument
)
3365 warning (_("Remote qSupported response supplied an unexpected value for"
3366 " \"%s\"."), feature
->name
);
3370 if (remote_protocol_packets
[feature
->packet
].support
3371 == PACKET_SUPPORT_UNKNOWN
)
3372 remote_protocol_packets
[feature
->packet
].support
= support
;
3376 remote_packet_size (const struct protocol_feature
*feature
,
3377 enum packet_support support
, const char *value
)
3379 struct remote_state
*rs
= get_remote_state ();
3384 if (support
!= PACKET_ENABLE
)
3387 if (value
== NULL
|| *value
== '\0')
3389 warning (_("Remote target reported \"%s\" without a size."),
3395 packet_size
= strtol (value
, &value_end
, 16);
3396 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
3398 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
3399 feature
->name
, value
);
3403 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
3405 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
3406 packet_size
, MAX_REMOTE_PACKET_SIZE
);
3407 packet_size
= MAX_REMOTE_PACKET_SIZE
;
3410 /* Record the new maximum packet size. */
3411 rs
->explicit_packet_size
= packet_size
;
3415 remote_multi_process_feature (const struct protocol_feature
*feature
,
3416 enum packet_support support
, const char *value
)
3418 struct remote_state
*rs
= get_remote_state ();
3419 rs
->multi_process_aware
= (support
== PACKET_ENABLE
);
3423 remote_non_stop_feature (const struct protocol_feature
*feature
,
3424 enum packet_support support
, const char *value
)
3426 struct remote_state
*rs
= get_remote_state ();
3427 rs
->non_stop_aware
= (support
== PACKET_ENABLE
);
3431 remote_cond_tracepoint_feature (const struct protocol_feature
*feature
,
3432 enum packet_support support
,
3435 struct remote_state
*rs
= get_remote_state ();
3436 rs
->cond_tracepoints
= (support
== PACKET_ENABLE
);
3440 remote_fast_tracepoint_feature (const struct protocol_feature
*feature
,
3441 enum packet_support support
,
3444 struct remote_state
*rs
= get_remote_state ();
3445 rs
->fast_tracepoints
= (support
== PACKET_ENABLE
);
3449 remote_disconnected_tracing_feature (const struct protocol_feature
*feature
,
3450 enum packet_support support
,
3453 struct remote_state
*rs
= get_remote_state ();
3454 rs
->disconnected_tracing
= (support
== PACKET_ENABLE
);
3457 static struct protocol_feature remote_protocol_features
[] = {
3458 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
3459 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
3460 PACKET_qXfer_auxv
},
3461 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
3462 PACKET_qXfer_features
},
3463 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
3464 PACKET_qXfer_libraries
},
3465 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
3466 PACKET_qXfer_memory_map
},
3467 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
3468 PACKET_qXfer_spu_read
},
3469 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
3470 PACKET_qXfer_spu_write
},
3471 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
3472 PACKET_qXfer_osdata
},
3473 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
3474 PACKET_qXfer_threads
},
3475 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
3476 PACKET_QPassSignals
},
3477 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
3478 PACKET_QStartNoAckMode
},
3479 { "multiprocess", PACKET_DISABLE
, remote_multi_process_feature
, -1 },
3480 { "QNonStop", PACKET_DISABLE
, remote_non_stop_feature
, -1 },
3481 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
3482 PACKET_qXfer_siginfo_read
},
3483 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
3484 PACKET_qXfer_siginfo_write
},
3485 { "ConditionalTracepoints", PACKET_DISABLE
, remote_cond_tracepoint_feature
,
3486 PACKET_ConditionalTracepoints
},
3487 { "FastTracepoints", PACKET_DISABLE
, remote_fast_tracepoint_feature
,
3488 PACKET_FastTracepoints
},
3489 { "DisconnectedTracing", PACKET_DISABLE
, remote_disconnected_tracing_feature
,
3491 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
3493 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
3495 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
3496 PACKET_TracepointSource
},
3499 static char *remote_support_xml
;
3501 /* Register string appended to "xmlRegisters=" in qSupported query. */
3504 register_remote_support_xml (const char *xml
)
3506 #if defined(HAVE_LIBEXPAT)
3507 if (remote_support_xml
== NULL
)
3508 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
3511 char *copy
= xstrdup (remote_support_xml
+ 13);
3512 char *p
= strtok (copy
, ",");
3516 if (strcmp (p
, xml
) == 0)
3523 while ((p
= strtok (NULL
, ",")) != NULL
);
3526 p
= concat (remote_support_xml
, ",", xml
, (char *) NULL
);
3527 xfree (remote_support_xml
);
3528 remote_support_xml
= p
;
3534 remote_query_supported_append (char *msg
, const char *append
)
3538 char *p
= concat (msg
, ";", append
, (char *) NULL
);
3543 return xstrdup (append
);
3547 remote_query_supported (void)
3549 struct remote_state
*rs
= get_remote_state ();
3552 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
3554 /* The packet support flags are handled differently for this packet
3555 than for most others. We treat an error, a disabled packet, and
3556 an empty response identically: any features which must be reported
3557 to be used will be automatically disabled. An empty buffer
3558 accomplishes this, since that is also the representation for a list
3559 containing no features. */
3562 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
3567 q
= remote_query_supported_append (q
, "multiprocess+");
3569 if (remote_support_xml
)
3570 q
= remote_query_supported_append (q
, remote_support_xml
);
3574 char *p
= concat ("qSupported:", q
, (char *) NULL
);
3580 putpkt ("qSupported");
3582 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3584 /* If an error occured, warn, but do not return - just reset the
3585 buffer to empty and go on to disable features. */
3586 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
3589 warning (_("Remote failure reply: %s"), rs
->buf
);
3594 memset (seen
, 0, sizeof (seen
));
3599 enum packet_support is_supported
;
3600 char *p
, *end
, *name_end
, *value
;
3602 /* First separate out this item from the rest of the packet. If
3603 there's another item after this, we overwrite the separator
3604 (terminated strings are much easier to work with). */
3606 end
= strchr (p
, ';');
3609 end
= p
+ strlen (p
);
3619 warning (_("empty item in \"qSupported\" response"));
3624 name_end
= strchr (p
, '=');
3627 /* This is a name=value entry. */
3628 is_supported
= PACKET_ENABLE
;
3629 value
= name_end
+ 1;
3638 is_supported
= PACKET_ENABLE
;
3642 is_supported
= PACKET_DISABLE
;
3646 is_supported
= PACKET_SUPPORT_UNKNOWN
;
3650 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p
);
3656 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
3657 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
3659 const struct protocol_feature
*feature
;
3662 feature
= &remote_protocol_features
[i
];
3663 feature
->func (feature
, is_supported
, value
);
3668 /* If we increased the packet size, make sure to increase the global
3669 buffer size also. We delay this until after parsing the entire
3670 qSupported packet, because this is the same buffer we were
3672 if (rs
->buf_size
< rs
->explicit_packet_size
)
3674 rs
->buf_size
= rs
->explicit_packet_size
;
3675 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
3678 /* Handle the defaults for unmentioned features. */
3679 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
3682 const struct protocol_feature
*feature
;
3684 feature
= &remote_protocol_features
[i
];
3685 feature
->func (feature
, feature
->default_support
, NULL
);
3691 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
, int extended_p
)
3693 struct remote_state
*rs
= get_remote_state ();
3696 error (_("To open a remote debug connection, you need to specify what\n"
3697 "serial device is attached to the remote system\n"
3698 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
3700 /* See FIXME above. */
3701 if (!target_async_permitted
)
3702 wait_forever_enabled_p
= 1;
3704 /* If we're connected to a running target, target_preopen will kill it.
3705 But if we're connected to a target system with no running process,
3706 then we will still be connected when it returns. Ask this question
3707 first, before target_preopen has a chance to kill anything. */
3708 if (remote_desc
!= NULL
&& !have_inferiors ())
3711 || query (_("Already connected to a remote target. Disconnect? ")))
3714 error (_("Still connected."));
3717 target_preopen (from_tty
);
3719 unpush_target (target
);
3721 /* This time without a query. If we were connected to an
3722 extended-remote target and target_preopen killed the running
3723 process, we may still be connected. If we are starting "target
3724 remote" now, the extended-remote target will not have been
3725 removed by unpush_target. */
3726 if (remote_desc
!= NULL
&& !have_inferiors ())
3729 /* Make sure we send the passed signals list the next time we resume. */
3730 xfree (last_pass_packet
);
3731 last_pass_packet
= NULL
;
3733 remote_fileio_reset ();
3734 reopen_exec_file ();
3737 remote_desc
= remote_serial_open (name
);
3739 perror_with_name (name
);
3741 if (baud_rate
!= -1)
3743 if (serial_setbaudrate (remote_desc
, baud_rate
))
3745 /* The requested speed could not be set. Error out to
3746 top level after closing remote_desc. Take care to
3747 set remote_desc to NULL to avoid closing remote_desc
3749 serial_close (remote_desc
);
3751 perror_with_name (name
);
3755 serial_raw (remote_desc
);
3757 /* If there is something sitting in the buffer we might take it as a
3758 response to a command, which would be bad. */
3759 serial_flush_input (remote_desc
);
3763 puts_filtered ("Remote debugging using ");
3764 puts_filtered (name
);
3765 puts_filtered ("\n");
3767 push_target (target
); /* Switch to using remote target now. */
3769 /* Register extra event sources in the event loop. */
3770 remote_async_inferior_event_token
3771 = create_async_event_handler (remote_async_inferior_event_handler
,
3773 remote_async_get_pending_events_token
3774 = create_async_event_handler (remote_async_get_pending_events_handler
,
3777 /* Reset the target state; these things will be queried either by
3778 remote_query_supported or as they are needed. */
3779 init_all_packet_configs ();
3780 rs
->cached_wait_status
= 0;
3781 rs
->explicit_packet_size
= 0;
3783 rs
->multi_process_aware
= 0;
3784 rs
->extended
= extended_p
;
3785 rs
->non_stop_aware
= 0;
3786 rs
->waiting_for_stop_reply
= 0;
3787 rs
->ctrlc_pending_p
= 0;
3789 general_thread
= not_sent_ptid
;
3790 continue_thread
= not_sent_ptid
;
3792 /* Probe for ability to use "ThreadInfo" query, as required. */
3793 use_threadinfo_query
= 1;
3794 use_threadextra_query
= 1;
3796 if (target_async_permitted
)
3798 /* With this target we start out by owning the terminal. */
3799 remote_async_terminal_ours_p
= 1;
3801 /* FIXME: cagney/1999-09-23: During the initial connection it is
3802 assumed that the target is already ready and able to respond to
3803 requests. Unfortunately remote_start_remote() eventually calls
3804 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
3805 around this. Eventually a mechanism that allows
3806 wait_for_inferior() to expect/get timeouts will be
3808 wait_forever_enabled_p
= 0;
3811 /* First delete any symbols previously loaded from shared libraries. */
3812 no_shared_libraries (NULL
, 0);
3815 init_thread_list ();
3817 /* Start the remote connection. If error() or QUIT, discard this
3818 target (we'd otherwise be in an inconsistent state) and then
3819 propogate the error on up the exception chain. This ensures that
3820 the caller doesn't stumble along blindly assuming that the
3821 function succeeded. The CLI doesn't have this problem but other
3822 UI's, such as MI do.
3824 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
3825 this function should return an error indication letting the
3826 caller restore the previous state. Unfortunately the command
3827 ``target remote'' is directly wired to this function making that
3828 impossible. On a positive note, the CLI side of this problem has
3829 been fixed - the function set_cmd_context() makes it possible for
3830 all the ``target ....'' commands to share a common callback
3831 function. See cli-dump.c. */
3833 struct gdb_exception ex
;
3834 struct start_remote_args args
;
3836 args
.from_tty
= from_tty
;
3837 args
.target
= target
;
3838 args
.extended_p
= extended_p
;
3840 ex
= catch_exception (uiout
, remote_start_remote
, &args
, RETURN_MASK_ALL
);
3843 /* Pop the partially set up target - unless something else did
3844 already before throwing the exception. */
3845 if (remote_desc
!= NULL
)
3847 if (target_async_permitted
)
3848 wait_forever_enabled_p
= 1;
3849 throw_exception (ex
);
3853 if (target_async_permitted
)
3854 wait_forever_enabled_p
= 1;
3857 /* This takes a program previously attached to and detaches it. After
3858 this is done, GDB can be used to debug some other program. We
3859 better not have left any breakpoints in the target program or it'll
3860 die when it hits one. */
3863 remote_detach_1 (char *args
, int from_tty
, int extended
)
3865 int pid
= ptid_get_pid (inferior_ptid
);
3866 struct remote_state
*rs
= get_remote_state ();
3869 error (_("Argument given to \"detach\" when remotely debugging."));
3871 if (!target_has_execution
)
3872 error (_("No process to detach from."));
3874 /* Tell the remote target to detach. */
3875 if (remote_multi_process_p (rs
))
3876 sprintf (rs
->buf
, "D;%x", pid
);
3878 strcpy (rs
->buf
, "D");
3881 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3883 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
3885 else if (rs
->buf
[0] == '\0')
3886 error (_("Remote doesn't know how to detach"));
3888 error (_("Can't detach process."));
3892 if (remote_multi_process_p (rs
))
3893 printf_filtered (_("Detached from remote %s.\n"),
3894 target_pid_to_str (pid_to_ptid (pid
)));
3898 puts_filtered (_("Detached from remote process.\n"));
3900 puts_filtered (_("Ending remote debugging.\n"));
3904 discard_pending_stop_replies (pid
);
3905 target_mourn_inferior ();
3909 remote_detach (struct target_ops
*ops
, char *args
, int from_tty
)
3911 remote_detach_1 (args
, from_tty
, 0);
3915 extended_remote_detach (struct target_ops
*ops
, char *args
, int from_tty
)
3917 remote_detach_1 (args
, from_tty
, 1);
3920 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
3923 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
3926 error (_("Argument given to \"disconnect\" when remotely debugging."));
3928 /* Make sure we unpush even the extended remote targets; mourn
3929 won't do it. So call remote_mourn_1 directly instead of
3930 target_mourn_inferior. */
3931 remote_mourn_1 (target
);
3934 puts_filtered ("Ending remote debugging.\n");
3937 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
3938 be chatty about it. */
3941 extended_remote_attach_1 (struct target_ops
*target
, char *args
, int from_tty
)
3943 struct remote_state
*rs
= get_remote_state ();
3945 char *wait_status
= NULL
;
3947 pid
= parse_pid_to_attach (args
);
3949 /* Remote PID can be freely equal to getpid, do not check it here the same
3950 way as in other targets. */
3952 if (remote_protocol_packets
[PACKET_vAttach
].support
== PACKET_DISABLE
)
3953 error (_("This target does not support attaching to a process"));
3955 sprintf (rs
->buf
, "vAttach;%x", pid
);
3957 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3959 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vAttach
]) == PACKET_OK
)
3962 printf_unfiltered (_("Attached to %s\n"),
3963 target_pid_to_str (pid_to_ptid (pid
)));
3967 /* Save the reply for later. */
3968 wait_status
= alloca (strlen (rs
->buf
) + 1);
3969 strcpy (wait_status
, rs
->buf
);
3971 else if (strcmp (rs
->buf
, "OK") != 0)
3972 error (_("Attaching to %s failed with: %s"),
3973 target_pid_to_str (pid_to_ptid (pid
)),
3976 else if (remote_protocol_packets
[PACKET_vAttach
].support
== PACKET_DISABLE
)
3977 error (_("This target does not support attaching to a process"));
3979 error (_("Attaching to %s failed"),
3980 target_pid_to_str (pid_to_ptid (pid
)));
3982 set_current_inferior (remote_add_inferior (pid
, 1));
3984 inferior_ptid
= pid_to_ptid (pid
);
3988 struct thread_info
*thread
;
3990 /* Get list of threads. */
3991 remote_threads_info (target
);
3993 thread
= first_thread_of_process (pid
);
3995 inferior_ptid
= thread
->ptid
;
3997 inferior_ptid
= pid_to_ptid (pid
);
3999 /* Invalidate our notion of the remote current thread. */
4000 record_currthread (minus_one_ptid
);
4004 /* Now, if we have thread information, update inferior_ptid. */
4005 inferior_ptid
= remote_current_thread (inferior_ptid
);
4007 /* Add the main thread to the thread list. */
4008 add_thread_silent (inferior_ptid
);
4011 /* Next, if the target can specify a description, read it. We do
4012 this before anything involving memory or registers. */
4013 target_find_description ();
4017 /* Use the previously fetched status. */
4018 gdb_assert (wait_status
!= NULL
);
4020 if (target_can_async_p ())
4022 struct stop_reply
*stop_reply
;
4023 struct cleanup
*old_chain
;
4025 stop_reply
= stop_reply_xmalloc ();
4026 old_chain
= make_cleanup (do_stop_reply_xfree
, stop_reply
);
4027 remote_parse_stop_reply (wait_status
, stop_reply
);
4028 discard_cleanups (old_chain
);
4029 push_stop_reply (stop_reply
);
4031 target_async (inferior_event_handler
, 0);
4035 gdb_assert (wait_status
!= NULL
);
4036 strcpy (rs
->buf
, wait_status
);
4037 rs
->cached_wait_status
= 1;
4041 gdb_assert (wait_status
== NULL
);
4045 extended_remote_attach (struct target_ops
*ops
, char *args
, int from_tty
)
4047 extended_remote_attach_1 (ops
, args
, from_tty
);
4050 /* Convert hex digit A to a number. */
4055 if (a
>= '0' && a
<= '9')
4057 else if (a
>= 'a' && a
<= 'f')
4058 return a
- 'a' + 10;
4059 else if (a
>= 'A' && a
<= 'F')
4060 return a
- 'A' + 10;
4062 error (_("Reply contains invalid hex digit %d"), a
);
4066 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
4070 for (i
= 0; i
< count
; i
++)
4072 if (hex
[0] == 0 || hex
[1] == 0)
4074 /* Hex string is short, or of uneven length.
4075 Return the count that has been converted so far. */
4078 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
4084 /* Convert number NIB to a hex digit. */
4092 return 'a' + nib
- 10;
4096 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
4099 /* May use a length, or a nul-terminated string as input. */
4101 count
= strlen ((char *) bin
);
4103 for (i
= 0; i
< count
; i
++)
4105 *hex
++ = tohex ((*bin
>> 4) & 0xf);
4106 *hex
++ = tohex (*bin
++ & 0xf);
4112 /* Check for the availability of vCont. This function should also check
4116 remote_vcont_probe (struct remote_state
*rs
)
4120 strcpy (rs
->buf
, "vCont?");
4122 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4125 /* Make sure that the features we assume are supported. */
4126 if (strncmp (buf
, "vCont", 5) == 0)
4129 int support_s
, support_S
, support_c
, support_C
;
4135 rs
->support_vCont_t
= 0;
4136 while (p
&& *p
== ';')
4139 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4141 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4143 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4145 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4147 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4148 rs
->support_vCont_t
= 1;
4150 p
= strchr (p
, ';');
4153 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
4154 BUF will make packet_ok disable the packet. */
4155 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
4159 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
4162 /* Helper function for building "vCont" resumptions. Write a
4163 resumption to P. ENDP points to one-passed-the-end of the buffer
4164 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
4165 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
4166 resumed thread should be single-stepped and/or signalled. If PTID
4167 equals minus_one_ptid, then all threads are resumed; if PTID
4168 represents a process, then all threads of the process are resumed;
4169 the thread to be stepped and/or signalled is given in the global
4173 append_resumption (char *p
, char *endp
,
4174 ptid_t ptid
, int step
, enum target_signal siggnal
)
4176 struct remote_state
*rs
= get_remote_state ();
4178 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
4179 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
4181 p
+= xsnprintf (p
, endp
- p
, ";s");
4182 else if (siggnal
!= TARGET_SIGNAL_0
)
4183 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
4185 p
+= xsnprintf (p
, endp
- p
, ";c");
4187 if (remote_multi_process_p (rs
) && ptid_is_pid (ptid
))
4191 /* All (-1) threads of process. */
4192 nptid
= ptid_build (ptid_get_pid (ptid
), 0, -1);
4194 p
+= xsnprintf (p
, endp
- p
, ":");
4195 p
= write_ptid (p
, endp
, nptid
);
4197 else if (!ptid_equal (ptid
, minus_one_ptid
))
4199 p
+= xsnprintf (p
, endp
- p
, ":");
4200 p
= write_ptid (p
, endp
, ptid
);
4206 /* Resume the remote inferior by using a "vCont" packet. The thread
4207 to be resumed is PTID; STEP and SIGGNAL indicate whether the
4208 resumed thread should be single-stepped and/or signalled. If PTID
4209 equals minus_one_ptid, then all threads are resumed; the thread to
4210 be stepped and/or signalled is given in the global INFERIOR_PTID.
4211 This function returns non-zero iff it resumes the inferior.
4213 This function issues a strict subset of all possible vCont commands at the
4217 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
4219 struct remote_state
*rs
= get_remote_state ();
4223 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
4224 remote_vcont_probe (rs
);
4226 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
4230 endp
= rs
->buf
+ get_remote_packet_size ();
4232 /* If we could generate a wider range of packets, we'd have to worry
4233 about overflowing BUF. Should there be a generic
4234 "multi-part-packet" packet? */
4236 p
+= xsnprintf (p
, endp
- p
, "vCont");
4238 if (ptid_equal (ptid
, magic_null_ptid
))
4240 /* MAGIC_NULL_PTID means that we don't have any active threads,
4241 so we don't have any TID numbers the inferior will
4242 understand. Make sure to only send forms that do not specify
4244 p
= append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
4246 else if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
4248 /* Resume all threads (of all processes, or of a single
4249 process), with preference for INFERIOR_PTID. This assumes
4250 inferior_ptid belongs to the set of all threads we are about
4252 if (step
|| siggnal
!= TARGET_SIGNAL_0
)
4254 /* Step inferior_ptid, with or without signal. */
4255 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
4258 /* And continue others without a signal. */
4259 p
= append_resumption (p
, endp
, ptid
, /*step=*/ 0, TARGET_SIGNAL_0
);
4263 /* Scheduler locking; resume only PTID. */
4264 p
= append_resumption (p
, endp
, ptid
, step
, siggnal
);
4267 gdb_assert (strlen (rs
->buf
) < get_remote_packet_size ());
4272 /* In non-stop, the stub replies to vCont with "OK". The stop
4273 reply will be reported asynchronously by means of a `%Stop'
4275 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4276 if (strcmp (rs
->buf
, "OK") != 0)
4277 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
);
4283 /* Tell the remote machine to resume. */
4285 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
4287 static int last_sent_step
;
4290 remote_resume (struct target_ops
*ops
,
4291 ptid_t ptid
, int step
, enum target_signal siggnal
)
4293 struct remote_state
*rs
= get_remote_state ();
4296 last_sent_signal
= siggnal
;
4297 last_sent_step
= step
;
4299 /* Update the inferior on signals to silently pass, if they've changed. */
4300 remote_pass_signals ();
4302 /* The vCont packet doesn't need to specify threads via Hc. */
4303 /* No reverse support (yet) for vCont. */
4304 if (execution_direction
!= EXEC_REVERSE
)
4305 if (remote_vcont_resume (ptid
, step
, siggnal
))
4308 /* All other supported resume packets do use Hc, so set the continue
4310 if (ptid_equal (ptid
, minus_one_ptid
))
4311 set_continue_thread (any_thread_ptid
);
4313 set_continue_thread (ptid
);
4316 if (execution_direction
== EXEC_REVERSE
)
4318 /* We don't pass signals to the target in reverse exec mode. */
4319 if (info_verbose
&& siggnal
!= TARGET_SIGNAL_0
)
4320 warning (" - Can't pass signal %d to target in reverse: ignored.\n",
4324 && remote_protocol_packets
[PACKET_bs
].support
== PACKET_DISABLE
)
4325 error (_("Remote reverse-step not supported."));
4327 && remote_protocol_packets
[PACKET_bc
].support
== PACKET_DISABLE
)
4328 error (_("Remote reverse-continue not supported."));
4330 strcpy (buf
, step
? "bs" : "bc");
4332 else if (siggnal
!= TARGET_SIGNAL_0
)
4334 buf
[0] = step
? 'S' : 'C';
4335 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
4336 buf
[2] = tohex (((int) siggnal
) & 0xf);
4340 strcpy (buf
, step
? "s" : "c");
4345 /* We are about to start executing the inferior, let's register it
4346 with the event loop. NOTE: this is the one place where all the
4347 execution commands end up. We could alternatively do this in each
4348 of the execution commands in infcmd.c. */
4349 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
4350 into infcmd.c in order to allow inferior function calls to work
4351 NOT asynchronously. */
4352 if (target_can_async_p ())
4353 target_async (inferior_event_handler
, 0);
4355 /* We've just told the target to resume. The remote server will
4356 wait for the inferior to stop, and then send a stop reply. In
4357 the mean time, we can't start another command/query ourselves
4358 because the stub wouldn't be ready to process it. This applies
4359 only to the base all-stop protocol, however. In non-stop (which
4360 only supports vCont), the stub replies with an "OK", and is
4361 immediate able to process further serial input. */
4363 rs
->waiting_for_stop_reply
= 1;
4367 /* Set up the signal handler for SIGINT, while the target is
4368 executing, ovewriting the 'regular' SIGINT signal handler. */
4370 initialize_sigint_signal_handler (void)
4372 signal (SIGINT
, handle_remote_sigint
);
4375 /* Signal handler for SIGINT, while the target is executing. */
4377 handle_remote_sigint (int sig
)
4379 signal (sig
, handle_remote_sigint_twice
);
4380 mark_async_signal_handler_wrapper (sigint_remote_token
);
4383 /* Signal handler for SIGINT, installed after SIGINT has already been
4384 sent once. It will take effect the second time that the user sends
4387 handle_remote_sigint_twice (int sig
)
4389 signal (sig
, handle_remote_sigint
);
4390 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
4393 /* Perform the real interruption of the target execution, in response
4396 async_remote_interrupt (gdb_client_data arg
)
4399 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
4401 target_stop (inferior_ptid
);
4404 /* Perform interrupt, if the first attempt did not succeed. Just give
4405 up on the target alltogether. */
4407 async_remote_interrupt_twice (gdb_client_data arg
)
4410 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
4415 /* Reinstall the usual SIGINT handlers, after the target has
4418 cleanup_sigint_signal_handler (void *dummy
)
4420 signal (SIGINT
, handle_sigint
);
4423 /* Send ^C to target to halt it. Target will respond, and send us a
4425 static void (*ofunc
) (int);
4427 /* The command line interface's stop routine. This function is installed
4428 as a signal handler for SIGINT. The first time a user requests a
4429 stop, we call remote_stop to send a break or ^C. If there is no
4430 response from the target (it didn't stop when the user requested it),
4431 we ask the user if he'd like to detach from the target. */
4433 remote_interrupt (int signo
)
4435 /* If this doesn't work, try more severe steps. */
4436 signal (signo
, remote_interrupt_twice
);
4438 gdb_call_async_signal_handler (sigint_remote_token
, 1);
4441 /* The user typed ^C twice. */
4444 remote_interrupt_twice (int signo
)
4446 signal (signo
, ofunc
);
4447 gdb_call_async_signal_handler (sigint_remote_twice_token
, 1);
4448 signal (signo
, remote_interrupt
);
4451 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
4452 thread, all threads of a remote process, or all threads of all
4456 remote_stop_ns (ptid_t ptid
)
4458 struct remote_state
*rs
= get_remote_state ();
4460 char *endp
= rs
->buf
+ get_remote_packet_size ();
4462 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
4463 remote_vcont_probe (rs
);
4465 if (!rs
->support_vCont_t
)
4466 error (_("Remote server does not support stopping threads"));
4468 if (ptid_equal (ptid
, minus_one_ptid
)
4469 || (!remote_multi_process_p (rs
) && ptid_is_pid (ptid
)))
4470 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
4475 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
4477 if (ptid_is_pid (ptid
))
4478 /* All (-1) threads of process. */
4479 nptid
= ptid_build (ptid_get_pid (ptid
), 0, -1);
4482 /* Small optimization: if we already have a stop reply for
4483 this thread, no use in telling the stub we want this
4485 if (peek_stop_reply (ptid
))
4491 p
= write_ptid (p
, endp
, nptid
);
4494 /* In non-stop, we get an immediate OK reply. The stop reply will
4495 come in asynchronously by notification. */
4497 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4498 if (strcmp (rs
->buf
, "OK") != 0)
4499 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
), rs
->buf
);
4502 /* All-stop version of target_stop. Sends a break or a ^C to stop the
4503 remote target. It is undefined which thread of which process
4504 reports the stop. */
4507 remote_stop_as (ptid_t ptid
)
4509 struct remote_state
*rs
= get_remote_state ();
4511 rs
->ctrlc_pending_p
= 1;
4513 /* If the inferior is stopped already, but the core didn't know
4514 about it yet, just ignore the request. The cached wait status
4515 will be collected in remote_wait. */
4516 if (rs
->cached_wait_status
)
4519 /* Send interrupt_sequence to remote target. */
4520 send_interrupt_sequence ();
4523 /* This is the generic stop called via the target vector. When a target
4524 interrupt is requested, either by the command line or the GUI, we
4525 will eventually end up here. */
4528 remote_stop (ptid_t ptid
)
4531 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
4534 remote_stop_ns (ptid
);
4536 remote_stop_as (ptid
);
4539 /* Ask the user what to do when an interrupt is received. */
4542 interrupt_query (void)
4544 target_terminal_ours ();
4546 if (target_can_async_p ())
4548 signal (SIGINT
, handle_sigint
);
4549 deprecated_throw_reason (RETURN_QUIT
);
4553 if (query (_("Interrupted while waiting for the program.\n\
4554 Give up (and stop debugging it)? ")))
4557 deprecated_throw_reason (RETURN_QUIT
);
4561 target_terminal_inferior ();
4564 /* Enable/disable target terminal ownership. Most targets can use
4565 terminal groups to control terminal ownership. Remote targets are
4566 different in that explicit transfer of ownership to/from GDB/target
4570 remote_terminal_inferior (void)
4572 if (!target_async_permitted
)
4573 /* Nothing to do. */
4576 /* FIXME: cagney/1999-09-27: Make calls to target_terminal_*()
4577 idempotent. The event-loop GDB talking to an asynchronous target
4578 with a synchronous command calls this function from both
4579 event-top.c and infrun.c/infcmd.c. Once GDB stops trying to
4580 transfer the terminal to the target when it shouldn't this guard
4582 if (!remote_async_terminal_ours_p
)
4584 delete_file_handler (input_fd
);
4585 remote_async_terminal_ours_p
= 0;
4586 initialize_sigint_signal_handler ();
4587 /* NOTE: At this point we could also register our selves as the
4588 recipient of all input. Any characters typed could then be
4589 passed on down to the target. */
4593 remote_terminal_ours (void)
4595 if (!target_async_permitted
)
4596 /* Nothing to do. */
4599 /* See FIXME in remote_terminal_inferior. */
4600 if (remote_async_terminal_ours_p
)
4602 cleanup_sigint_signal_handler (NULL
);
4603 add_file_handler (input_fd
, stdin_event_handler
, 0);
4604 remote_async_terminal_ours_p
= 1;
4608 remote_console_output (char *msg
)
4612 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
4615 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
4618 fputs_unfiltered (tb
, gdb_stdtarg
);
4620 gdb_flush (gdb_stdtarg
);
4623 typedef struct cached_reg
4626 gdb_byte data
[MAX_REGISTER_SIZE
];
4629 DEF_VEC_O(cached_reg_t
);
4633 struct stop_reply
*next
;
4637 struct target_waitstatus ws
;
4639 VEC(cached_reg_t
) *regcache
;
4641 int stopped_by_watchpoint_p
;
4642 CORE_ADDR watch_data_address
;
4650 /* The list of already fetched and acknowledged stop events. */
4651 static struct stop_reply
*stop_reply_queue
;
4653 static struct stop_reply
*
4654 stop_reply_xmalloc (void)
4656 struct stop_reply
*r
= XMALLOC (struct stop_reply
);
4662 stop_reply_xfree (struct stop_reply
*r
)
4666 VEC_free (cached_reg_t
, r
->regcache
);
4671 /* Discard all pending stop replies of inferior PID. If PID is -1,
4672 discard everything. */
4675 discard_pending_stop_replies (int pid
)
4677 struct stop_reply
*prev
= NULL
, *reply
, *next
;
4679 /* Discard the in-flight notification. */
4680 if (pending_stop_reply
!= NULL
4682 || ptid_get_pid (pending_stop_reply
->ptid
) == pid
))
4684 stop_reply_xfree (pending_stop_reply
);
4685 pending_stop_reply
= NULL
;
4688 /* Discard the stop replies we have already pulled with
4690 for (reply
= stop_reply_queue
; reply
; reply
= next
)
4694 || ptid_get_pid (reply
->ptid
) == pid
)
4696 if (reply
== stop_reply_queue
)
4697 stop_reply_queue
= reply
->next
;
4699 prev
->next
= reply
->next
;
4701 stop_reply_xfree (reply
);
4708 /* Cleanup wrapper. */
4711 do_stop_reply_xfree (void *arg
)
4713 struct stop_reply
*r
= arg
;
4714 stop_reply_xfree (r
);
4717 /* Look for a queued stop reply belonging to PTID. If one is found,
4718 remove it from the queue, and return it. Returns NULL if none is
4719 found. If there are still queued events left to process, tell the
4720 event loop to get back to target_wait soon. */
4722 static struct stop_reply
*
4723 queued_stop_reply (ptid_t ptid
)
4725 struct stop_reply
*it
;
4726 struct stop_reply
**it_link
;
4728 it
= stop_reply_queue
;
4729 it_link
= &stop_reply_queue
;
4732 if (ptid_match (it
->ptid
, ptid
))
4734 *it_link
= it
->next
;
4739 it_link
= &it
->next
;
4743 if (stop_reply_queue
)
4744 /* There's still at least an event left. */
4745 mark_async_event_handler (remote_async_inferior_event_token
);
4750 /* Push a fully parsed stop reply in the stop reply queue. Since we
4751 know that we now have at least one queued event left to pass to the
4752 core side, tell the event loop to get back to target_wait soon. */
4755 push_stop_reply (struct stop_reply
*new_event
)
4757 struct stop_reply
*event
;
4759 if (stop_reply_queue
)
4761 for (event
= stop_reply_queue
;
4762 event
&& event
->next
;
4763 event
= event
->next
)
4766 event
->next
= new_event
;
4769 stop_reply_queue
= new_event
;
4771 mark_async_event_handler (remote_async_inferior_event_token
);
4774 /* Returns true if we have a stop reply for PTID. */
4777 peek_stop_reply (ptid_t ptid
)
4779 struct stop_reply
*it
;
4781 for (it
= stop_reply_queue
; it
; it
= it
->next
)
4782 if (ptid_equal (ptid
, it
->ptid
))
4784 if (it
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
4791 /* Parse the stop reply in BUF. Either the function succeeds, and the
4792 result is stored in EVENT, or throws an error. */
4795 remote_parse_stop_reply (char *buf
, struct stop_reply
*event
)
4797 struct remote_arch_state
*rsa
= get_remote_arch_state ();
4801 event
->ptid
= null_ptid
;
4802 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
4803 event
->ws
.value
.integer
= 0;
4804 event
->solibs_changed
= 0;
4805 event
->replay_event
= 0;
4806 event
->stopped_by_watchpoint_p
= 0;
4807 event
->regcache
= NULL
;
4812 case 'T': /* Status with PC, SP, FP, ... */
4813 /* Expedited reply, containing Signal, {regno, reg} repeat. */
4814 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
4816 n... = register number
4817 r... = register contents
4820 p
= &buf
[3]; /* after Txx */
4828 /* If the packet contains a register number, save it in
4829 pnum and set p1 to point to the character following it.
4830 Otherwise p1 points to p. */
4832 /* If this packet is an awatch packet, don't parse the 'a'
4833 as a register number. */
4835 if (strncmp (p
, "awatch", strlen("awatch")) != 0
4836 && strncmp (p
, "core", strlen ("core") != 0))
4838 /* Read the ``P'' register number. */
4839 pnum
= strtol (p
, &p_temp
, 16);
4845 if (p1
== p
) /* No register number present here. */
4847 p1
= strchr (p
, ':');
4849 error (_("Malformed packet(a) (missing colon): %s\n\
4852 if (strncmp (p
, "thread", p1
- p
) == 0)
4853 event
->ptid
= read_ptid (++p1
, &p
);
4854 else if ((strncmp (p
, "watch", p1
- p
) == 0)
4855 || (strncmp (p
, "rwatch", p1
- p
) == 0)
4856 || (strncmp (p
, "awatch", p1
- p
) == 0))
4858 event
->stopped_by_watchpoint_p
= 1;
4859 p
= unpack_varlen_hex (++p1
, &addr
);
4860 event
->watch_data_address
= (CORE_ADDR
) addr
;
4862 else if (strncmp (p
, "library", p1
- p
) == 0)
4866 while (*p_temp
&& *p_temp
!= ';')
4869 event
->solibs_changed
= 1;
4872 else if (strncmp (p
, "replaylog", p1
- p
) == 0)
4874 /* NO_HISTORY event.
4875 p1 will indicate "begin" or "end", but
4876 it makes no difference for now, so ignore it. */
4877 event
->replay_event
= 1;
4878 p_temp
= strchr (p1
+ 1, ';');
4882 else if (strncmp (p
, "core", p1
- p
) == 0)
4885 p
= unpack_varlen_hex (++p1
, &c
);
4890 /* Silently skip unknown optional info. */
4891 p_temp
= strchr (p1
+ 1, ';');
4898 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
4899 cached_reg_t cached_reg
;
4904 error (_("Malformed packet(b) (missing colon): %s\n\
4910 error (_("Remote sent bad register number %s: %s\n\
4912 hex_string (pnum
), p
, buf
);
4914 cached_reg
.num
= reg
->regnum
;
4916 fieldsize
= hex2bin (p
, cached_reg
.data
,
4917 register_size (target_gdbarch
,
4920 if (fieldsize
< register_size (target_gdbarch
,
4922 warning (_("Remote reply is too short: %s"), buf
);
4924 VEC_safe_push (cached_reg_t
, event
->regcache
, &cached_reg
);
4928 error (_("Remote register badly formatted: %s\nhere: %s"),
4933 case 'S': /* Old style status, just signal only. */
4934 if (event
->solibs_changed
)
4935 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
4936 else if (event
->replay_event
)
4937 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
4940 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
4941 event
->ws
.value
.sig
= (enum target_signal
)
4942 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
4945 case 'W': /* Target exited. */
4952 /* GDB used to accept only 2 hex chars here. Stubs should
4953 only send more if they detect GDB supports multi-process
4955 p
= unpack_varlen_hex (&buf
[1], &value
);
4959 /* The remote process exited. */
4960 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
4961 event
->ws
.value
.integer
= value
;
4965 /* The remote process exited with a signal. */
4966 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
4967 event
->ws
.value
.sig
= (enum target_signal
) value
;
4970 /* If no process is specified, assume inferior_ptid. */
4971 pid
= ptid_get_pid (inferior_ptid
);
4980 else if (strncmp (p
,
4981 "process:", sizeof ("process:") - 1) == 0)
4984 p
+= sizeof ("process:") - 1;
4985 unpack_varlen_hex (p
, &upid
);
4989 error (_("unknown stop reply packet: %s"), buf
);
4992 error (_("unknown stop reply packet: %s"), buf
);
4993 event
->ptid
= pid_to_ptid (pid
);
4998 if (non_stop
&& ptid_equal (event
->ptid
, null_ptid
))
4999 error (_("No process or thread specified in stop reply: %s"), buf
);
5002 /* When the stub wants to tell GDB about a new stop reply, it sends a
5003 stop notification (%Stop). Those can come it at any time, hence,
5004 we have to make sure that any pending putpkt/getpkt sequence we're
5005 making is finished, before querying the stub for more events with
5006 vStopped. E.g., if we started a vStopped sequence immediatelly
5007 upon receiving the %Stop notification, something like this could
5015 1.6) <-- (registers reply to step #1.3)
5017 Obviously, the reply in step #1.6 would be unexpected to a vStopped
5020 To solve this, whenever we parse a %Stop notification sucessfully,
5021 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
5022 doing whatever we were doing:
5028 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
5029 2.5) <-- (registers reply to step #2.3)
5031 Eventualy after step #2.5, we return to the event loop, which
5032 notices there's an event on the
5033 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
5034 associated callback --- the function below. At this point, we're
5035 always safe to start a vStopped sequence. :
5038 2.7) <-- T05 thread:2
5044 remote_get_pending_stop_replies (void)
5046 struct remote_state
*rs
= get_remote_state ();
5048 if (pending_stop_reply
)
5051 putpkt ("vStopped");
5053 /* Now we can rely on it. */
5054 push_stop_reply (pending_stop_reply
);
5055 pending_stop_reply
= NULL
;
5059 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5060 if (strcmp (rs
->buf
, "OK") == 0)
5064 struct cleanup
*old_chain
;
5065 struct stop_reply
*stop_reply
= stop_reply_xmalloc ();
5067 old_chain
= make_cleanup (do_stop_reply_xfree
, stop_reply
);
5068 remote_parse_stop_reply (rs
->buf
, stop_reply
);
5071 putpkt ("vStopped");
5073 if (stop_reply
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
5075 /* Now we can rely on it. */
5076 discard_cleanups (old_chain
);
5077 push_stop_reply (stop_reply
);
5080 /* We got an unknown stop reply. */
5081 do_cleanups (old_chain
);
5088 /* Called when it is decided that STOP_REPLY holds the info of the
5089 event that is to be returned to the core. This function always
5090 destroys STOP_REPLY. */
5093 process_stop_reply (struct stop_reply
*stop_reply
,
5094 struct target_waitstatus
*status
)
5098 *status
= stop_reply
->ws
;
5099 ptid
= stop_reply
->ptid
;
5101 /* If no thread/process was reported by the stub, assume the current
5103 if (ptid_equal (ptid
, null_ptid
))
5104 ptid
= inferior_ptid
;
5106 if (status
->kind
!= TARGET_WAITKIND_EXITED
5107 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
5109 /* Expedited registers. */
5110 if (stop_reply
->regcache
)
5112 struct regcache
*regcache
5113 = get_thread_arch_regcache (ptid
, target_gdbarch
);
5118 VEC_iterate(cached_reg_t
, stop_reply
->regcache
, ix
, reg
);
5120 regcache_raw_supply (regcache
, reg
->num
, reg
->data
);
5121 VEC_free (cached_reg_t
, stop_reply
->regcache
);
5124 remote_stopped_by_watchpoint_p
= stop_reply
->stopped_by_watchpoint_p
;
5125 remote_watch_data_address
= stop_reply
->watch_data_address
;
5127 remote_notice_new_inferior (ptid
, 0);
5128 demand_private_info (ptid
)->core
= stop_reply
->core
;
5131 stop_reply_xfree (stop_reply
);
5135 /* The non-stop mode version of target_wait. */
5138 remote_wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
5140 struct remote_state
*rs
= get_remote_state ();
5141 struct stop_reply
*stop_reply
;
5144 /* If in non-stop mode, get out of getpkt even if a
5145 notification is received. */
5147 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
5154 case 'E': /* Error of some sort. */
5155 /* We're out of sync with the target now. Did it continue
5156 or not? We can't tell which thread it was in non-stop,
5157 so just ignore this. */
5158 warning (_("Remote failure reply: %s"), rs
->buf
);
5160 case 'O': /* Console output. */
5161 remote_console_output (rs
->buf
+ 1);
5164 warning (_("Invalid remote reply: %s"), rs
->buf
);
5168 /* Acknowledge a pending stop reply that may have arrived in the
5170 if (pending_stop_reply
!= NULL
)
5171 remote_get_pending_stop_replies ();
5173 /* If indeed we noticed a stop reply, we're done. */
5174 stop_reply
= queued_stop_reply (ptid
);
5175 if (stop_reply
!= NULL
)
5176 return process_stop_reply (stop_reply
, status
);
5178 /* Still no event. If we're just polling for an event, then
5179 return to the event loop. */
5180 if (options
& TARGET_WNOHANG
)
5182 status
->kind
= TARGET_WAITKIND_IGNORE
;
5183 return minus_one_ptid
;
5186 /* Otherwise do a blocking wait. */
5187 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
5192 /* Wait until the remote machine stops, then return, storing status in
5193 STATUS just as `wait' would. */
5196 remote_wait_as (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
5198 struct remote_state
*rs
= get_remote_state ();
5199 ptid_t event_ptid
= null_ptid
;
5201 struct stop_reply
*stop_reply
;
5205 status
->kind
= TARGET_WAITKIND_IGNORE
;
5206 status
->value
.integer
= 0;
5208 stop_reply
= queued_stop_reply (ptid
);
5209 if (stop_reply
!= NULL
)
5210 return process_stop_reply (stop_reply
, status
);
5212 if (rs
->cached_wait_status
)
5213 /* Use the cached wait status, but only once. */
5214 rs
->cached_wait_status
= 0;
5219 if (!target_is_async_p ())
5221 ofunc
= signal (SIGINT
, remote_interrupt
);
5222 /* If the user hit C-c before this packet, or between packets,
5223 pretend that it was hit right here. */
5227 remote_interrupt (SIGINT
);
5231 /* FIXME: cagney/1999-09-27: If we're in async mode we should
5232 _never_ wait for ever -> test on target_is_async_p().
5233 However, before we do that we need to ensure that the caller
5234 knows how to take the target into/out of async mode. */
5235 ret
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
5236 if (!target_is_async_p ())
5237 signal (SIGINT
, ofunc
);
5242 remote_stopped_by_watchpoint_p
= 0;
5244 /* We got something. */
5245 rs
->waiting_for_stop_reply
= 0;
5247 /* Assume that the target has acknowledged Ctrl-C unless we receive
5248 an 'F' or 'O' packet. */
5249 if (buf
[0] != 'F' && buf
[0] != 'O')
5250 rs
->ctrlc_pending_p
= 0;
5254 case 'E': /* Error of some sort. */
5255 /* We're out of sync with the target now. Did it continue or
5256 not? Not is more likely, so report a stop. */
5257 warning (_("Remote failure reply: %s"), buf
);
5258 status
->kind
= TARGET_WAITKIND_STOPPED
;
5259 status
->value
.sig
= TARGET_SIGNAL_0
;
5261 case 'F': /* File-I/O request. */
5262 remote_fileio_request (buf
, rs
->ctrlc_pending_p
);
5263 rs
->ctrlc_pending_p
= 0;
5265 case 'T': case 'S': case 'X': case 'W':
5267 struct stop_reply
*stop_reply
;
5268 struct cleanup
*old_chain
;
5270 stop_reply
= stop_reply_xmalloc ();
5271 old_chain
= make_cleanup (do_stop_reply_xfree
, stop_reply
);
5272 remote_parse_stop_reply (buf
, stop_reply
);
5273 discard_cleanups (old_chain
);
5274 event_ptid
= process_stop_reply (stop_reply
, status
);
5277 case 'O': /* Console output. */
5278 remote_console_output (buf
+ 1);
5280 /* The target didn't really stop; keep waiting. */
5281 rs
->waiting_for_stop_reply
= 1;
5285 if (last_sent_signal
!= TARGET_SIGNAL_0
)
5287 /* Zero length reply means that we tried 'S' or 'C' and the
5288 remote system doesn't support it. */
5289 target_terminal_ours_for_output ();
5291 ("Can't send signals to this remote system. %s not sent.\n",
5292 target_signal_to_name (last_sent_signal
));
5293 last_sent_signal
= TARGET_SIGNAL_0
;
5294 target_terminal_inferior ();
5296 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
5297 putpkt ((char *) buf
);
5299 /* We just told the target to resume, so a stop reply is in
5301 rs
->waiting_for_stop_reply
= 1;
5304 /* else fallthrough */
5306 warning (_("Invalid remote reply: %s"), buf
);
5308 rs
->waiting_for_stop_reply
= 1;
5312 if (status
->kind
== TARGET_WAITKIND_IGNORE
)
5314 /* Nothing interesting happened. If we're doing a non-blocking
5315 poll, we're done. Otherwise, go back to waiting. */
5316 if (options
& TARGET_WNOHANG
)
5317 return minus_one_ptid
;
5321 else if (status
->kind
!= TARGET_WAITKIND_EXITED
5322 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
5324 if (!ptid_equal (event_ptid
, null_ptid
))
5325 record_currthread (event_ptid
);
5327 event_ptid
= inferior_ptid
;
5330 /* A process exit. Invalidate our notion of current thread. */
5331 record_currthread (minus_one_ptid
);
5336 /* Wait until the remote machine stops, then return, storing status in
5337 STATUS just as `wait' would. */
5340 remote_wait (struct target_ops
*ops
,
5341 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
5346 event_ptid
= remote_wait_ns (ptid
, status
, options
);
5348 event_ptid
= remote_wait_as (ptid
, status
, options
);
5350 if (target_can_async_p ())
5352 /* If there are are events left in the queue tell the event loop
5354 if (stop_reply_queue
)
5355 mark_async_event_handler (remote_async_inferior_event_token
);
5361 /* Fetch a single register using a 'p' packet. */
5364 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
5366 struct remote_state
*rs
= get_remote_state ();
5368 char regp
[MAX_REGISTER_SIZE
];
5371 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
5374 if (reg
->pnum
== -1)
5379 p
+= hexnumstr (p
, reg
->pnum
);
5382 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5386 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
5390 case PACKET_UNKNOWN
:
5393 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
5394 gdbarch_register_name (get_regcache_arch (regcache
),
5399 /* If this register is unfetchable, tell the regcache. */
5402 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
5406 /* Otherwise, parse and supply the value. */
5412 error (_("fetch_register_using_p: early buf termination"));
5414 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
5417 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
5421 /* Fetch the registers included in the target's 'g' packet. */
5424 send_g_packet (void)
5426 struct remote_state
*rs
= get_remote_state ();
5429 sprintf (rs
->buf
, "g");
5430 remote_send (&rs
->buf
, &rs
->buf_size
);
5432 /* We can get out of synch in various cases. If the first character
5433 in the buffer is not a hex character, assume that has happened
5434 and try to fetch another packet to read. */
5435 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
5436 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
5437 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
5438 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
5441 fprintf_unfiltered (gdb_stdlog
,
5442 "Bad register packet; fetching a new packet\n");
5443 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5446 buf_len
= strlen (rs
->buf
);
5448 /* Sanity check the received packet. */
5449 if (buf_len
% 2 != 0)
5450 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
5456 process_g_packet (struct regcache
*regcache
)
5458 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
5459 struct remote_state
*rs
= get_remote_state ();
5460 struct remote_arch_state
*rsa
= get_remote_arch_state ();
5465 buf_len
= strlen (rs
->buf
);
5467 /* Further sanity checks, with knowledge of the architecture. */
5468 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
5469 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
5471 /* Save the size of the packet sent to us by the target. It is used
5472 as a heuristic when determining the max size of packets that the
5473 target can safely receive. */
5474 if (rsa
->actual_register_packet_size
== 0)
5475 rsa
->actual_register_packet_size
= buf_len
;
5477 /* If this is smaller than we guessed the 'g' packet would be,
5478 update our records. A 'g' reply that doesn't include a register's
5479 value implies either that the register is not available, or that
5480 the 'p' packet must be used. */
5481 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
5483 rsa
->sizeof_g_packet
= buf_len
/ 2;
5485 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
5487 if (rsa
->regs
[i
].pnum
== -1)
5490 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
5491 rsa
->regs
[i
].in_g_packet
= 0;
5493 rsa
->regs
[i
].in_g_packet
= 1;
5497 regs
= alloca (rsa
->sizeof_g_packet
);
5499 /* Unimplemented registers read as all bits zero. */
5500 memset (regs
, 0, rsa
->sizeof_g_packet
);
5502 /* Reply describes registers byte by byte, each byte encoded as two
5503 hex characters. Suck them all up, then supply them to the
5504 register cacheing/storage mechanism. */
5507 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
5509 if (p
[0] == 0 || p
[1] == 0)
5510 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
5511 internal_error (__FILE__
, __LINE__
,
5512 "unexpected end of 'g' packet reply");
5514 if (p
[0] == 'x' && p
[1] == 'x')
5515 regs
[i
] = 0; /* 'x' */
5517 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
5523 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
5525 struct packet_reg
*r
= &rsa
->regs
[i
];
5528 if (r
->offset
* 2 >= strlen (rs
->buf
))
5529 /* This shouldn't happen - we adjusted in_g_packet above. */
5530 internal_error (__FILE__
, __LINE__
,
5531 "unexpected end of 'g' packet reply");
5532 else if (rs
->buf
[r
->offset
* 2] == 'x')
5534 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
5535 /* The register isn't available, mark it as such (at
5536 the same time setting the value to zero). */
5537 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
5540 regcache_raw_supply (regcache
, r
->regnum
,
5548 fetch_registers_using_g (struct regcache
*regcache
)
5551 process_g_packet (regcache
);
5555 remote_fetch_registers (struct target_ops
*ops
,
5556 struct regcache
*regcache
, int regnum
)
5558 struct remote_arch_state
*rsa
= get_remote_arch_state ();
5561 set_general_thread (inferior_ptid
);
5565 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
5566 gdb_assert (reg
!= NULL
);
5568 /* If this register might be in the 'g' packet, try that first -
5569 we are likely to read more than one register. If this is the
5570 first 'g' packet, we might be overly optimistic about its
5571 contents, so fall back to 'p'. */
5572 if (reg
->in_g_packet
)
5574 fetch_registers_using_g (regcache
);
5575 if (reg
->in_g_packet
)
5579 if (fetch_register_using_p (regcache
, reg
))
5582 /* This register is not available. */
5583 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
5588 fetch_registers_using_g (regcache
);
5590 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
5591 if (!rsa
->regs
[i
].in_g_packet
)
5592 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
5594 /* This register is not available. */
5595 regcache_raw_supply (regcache
, i
, NULL
);
5599 /* Prepare to store registers. Since we may send them all (using a
5600 'G' request), we have to read out the ones we don't want to change
5604 remote_prepare_to_store (struct regcache
*regcache
)
5606 struct remote_arch_state
*rsa
= get_remote_arch_state ();
5608 gdb_byte buf
[MAX_REGISTER_SIZE
];
5610 /* Make sure the entire registers array is valid. */
5611 switch (remote_protocol_packets
[PACKET_P
].support
)
5613 case PACKET_DISABLE
:
5614 case PACKET_SUPPORT_UNKNOWN
:
5615 /* Make sure all the necessary registers are cached. */
5616 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
5617 if (rsa
->regs
[i
].in_g_packet
)
5618 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
5625 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
5626 packet was not recognized. */
5629 store_register_using_P (const struct regcache
*regcache
,
5630 struct packet_reg
*reg
)
5632 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
5633 struct remote_state
*rs
= get_remote_state ();
5634 /* Try storing a single register. */
5635 char *buf
= rs
->buf
;
5636 gdb_byte regp
[MAX_REGISTER_SIZE
];
5639 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
5642 if (reg
->pnum
== -1)
5645 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
5646 p
= buf
+ strlen (buf
);
5647 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
5648 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
5650 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5652 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
5657 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
5658 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
);
5659 case PACKET_UNKNOWN
:
5662 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
5666 /* Store register REGNUM, or all registers if REGNUM == -1, from the
5667 contents of the register cache buffer. FIXME: ignores errors. */
5670 store_registers_using_G (const struct regcache
*regcache
)
5672 struct remote_state
*rs
= get_remote_state ();
5673 struct remote_arch_state
*rsa
= get_remote_arch_state ();
5677 /* Extract all the registers in the regcache copying them into a
5681 regs
= alloca (rsa
->sizeof_g_packet
);
5682 memset (regs
, 0, rsa
->sizeof_g_packet
);
5683 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
5685 struct packet_reg
*r
= &rsa
->regs
[i
];
5687 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
5691 /* Command describes registers byte by byte,
5692 each byte encoded as two hex characters. */
5695 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
5697 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
5699 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5700 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
5701 error (_("Could not write registers; remote failure reply '%s'"),
5705 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
5706 of the register cache buffer. FIXME: ignores errors. */
5709 remote_store_registers (struct target_ops
*ops
,
5710 struct regcache
*regcache
, int regnum
)
5712 struct remote_arch_state
*rsa
= get_remote_arch_state ();
5715 set_general_thread (inferior_ptid
);
5719 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
5720 gdb_assert (reg
!= NULL
);
5722 /* Always prefer to store registers using the 'P' packet if
5723 possible; we often change only a small number of registers.
5724 Sometimes we change a larger number; we'd need help from a
5725 higher layer to know to use 'G'. */
5726 if (store_register_using_P (regcache
, reg
))
5729 /* For now, don't complain if we have no way to write the
5730 register. GDB loses track of unavailable registers too
5731 easily. Some day, this may be an error. We don't have
5732 any way to read the register, either... */
5733 if (!reg
->in_g_packet
)
5736 store_registers_using_G (regcache
);
5740 store_registers_using_G (regcache
);
5742 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
5743 if (!rsa
->regs
[i
].in_g_packet
)
5744 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
5745 /* See above for why we do not issue an error here. */
5750 /* Return the number of hex digits in num. */
5753 hexnumlen (ULONGEST num
)
5757 for (i
= 0; num
!= 0; i
++)
5763 /* Set BUF to the minimum number of hex digits representing NUM. */
5766 hexnumstr (char *buf
, ULONGEST num
)
5768 int len
= hexnumlen (num
);
5769 return hexnumnstr (buf
, num
, len
);
5773 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
5776 hexnumnstr (char *buf
, ULONGEST num
, int width
)
5782 for (i
= width
- 1; i
>= 0; i
--)
5784 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
5791 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
5794 remote_address_masked (CORE_ADDR addr
)
5796 int address_size
= remote_address_size
;
5797 /* If "remoteaddresssize" was not set, default to target address size. */
5799 address_size
= gdbarch_addr_bit (target_gdbarch
);
5801 if (address_size
> 0
5802 && address_size
< (sizeof (ULONGEST
) * 8))
5804 /* Only create a mask when that mask can safely be constructed
5805 in a ULONGEST variable. */
5807 mask
= (mask
<< address_size
) - 1;
5813 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
5814 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
5815 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
5816 (which may be more than *OUT_LEN due to escape characters). The
5817 total number of bytes in the output buffer will be at most
5821 remote_escape_output (const gdb_byte
*buffer
, int len
,
5822 gdb_byte
*out_buf
, int *out_len
,
5825 int input_index
, output_index
;
5828 for (input_index
= 0; input_index
< len
; input_index
++)
5830 gdb_byte b
= buffer
[input_index
];
5832 if (b
== '$' || b
== '#' || b
== '}')
5834 /* These must be escaped. */
5835 if (output_index
+ 2 > out_maxlen
)
5837 out_buf
[output_index
++] = '}';
5838 out_buf
[output_index
++] = b
^ 0x20;
5842 if (output_index
+ 1 > out_maxlen
)
5844 out_buf
[output_index
++] = b
;
5848 *out_len
= input_index
;
5849 return output_index
;
5852 /* Convert BUFFER, escaped data LEN bytes long, into binary data
5853 in OUT_BUF. Return the number of bytes written to OUT_BUF.
5854 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
5856 This function reverses remote_escape_output. It allows more
5857 escaped characters than that function does, in particular because
5858 '*' must be escaped to avoid the run-length encoding processing
5859 in reading packets. */
5862 remote_unescape_input (const gdb_byte
*buffer
, int len
,
5863 gdb_byte
*out_buf
, int out_maxlen
)
5865 int input_index
, output_index
;
5870 for (input_index
= 0; input_index
< len
; input_index
++)
5872 gdb_byte b
= buffer
[input_index
];
5874 if (output_index
+ 1 > out_maxlen
)
5876 warning (_("Received too much data from remote target;"
5877 " ignoring overflow."));
5878 return output_index
;
5883 out_buf
[output_index
++] = b
^ 0x20;
5889 out_buf
[output_index
++] = b
;
5893 error (_("Unmatched escape character in target response."));
5895 return output_index
;
5898 /* Determine whether the remote target supports binary downloading.
5899 This is accomplished by sending a no-op memory write of zero length
5900 to the target at the specified address. It does not suffice to send
5901 the whole packet, since many stubs strip the eighth bit and
5902 subsequently compute a wrong checksum, which causes real havoc with
5905 NOTE: This can still lose if the serial line is not eight-bit
5906 clean. In cases like this, the user should clear "remote
5910 check_binary_download (CORE_ADDR addr
)
5912 struct remote_state
*rs
= get_remote_state ();
5914 switch (remote_protocol_packets
[PACKET_X
].support
)
5916 case PACKET_DISABLE
:
5920 case PACKET_SUPPORT_UNKNOWN
:
5926 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5928 p
+= hexnumstr (p
, (ULONGEST
) 0);
5932 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
5933 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5935 if (rs
->buf
[0] == '\0')
5938 fprintf_unfiltered (gdb_stdlog
,
5939 "binary downloading NOT suppported by target\n");
5940 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
5945 fprintf_unfiltered (gdb_stdlog
,
5946 "binary downloading suppported by target\n");
5947 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
5954 /* Write memory data directly to the remote machine.
5955 This does not inform the data cache; the data cache uses this.
5956 HEADER is the starting part of the packet.
5957 MEMADDR is the address in the remote memory space.
5958 MYADDR is the address of the buffer in our space.
5959 LEN is the number of bytes.
5960 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
5961 should send data as binary ('X'), or hex-encoded ('M').
5963 The function creates packet of the form
5964 <HEADER><ADDRESS>,<LENGTH>:<DATA>
5966 where encoding of <DATA> is termined by PACKET_FORMAT.
5968 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
5971 Returns the number of bytes transferred, or 0 (setting errno) for
5972 error. Only transfer a single packet. */
5975 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
5976 const gdb_byte
*myaddr
, int len
,
5977 char packet_format
, int use_length
)
5979 struct remote_state
*rs
= get_remote_state ();
5989 if (packet_format
!= 'X' && packet_format
!= 'M')
5990 internal_error (__FILE__
, __LINE__
,
5991 "remote_write_bytes_aux: bad packet format");
5996 payload_size
= get_memory_write_packet_size ();
5998 /* The packet buffer will be large enough for the payload;
5999 get_memory_packet_size ensures this. */
6002 /* Compute the size of the actual payload by subtracting out the
6003 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
6005 payload_size
-= strlen ("$,:#NN");
6007 /* The comma won't be used. */
6009 header_length
= strlen (header
);
6010 payload_size
-= header_length
;
6011 payload_size
-= hexnumlen (memaddr
);
6013 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
6015 strcat (rs
->buf
, header
);
6016 p
= rs
->buf
+ strlen (header
);
6018 /* Compute a best guess of the number of bytes actually transfered. */
6019 if (packet_format
== 'X')
6021 /* Best guess at number of bytes that will fit. */
6022 todo
= min (len
, payload_size
);
6024 payload_size
-= hexnumlen (todo
);
6025 todo
= min (todo
, payload_size
);
6029 /* Num bytes that will fit. */
6030 todo
= min (len
, payload_size
/ 2);
6032 payload_size
-= hexnumlen (todo
);
6033 todo
= min (todo
, payload_size
/ 2);
6037 internal_error (__FILE__
, __LINE__
,
6038 _("minumum packet size too small to write data"));
6040 /* If we already need another packet, then try to align the end
6041 of this packet to a useful boundary. */
6042 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
6043 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
6045 /* Append "<memaddr>". */
6046 memaddr
= remote_address_masked (memaddr
);
6047 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
6054 /* Append <len>. Retain the location/size of <len>. It may need to
6055 be adjusted once the packet body has been created. */
6057 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
6065 /* Append the packet body. */
6066 if (packet_format
== 'X')
6068 /* Binary mode. Send target system values byte by byte, in
6069 increasing byte addresses. Only escape certain critical
6071 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
6074 /* If not all TODO bytes fit, then we'll need another packet. Make
6075 a second try to keep the end of the packet aligned. Don't do
6076 this if the packet is tiny. */
6077 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
6081 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
6083 if (new_nr_bytes
!= nr_bytes
)
6084 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
6089 p
+= payload_length
;
6090 if (use_length
&& nr_bytes
< todo
)
6092 /* Escape chars have filled up the buffer prematurely,
6093 and we have actually sent fewer bytes than planned.
6094 Fix-up the length field of the packet. Use the same
6095 number of characters as before. */
6096 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
6097 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
6102 /* Normal mode: Send target system values byte by byte, in
6103 increasing byte addresses. Each byte is encoded as a two hex
6105 nr_bytes
= bin2hex (myaddr
, p
, todo
);
6109 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
6110 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6112 if (rs
->buf
[0] == 'E')
6114 /* There is no correspondance between what the remote protocol
6115 uses for errors and errno codes. We would like a cleaner way
6116 of representing errors (big enough to include errno codes,
6117 bfd_error codes, and others). But for now just return EIO. */
6122 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
6123 fewer bytes than we'd planned. */
6127 /* Write memory data directly to the remote machine.
6128 This does not inform the data cache; the data cache uses this.
6129 MEMADDR is the address in the remote memory space.
6130 MYADDR is the address of the buffer in our space.
6131 LEN is the number of bytes.
6133 Returns number of bytes transferred, or 0 (setting errno) for
6134 error. Only transfer a single packet. */
6137 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
6139 char *packet_format
= 0;
6141 /* Check whether the target supports binary download. */
6142 check_binary_download (memaddr
);
6144 switch (remote_protocol_packets
[PACKET_X
].support
)
6147 packet_format
= "X";
6149 case PACKET_DISABLE
:
6150 packet_format
= "M";
6152 case PACKET_SUPPORT_UNKNOWN
:
6153 internal_error (__FILE__
, __LINE__
,
6154 _("remote_write_bytes: bad internal state"));
6156 internal_error (__FILE__
, __LINE__
, _("bad switch"));
6159 return remote_write_bytes_aux (packet_format
,
6160 memaddr
, myaddr
, len
, packet_format
[0], 1);
6163 /* Read memory data directly from the remote machine.
6164 This does not use the data cache; the data cache uses this.
6165 MEMADDR is the address in the remote memory space.
6166 MYADDR is the address of the buffer in our space.
6167 LEN is the number of bytes.
6169 Returns number of bytes transferred, or 0 for error. */
6171 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
6172 remote targets) shouldn't attempt to read the entire buffer.
6173 Instead it should read a single packet worth of data and then
6174 return the byte size of that packet to the caller. The caller (its
6175 caller and its callers caller ;-) already contains code for
6176 handling partial reads. */
6179 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
6181 struct remote_state
*rs
= get_remote_state ();
6182 int max_buf_size
; /* Max size of packet output buffer. */
6188 max_buf_size
= get_memory_read_packet_size ();
6189 /* The packet buffer will be large enough for the payload;
6190 get_memory_packet_size ensures this. */
6199 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
6201 /* construct "m"<memaddr>","<len>" */
6202 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
6203 memaddr
= remote_address_masked (memaddr
);
6206 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
6208 p
+= hexnumstr (p
, (ULONGEST
) todo
);
6212 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6214 if (rs
->buf
[0] == 'E'
6215 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
6216 && rs
->buf
[3] == '\0')
6218 /* There is no correspondance between what the remote
6219 protocol uses for errors and errno codes. We would like
6220 a cleaner way of representing errors (big enough to
6221 include errno codes, bfd_error codes, and others). But
6222 for now just return EIO. */
6227 /* Reply describes memory byte by byte,
6228 each byte encoded as two hex characters. */
6231 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
6233 /* Reply is short. This means that we were able to read
6234 only part of what we wanted to. */
6235 return i
+ (origlen
- len
);
6245 /* Remote notification handler. */
6248 handle_notification (char *buf
, size_t length
)
6250 if (strncmp (buf
, "Stop:", 5) == 0)
6252 if (pending_stop_reply
)
6254 /* We've already parsed the in-flight stop-reply, but the
6255 stub for some reason thought we didn't, possibly due to
6256 timeout on its side. Just ignore it. */
6258 fprintf_unfiltered (gdb_stdlog
, "ignoring resent notification\n");
6262 struct cleanup
*old_chain
;
6263 struct stop_reply
*reply
= stop_reply_xmalloc ();
6264 old_chain
= make_cleanup (do_stop_reply_xfree
, reply
);
6266 remote_parse_stop_reply (buf
+ 5, reply
);
6268 discard_cleanups (old_chain
);
6270 /* Be careful to only set it after parsing, since an error
6271 may be thrown then. */
6272 pending_stop_reply
= reply
;
6274 /* Notify the event loop there's a stop reply to acknowledge
6275 and that there may be more events to fetch. */
6276 mark_async_event_handler (remote_async_get_pending_events_token
);
6279 fprintf_unfiltered (gdb_stdlog
, "stop notification captured\n");
6283 /* We ignore notifications we don't recognize, for compatibility
6284 with newer stubs. */
6289 /* Read or write LEN bytes from inferior memory at MEMADDR,
6290 transferring to or from debugger address BUFFER. Write to inferior
6291 if SHOULD_WRITE is nonzero. Returns length of data written or
6292 read; 0 for error. TARGET is unused. */
6295 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
6296 int should_write
, struct mem_attrib
*attrib
,
6297 struct target_ops
*target
)
6301 set_general_thread (inferior_ptid
);
6304 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
6306 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
6311 /* Sends a packet with content determined by the printf format string
6312 FORMAT and the remaining arguments, then gets the reply. Returns
6313 whether the packet was a success, a failure, or unknown. */
6315 static enum packet_result
6316 remote_send_printf (const char *format
, ...)
6318 struct remote_state
*rs
= get_remote_state ();
6319 int max_size
= get_remote_packet_size ();
6322 va_start (ap
, format
);
6325 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
6326 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
6328 if (putpkt (rs
->buf
) < 0)
6329 error (_("Communication problem with target."));
6332 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6334 return packet_check_result (rs
->buf
);
6338 restore_remote_timeout (void *p
)
6340 int value
= *(int *)p
;
6341 remote_timeout
= value
;
6344 /* Flash writing can take quite some time. We'll set
6345 effectively infinite timeout for flash operations.
6346 In future, we'll need to decide on a better approach. */
6347 static const int remote_flash_timeout
= 1000;
6350 remote_flash_erase (struct target_ops
*ops
,
6351 ULONGEST address
, LONGEST length
)
6353 int addr_size
= gdbarch_addr_bit (target_gdbarch
) / 8;
6354 int saved_remote_timeout
= remote_timeout
;
6355 enum packet_result ret
;
6357 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
6358 &saved_remote_timeout
);
6359 remote_timeout
= remote_flash_timeout
;
6361 ret
= remote_send_printf ("vFlashErase:%s,%s",
6362 phex (address
, addr_size
),
6366 case PACKET_UNKNOWN
:
6367 error (_("Remote target does not support flash erase"));
6369 error (_("Error erasing flash with vFlashErase packet"));
6374 do_cleanups (back_to
);
6378 remote_flash_write (struct target_ops
*ops
,
6379 ULONGEST address
, LONGEST length
,
6380 const gdb_byte
*data
)
6382 int saved_remote_timeout
= remote_timeout
;
6384 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
6385 &saved_remote_timeout
);
6387 remote_timeout
= remote_flash_timeout
;
6388 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
6389 do_cleanups (back_to
);
6395 remote_flash_done (struct target_ops
*ops
)
6397 int saved_remote_timeout
= remote_timeout
;
6399 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
6400 &saved_remote_timeout
);
6402 remote_timeout
= remote_flash_timeout
;
6403 ret
= remote_send_printf ("vFlashDone");
6404 do_cleanups (back_to
);
6408 case PACKET_UNKNOWN
:
6409 error (_("Remote target does not support vFlashDone"));
6411 error (_("Error finishing flash operation"));
6418 remote_files_info (struct target_ops
*ignore
)
6420 puts_filtered ("Debugging a target over a serial line.\n");
6423 /* Stuff for dealing with the packets which are part of this protocol.
6424 See comment at top of file for details. */
6426 /* Read a single character from the remote end. */
6429 readchar (int timeout
)
6433 ch
= serial_readchar (remote_desc
, timeout
);
6438 switch ((enum serial_rc
) ch
)
6442 error (_("Remote connection closed"));
6445 perror_with_name (_("Remote communication error"));
6447 case SERIAL_TIMEOUT
:
6453 /* Send the command in *BUF to the remote machine, and read the reply
6454 into *BUF. Report an error if we get an error reply. Resize
6455 *BUF using xrealloc if necessary to hold the result, and update
6459 remote_send (char **buf
,
6463 getpkt (buf
, sizeof_buf
, 0);
6465 if ((*buf
)[0] == 'E')
6466 error (_("Remote failure reply: %s"), *buf
);
6469 /* Return a pointer to an xmalloc'ed string representing an escaped
6470 version of BUF, of len N. E.g. \n is converted to \\n, \t to \\t,
6471 etc. The caller is responsible for releasing the returned
6475 escape_buffer (const char *buf
, int n
)
6477 struct cleanup
*old_chain
;
6478 struct ui_file
*stb
;
6481 stb
= mem_fileopen ();
6482 old_chain
= make_cleanup_ui_file_delete (stb
);
6484 fputstrn_unfiltered (buf
, n
, 0, stb
);
6485 str
= ui_file_xstrdup (stb
, NULL
);
6486 do_cleanups (old_chain
);
6490 /* Display a null-terminated packet on stdout, for debugging, using C
6494 print_packet (char *buf
)
6496 puts_filtered ("\"");
6497 fputstr_filtered (buf
, '"', gdb_stdout
);
6498 puts_filtered ("\"");
6504 return putpkt_binary (buf
, strlen (buf
));
6507 /* Send a packet to the remote machine, with error checking. The data
6508 of the packet is in BUF. The string in BUF can be at most
6509 get_remote_packet_size () - 5 to account for the $, # and checksum,
6510 and for a possible /0 if we are debugging (remote_debug) and want
6511 to print the sent packet as a string. */
6514 putpkt_binary (char *buf
, int cnt
)
6516 struct remote_state
*rs
= get_remote_state ();
6518 unsigned char csum
= 0;
6519 char *buf2
= alloca (cnt
+ 6);
6525 /* Catch cases like trying to read memory or listing threads while
6526 we're waiting for a stop reply. The remote server wouldn't be
6527 ready to handle this request, so we'd hang and timeout. We don't
6528 have to worry about this in synchronous mode, because in that
6529 case it's not possible to issue a command while the target is
6530 running. This is not a problem in non-stop mode, because in that
6531 case, the stub is always ready to process serial input. */
6532 if (!non_stop
&& target_can_async_p () && rs
->waiting_for_stop_reply
)
6533 error (_("Cannot execute this command while the target is running."));
6535 /* We're sending out a new packet. Make sure we don't look at a
6536 stale cached response. */
6537 rs
->cached_wait_status
= 0;
6539 /* Copy the packet into buffer BUF2, encapsulating it
6540 and giving it a checksum. */
6545 for (i
= 0; i
< cnt
; i
++)
6551 *p
++ = tohex ((csum
>> 4) & 0xf);
6552 *p
++ = tohex (csum
& 0xf);
6554 /* Send it over and over until we get a positive ack. */
6558 int started_error_output
= 0;
6562 struct cleanup
*old_chain
;
6566 str
= escape_buffer (buf2
, p
- buf2
);
6567 old_chain
= make_cleanup (xfree
, str
);
6568 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s...", str
);
6569 gdb_flush (gdb_stdlog
);
6570 do_cleanups (old_chain
);
6572 if (serial_write (remote_desc
, buf2
, p
- buf2
))
6573 perror_with_name (_("putpkt: write failed"));
6575 /* If this is a no acks version of the remote protocol, send the
6576 packet and move on. */
6580 /* Read until either a timeout occurs (-2) or '+' is read.
6581 Handle any notification that arrives in the mean time. */
6584 ch
= readchar (remote_timeout
);
6592 case SERIAL_TIMEOUT
:
6595 if (started_error_output
)
6597 putchar_unfiltered ('\n');
6598 started_error_output
= 0;
6607 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
6611 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
6612 case SERIAL_TIMEOUT
:
6616 break; /* Retransmit buffer. */
6620 fprintf_unfiltered (gdb_stdlog
,
6621 "Packet instead of Ack, ignoring it\n");
6622 /* It's probably an old response sent because an ACK
6623 was lost. Gobble up the packet and ack it so it
6624 doesn't get retransmitted when we resend this
6627 serial_write (remote_desc
, "+", 1);
6628 continue; /* Now, go look for +. */
6635 /* If we got a notification, handle it, and go back to looking
6637 /* We've found the start of a notification. Now
6638 collect the data. */
6639 val
= read_frame (&rs
->buf
, &rs
->buf_size
);
6644 struct cleanup
*old_chain
;
6647 str
= escape_buffer (rs
->buf
, val
);
6648 old_chain
= make_cleanup (xfree
, str
);
6649 fprintf_unfiltered (gdb_stdlog
,
6650 " Notification received: %s\n",
6652 do_cleanups (old_chain
);
6654 handle_notification (rs
->buf
, val
);
6655 /* We're in sync now, rewait for the ack. */
6662 if (!started_error_output
)
6664 started_error_output
= 1;
6665 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
6667 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
6668 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
);
6677 if (!started_error_output
)
6679 started_error_output
= 1;
6680 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
6682 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
6686 break; /* Here to retransmit. */
6690 /* This is wrong. If doing a long backtrace, the user should be
6691 able to get out next time we call QUIT, without anything as
6692 violent as interrupt_query. If we want to provide a way out of
6693 here without getting to the next QUIT, it should be based on
6694 hitting ^C twice as in remote_wait. */
6705 /* Come here after finding the start of a frame when we expected an
6706 ack. Do our best to discard the rest of this packet. */
6715 c
= readchar (remote_timeout
);
6718 case SERIAL_TIMEOUT
:
6719 /* Nothing we can do. */
6722 /* Discard the two bytes of checksum and stop. */
6723 c
= readchar (remote_timeout
);
6725 c
= readchar (remote_timeout
);
6728 case '*': /* Run length encoding. */
6729 /* Discard the repeat count. */
6730 c
= readchar (remote_timeout
);
6735 /* A regular character. */
6741 /* Come here after finding the start of the frame. Collect the rest
6742 into *BUF, verifying the checksum, length, and handling run-length
6743 compression. NUL terminate the buffer. If there is not enough room,
6744 expand *BUF using xrealloc.
6746 Returns -1 on error, number of characters in buffer (ignoring the
6747 trailing NULL) on success. (could be extended to return one of the
6748 SERIAL status indications). */
6751 read_frame (char **buf_p
,
6758 struct remote_state
*rs
= get_remote_state ();
6765 c
= readchar (remote_timeout
);
6768 case SERIAL_TIMEOUT
:
6770 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
6774 fputs_filtered ("Saw new packet start in middle of old one\n",
6776 return -1; /* Start a new packet, count retries. */
6779 unsigned char pktcsum
;
6785 check_0
= readchar (remote_timeout
);
6787 check_1
= readchar (remote_timeout
);
6789 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
6792 fputs_filtered ("Timeout in checksum, retrying\n",
6796 else if (check_0
< 0 || check_1
< 0)
6799 fputs_filtered ("Communication error in checksum\n",
6804 /* Don't recompute the checksum; with no ack packets we
6805 don't have any way to indicate a packet retransmission
6810 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
6811 if (csum
== pktcsum
)
6816 struct cleanup
*old_chain
;
6819 str
= escape_buffer (buf
, bc
);
6820 old_chain
= make_cleanup (xfree
, str
);
6821 fprintf_unfiltered (gdb_stdlog
,
6823 Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
6824 pktcsum
, csum
, str
);
6825 do_cleanups (old_chain
);
6827 /* Number of characters in buffer ignoring trailing
6831 case '*': /* Run length encoding. */
6836 c
= readchar (remote_timeout
);
6838 repeat
= c
- ' ' + 3; /* Compute repeat count. */
6840 /* The character before ``*'' is repeated. */
6842 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
6844 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
6846 /* Make some more room in the buffer. */
6847 *sizeof_buf
+= repeat
;
6848 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
6852 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
6858 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
6862 if (bc
>= *sizeof_buf
- 1)
6864 /* Make some more room in the buffer. */
6866 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
6877 /* Read a packet from the remote machine, with error checking, and
6878 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
6879 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
6880 rather than timing out; this is used (in synchronous mode) to wait
6881 for a target that is is executing user code to stop. */
6882 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
6883 don't have to change all the calls to getpkt to deal with the
6884 return value, because at the moment I don't know what the right
6885 thing to do it for those. */
6893 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
6897 /* Read a packet from the remote machine, with error checking, and
6898 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
6899 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
6900 rather than timing out; this is used (in synchronous mode) to wait
6901 for a target that is is executing user code to stop. If FOREVER ==
6902 0, this function is allowed to time out gracefully and return an
6903 indication of this to the caller. Otherwise return the number of
6904 bytes read. If EXPECTING_NOTIF, consider receiving a notification
6905 enough reason to return to the caller. */
6908 getpkt_or_notif_sane_1 (char **buf
, long *sizeof_buf
, int forever
,
6909 int expecting_notif
)
6911 struct remote_state
*rs
= get_remote_state ();
6917 /* We're reading a new response. Make sure we don't look at a
6918 previously cached response. */
6919 rs
->cached_wait_status
= 0;
6921 strcpy (*buf
, "timeout");
6924 timeout
= watchdog
> 0 ? watchdog
: -1;
6925 else if (expecting_notif
)
6926 timeout
= 0; /* There should already be a char in the buffer. If
6929 timeout
= remote_timeout
;
6933 /* Process any number of notifications, and then return when
6937 /* If we get a timeout or bad checksm, retry up to MAX_TRIES
6939 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
6941 /* This can loop forever if the remote side sends us
6942 characters continuously, but if it pauses, we'll get
6943 SERIAL_TIMEOUT from readchar because of timeout. Then
6944 we'll count that as a retry.
6946 Note that even when forever is set, we will only wait
6947 forever prior to the start of a packet. After that, we
6948 expect characters to arrive at a brisk pace. They should
6949 show up within remote_timeout intervals. */
6951 c
= readchar (timeout
);
6952 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
6954 if (c
== SERIAL_TIMEOUT
)
6956 if (expecting_notif
)
6957 return -1; /* Don't complain, it's normal to not get
6958 anything in this case. */
6960 if (forever
) /* Watchdog went off? Kill the target. */
6964 error (_("Watchdog timeout has expired. Target detached."));
6967 fputs_filtered ("Timed out.\n", gdb_stdlog
);
6971 /* We've found the start of a packet or notification.
6972 Now collect the data. */
6973 val
= read_frame (buf
, sizeof_buf
);
6978 serial_write (remote_desc
, "-", 1);
6981 if (tries
> MAX_TRIES
)
6983 /* We have tried hard enough, and just can't receive the
6984 packet/notification. Give up. */
6985 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
6987 /* Skip the ack char if we're in no-ack mode. */
6988 if (!rs
->noack_mode
)
6989 serial_write (remote_desc
, "+", 1);
6993 /* If we got an ordinary packet, return that to our caller. */
6998 struct cleanup
*old_chain
;
7001 str
= escape_buffer (*buf
, val
);
7002 old_chain
= make_cleanup (xfree
, str
);
7003 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s\n", str
);
7004 do_cleanups (old_chain
);
7007 /* Skip the ack char if we're in no-ack mode. */
7008 if (!rs
->noack_mode
)
7009 serial_write (remote_desc
, "+", 1);
7013 /* If we got a notification, handle it, and go back to looking
7017 gdb_assert (c
== '%');
7021 struct cleanup
*old_chain
;
7024 str
= escape_buffer (*buf
, val
);
7025 old_chain
= make_cleanup (xfree
, str
);
7026 fprintf_unfiltered (gdb_stdlog
,
7027 " Notification received: %s\n",
7029 do_cleanups (old_chain
);
7032 handle_notification (*buf
, val
);
7034 /* Notifications require no acknowledgement. */
7036 if (expecting_notif
)
7043 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
7045 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 0);
7049 getpkt_or_notif_sane (char **buf
, long *sizeof_buf
, int forever
)
7051 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 1);
7056 remote_kill (struct target_ops
*ops
)
7058 /* Use catch_errors so the user can quit from gdb even when we
7059 aren't on speaking terms with the remote system. */
7060 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
7062 /* Don't wait for it to die. I'm not really sure it matters whether
7063 we do or not. For the existing stubs, kill is a noop. */
7064 target_mourn_inferior ();
7068 remote_vkill (int pid
, struct remote_state
*rs
)
7070 if (remote_protocol_packets
[PACKET_vKill
].support
== PACKET_DISABLE
)
7073 /* Tell the remote target to detach. */
7074 sprintf (rs
->buf
, "vKill;%x", pid
);
7076 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7078 if (packet_ok (rs
->buf
,
7079 &remote_protocol_packets
[PACKET_vKill
]) == PACKET_OK
)
7081 else if (remote_protocol_packets
[PACKET_vKill
].support
== PACKET_DISABLE
)
7088 extended_remote_kill (struct target_ops
*ops
)
7091 int pid
= ptid_get_pid (inferior_ptid
);
7092 struct remote_state
*rs
= get_remote_state ();
7094 res
= remote_vkill (pid
, rs
);
7095 if (res
== -1 && !remote_multi_process_p (rs
))
7097 /* Don't try 'k' on a multi-process aware stub -- it has no way
7098 to specify the pid. */
7102 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7103 if (rs
->buf
[0] != 'O' || rs
->buf
[0] != 'K')
7106 /* Don't wait for it to die. I'm not really sure it matters whether
7107 we do or not. For the existing stubs, kill is a noop. */
7113 error (_("Can't kill process"));
7115 target_mourn_inferior ();
7119 remote_mourn (struct target_ops
*ops
)
7121 remote_mourn_1 (ops
);
7124 /* Worker function for remote_mourn. */
7126 remote_mourn_1 (struct target_ops
*target
)
7128 unpush_target (target
);
7130 /* remote_close takes care of doing most of the clean up. */
7131 generic_mourn_inferior ();
7135 extended_remote_mourn_1 (struct target_ops
*target
)
7137 struct remote_state
*rs
= get_remote_state ();
7139 /* In case we got here due to an error, but we're going to stay
7141 rs
->waiting_for_stop_reply
= 0;
7143 /* We're no longer interested in these events. */
7144 discard_pending_stop_replies (ptid_get_pid (inferior_ptid
));
7146 /* If the current general thread belonged to the process we just
7147 detached from or has exited, the remote side current general
7148 thread becomes undefined. Considering a case like this:
7150 - We just got here due to a detach.
7151 - The process that we're detaching from happens to immediately
7152 report a global breakpoint being hit in non-stop mode, in the
7153 same thread we had selected before.
7154 - GDB attaches to this process again.
7155 - This event happens to be the next event we handle.
7157 GDB would consider that the current general thread didn't need to
7158 be set on the stub side (with Hg), since for all it knew,
7159 GENERAL_THREAD hadn't changed.
7161 Notice that although in all-stop mode, the remote server always
7162 sets the current thread to the thread reporting the stop event,
7163 that doesn't happen in non-stop mode; in non-stop, the stub *must
7164 not* change the current thread when reporting a breakpoint hit,
7165 due to the decoupling of event reporting and event handling.
7167 To keep things simple, we always invalidate our notion of the
7169 record_currthread (minus_one_ptid
);
7171 /* Unlike "target remote", we do not want to unpush the target; then
7172 the next time the user says "run", we won't be connected. */
7174 /* Call common code to mark the inferior as not running. */
7175 generic_mourn_inferior ();
7177 if (!have_inferiors ())
7179 if (!remote_multi_process_p (rs
))
7181 /* Check whether the target is running now - some remote stubs
7182 automatically restart after kill. */
7184 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7186 if (rs
->buf
[0] == 'S' || rs
->buf
[0] == 'T')
7188 /* Assume that the target has been restarted. Set inferior_ptid
7189 so that bits of core GDB realizes there's something here, e.g.,
7190 so that the user can say "kill" again. */
7191 inferior_ptid
= magic_null_ptid
;
7198 extended_remote_mourn (struct target_ops
*ops
)
7200 extended_remote_mourn_1 (ops
);
7204 extended_remote_run (char *args
)
7206 struct remote_state
*rs
= get_remote_state ();
7209 /* If the user has disabled vRun support, or we have detected that
7210 support is not available, do not try it. */
7211 if (remote_protocol_packets
[PACKET_vRun
].support
== PACKET_DISABLE
)
7214 strcpy (rs
->buf
, "vRun;");
7215 len
= strlen (rs
->buf
);
7217 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
7218 error (_("Remote file name too long for run packet"));
7219 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
+ len
, 0);
7221 gdb_assert (args
!= NULL
);
7224 struct cleanup
*back_to
;
7228 argv
= gdb_buildargv (args
);
7229 back_to
= make_cleanup ((void (*) (void *)) freeargv
, argv
);
7230 for (i
= 0; argv
[i
] != NULL
; i
++)
7232 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
7233 error (_("Argument list too long for run packet"));
7234 rs
->buf
[len
++] = ';';
7235 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
+ len
, 0);
7237 do_cleanups (back_to
);
7240 rs
->buf
[len
++] = '\0';
7243 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7245 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]) == PACKET_OK
)
7247 /* We have a wait response; we don't need it, though. All is well. */
7250 else if (remote_protocol_packets
[PACKET_vRun
].support
== PACKET_DISABLE
)
7251 /* It wasn't disabled before, but it is now. */
7255 if (remote_exec_file
[0] == '\0')
7256 error (_("Running the default executable on the remote target failed; "
7257 "try \"set remote exec-file\"?"));
7259 error (_("Running \"%s\" on the remote target failed"),
7264 /* In the extended protocol we want to be able to do things like
7265 "run" and have them basically work as expected. So we need
7266 a special create_inferior function. We support changing the
7267 executable file and the command line arguments, but not the
7271 extended_remote_create_inferior_1 (char *exec_file
, char *args
,
7272 char **env
, int from_tty
)
7274 /* If running asynchronously, register the target file descriptor
7275 with the event loop. */
7276 if (target_can_async_p ())
7277 target_async (inferior_event_handler
, 0);
7279 /* Now restart the remote server. */
7280 if (extended_remote_run (args
) == -1)
7282 /* vRun was not supported. Fail if we need it to do what the
7284 if (remote_exec_file
[0])
7285 error (_("Remote target does not support \"set remote exec-file\""));
7287 error (_("Remote target does not support \"set args\" or run <ARGS>"));
7289 /* Fall back to "R". */
7290 extended_remote_restart ();
7293 if (!have_inferiors ())
7295 /* Clean up from the last time we ran, before we mark the target
7296 running again. This will mark breakpoints uninserted, and
7297 get_offsets may insert breakpoints. */
7298 init_thread_list ();
7299 init_wait_for_inferior ();
7302 /* Now mark the inferior as running before we do anything else. */
7303 inferior_ptid
= magic_null_ptid
;
7305 /* Now, if we have thread information, update inferior_ptid. */
7306 inferior_ptid
= remote_current_thread (inferior_ptid
);
7308 remote_add_inferior (ptid_get_pid (inferior_ptid
), 0);
7309 add_thread_silent (inferior_ptid
);
7311 /* Get updated offsets, if the stub uses qOffsets. */
7316 extended_remote_create_inferior (struct target_ops
*ops
,
7317 char *exec_file
, char *args
,
7318 char **env
, int from_tty
)
7320 extended_remote_create_inferior_1 (exec_file
, args
, env
, from_tty
);
7324 /* Insert a breakpoint. On targets that have software breakpoint
7325 support, we ask the remote target to do the work; on targets
7326 which don't, we insert a traditional memory breakpoint. */
7329 remote_insert_breakpoint (struct gdbarch
*gdbarch
,
7330 struct bp_target_info
*bp_tgt
)
7332 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
7333 If it succeeds, then set the support to PACKET_ENABLE. If it
7334 fails, and the user has explicitly requested the Z support then
7335 report an error, otherwise, mark it disabled and go on. */
7337 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
7339 CORE_ADDR addr
= bp_tgt
->placed_address
;
7340 struct remote_state
*rs
;
7344 gdbarch_remote_breakpoint_from_pc (gdbarch
, &addr
, &bpsize
);
7346 rs
= get_remote_state ();
7352 addr
= (ULONGEST
) remote_address_masked (addr
);
7353 p
+= hexnumstr (p
, addr
);
7354 sprintf (p
, ",%d", bpsize
);
7357 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7359 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
7364 bp_tgt
->placed_address
= addr
;
7365 bp_tgt
->placed_size
= bpsize
;
7367 case PACKET_UNKNOWN
:
7372 return memory_insert_breakpoint (gdbarch
, bp_tgt
);
7376 remote_remove_breakpoint (struct gdbarch
*gdbarch
,
7377 struct bp_target_info
*bp_tgt
)
7379 CORE_ADDR addr
= bp_tgt
->placed_address
;
7380 struct remote_state
*rs
= get_remote_state ();
7382 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
7390 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
7391 p
+= hexnumstr (p
, addr
);
7392 sprintf (p
, ",%d", bp_tgt
->placed_size
);
7395 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7397 return (rs
->buf
[0] == 'E');
7400 return memory_remove_breakpoint (gdbarch
, bp_tgt
);
7404 watchpoint_to_Z_packet (int type
)
7409 return Z_PACKET_WRITE_WP
;
7412 return Z_PACKET_READ_WP
;
7415 return Z_PACKET_ACCESS_WP
;
7418 internal_error (__FILE__
, __LINE__
,
7419 _("hw_bp_to_z: bad watchpoint type %d"), type
);
7424 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
7426 struct remote_state
*rs
= get_remote_state ();
7428 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
7430 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
7433 sprintf (rs
->buf
, "Z%x,", packet
);
7434 p
= strchr (rs
->buf
, '\0');
7435 addr
= remote_address_masked (addr
);
7436 p
+= hexnumstr (p
, (ULONGEST
) addr
);
7437 sprintf (p
, ",%x", len
);
7440 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7442 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
7446 case PACKET_UNKNOWN
:
7451 internal_error (__FILE__
, __LINE__
,
7452 _("remote_insert_watchpoint: reached end of function"));
7457 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
7459 struct remote_state
*rs
= get_remote_state ();
7461 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
7463 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
7466 sprintf (rs
->buf
, "z%x,", packet
);
7467 p
= strchr (rs
->buf
, '\0');
7468 addr
= remote_address_masked (addr
);
7469 p
+= hexnumstr (p
, (ULONGEST
) addr
);
7470 sprintf (p
, ",%x", len
);
7472 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7474 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
7477 case PACKET_UNKNOWN
:
7482 internal_error (__FILE__
, __LINE__
,
7483 _("remote_remove_watchpoint: reached end of function"));
7487 int remote_hw_watchpoint_limit
= -1;
7488 int remote_hw_breakpoint_limit
= -1;
7491 remote_check_watch_resources (int type
, int cnt
, int ot
)
7493 if (type
== bp_hardware_breakpoint
)
7495 if (remote_hw_breakpoint_limit
== 0)
7497 else if (remote_hw_breakpoint_limit
< 0)
7499 else if (cnt
<= remote_hw_breakpoint_limit
)
7504 if (remote_hw_watchpoint_limit
== 0)
7506 else if (remote_hw_watchpoint_limit
< 0)
7510 else if (cnt
<= remote_hw_watchpoint_limit
)
7517 remote_stopped_by_watchpoint (void)
7519 return remote_stopped_by_watchpoint_p
;
7523 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
7526 if (remote_stopped_by_watchpoint ())
7528 *addr_p
= remote_watch_data_address
;
7537 remote_insert_hw_breakpoint (struct gdbarch
*gdbarch
,
7538 struct bp_target_info
*bp_tgt
)
7541 struct remote_state
*rs
;
7544 /* The length field should be set to the size of a breakpoint
7545 instruction, even though we aren't inserting one ourselves. */
7547 gdbarch_remote_breakpoint_from_pc
7548 (gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
7550 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
7553 rs
= get_remote_state ();
7560 addr
= remote_address_masked (bp_tgt
->placed_address
);
7561 p
+= hexnumstr (p
, (ULONGEST
) addr
);
7562 sprintf (p
, ",%x", bp_tgt
->placed_size
);
7565 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7567 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
7570 case PACKET_UNKNOWN
:
7575 internal_error (__FILE__
, __LINE__
,
7576 _("remote_insert_hw_breakpoint: reached end of function"));
7581 remote_remove_hw_breakpoint (struct gdbarch
*gdbarch
,
7582 struct bp_target_info
*bp_tgt
)
7585 struct remote_state
*rs
= get_remote_state ();
7588 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
7595 addr
= remote_address_masked (bp_tgt
->placed_address
);
7596 p
+= hexnumstr (p
, (ULONGEST
) addr
);
7597 sprintf (p
, ",%x", bp_tgt
->placed_size
);
7600 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7602 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
7605 case PACKET_UNKNOWN
:
7610 internal_error (__FILE__
, __LINE__
,
7611 _("remote_remove_hw_breakpoint: reached end of function"));
7614 /* Table used by the crc32 function to calcuate the checksum. */
7616 static unsigned long crc32_table
[256] =
7619 static unsigned long
7620 crc32 (const unsigned char *buf
, int len
, unsigned int crc
)
7622 if (!crc32_table
[1])
7624 /* Initialize the CRC table and the decoding table. */
7628 for (i
= 0; i
< 256; i
++)
7630 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
7631 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
7638 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
7644 /* Verify memory using the "qCRC:" request. */
7647 remote_verify_memory (struct target_ops
*ops
,
7648 const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
7650 struct remote_state
*rs
= get_remote_state ();
7651 unsigned long host_crc
, target_crc
;
7654 /* FIXME: assumes lma can fit into long. */
7655 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
7656 (long) lma
, (long) size
);
7659 /* Be clever; compute the host_crc before waiting for target
7661 host_crc
= crc32 (data
, size
, 0xffffffff);
7663 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7664 if (rs
->buf
[0] == 'E')
7667 if (rs
->buf
[0] != 'C')
7668 error (_("remote target does not support this operation"));
7670 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
7671 target_crc
= target_crc
* 16 + fromhex (*tmp
);
7673 return (host_crc
== target_crc
);
7676 /* compare-sections command
7678 With no arguments, compares each loadable section in the exec bfd
7679 with the same memory range on the target, and reports mismatches.
7680 Useful for verifying the image on the target against the exec file. */
7683 compare_sections_command (char *args
, int from_tty
)
7686 struct cleanup
*old_chain
;
7688 const char *sectname
;
7696 error (_("command cannot be used without an exec file"));
7698 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
7700 if (!(s
->flags
& SEC_LOAD
))
7701 continue; /* skip non-loadable section */
7703 size
= bfd_get_section_size (s
);
7705 continue; /* skip zero-length section */
7707 sectname
= bfd_get_section_name (exec_bfd
, s
);
7708 if (args
&& strcmp (args
, sectname
) != 0)
7709 continue; /* not the section selected by user */
7711 matched
= 1; /* do this section */
7714 sectdata
= xmalloc (size
);
7715 old_chain
= make_cleanup (xfree
, sectdata
);
7716 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
7718 res
= target_verify_memory (sectdata
, lma
, size
);
7721 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
7722 paddress (target_gdbarch
, lma
),
7723 paddress (target_gdbarch
, lma
+ size
));
7725 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
7726 paddress (target_gdbarch
, lma
),
7727 paddress (target_gdbarch
, lma
+ size
));
7729 printf_filtered ("matched.\n");
7732 printf_filtered ("MIS-MATCHED!\n");
7736 do_cleanups (old_chain
);
7739 warning (_("One or more sections of the remote executable does not match\n\
7740 the loaded file\n"));
7741 if (args
&& !matched
)
7742 printf_filtered (_("No loaded section named '%s'.\n"), args
);
7745 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
7746 into remote target. The number of bytes written to the remote
7747 target is returned, or -1 for error. */
7750 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
7751 const char *annex
, const gdb_byte
*writebuf
,
7752 ULONGEST offset
, LONGEST len
,
7753 struct packet_config
*packet
)
7757 struct remote_state
*rs
= get_remote_state ();
7758 int max_size
= get_memory_write_packet_size ();
7760 if (packet
->support
== PACKET_DISABLE
)
7763 /* Insert header. */
7764 i
= snprintf (rs
->buf
, max_size
,
7765 "qXfer:%s:write:%s:%s:",
7766 object_name
, annex
? annex
: "",
7767 phex_nz (offset
, sizeof offset
));
7768 max_size
-= (i
+ 1);
7770 /* Escape as much data as fits into rs->buf. */
7771 buf_len
= remote_escape_output
7772 (writebuf
, len
, (rs
->buf
+ i
), &max_size
, max_size
);
7774 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
7775 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
7776 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
7779 unpack_varlen_hex (rs
->buf
, &n
);
7783 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
7784 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
7785 number of bytes read is returned, or 0 for EOF, or -1 for error.
7786 The number of bytes read may be less than LEN without indicating an
7787 EOF. PACKET is checked and updated to indicate whether the remote
7788 target supports this object. */
7791 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
7793 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
7794 struct packet_config
*packet
)
7796 static char *finished_object
;
7797 static char *finished_annex
;
7798 static ULONGEST finished_offset
;
7800 struct remote_state
*rs
= get_remote_state ();
7801 LONGEST i
, n
, packet_len
;
7803 if (packet
->support
== PACKET_DISABLE
)
7806 /* Check whether we've cached an end-of-object packet that matches
7808 if (finished_object
)
7810 if (strcmp (object_name
, finished_object
) == 0
7811 && strcmp (annex
? annex
: "", finished_annex
) == 0
7812 && offset
== finished_offset
)
7815 /* Otherwise, we're now reading something different. Discard
7817 xfree (finished_object
);
7818 xfree (finished_annex
);
7819 finished_object
= NULL
;
7820 finished_annex
= NULL
;
7823 /* Request only enough to fit in a single packet. The actual data
7824 may not, since we don't know how much of it will need to be escaped;
7825 the target is free to respond with slightly less data. We subtract
7826 five to account for the response type and the protocol frame. */
7827 n
= min (get_remote_packet_size () - 5, len
);
7828 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
7829 object_name
, annex
? annex
: "",
7830 phex_nz (offset
, sizeof offset
),
7831 phex_nz (n
, sizeof n
));
7832 i
= putpkt (rs
->buf
);
7837 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
7838 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
7841 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
7842 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
7844 /* 'm' means there is (or at least might be) more data after this
7845 batch. That does not make sense unless there's at least one byte
7846 of data in this reply. */
7847 if (rs
->buf
[0] == 'm' && packet_len
== 1)
7848 error (_("Remote qXfer reply contained no data."));
7850 /* Got some data. */
7851 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
7853 /* 'l' is an EOF marker, possibly including a final block of data,
7854 or possibly empty. If we have the final block of a non-empty
7855 object, record this fact to bypass a subsequent partial read. */
7856 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
7858 finished_object
= xstrdup (object_name
);
7859 finished_annex
= xstrdup (annex
? annex
: "");
7860 finished_offset
= offset
+ i
;
7867 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
7868 const char *annex
, gdb_byte
*readbuf
,
7869 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
7871 struct remote_state
*rs
;
7876 set_general_thread (inferior_ptid
);
7878 rs
= get_remote_state ();
7880 /* Handle memory using the standard memory routines. */
7881 if (object
== TARGET_OBJECT_MEMORY
)
7886 /* If the remote target is connected but not running, we should
7887 pass this request down to a lower stratum (e.g. the executable
7889 if (!target_has_execution
)
7892 if (writebuf
!= NULL
)
7893 xfered
= remote_write_bytes (offset
, writebuf
, len
);
7895 xfered
= remote_read_bytes (offset
, readbuf
, len
);
7899 else if (xfered
== 0 && errno
== 0)
7905 /* Handle SPU memory using qxfer packets. */
7906 if (object
== TARGET_OBJECT_SPU
)
7909 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
7910 &remote_protocol_packets
7911 [PACKET_qXfer_spu_read
]);
7913 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
7914 &remote_protocol_packets
7915 [PACKET_qXfer_spu_write
]);
7918 /* Handle extra signal info using qxfer packets. */
7919 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
7922 return remote_read_qxfer (ops
, "siginfo", annex
, readbuf
, offset
, len
,
7923 &remote_protocol_packets
7924 [PACKET_qXfer_siginfo_read
]);
7926 return remote_write_qxfer (ops
, "siginfo", annex
, writebuf
, offset
, len
,
7927 &remote_protocol_packets
7928 [PACKET_qXfer_siginfo_write
]);
7931 /* Only handle flash writes. */
7932 if (writebuf
!= NULL
)
7938 case TARGET_OBJECT_FLASH
:
7939 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
7943 else if (xfered
== 0 && errno
== 0)
7953 /* Map pre-existing objects onto letters. DO NOT do this for new
7954 objects!!! Instead specify new query packets. */
7957 case TARGET_OBJECT_AVR
:
7961 case TARGET_OBJECT_AUXV
:
7962 gdb_assert (annex
== NULL
);
7963 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
7964 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
7966 case TARGET_OBJECT_AVAILABLE_FEATURES
:
7967 return remote_read_qxfer
7968 (ops
, "features", annex
, readbuf
, offset
, len
,
7969 &remote_protocol_packets
[PACKET_qXfer_features
]);
7971 case TARGET_OBJECT_LIBRARIES
:
7972 return remote_read_qxfer
7973 (ops
, "libraries", annex
, readbuf
, offset
, len
,
7974 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
7976 case TARGET_OBJECT_MEMORY_MAP
:
7977 gdb_assert (annex
== NULL
);
7978 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
7979 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
7981 case TARGET_OBJECT_OSDATA
:
7982 /* Should only get here if we're connected. */
7983 gdb_assert (remote_desc
);
7984 return remote_read_qxfer
7985 (ops
, "osdata", annex
, readbuf
, offset
, len
,
7986 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
7988 case TARGET_OBJECT_THREADS
:
7989 gdb_assert (annex
== NULL
);
7990 return remote_read_qxfer (ops
, "threads", annex
, readbuf
, offset
, len
,
7991 &remote_protocol_packets
[PACKET_qXfer_threads
]);
7997 /* Note: a zero OFFSET and LEN can be used to query the minimum
7999 if (offset
== 0 && len
== 0)
8000 return (get_remote_packet_size ());
8001 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
8002 large enough let the caller deal with it. */
8003 if (len
< get_remote_packet_size ())
8005 len
= get_remote_packet_size ();
8007 /* Except for querying the minimum buffer size, target must be open. */
8009 error (_("remote query is only available after target open"));
8011 gdb_assert (annex
!= NULL
);
8012 gdb_assert (readbuf
!= NULL
);
8018 /* We used one buffer char for the remote protocol q command and
8019 another for the query type. As the remote protocol encapsulation
8020 uses 4 chars plus one extra in case we are debugging
8021 (remote_debug), we have PBUFZIZ - 7 left to pack the query
8024 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
8026 /* Bad caller may have sent forbidden characters. */
8027 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
8032 gdb_assert (annex
[i
] == '\0');
8034 i
= putpkt (rs
->buf
);
8038 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8039 strcpy ((char *) readbuf
, rs
->buf
);
8041 return strlen ((char *) readbuf
);
8045 remote_search_memory (struct target_ops
* ops
,
8046 CORE_ADDR start_addr
, ULONGEST search_space_len
,
8047 const gdb_byte
*pattern
, ULONGEST pattern_len
,
8048 CORE_ADDR
*found_addrp
)
8050 int addr_size
= gdbarch_addr_bit (target_gdbarch
) / 8;
8051 struct remote_state
*rs
= get_remote_state ();
8052 int max_size
= get_memory_write_packet_size ();
8053 struct packet_config
*packet
=
8054 &remote_protocol_packets
[PACKET_qSearch_memory
];
8055 /* number of packet bytes used to encode the pattern,
8056 this could be more than PATTERN_LEN due to escape characters */
8057 int escaped_pattern_len
;
8058 /* amount of pattern that was encodable in the packet */
8059 int used_pattern_len
;
8062 ULONGEST found_addr
;
8064 /* Don't go to the target if we don't have to.
8065 This is done before checking packet->support to avoid the possibility that
8066 a success for this edge case means the facility works in general. */
8067 if (pattern_len
> search_space_len
)
8069 if (pattern_len
== 0)
8071 *found_addrp
= start_addr
;
8075 /* If we already know the packet isn't supported, fall back to the simple
8076 way of searching memory. */
8078 if (packet
->support
== PACKET_DISABLE
)
8080 /* Target doesn't provided special support, fall back and use the
8081 standard support (copy memory and do the search here). */
8082 return simple_search_memory (ops
, start_addr
, search_space_len
,
8083 pattern
, pattern_len
, found_addrp
);
8086 /* Insert header. */
8087 i
= snprintf (rs
->buf
, max_size
,
8088 "qSearch:memory:%s;%s;",
8089 phex_nz (start_addr
, addr_size
),
8090 phex_nz (search_space_len
, sizeof (search_space_len
)));
8091 max_size
-= (i
+ 1);
8093 /* Escape as much data as fits into rs->buf. */
8094 escaped_pattern_len
=
8095 remote_escape_output (pattern
, pattern_len
, (rs
->buf
+ i
),
8096 &used_pattern_len
, max_size
);
8098 /* Bail if the pattern is too large. */
8099 if (used_pattern_len
!= pattern_len
)
8100 error ("Pattern is too large to transmit to remote target.");
8102 if (putpkt_binary (rs
->buf
, i
+ escaped_pattern_len
) < 0
8103 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
8104 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
8106 /* The request may not have worked because the command is not
8107 supported. If so, fall back to the simple way. */
8108 if (packet
->support
== PACKET_DISABLE
)
8110 return simple_search_memory (ops
, start_addr
, search_space_len
,
8111 pattern
, pattern_len
, found_addrp
);
8116 if (rs
->buf
[0] == '0')
8118 else if (rs
->buf
[0] == '1')
8121 if (rs
->buf
[1] != ',')
8122 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
8123 unpack_varlen_hex (rs
->buf
+ 2, &found_addr
);
8124 *found_addrp
= found_addr
;
8127 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
8133 remote_rcmd (char *command
,
8134 struct ui_file
*outbuf
)
8136 struct remote_state
*rs
= get_remote_state ();
8140 error (_("remote rcmd is only available after target open"));
8142 /* Send a NULL command across as an empty command. */
8143 if (command
== NULL
)
8146 /* The query prefix. */
8147 strcpy (rs
->buf
, "qRcmd,");
8148 p
= strchr (rs
->buf
, '\0');
8150 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
8151 error (_("\"monitor\" command ``%s'' is too long."), command
);
8153 /* Encode the actual command. */
8154 bin2hex ((gdb_byte
*) command
, p
, 0);
8156 if (putpkt (rs
->buf
) < 0)
8157 error (_("Communication problem with target."));
8159 /* get/display the response */
8164 /* XXX - see also remote_get_noisy_reply(). */
8166 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8169 error (_("Target does not support this command."));
8170 if (buf
[0] == 'O' && buf
[1] != 'K')
8172 remote_console_output (buf
+ 1); /* 'O' message from stub. */
8175 if (strcmp (buf
, "OK") == 0)
8177 if (strlen (buf
) == 3 && buf
[0] == 'E'
8178 && isdigit (buf
[1]) && isdigit (buf
[2]))
8180 error (_("Protocol error with Rcmd"));
8182 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
8184 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
8185 fputc_unfiltered (c
, outbuf
);
8191 static VEC(mem_region_s
) *
8192 remote_memory_map (struct target_ops
*ops
)
8194 VEC(mem_region_s
) *result
= NULL
;
8195 char *text
= target_read_stralloc (¤t_target
,
8196 TARGET_OBJECT_MEMORY_MAP
, NULL
);
8200 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
8201 result
= parse_memory_map (text
);
8202 do_cleanups (back_to
);
8209 packet_command (char *args
, int from_tty
)
8211 struct remote_state
*rs
= get_remote_state ();
8214 error (_("command can only be used with remote target"));
8217 error (_("remote-packet command requires packet text as argument"));
8219 puts_filtered ("sending: ");
8220 print_packet (args
);
8221 puts_filtered ("\n");
8224 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8225 puts_filtered ("received: ");
8226 print_packet (rs
->buf
);
8227 puts_filtered ("\n");
8231 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
8233 static void display_thread_info (struct gdb_ext_thread_info
*info
);
8235 static void threadset_test_cmd (char *cmd
, int tty
);
8237 static void threadalive_test (char *cmd
, int tty
);
8239 static void threadlist_test_cmd (char *cmd
, int tty
);
8241 int get_and_display_threadinfo (threadref
*ref
);
8243 static void threadinfo_test_cmd (char *cmd
, int tty
);
8245 static int thread_display_step (threadref
*ref
, void *context
);
8247 static void threadlist_update_test_cmd (char *cmd
, int tty
);
8249 static void init_remote_threadtests (void);
8251 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
8254 threadset_test_cmd (char *cmd
, int tty
)
8256 int sample_thread
= SAMPLE_THREAD
;
8258 printf_filtered (_("Remote threadset test\n"));
8259 set_general_thread (sample_thread
);
8264 threadalive_test (char *cmd
, int tty
)
8266 int sample_thread
= SAMPLE_THREAD
;
8267 int pid
= ptid_get_pid (inferior_ptid
);
8268 ptid_t ptid
= ptid_build (pid
, 0, sample_thread
);
8270 if (remote_thread_alive (ptid
))
8271 printf_filtered ("PASS: Thread alive test\n");
8273 printf_filtered ("FAIL: Thread alive test\n");
8276 void output_threadid (char *title
, threadref
*ref
);
8279 output_threadid (char *title
, threadref
*ref
)
8283 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
8285 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
8289 threadlist_test_cmd (char *cmd
, int tty
)
8292 threadref nextthread
;
8293 int done
, result_count
;
8294 threadref threadlist
[3];
8296 printf_filtered ("Remote Threadlist test\n");
8297 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
8298 &result_count
, &threadlist
[0]))
8299 printf_filtered ("FAIL: threadlist test\n");
8302 threadref
*scan
= threadlist
;
8303 threadref
*limit
= scan
+ result_count
;
8305 while (scan
< limit
)
8306 output_threadid (" thread ", scan
++);
8311 display_thread_info (struct gdb_ext_thread_info
*info
)
8313 output_threadid ("Threadid: ", &info
->threadid
);
8314 printf_filtered ("Name: %s\n ", info
->shortname
);
8315 printf_filtered ("State: %s\n", info
->display
);
8316 printf_filtered ("other: %s\n\n", info
->more_display
);
8320 get_and_display_threadinfo (threadref
*ref
)
8324 struct gdb_ext_thread_info threadinfo
;
8326 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
8327 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
8328 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
8329 display_thread_info (&threadinfo
);
8334 threadinfo_test_cmd (char *cmd
, int tty
)
8336 int athread
= SAMPLE_THREAD
;
8340 int_to_threadref (&thread
, athread
);
8341 printf_filtered ("Remote Threadinfo test\n");
8342 if (!get_and_display_threadinfo (&thread
))
8343 printf_filtered ("FAIL cannot get thread info\n");
8347 thread_display_step (threadref
*ref
, void *context
)
8349 /* output_threadid(" threadstep ",ref); *//* simple test */
8350 return get_and_display_threadinfo (ref
);
8354 threadlist_update_test_cmd (char *cmd
, int tty
)
8356 printf_filtered ("Remote Threadlist update test\n");
8357 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
8361 init_remote_threadtests (void)
8363 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
8364 Fetch and print the remote list of thread identifiers, one pkt only"));
8365 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
8366 _("Fetch and display info about one thread"));
8367 add_com ("tset", class_obscure
, threadset_test_cmd
,
8368 _("Test setting to a different thread"));
8369 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
8370 _("Iterate through updating all remote thread info"));
8371 add_com ("talive", class_obscure
, threadalive_test
,
8372 _(" Remote thread alive test "));
8377 /* Convert a thread ID to a string. Returns the string in a static
8381 remote_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
8383 static char buf
[64];
8384 struct remote_state
*rs
= get_remote_state ();
8386 if (ptid_is_pid (ptid
))
8388 /* Printing an inferior target id. */
8390 /* When multi-process extensions are off, there's no way in the
8391 remote protocol to know the remote process id, if there's any
8392 at all. There's one exception --- when we're connected with
8393 target extended-remote, and we manually attached to a process
8394 with "attach PID". We don't record anywhere a flag that
8395 allows us to distinguish that case from the case of
8396 connecting with extended-remote and the stub already being
8397 attached to a process, and reporting yes to qAttached, hence
8398 no smart special casing here. */
8399 if (!remote_multi_process_p (rs
))
8401 xsnprintf (buf
, sizeof buf
, "Remote target");
8405 return normal_pid_to_str (ptid
);
8409 if (ptid_equal (magic_null_ptid
, ptid
))
8410 xsnprintf (buf
, sizeof buf
, "Thread <main>");
8411 else if (remote_multi_process_p (rs
))
8412 xsnprintf (buf
, sizeof buf
, "Thread %d.%ld",
8413 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
8415 xsnprintf (buf
, sizeof buf
, "Thread %ld",
8416 ptid_get_tid (ptid
));
8421 /* Get the address of the thread local variable in OBJFILE which is
8422 stored at OFFSET within the thread local storage for thread PTID. */
8425 remote_get_thread_local_address (struct target_ops
*ops
,
8426 ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
8428 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
8430 struct remote_state
*rs
= get_remote_state ();
8432 char *endp
= rs
->buf
+ get_remote_packet_size ();
8433 enum packet_result result
;
8435 strcpy (p
, "qGetTLSAddr:");
8437 p
= write_ptid (p
, endp
, ptid
);
8439 p
+= hexnumstr (p
, offset
);
8441 p
+= hexnumstr (p
, lm
);
8445 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8446 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
8447 if (result
== PACKET_OK
)
8451 unpack_varlen_hex (rs
->buf
, &result
);
8454 else if (result
== PACKET_UNKNOWN
)
8455 throw_error (TLS_GENERIC_ERROR
,
8456 _("Remote target doesn't support qGetTLSAddr packet"));
8458 throw_error (TLS_GENERIC_ERROR
,
8459 _("Remote target failed to process qGetTLSAddr request"));
8462 throw_error (TLS_GENERIC_ERROR
,
8463 _("TLS not supported or disabled on this target"));
8468 /* Provide thread local base, i.e. Thread Information Block address.
8469 Returns 1 if ptid is found and thread_local_base is non zero. */
8472 remote_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
8474 if (remote_protocol_packets
[PACKET_qGetTIBAddr
].support
!= PACKET_DISABLE
)
8476 struct remote_state
*rs
= get_remote_state ();
8478 char *endp
= rs
->buf
+ get_remote_packet_size ();
8479 enum packet_result result
;
8481 strcpy (p
, "qGetTIBAddr:");
8483 p
= write_ptid (p
, endp
, ptid
);
8487 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8488 result
= packet_ok (rs
->buf
,
8489 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
8490 if (result
== PACKET_OK
)
8494 unpack_varlen_hex (rs
->buf
, &result
);
8496 *addr
= (CORE_ADDR
) result
;
8499 else if (result
== PACKET_UNKNOWN
)
8500 error (_("Remote target doesn't support qGetTIBAddr packet"));
8502 error (_("Remote target failed to process qGetTIBAddr request"));
8505 error (_("qGetTIBAddr not supported or disabled on this target"));
8510 /* Support for inferring a target description based on the current
8511 architecture and the size of a 'g' packet. While the 'g' packet
8512 can have any size (since optional registers can be left off the
8513 end), some sizes are easily recognizable given knowledge of the
8514 approximate architecture. */
8516 struct remote_g_packet_guess
8519 const struct target_desc
*tdesc
;
8521 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
8522 DEF_VEC_O(remote_g_packet_guess_s
);
8524 struct remote_g_packet_data
8526 VEC(remote_g_packet_guess_s
) *guesses
;
8529 static struct gdbarch_data
*remote_g_packet_data_handle
;
8532 remote_g_packet_data_init (struct obstack
*obstack
)
8534 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
8538 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
8539 const struct target_desc
*tdesc
)
8541 struct remote_g_packet_data
*data
8542 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
8543 struct remote_g_packet_guess new_guess
, *guess
;
8546 gdb_assert (tdesc
!= NULL
);
8549 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
8551 if (guess
->bytes
== bytes
)
8552 internal_error (__FILE__
, __LINE__
,
8553 "Duplicate g packet description added for size %d",
8556 new_guess
.bytes
= bytes
;
8557 new_guess
.tdesc
= tdesc
;
8558 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
8561 /* Return 1 if remote_read_description would do anything on this target
8562 and architecture, 0 otherwise. */
8565 remote_read_description_p (struct target_ops
*target
)
8567 struct remote_g_packet_data
*data
8568 = gdbarch_data (target_gdbarch
, remote_g_packet_data_handle
);
8570 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
8576 static const struct target_desc
*
8577 remote_read_description (struct target_ops
*target
)
8579 struct remote_g_packet_data
*data
8580 = gdbarch_data (target_gdbarch
, remote_g_packet_data_handle
);
8582 /* Do not try this during initial connection, when we do not know
8583 whether there is a running but stopped thread. */
8584 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
8587 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
8589 struct remote_g_packet_guess
*guess
;
8591 int bytes
= send_g_packet ();
8594 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
8596 if (guess
->bytes
== bytes
)
8597 return guess
->tdesc
;
8599 /* We discard the g packet. A minor optimization would be to
8600 hold on to it, and fill the register cache once we have selected
8601 an architecture, but it's too tricky to do safely. */
8607 /* Remote file transfer support. This is host-initiated I/O, not
8608 target-initiated; for target-initiated, see remote-fileio.c. */
8610 /* If *LEFT is at least the length of STRING, copy STRING to
8611 *BUFFER, update *BUFFER to point to the new end of the buffer, and
8612 decrease *LEFT. Otherwise raise an error. */
8615 remote_buffer_add_string (char **buffer
, int *left
, char *string
)
8617 int len
= strlen (string
);
8620 error (_("Packet too long for target."));
8622 memcpy (*buffer
, string
, len
);
8626 /* NUL-terminate the buffer as a convenience, if there is
8632 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
8633 *BUFFER, update *BUFFER to point to the new end of the buffer, and
8634 decrease *LEFT. Otherwise raise an error. */
8637 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
8640 if (2 * len
> *left
)
8641 error (_("Packet too long for target."));
8643 bin2hex (bytes
, *buffer
, len
);
8647 /* NUL-terminate the buffer as a convenience, if there is
8653 /* If *LEFT is large enough, convert VALUE to hex and add it to
8654 *BUFFER, update *BUFFER to point to the new end of the buffer, and
8655 decrease *LEFT. Otherwise raise an error. */
8658 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
8660 int len
= hexnumlen (value
);
8663 error (_("Packet too long for target."));
8665 hexnumstr (*buffer
, value
);
8669 /* NUL-terminate the buffer as a convenience, if there is
8675 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
8676 value, *REMOTE_ERRNO to the remote error number or zero if none
8677 was included, and *ATTACHMENT to point to the start of the annex
8678 if any. The length of the packet isn't needed here; there may
8679 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
8681 Return 0 if the packet could be parsed, -1 if it could not. If
8682 -1 is returned, the other variables may not be initialized. */
8685 remote_hostio_parse_result (char *buffer
, int *retcode
,
8686 int *remote_errno
, char **attachment
)
8693 if (buffer
[0] != 'F')
8697 *retcode
= strtol (&buffer
[1], &p
, 16);
8698 if (errno
!= 0 || p
== &buffer
[1])
8701 /* Check for ",errno". */
8705 *remote_errno
= strtol (p
+ 1, &p2
, 16);
8706 if (errno
!= 0 || p
+ 1 == p2
)
8711 /* Check for ";attachment". If there is no attachment, the
8712 packet should end here. */
8715 *attachment
= p
+ 1;
8718 else if (*p
== '\0')
8724 /* Send a prepared I/O packet to the target and read its response.
8725 The prepared packet is in the global RS->BUF before this function
8726 is called, and the answer is there when we return.
8728 COMMAND_BYTES is the length of the request to send, which may include
8729 binary data. WHICH_PACKET is the packet configuration to check
8730 before attempting a packet. If an error occurs, *REMOTE_ERRNO
8731 is set to the error number and -1 is returned. Otherwise the value
8732 returned by the function is returned.
8734 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
8735 attachment is expected; an error will be reported if there's a
8736 mismatch. If one is found, *ATTACHMENT will be set to point into
8737 the packet buffer and *ATTACHMENT_LEN will be set to the
8738 attachment's length. */
8741 remote_hostio_send_command (int command_bytes
, int which_packet
,
8742 int *remote_errno
, char **attachment
,
8743 int *attachment_len
)
8745 struct remote_state
*rs
= get_remote_state ();
8746 int ret
, bytes_read
;
8747 char *attachment_tmp
;
8750 || remote_protocol_packets
[which_packet
].support
== PACKET_DISABLE
)
8752 *remote_errno
= FILEIO_ENOSYS
;
8756 putpkt_binary (rs
->buf
, command_bytes
);
8757 bytes_read
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
8759 /* If it timed out, something is wrong. Don't try to parse the
8763 *remote_errno
= FILEIO_EINVAL
;
8767 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
8770 *remote_errno
= FILEIO_EINVAL
;
8772 case PACKET_UNKNOWN
:
8773 *remote_errno
= FILEIO_ENOSYS
;
8779 if (remote_hostio_parse_result (rs
->buf
, &ret
, remote_errno
,
8782 *remote_errno
= FILEIO_EINVAL
;
8786 /* Make sure we saw an attachment if and only if we expected one. */
8787 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
8788 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
8790 *remote_errno
= FILEIO_EINVAL
;
8794 /* If an attachment was found, it must point into the packet buffer;
8795 work out how many bytes there were. */
8796 if (attachment_tmp
!= NULL
)
8798 *attachment
= attachment_tmp
;
8799 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
);
8805 /* Open FILENAME on the remote target, using FLAGS and MODE. Return a
8806 remote file descriptor, or -1 if an error occurs (and set
8810 remote_hostio_open (const char *filename
, int flags
, int mode
,
8813 struct remote_state
*rs
= get_remote_state ();
8815 int left
= get_remote_packet_size () - 1;
8817 remote_buffer_add_string (&p
, &left
, "vFile:open:");
8819 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
8821 remote_buffer_add_string (&p
, &left
, ",");
8823 remote_buffer_add_int (&p
, &left
, flags
);
8824 remote_buffer_add_string (&p
, &left
, ",");
8826 remote_buffer_add_int (&p
, &left
, mode
);
8828 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_open
,
8829 remote_errno
, NULL
, NULL
);
8832 /* Write up to LEN bytes from WRITE_BUF to FD on the remote target.
8833 Return the number of bytes written, or -1 if an error occurs (and
8834 set *REMOTE_ERRNO). */
8837 remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
8838 ULONGEST offset
, int *remote_errno
)
8840 struct remote_state
*rs
= get_remote_state ();
8842 int left
= get_remote_packet_size ();
8845 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
8847 remote_buffer_add_int (&p
, &left
, fd
);
8848 remote_buffer_add_string (&p
, &left
, ",");
8850 remote_buffer_add_int (&p
, &left
, offset
);
8851 remote_buffer_add_string (&p
, &left
, ",");
8853 p
+= remote_escape_output (write_buf
, len
, p
, &out_len
,
8854 get_remote_packet_size () - (p
- rs
->buf
));
8856 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pwrite
,
8857 remote_errno
, NULL
, NULL
);
8860 /* Read up to LEN bytes FD on the remote target into READ_BUF
8861 Return the number of bytes read, or -1 if an error occurs (and
8862 set *REMOTE_ERRNO). */
8865 remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
8866 ULONGEST offset
, int *remote_errno
)
8868 struct remote_state
*rs
= get_remote_state ();
8871 int left
= get_remote_packet_size ();
8872 int ret
, attachment_len
;
8875 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
8877 remote_buffer_add_int (&p
, &left
, fd
);
8878 remote_buffer_add_string (&p
, &left
, ",");
8880 remote_buffer_add_int (&p
, &left
, len
);
8881 remote_buffer_add_string (&p
, &left
, ",");
8883 remote_buffer_add_int (&p
, &left
, offset
);
8885 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pread
,
8886 remote_errno
, &attachment
,
8892 read_len
= remote_unescape_input (attachment
, attachment_len
,
8894 if (read_len
!= ret
)
8895 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
8900 /* Close FD on the remote target. Return 0, or -1 if an error occurs
8901 (and set *REMOTE_ERRNO). */
8904 remote_hostio_close (int fd
, int *remote_errno
)
8906 struct remote_state
*rs
= get_remote_state ();
8908 int left
= get_remote_packet_size () - 1;
8910 remote_buffer_add_string (&p
, &left
, "vFile:close:");
8912 remote_buffer_add_int (&p
, &left
, fd
);
8914 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_close
,
8915 remote_errno
, NULL
, NULL
);
8918 /* Unlink FILENAME on the remote target. Return 0, or -1 if an error
8919 occurs (and set *REMOTE_ERRNO). */
8922 remote_hostio_unlink (const char *filename
, int *remote_errno
)
8924 struct remote_state
*rs
= get_remote_state ();
8926 int left
= get_remote_packet_size () - 1;
8928 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
8930 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
8933 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_unlink
,
8934 remote_errno
, NULL
, NULL
);
8938 remote_fileio_errno_to_host (int errnum
)
8962 case FILEIO_ENOTDIR
:
8982 case FILEIO_ENAMETOOLONG
:
8983 return ENAMETOOLONG
;
8989 remote_hostio_error (int errnum
)
8991 int host_error
= remote_fileio_errno_to_host (errnum
);
8993 if (host_error
== -1)
8994 error (_("Unknown remote I/O error %d"), errnum
);
8996 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
9000 remote_hostio_close_cleanup (void *opaque
)
9002 int fd
= *(int *) opaque
;
9005 remote_hostio_close (fd
, &remote_errno
);
9010 remote_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
9012 const char *filename
= bfd_get_filename (abfd
);
9013 int fd
, remote_errno
;
9016 gdb_assert (remote_filename_p (filename
));
9018 fd
= remote_hostio_open (filename
+ 7, FILEIO_O_RDONLY
, 0, &remote_errno
);
9021 errno
= remote_fileio_errno_to_host (remote_errno
);
9022 bfd_set_error (bfd_error_system_call
);
9026 stream
= xmalloc (sizeof (int));
9032 remote_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
9034 int fd
= *(int *)stream
;
9039 /* Ignore errors on close; these may happen if the remote
9040 connection was already torn down. */
9041 remote_hostio_close (fd
, &remote_errno
);
9047 remote_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
9048 file_ptr nbytes
, file_ptr offset
)
9050 int fd
= *(int *)stream
;
9052 file_ptr pos
, bytes
;
9055 while (nbytes
> pos
)
9057 bytes
= remote_hostio_pread (fd
, (char *)buf
+ pos
, nbytes
- pos
,
9058 offset
+ pos
, &remote_errno
);
9060 /* Success, but no bytes, means end-of-file. */
9064 errno
= remote_fileio_errno_to_host (remote_errno
);
9065 bfd_set_error (bfd_error_system_call
);
9076 remote_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
9078 /* FIXME: We should probably implement remote_hostio_stat. */
9079 sb
->st_size
= INT_MAX
;
9084 remote_filename_p (const char *filename
)
9086 return strncmp (filename
, "remote:", 7) == 0;
9090 remote_bfd_open (const char *remote_file
, const char *target
)
9092 return bfd_openr_iovec (remote_file
, target
,
9093 remote_bfd_iovec_open
, NULL
,
9094 remote_bfd_iovec_pread
,
9095 remote_bfd_iovec_close
,
9096 remote_bfd_iovec_stat
);
9100 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
9102 struct cleanup
*back_to
, *close_cleanup
;
9103 int retcode
, fd
, remote_errno
, bytes
, io_size
;
9106 int bytes_in_buffer
;
9111 error (_("command can only be used with remote target"));
9113 file
= fopen (local_file
, "rb");
9115 perror_with_name (local_file
);
9116 back_to
= make_cleanup_fclose (file
);
9118 fd
= remote_hostio_open (remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
9120 0700, &remote_errno
);
9122 remote_hostio_error (remote_errno
);
9124 /* Send up to this many bytes at once. They won't all fit in the
9125 remote packet limit, so we'll transfer slightly fewer. */
9126 io_size
= get_remote_packet_size ();
9127 buffer
= xmalloc (io_size
);
9128 make_cleanup (xfree
, buffer
);
9130 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
9132 bytes_in_buffer
= 0;
9135 while (bytes_in_buffer
|| !saw_eof
)
9139 bytes
= fread (buffer
+ bytes_in_buffer
, 1, io_size
- bytes_in_buffer
,
9144 error (_("Error reading %s."), local_file
);
9147 /* EOF. Unless there is something still in the
9148 buffer from the last iteration, we are done. */
9150 if (bytes_in_buffer
== 0)
9158 bytes
+= bytes_in_buffer
;
9159 bytes_in_buffer
= 0;
9161 retcode
= remote_hostio_pwrite (fd
, buffer
, bytes
, offset
, &remote_errno
);
9164 remote_hostio_error (remote_errno
);
9165 else if (retcode
== 0)
9166 error (_("Remote write of %d bytes returned 0!"), bytes
);
9167 else if (retcode
< bytes
)
9169 /* Short write. Save the rest of the read data for the next
9171 bytes_in_buffer
= bytes
- retcode
;
9172 memmove (buffer
, buffer
+ retcode
, bytes_in_buffer
);
9178 discard_cleanups (close_cleanup
);
9179 if (remote_hostio_close (fd
, &remote_errno
))
9180 remote_hostio_error (remote_errno
);
9183 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
9184 do_cleanups (back_to
);
9188 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
9190 struct cleanup
*back_to
, *close_cleanup
;
9191 int fd
, remote_errno
, bytes
, io_size
;
9197 error (_("command can only be used with remote target"));
9199 fd
= remote_hostio_open (remote_file
, FILEIO_O_RDONLY
, 0, &remote_errno
);
9201 remote_hostio_error (remote_errno
);
9203 file
= fopen (local_file
, "wb");
9205 perror_with_name (local_file
);
9206 back_to
= make_cleanup_fclose (file
);
9208 /* Send up to this many bytes at once. They won't all fit in the
9209 remote packet limit, so we'll transfer slightly fewer. */
9210 io_size
= get_remote_packet_size ();
9211 buffer
= xmalloc (io_size
);
9212 make_cleanup (xfree
, buffer
);
9214 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
9219 bytes
= remote_hostio_pread (fd
, buffer
, io_size
, offset
, &remote_errno
);
9221 /* Success, but no bytes, means end-of-file. */
9224 remote_hostio_error (remote_errno
);
9228 bytes
= fwrite (buffer
, 1, bytes
, file
);
9230 perror_with_name (local_file
);
9233 discard_cleanups (close_cleanup
);
9234 if (remote_hostio_close (fd
, &remote_errno
))
9235 remote_hostio_error (remote_errno
);
9238 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
9239 do_cleanups (back_to
);
9243 remote_file_delete (const char *remote_file
, int from_tty
)
9245 int retcode
, remote_errno
;
9248 error (_("command can only be used with remote target"));
9250 retcode
= remote_hostio_unlink (remote_file
, &remote_errno
);
9252 remote_hostio_error (remote_errno
);
9255 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
9259 remote_put_command (char *args
, int from_tty
)
9261 struct cleanup
*back_to
;
9265 error_no_arg (_("file to put"));
9267 argv
= gdb_buildargv (args
);
9268 back_to
= make_cleanup_freeargv (argv
);
9269 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
9270 error (_("Invalid parameters to remote put"));
9272 remote_file_put (argv
[0], argv
[1], from_tty
);
9274 do_cleanups (back_to
);
9278 remote_get_command (char *args
, int from_tty
)
9280 struct cleanup
*back_to
;
9284 error_no_arg (_("file to get"));
9286 argv
= gdb_buildargv (args
);
9287 back_to
= make_cleanup_freeargv (argv
);
9288 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
9289 error (_("Invalid parameters to remote get"));
9291 remote_file_get (argv
[0], argv
[1], from_tty
);
9293 do_cleanups (back_to
);
9297 remote_delete_command (char *args
, int from_tty
)
9299 struct cleanup
*back_to
;
9303 error_no_arg (_("file to delete"));
9305 argv
= gdb_buildargv (args
);
9306 back_to
= make_cleanup_freeargv (argv
);
9307 if (argv
[0] == NULL
|| argv
[1] != NULL
)
9308 error (_("Invalid parameters to remote delete"));
9310 remote_file_delete (argv
[0], from_tty
);
9312 do_cleanups (back_to
);
9316 remote_command (char *args
, int from_tty
)
9318 help_list (remote_cmdlist
, "remote ", -1, gdb_stdout
);
9322 remote_can_execute_reverse (void)
9324 if (remote_protocol_packets
[PACKET_bs
].support
== PACKET_ENABLE
9325 || remote_protocol_packets
[PACKET_bc
].support
== PACKET_ENABLE
)
9332 remote_supports_non_stop (void)
9338 remote_supports_multi_process (void)
9340 struct remote_state
*rs
= get_remote_state ();
9341 return remote_multi_process_p (rs
);
9345 remote_supports_cond_tracepoints (void)
9347 struct remote_state
*rs
= get_remote_state ();
9348 return rs
->cond_tracepoints
;
9352 remote_supports_fast_tracepoints (void)
9354 struct remote_state
*rs
= get_remote_state ();
9355 return rs
->fast_tracepoints
;
9359 remote_trace_init (void)
9362 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9363 if (strcmp (target_buf
, "OK") != 0)
9364 error (_("Target does not support this command."));
9367 static void free_actions_list (char **actions_list
);
9368 static void free_actions_list_cleanup_wrapper (void *);
9370 free_actions_list_cleanup_wrapper (void *al
)
9372 free_actions_list (al
);
9376 free_actions_list (char **actions_list
)
9380 if (actions_list
== 0)
9383 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
9384 xfree (actions_list
[ndx
]);
9386 xfree (actions_list
);
9389 /* Recursive routine to walk through command list including loops, and
9390 download packets for each command. */
9393 remote_download_command_source (int num
, ULONGEST addr
,
9394 struct command_line
*cmds
)
9396 struct remote_state
*rs
= get_remote_state ();
9397 struct command_line
*cmd
;
9399 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
9401 QUIT
; /* allow user to bail out with ^C */
9402 strcpy (rs
->buf
, "QTDPsrc:");
9403 encode_source_string (num
, addr
, "cmd", cmd
->line
,
9404 rs
->buf
+ strlen (rs
->buf
),
9405 rs
->buf_size
- strlen (rs
->buf
));
9407 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9408 if (strcmp (target_buf
, "OK"))
9409 warning (_("Target does not support source download."));
9411 if (cmd
->control_type
== while_control
9412 || cmd
->control_type
== while_stepping_control
)
9414 remote_download_command_source (num
, addr
, *cmd
->body_list
);
9416 QUIT
; /* allow user to bail out with ^C */
9417 strcpy (rs
->buf
, "QTDPsrc:");
9418 encode_source_string (num
, addr
, "cmd", "end",
9419 rs
->buf
+ strlen (rs
->buf
),
9420 rs
->buf_size
- strlen (rs
->buf
));
9422 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9423 if (strcmp (target_buf
, "OK"))
9424 warning (_("Target does not support source download."));
9430 remote_download_tracepoint (struct breakpoint
*t
)
9432 struct bp_location
*loc
;
9437 char **stepping_actions
;
9439 struct cleanup
*old_chain
= NULL
;
9440 struct agent_expr
*aexpr
;
9441 struct cleanup
*aexpr_chain
= NULL
;
9444 /* Iterate over all the tracepoint locations. It's up to the target to
9445 notice multiple tracepoint packets with the same number but different
9446 addresses, and treat them as multiple locations. */
9447 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
9449 encode_actions (t
, loc
, &tdp_actions
, &stepping_actions
);
9450 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
9452 (void) make_cleanup (free_actions_list_cleanup_wrapper
, stepping_actions
);
9454 tpaddr
= loc
->address
;
9455 sprintf_vma (addrbuf
, tpaddr
);
9456 sprintf (buf
, "QTDP:%x:%s:%c:%lx:%x", t
->number
,
9457 addrbuf
, /* address */
9458 (t
->enable_state
== bp_enabled
? 'E' : 'D'),
9459 t
->step_count
, t
->pass_count
);
9460 /* Fast tracepoints are mostly handled by the target, but we can
9461 tell the target how big of an instruction block should be moved
9463 if (t
->type
== bp_fast_tracepoint
)
9465 /* Only test for support at download time; we may not know
9466 target capabilities at definition time. */
9467 if (remote_supports_fast_tracepoints ())
9471 if (gdbarch_fast_tracepoint_valid_at (target_gdbarch
,
9472 tpaddr
, &isize
, NULL
))
9473 sprintf (buf
+ strlen (buf
), ":F%x", isize
);
9475 /* If it passed validation at definition but fails now,
9476 something is very wrong. */
9477 internal_error (__FILE__
, __LINE__
,
9478 "Fast tracepoint not valid during download");
9481 /* Fast tracepoints are functionally identical to regular
9482 tracepoints, so don't take lack of support as a reason to
9483 give up on the trace run. */
9484 warning (_("Target does not support fast tracepoints, downloading %d as regular tracepoint"), t
->number
);
9486 /* If the tracepoint has a conditional, make it into an agent
9487 expression and append to the definition. */
9490 /* Only test support at download time, we may not know target
9491 capabilities at definition time. */
9492 if (remote_supports_cond_tracepoints ())
9494 aexpr
= gen_eval_for_expr (tpaddr
, loc
->cond
);
9495 aexpr_chain
= make_cleanup_free_agent_expr (aexpr
);
9496 sprintf (buf
+ strlen (buf
), ":X%x,", aexpr
->len
);
9497 pkt
= buf
+ strlen (buf
);
9498 for (ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
9499 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
9501 do_cleanups (aexpr_chain
);
9504 warning (_("Target does not support conditional tracepoints, ignoring tp %d cond"), t
->number
);
9507 if (t
->commands
|| *default_collect
)
9510 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9511 if (strcmp (target_buf
, "OK"))
9512 error (_("Target does not support tracepoints."));
9514 /* do_single_steps (t); */
9517 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
9519 QUIT
; /* allow user to bail out with ^C */
9520 sprintf (buf
, "QTDP:-%x:%s:%s%c",
9521 t
->number
, addrbuf
, /* address */
9523 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
9526 remote_get_noisy_reply (&target_buf
,
9528 if (strcmp (target_buf
, "OK"))
9529 error (_("Error on target while setting tracepoints."));
9532 if (stepping_actions
)
9534 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
9536 QUIT
; /* allow user to bail out with ^C */
9537 sprintf (buf
, "QTDP:-%x:%s:%s%s%s",
9538 t
->number
, addrbuf
, /* address */
9539 ((ndx
== 0) ? "S" : ""),
9540 stepping_actions
[ndx
],
9541 (stepping_actions
[ndx
+ 1] ? "-" : ""));
9543 remote_get_noisy_reply (&target_buf
,
9545 if (strcmp (target_buf
, "OK"))
9546 error (_("Error on target while setting tracepoints."));
9550 if (remote_protocol_packets
[PACKET_TracepointSource
].support
== PACKET_ENABLE
)
9554 strcpy (buf
, "QTDPsrc:");
9555 encode_source_string (t
->number
, loc
->address
,
9556 "at", t
->addr_string
, buf
+ strlen (buf
),
9557 2048 - strlen (buf
));
9560 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9561 if (strcmp (target_buf
, "OK"))
9562 warning (_("Target does not support source download."));
9566 strcpy (buf
, "QTDPsrc:");
9567 encode_source_string (t
->number
, loc
->address
,
9568 "cond", t
->cond_string
, buf
+ strlen (buf
),
9569 2048 - strlen (buf
));
9571 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9572 if (strcmp (target_buf
, "OK"))
9573 warning (_("Target does not support source download."));
9575 remote_download_command_source (t
->number
, loc
->address
,
9576 breakpoint_commands (t
));
9579 do_cleanups (old_chain
);
9584 remote_download_trace_state_variable (struct trace_state_variable
*tsv
)
9586 struct remote_state
*rs
= get_remote_state ();
9589 sprintf (rs
->buf
, "QTDV:%x:%s:%x:",
9590 tsv
->number
, phex ((ULONGEST
) tsv
->initial_value
, 8), tsv
->builtin
);
9591 p
= rs
->buf
+ strlen (rs
->buf
);
9592 if ((p
- rs
->buf
) + strlen (tsv
->name
) * 2 >= get_remote_packet_size ())
9593 error (_("Trace state variable name too long for tsv definition packet"));
9594 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
->name
), p
, 0);
9597 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9598 if (*target_buf
== '\0')
9599 error (_("Target does not support this command."));
9600 if (strcmp (target_buf
, "OK") != 0)
9601 error (_("Error on target while downloading trace state variable."));
9605 remote_trace_set_readonly_regions (void)
9613 return; /* No information to give. */
9615 strcpy (target_buf
, "QTro");
9616 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
9618 char tmp1
[40], tmp2
[40];
9620 if ((s
->flags
& SEC_LOAD
) == 0 ||
9621 /* (s->flags & SEC_CODE) == 0 || */
9622 (s
->flags
& SEC_READONLY
) == 0)
9627 size
= bfd_get_section_size (s
);
9628 sprintf_vma (tmp1
, lma
);
9629 sprintf_vma (tmp2
, lma
+ size
);
9630 sprintf (target_buf
+ strlen (target_buf
),
9631 ":%s,%s", tmp1
, tmp2
);
9635 putpkt (target_buf
);
9636 getpkt (&target_buf
, &target_buf_size
, 0);
9641 remote_trace_start (void)
9644 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9645 if (*target_buf
== '\0')
9646 error (_("Target does not support this command."));
9647 if (strcmp (target_buf
, "OK") != 0)
9648 error (_("Bogus reply from target: %s"), target_buf
);
9652 remote_get_trace_status (struct trace_status
*ts
)
9655 /* FIXME we need to get register block size some other way */
9656 extern int trace_regblock_size
;
9657 trace_regblock_size
= get_remote_arch_state ()->sizeof_g_packet
;
9659 putpkt ("qTStatus");
9660 p
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9662 /* If the remote target doesn't do tracing, flag it. */
9666 /* We're working with a live target. */
9669 /* Set some defaults. */
9670 ts
->running_known
= 0;
9671 ts
->stop_reason
= trace_stop_reason_unknown
;
9672 ts
->traceframe_count
= -1;
9673 ts
->buffer_free
= 0;
9676 error (_("Bogus trace status reply from target: %s"), target_buf
);
9678 parse_trace_status (p
, ts
);
9684 remote_trace_stop (void)
9687 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9688 if (*target_buf
== '\0')
9689 error (_("Target does not support this command."));
9690 if (strcmp (target_buf
, "OK") != 0)
9691 error (_("Bogus reply from target: %s"), target_buf
);
9695 remote_trace_find (enum trace_find_type type
, int num
,
9696 ULONGEST addr1
, ULONGEST addr2
,
9699 struct remote_state
*rs
= get_remote_state ();
9701 int target_frameno
= -1, target_tracept
= -1;
9704 strcpy (p
, "QTFrame:");
9705 p
= strchr (p
, '\0');
9709 sprintf (p
, "%x", num
);
9712 sprintf (p
, "pc:%s", phex_nz (addr1
, 0));
9715 sprintf (p
, "tdp:%x", num
);
9718 sprintf (p
, "range:%s:%s", phex_nz (addr1
, 0), phex_nz (addr2
, 0));
9721 sprintf (p
, "outside:%s:%s", phex_nz (addr1
, 0), phex_nz (addr2
, 0));
9724 error ("Unknown trace find type %d", type
);
9728 reply
= remote_get_noisy_reply (&(rs
->buf
), &sizeof_pkt
);
9730 error (_("Target does not support this command."));
9732 while (reply
&& *reply
)
9737 target_frameno
= (int) strtol (p
, &reply
, 16);
9739 error (_("Unable to parse trace frame number"));
9740 if (target_frameno
== -1)
9745 target_tracept
= (int) strtol (p
, &reply
, 16);
9747 error (_("Unable to parse tracepoint number"));
9749 case 'O': /* "OK"? */
9750 if (reply
[1] == 'K' && reply
[2] == '\0')
9753 error (_("Bogus reply from target: %s"), reply
);
9756 error (_("Bogus reply from target: %s"), reply
);
9759 *tpp
= target_tracept
;
9760 return target_frameno
;
9764 remote_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
9766 struct remote_state
*rs
= get_remote_state ();
9770 sprintf (rs
->buf
, "qTV:%x", tsvnum
);
9772 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9773 if (reply
&& *reply
)
9777 unpack_varlen_hex (reply
+ 1, &uval
);
9778 *val
= (LONGEST
) uval
;
9786 remote_save_trace_data (const char *filename
)
9788 struct remote_state
*rs
= get_remote_state ();
9792 strcpy (p
, "QTSave:");
9794 if ((p
- rs
->buf
) + strlen (filename
) * 2 >= get_remote_packet_size ())
9795 error (_("Remote file name too long for trace save packet"));
9796 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, 0);
9799 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9801 error (_("Target does not support this command."));
9802 if (strcmp (reply
, "OK") != 0)
9803 error (_("Bogus reply from target: %s"), reply
);
9807 /* This is basically a memory transfer, but needs to be its own packet
9808 because we don't know how the target actually organizes its trace
9809 memory, plus we want to be able to ask for as much as possible, but
9810 not be unhappy if we don't get as much as we ask for. */
9813 remote_get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
9815 struct remote_state
*rs
= get_remote_state ();
9821 strcpy (p
, "qTBuffer:");
9823 p
+= hexnumstr (p
, offset
);
9825 p
+= hexnumstr (p
, len
);
9829 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9830 if (reply
&& *reply
)
9832 /* 'l' by itself means we're at the end of the buffer and
9833 there is nothing more to get. */
9837 /* Convert the reply into binary. Limit the number of bytes to
9838 convert according to our passed-in buffer size, rather than
9839 what was returned in the packet; if the target is
9840 unexpectedly generous and gives us a bigger reply than we
9841 asked for, we don't want to crash. */
9842 rslt
= hex2bin (target_buf
, buf
, len
);
9846 /* Something went wrong, flag as an error. */
9851 remote_set_disconnected_tracing (int val
)
9853 struct remote_state
*rs
= get_remote_state ();
9855 if (rs
->disconnected_tracing
)
9859 sprintf (rs
->buf
, "QTDisconnected:%x", val
);
9861 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9863 error (_("Target does not support this command."));
9864 if (strcmp (reply
, "OK") != 0)
9865 error (_("Bogus reply from target: %s"), reply
);
9868 warning (_("Target does not support disconnected tracing."));
9872 remote_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
9874 struct thread_info
*info
= find_thread_ptid (ptid
);
9875 if (info
&& info
->private)
9876 return info
->private->core
;
9881 remote_set_circular_trace_buffer (int val
)
9883 struct remote_state
*rs
= get_remote_state ();
9886 sprintf (rs
->buf
, "QTBuffer:circular:%x", val
);
9888 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9890 error (_("Target does not support this command."));
9891 if (strcmp (reply
, "OK") != 0)
9892 error (_("Bogus reply from target: %s"), reply
);
9896 init_remote_ops (void)
9898 remote_ops
.to_shortname
= "remote";
9899 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
9901 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
9902 Specify the serial device it is connected to\n\
9903 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
9904 remote_ops
.to_open
= remote_open
;
9905 remote_ops
.to_close
= remote_close
;
9906 remote_ops
.to_detach
= remote_detach
;
9907 remote_ops
.to_disconnect
= remote_disconnect
;
9908 remote_ops
.to_resume
= remote_resume
;
9909 remote_ops
.to_wait
= remote_wait
;
9910 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
9911 remote_ops
.to_store_registers
= remote_store_registers
;
9912 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
9913 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
9914 remote_ops
.to_files_info
= remote_files_info
;
9915 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
9916 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
9917 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
9918 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
9919 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
9920 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
9921 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
9922 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
9923 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
9924 remote_ops
.to_kill
= remote_kill
;
9925 remote_ops
.to_load
= generic_load
;
9926 remote_ops
.to_mourn_inferior
= remote_mourn
;
9927 remote_ops
.to_notice_signals
= remote_notice_signals
;
9928 remote_ops
.to_thread_alive
= remote_thread_alive
;
9929 remote_ops
.to_find_new_threads
= remote_threads_info
;
9930 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
9931 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
9932 remote_ops
.to_get_ada_task_ptid
= remote_get_ada_task_ptid
;
9933 remote_ops
.to_stop
= remote_stop
;
9934 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
9935 remote_ops
.to_rcmd
= remote_rcmd
;
9936 remote_ops
.to_log_command
= serial_log_command
;
9937 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
9938 remote_ops
.to_stratum
= process_stratum
;
9939 remote_ops
.to_has_all_memory
= default_child_has_all_memory
;
9940 remote_ops
.to_has_memory
= default_child_has_memory
;
9941 remote_ops
.to_has_stack
= default_child_has_stack
;
9942 remote_ops
.to_has_registers
= default_child_has_registers
;
9943 remote_ops
.to_has_execution
= default_child_has_execution
;
9944 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
9945 remote_ops
.to_can_execute_reverse
= remote_can_execute_reverse
;
9946 remote_ops
.to_magic
= OPS_MAGIC
;
9947 remote_ops
.to_memory_map
= remote_memory_map
;
9948 remote_ops
.to_flash_erase
= remote_flash_erase
;
9949 remote_ops
.to_flash_done
= remote_flash_done
;
9950 remote_ops
.to_read_description
= remote_read_description
;
9951 remote_ops
.to_search_memory
= remote_search_memory
;
9952 remote_ops
.to_can_async_p
= remote_can_async_p
;
9953 remote_ops
.to_is_async_p
= remote_is_async_p
;
9954 remote_ops
.to_async
= remote_async
;
9955 remote_ops
.to_async_mask
= remote_async_mask
;
9956 remote_ops
.to_terminal_inferior
= remote_terminal_inferior
;
9957 remote_ops
.to_terminal_ours
= remote_terminal_ours
;
9958 remote_ops
.to_supports_non_stop
= remote_supports_non_stop
;
9959 remote_ops
.to_supports_multi_process
= remote_supports_multi_process
;
9960 remote_ops
.to_trace_init
= remote_trace_init
;
9961 remote_ops
.to_download_tracepoint
= remote_download_tracepoint
;
9962 remote_ops
.to_download_trace_state_variable
= remote_download_trace_state_variable
;
9963 remote_ops
.to_trace_set_readonly_regions
= remote_trace_set_readonly_regions
;
9964 remote_ops
.to_trace_start
= remote_trace_start
;
9965 remote_ops
.to_get_trace_status
= remote_get_trace_status
;
9966 remote_ops
.to_trace_stop
= remote_trace_stop
;
9967 remote_ops
.to_trace_find
= remote_trace_find
;
9968 remote_ops
.to_get_trace_state_variable_value
= remote_get_trace_state_variable_value
;
9969 remote_ops
.to_save_trace_data
= remote_save_trace_data
;
9970 remote_ops
.to_upload_tracepoints
= remote_upload_tracepoints
;
9971 remote_ops
.to_upload_trace_state_variables
= remote_upload_trace_state_variables
;
9972 remote_ops
.to_get_raw_trace_data
= remote_get_raw_trace_data
;
9973 remote_ops
.to_set_disconnected_tracing
= remote_set_disconnected_tracing
;
9974 remote_ops
.to_set_circular_trace_buffer
= remote_set_circular_trace_buffer
;
9975 remote_ops
.to_core_of_thread
= remote_core_of_thread
;
9976 remote_ops
.to_verify_memory
= remote_verify_memory
;
9977 remote_ops
.to_get_tib_address
= remote_get_tib_address
;
9980 /* Set up the extended remote vector by making a copy of the standard
9981 remote vector and adding to it. */
9984 init_extended_remote_ops (void)
9986 extended_remote_ops
= remote_ops
;
9988 extended_remote_ops
.to_shortname
= "extended-remote";
9989 extended_remote_ops
.to_longname
=
9990 "Extended remote serial target in gdb-specific protocol";
9991 extended_remote_ops
.to_doc
=
9992 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
9993 Specify the serial device it is connected to (e.g. /dev/ttya).";
9994 extended_remote_ops
.to_open
= extended_remote_open
;
9995 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
9996 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
9997 extended_remote_ops
.to_detach
= extended_remote_detach
;
9998 extended_remote_ops
.to_attach
= extended_remote_attach
;
9999 extended_remote_ops
.to_kill
= extended_remote_kill
;
10003 remote_can_async_p (void)
10005 if (!target_async_permitted
)
10006 /* We only enable async when the user specifically asks for it. */
10009 /* We're async whenever the serial device is. */
10010 return remote_async_mask_value
&& serial_can_async_p (remote_desc
);
10014 remote_is_async_p (void)
10016 if (!target_async_permitted
)
10017 /* We only enable async when the user specifically asks for it. */
10020 /* We're async whenever the serial device is. */
10021 return remote_async_mask_value
&& serial_is_async_p (remote_desc
);
10024 /* Pass the SERIAL event on and up to the client. One day this code
10025 will be able to delay notifying the client of an event until the
10026 point where an entire packet has been received. */
10028 static void (*async_client_callback
) (enum inferior_event_type event_type
,
10030 static void *async_client_context
;
10031 static serial_event_ftype remote_async_serial_handler
;
10034 remote_async_serial_handler (struct serial
*scb
, void *context
)
10036 /* Don't propogate error information up to the client. Instead let
10037 the client find out about the error by querying the target. */
10038 async_client_callback (INF_REG_EVENT
, async_client_context
);
10042 remote_async_inferior_event_handler (gdb_client_data data
)
10044 inferior_event_handler (INF_REG_EVENT
, NULL
);
10048 remote_async_get_pending_events_handler (gdb_client_data data
)
10050 remote_get_pending_stop_replies ();
10054 remote_async (void (*callback
) (enum inferior_event_type event_type
,
10055 void *context
), void *context
)
10057 if (remote_async_mask_value
== 0)
10058 internal_error (__FILE__
, __LINE__
,
10059 _("Calling remote_async when async is masked"));
10061 if (callback
!= NULL
)
10063 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
10064 async_client_callback
= callback
;
10065 async_client_context
= context
;
10068 serial_async (remote_desc
, NULL
, NULL
);
10072 remote_async_mask (int new_mask
)
10074 int curr_mask
= remote_async_mask_value
;
10075 remote_async_mask_value
= new_mask
;
10080 set_remote_cmd (char *args
, int from_tty
)
10082 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
10086 show_remote_cmd (char *args
, int from_tty
)
10088 /* We can't just use cmd_show_list here, because we want to skip
10089 the redundant "show remote Z-packet" and the legacy aliases. */
10090 struct cleanup
*showlist_chain
;
10091 struct cmd_list_element
*list
= remote_show_cmdlist
;
10093 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
10094 for (; list
!= NULL
; list
= list
->next
)
10095 if (strcmp (list
->name
, "Z-packet") == 0)
10097 else if (list
->type
== not_set_cmd
)
10098 /* Alias commands are exactly like the original, except they
10099 don't have the normal type. */
10103 struct cleanup
*option_chain
10104 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
10105 ui_out_field_string (uiout
, "name", list
->name
);
10106 ui_out_text (uiout
, ": ");
10107 if (list
->type
== show_cmd
)
10108 do_setshow_command ((char *) NULL
, from_tty
, list
);
10110 cmd_func (list
, NULL
, from_tty
);
10111 /* Close the tuple. */
10112 do_cleanups (option_chain
);
10115 /* Close the tuple. */
10116 do_cleanups (showlist_chain
);
10120 /* Function to be called whenever a new objfile (shlib) is detected. */
10122 remote_new_objfile (struct objfile
*objfile
)
10124 if (remote_desc
!= 0) /* Have a remote connection. */
10125 remote_check_symbols (objfile
);
10128 /* Pull all the tracepoints defined on the target and create local
10129 data structures representing them. We don't want to create real
10130 tracepoints yet, we don't want to mess up the user's existing
10134 remote_upload_tracepoints (struct uploaded_tp
**utpp
)
10136 struct remote_state
*rs
= get_remote_state ();
10139 /* Ask for a first packet of tracepoint definition. */
10141 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10143 while (*p
&& *p
!= 'l')
10145 parse_tracepoint_definition (p
, utpp
);
10146 /* Ask for another packet of tracepoint definition. */
10148 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10155 remote_upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
10157 struct remote_state
*rs
= get_remote_state ();
10160 /* Ask for a first packet of variable definition. */
10162 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10164 while (*p
&& *p
!= 'l')
10166 parse_tsv_definition (p
, utsvp
);
10167 /* Ask for another packet of variable definition. */
10169 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10176 _initialize_remote (void)
10178 struct remote_state
*rs
;
10179 struct cmd_list_element
*cmd
;
10182 /* architecture specific data */
10183 remote_gdbarch_data_handle
=
10184 gdbarch_data_register_post_init (init_remote_state
);
10185 remote_g_packet_data_handle
=
10186 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
10188 /* Initialize the per-target state. At the moment there is only one
10189 of these, not one per target. Only one target is active at a
10190 time. The default buffer size is unimportant; it will be expanded
10191 whenever a larger buffer is needed. */
10192 rs
= get_remote_state_raw ();
10193 rs
->buf_size
= 400;
10194 rs
->buf
= xmalloc (rs
->buf_size
);
10196 init_remote_ops ();
10197 add_target (&remote_ops
);
10199 init_extended_remote_ops ();
10200 add_target (&extended_remote_ops
);
10202 /* Hook into new objfile notification. */
10203 observer_attach_new_objfile (remote_new_objfile
);
10205 /* Set up signal handlers. */
10206 sigint_remote_token
=
10207 create_async_signal_handler (async_remote_interrupt
, NULL
);
10208 sigint_remote_twice_token
=
10209 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
10212 init_remote_threadtests ();
10215 /* set/show remote ... */
10217 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
10218 Remote protocol specific variables\n\
10219 Configure various remote-protocol specific variables such as\n\
10220 the packets being used"),
10221 &remote_set_cmdlist
, "set remote ",
10222 0 /* allow-unknown */, &setlist
);
10223 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
10224 Remote protocol specific variables\n\
10225 Configure various remote-protocol specific variables such as\n\
10226 the packets being used"),
10227 &remote_show_cmdlist
, "show remote ",
10228 0 /* allow-unknown */, &showlist
);
10230 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
10231 Compare section data on target to the exec file.\n\
10232 Argument is a single section name (default: all loaded sections)."),
10235 add_cmd ("packet", class_maintenance
, packet_command
, _("\
10236 Send an arbitrary packet to a remote target.\n\
10237 maintenance packet TEXT\n\
10238 If GDB is talking to an inferior via the GDB serial protocol, then\n\
10239 this command sends the string TEXT to the inferior, and displays the\n\
10240 response packet. GDB supplies the initial `$' character, and the\n\
10241 terminating `#' character and checksum."),
10244 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
10245 Set whether to send break if interrupted."), _("\
10246 Show whether to send break if interrupted."), _("\
10247 If set, a break, instead of a cntrl-c, is sent to the remote target."),
10248 set_remotebreak
, show_remotebreak
,
10249 &setlist
, &showlist
);
10250 cmd_name
= "remotebreak";
10251 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
10252 deprecate_cmd (cmd
, "set remote interrupt-sequence");
10253 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
10254 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
10255 deprecate_cmd (cmd
, "show remote interrupt-sequence");
10257 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
10258 interrupt_sequence_modes
, &interrupt_sequence_mode
, _("\
10259 Set interrupt sequence to remote target."), _("\
10260 Show interrupt sequence to remote target."), _("\
10261 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
10262 NULL
, show_interrupt_sequence
,
10263 &remote_set_cmdlist
,
10264 &remote_show_cmdlist
);
10266 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
10267 &interrupt_on_connect
, _("\
10268 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
10269 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
10270 If set, interrupt sequence is sent to remote target."),
10272 &remote_set_cmdlist
, &remote_show_cmdlist
);
10274 /* Install commands for configuring memory read/write packets. */
10276 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
10277 Set the maximum number of bytes per memory write packet (deprecated)."),
10279 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
10280 Show the maximum number of bytes per memory write packet (deprecated)."),
10282 add_cmd ("memory-write-packet-size", no_class
,
10283 set_memory_write_packet_size
, _("\
10284 Set the maximum number of bytes per memory-write packet.\n\
10285 Specify the number of bytes in a packet or 0 (zero) for the\n\
10286 default packet size. The actual limit is further reduced\n\
10287 dependent on the target. Specify ``fixed'' to disable the\n\
10288 further restriction and ``limit'' to enable that restriction."),
10289 &remote_set_cmdlist
);
10290 add_cmd ("memory-read-packet-size", no_class
,
10291 set_memory_read_packet_size
, _("\
10292 Set the maximum number of bytes per memory-read packet.\n\
10293 Specify the number of bytes in a packet or 0 (zero) for the\n\
10294 default packet size. The actual limit is further reduced\n\
10295 dependent on the target. Specify ``fixed'' to disable the\n\
10296 further restriction and ``limit'' to enable that restriction."),
10297 &remote_set_cmdlist
);
10298 add_cmd ("memory-write-packet-size", no_class
,
10299 show_memory_write_packet_size
,
10300 _("Show the maximum number of bytes per memory-write packet."),
10301 &remote_show_cmdlist
);
10302 add_cmd ("memory-read-packet-size", no_class
,
10303 show_memory_read_packet_size
,
10304 _("Show the maximum number of bytes per memory-read packet."),
10305 &remote_show_cmdlist
);
10307 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
10308 &remote_hw_watchpoint_limit
, _("\
10309 Set the maximum number of target hardware watchpoints."), _("\
10310 Show the maximum number of target hardware watchpoints."), _("\
10311 Specify a negative limit for unlimited."),
10312 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
10313 &remote_set_cmdlist
, &remote_show_cmdlist
);
10314 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
10315 &remote_hw_breakpoint_limit
, _("\
10316 Set the maximum number of target hardware breakpoints."), _("\
10317 Show the maximum number of target hardware breakpoints."), _("\
10318 Specify a negative limit for unlimited."),
10319 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
10320 &remote_set_cmdlist
, &remote_show_cmdlist
);
10322 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
10323 &remote_address_size
, _("\
10324 Set the maximum size of the address (in bits) in a memory packet."), _("\
10325 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
10327 NULL
, /* FIXME: i18n: */
10328 &setlist
, &showlist
);
10330 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
10331 "X", "binary-download", 1);
10333 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
10334 "vCont", "verbose-resume", 0);
10336 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
10337 "QPassSignals", "pass-signals", 0);
10339 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
10340 "qSymbol", "symbol-lookup", 0);
10342 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
10343 "P", "set-register", 1);
10345 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
10346 "p", "fetch-register", 1);
10348 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
10349 "Z0", "software-breakpoint", 0);
10351 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
10352 "Z1", "hardware-breakpoint", 0);
10354 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
10355 "Z2", "write-watchpoint", 0);
10357 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
10358 "Z3", "read-watchpoint", 0);
10360 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
10361 "Z4", "access-watchpoint", 0);
10363 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
10364 "qXfer:auxv:read", "read-aux-vector", 0);
10366 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
10367 "qXfer:features:read", "target-features", 0);
10369 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
10370 "qXfer:libraries:read", "library-info", 0);
10372 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
10373 "qXfer:memory-map:read", "memory-map", 0);
10375 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
10376 "qXfer:spu:read", "read-spu-object", 0);
10378 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
10379 "qXfer:spu:write", "write-spu-object", 0);
10381 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
10382 "qXfer:osdata:read", "osdata", 0);
10384 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
10385 "qXfer:threads:read", "threads", 0);
10387 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
10388 "qXfer:siginfo:read", "read-siginfo-object", 0);
10390 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
10391 "qXfer:siginfo:write", "write-siginfo-object", 0);
10393 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
10394 "qGetTLSAddr", "get-thread-local-storage-address",
10397 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
10398 "qGetTIBAddr", "get-thread-information-block-address",
10401 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
10402 "bc", "reverse-continue", 0);
10404 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
10405 "bs", "reverse-step", 0);
10407 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
10408 "qSupported", "supported-packets", 0);
10410 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
10411 "qSearch:memory", "search-memory", 0);
10413 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
10414 "vFile:open", "hostio-open", 0);
10416 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
10417 "vFile:pread", "hostio-pread", 0);
10419 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
10420 "vFile:pwrite", "hostio-pwrite", 0);
10422 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
10423 "vFile:close", "hostio-close", 0);
10425 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
10426 "vFile:unlink", "hostio-unlink", 0);
10428 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
10429 "vAttach", "attach", 0);
10431 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
10434 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
10435 "QStartNoAckMode", "noack", 0);
10437 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
10438 "vKill", "kill", 0);
10440 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
10441 "qAttached", "query-attached", 0);
10443 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
10444 "ConditionalTracepoints", "conditional-tracepoints", 0);
10445 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
10446 "FastTracepoints", "fast-tracepoints", 0);
10448 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
10449 "TracepointSource", "TracepointSource", 0);
10451 /* Keep the old ``set remote Z-packet ...'' working. Each individual
10452 Z sub-packet has its own set and show commands, but users may
10453 have sets to this variable in their .gdbinit files (or in their
10455 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
10456 &remote_Z_packet_detect
, _("\
10457 Set use of remote protocol `Z' packets"), _("\
10458 Show use of remote protocol `Z' packets "), _("\
10459 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
10461 set_remote_protocol_Z_packet_cmd
,
10462 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
10463 &remote_set_cmdlist
, &remote_show_cmdlist
);
10465 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
10466 Manipulate files on the remote system\n\
10467 Transfer files to and from the remote target system."),
10468 &remote_cmdlist
, "remote ",
10469 0 /* allow-unknown */, &cmdlist
);
10471 add_cmd ("put", class_files
, remote_put_command
,
10472 _("Copy a local file to the remote system."),
10475 add_cmd ("get", class_files
, remote_get_command
,
10476 _("Copy a remote file to the local system."),
10479 add_cmd ("delete", class_files
, remote_delete_command
,
10480 _("Delete a remote file."),
10483 remote_exec_file
= xstrdup ("");
10484 add_setshow_string_noescape_cmd ("exec-file", class_files
,
10485 &remote_exec_file
, _("\
10486 Set the remote pathname for \"run\""), _("\
10487 Show the remote pathname for \"run\""), NULL
, NULL
, NULL
,
10488 &remote_set_cmdlist
, &remote_show_cmdlist
);
10490 /* Eventually initialize fileio. See fileio.c */
10491 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);
10493 /* Take advantage of the fact that the LWP field is not used, to tag
10494 special ptids with it set to != 0. */
10495 magic_null_ptid
= ptid_build (42000, 1, -1);
10496 not_sent_ptid
= ptid_build (42000, 1, -2);
10497 any_thread_ptid
= ptid_build (42000, 1, 0);
10499 target_buf_size
= 2048;
10500 target_buf
= xmalloc (target_buf_size
);