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
}
2488 * Find all threads for info threads command.
2489 * Uses new thread protocol contributed by Cisco.
2490 * Falls back and attempts to use the older method (above)
2491 * if the target doesn't respond to the new method.
2495 remote_threads_info (struct target_ops
*ops
)
2497 struct remote_state
*rs
= get_remote_state ();
2501 if (remote_desc
== 0) /* paranoia */
2502 error (_("Command can only be used when connected to the remote target."));
2504 #if defined(HAVE_LIBEXPAT)
2505 if (remote_protocol_packets
[PACKET_qXfer_threads
].support
== PACKET_ENABLE
)
2507 char *xml
= target_read_stralloc (¤t_target
,
2508 TARGET_OBJECT_THREADS
, NULL
);
2510 struct cleanup
*back_to
= make_cleanup (xfree
, xml
);
2513 struct gdb_xml_parser
*parser
;
2514 struct threads_parsing_context context
;
2515 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2518 parser
= gdb_xml_create_parser_and_cleanup (_("threads"),
2522 gdb_xml_use_dtd (parser
, "threads.dtd");
2524 if (gdb_xml_parse (parser
, xml
) == 0)
2527 struct thread_item
*item
;
2529 for (i
= 0; VEC_iterate (thread_item_t
, context
.items
, i
, item
); ++i
)
2531 if (!ptid_equal (item
->ptid
, null_ptid
))
2533 struct private_thread_info
*info
;
2534 /* In non-stop mode, we assume new found threads
2535 are running until proven otherwise with a
2536 stop reply. In all-stop, we can only get
2537 here if all threads are stopped. */
2538 int running
= non_stop
? 1 : 0;
2540 remote_notice_new_inferior (item
->ptid
, running
);
2542 info
= demand_private_info (item
->ptid
);
2543 info
->core
= item
->core
;
2544 info
->extra
= item
->extra
;
2547 xfree (item
->extra
);
2551 VEC_free (thread_item_t
, context
.items
);
2554 do_cleanups (back_to
);
2559 if (use_threadinfo_query
)
2561 putpkt ("qfThreadInfo");
2562 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2564 if (bufp
[0] != '\0') /* q packet recognized */
2566 while (*bufp
++ == 'm') /* reply contains one or more TID */
2570 new_thread
= read_ptid (bufp
, &bufp
);
2571 if (!ptid_equal (new_thread
, null_ptid
))
2573 /* In non-stop mode, we assume new found threads
2574 are running until proven otherwise with a
2575 stop reply. In all-stop, we can only get
2576 here if all threads are stopped. */
2577 int running
= non_stop
? 1 : 0;
2579 remote_notice_new_inferior (new_thread
, running
);
2582 while (*bufp
++ == ','); /* comma-separated list */
2583 putpkt ("qsThreadInfo");
2584 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2591 /* Only qfThreadInfo is supported in non-stop mode. */
2595 /* Else fall back to old method based on jmetzler protocol. */
2596 use_threadinfo_query
= 0;
2597 remote_find_new_threads ();
2602 * Collect a descriptive string about the given thread.
2603 * The target may say anything it wants to about the thread
2604 * (typically info about its blocked / runnable state, name, etc.).
2605 * This string will appear in the info threads display.
2607 * Optional: targets are not required to implement this function.
2611 remote_threads_extra_info (struct thread_info
*tp
)
2613 struct remote_state
*rs
= get_remote_state ();
2617 struct gdb_ext_thread_info threadinfo
;
2618 static char display_buf
[100]; /* arbitrary... */
2619 int n
= 0; /* position in display_buf */
2621 if (remote_desc
== 0) /* paranoia */
2622 internal_error (__FILE__
, __LINE__
,
2623 _("remote_threads_extra_info"));
2625 if (ptid_equal (tp
->ptid
, magic_null_ptid
)
2626 || (ptid_get_pid (tp
->ptid
) != 0 && ptid_get_tid (tp
->ptid
) == 0))
2627 /* This is the main thread which was added by GDB. The remote
2628 server doesn't know about it. */
2631 if (remote_protocol_packets
[PACKET_qXfer_threads
].support
== PACKET_ENABLE
)
2633 struct thread_info
*info
= find_thread_ptid (tp
->ptid
);
2634 if (info
&& info
->private)
2635 return info
->private->extra
;
2640 if (use_threadextra_query
)
2643 char *endb
= rs
->buf
+ get_remote_packet_size ();
2645 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
2647 write_ptid (b
, endb
, tp
->ptid
);
2650 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2651 if (rs
->buf
[0] != 0)
2653 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
2654 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
2655 display_buf
[result
] = '\0';
2660 /* If the above query fails, fall back to the old method. */
2661 use_threadextra_query
= 0;
2662 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
2663 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
2664 int_to_threadref (&id
, ptid_get_tid (tp
->ptid
));
2665 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
2666 if (threadinfo
.active
)
2668 if (*threadinfo
.shortname
)
2669 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
2670 " Name: %s,", threadinfo
.shortname
);
2671 if (*threadinfo
.display
)
2672 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
2673 " State: %s,", threadinfo
.display
);
2674 if (*threadinfo
.more_display
)
2675 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
2676 " Priority: %s", threadinfo
.more_display
);
2680 /* For purely cosmetic reasons, clear up trailing commas. */
2681 if (',' == display_buf
[n
-1])
2682 display_buf
[n
-1] = ' ';
2690 /* Implement the to_get_ada_task_ptid function for the remote targets. */
2693 remote_get_ada_task_ptid (long lwp
, long thread
)
2695 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2699 /* Restart the remote side; this is an extended protocol operation. */
2702 extended_remote_restart (void)
2704 struct remote_state
*rs
= get_remote_state ();
2706 /* Send the restart command; for reasons I don't understand the
2707 remote side really expects a number after the "R". */
2708 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
2711 remote_fileio_reset ();
2714 /* Clean up connection to a remote debugger. */
2717 remote_close (int quitting
)
2719 if (remote_desc
== NULL
)
2720 return; /* already closed */
2722 /* Make sure we leave stdin registered in the event loop, and we
2723 don't leave the async SIGINT signal handler installed. */
2724 remote_terminal_ours ();
2726 serial_close (remote_desc
);
2729 /* We don't have a connection to the remote stub anymore. Get rid
2730 of all the inferiors and their threads we were controlling. */
2731 discard_all_inferiors ();
2733 /* We're no longer interested in any of these events. */
2734 discard_pending_stop_replies (-1);
2736 if (remote_async_inferior_event_token
)
2737 delete_async_event_handler (&remote_async_inferior_event_token
);
2738 if (remote_async_get_pending_events_token
)
2739 delete_async_event_handler (&remote_async_get_pending_events_token
);
2742 /* Query the remote side for the text, data and bss offsets. */
2747 struct remote_state
*rs
= get_remote_state ();
2750 int lose
, num_segments
= 0, do_sections
, do_segments
;
2751 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
2752 struct section_offsets
*offs
;
2753 struct symfile_segment_data
*data
;
2755 if (symfile_objfile
== NULL
)
2758 putpkt ("qOffsets");
2759 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2762 if (buf
[0] == '\000')
2763 return; /* Return silently. Stub doesn't support
2767 warning (_("Remote failure reply: %s"), buf
);
2771 /* Pick up each field in turn. This used to be done with scanf, but
2772 scanf will make trouble if CORE_ADDR size doesn't match
2773 conversion directives correctly. The following code will work
2774 with any size of CORE_ADDR. */
2775 text_addr
= data_addr
= bss_addr
= 0;
2779 if (strncmp (ptr
, "Text=", 5) == 0)
2782 /* Don't use strtol, could lose on big values. */
2783 while (*ptr
&& *ptr
!= ';')
2784 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2786 if (strncmp (ptr
, ";Data=", 6) == 0)
2789 while (*ptr
&& *ptr
!= ';')
2790 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2795 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
2798 while (*ptr
&& *ptr
!= ';')
2799 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
2801 if (bss_addr
!= data_addr
)
2802 warning (_("Target reported unsupported offsets: %s"), buf
);
2807 else if (strncmp (ptr
, "TextSeg=", 8) == 0)
2810 /* Don't use strtol, could lose on big values. */
2811 while (*ptr
&& *ptr
!= ';')
2812 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2815 if (strncmp (ptr
, ";DataSeg=", 9) == 0)
2818 while (*ptr
&& *ptr
!= ';')
2819 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2827 error (_("Malformed response to offset query, %s"), buf
);
2828 else if (*ptr
!= '\0')
2829 warning (_("Target reported unsupported offsets: %s"), buf
);
2831 offs
= ((struct section_offsets
*)
2832 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
2833 memcpy (offs
, symfile_objfile
->section_offsets
,
2834 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
2836 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
2837 do_segments
= (data
!= NULL
);
2838 do_sections
= num_segments
== 0;
2840 if (num_segments
> 0)
2842 segments
[0] = text_addr
;
2843 segments
[1] = data_addr
;
2845 /* If we have two segments, we can still try to relocate everything
2846 by assuming that the .text and .data offsets apply to the whole
2847 text and data segments. Convert the offsets given in the packet
2848 to base addresses for symfile_map_offsets_to_segments. */
2849 else if (data
&& data
->num_segments
== 2)
2851 segments
[0] = data
->segment_bases
[0] + text_addr
;
2852 segments
[1] = data
->segment_bases
[1] + data_addr
;
2855 /* If the object file has only one segment, assume that it is text
2856 rather than data; main programs with no writable data are rare,
2857 but programs with no code are useless. Of course the code might
2858 have ended up in the data segment... to detect that we would need
2859 the permissions here. */
2860 else if (data
&& data
->num_segments
== 1)
2862 segments
[0] = data
->segment_bases
[0] + text_addr
;
2865 /* There's no way to relocate by segment. */
2871 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
2872 offs
, num_segments
, segments
);
2874 if (ret
== 0 && !do_sections
)
2875 error (_("Can not handle qOffsets TextSeg response with this symbol file"));
2882 free_symfile_segment_data (data
);
2886 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
2888 /* This is a temporary kludge to force data and bss to use the same offsets
2889 because that's what nlmconv does now. The real solution requires changes
2890 to the stub and remote.c that I don't have time to do right now. */
2892 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
2893 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
2896 objfile_relocate (symfile_objfile
, offs
);
2899 /* Callback for iterate_over_threads. Set the STOP_REQUESTED flags in
2900 threads we know are stopped already. This is used during the
2901 initial remote connection in non-stop mode --- threads that are
2902 reported as already being stopped are left stopped. */
2905 set_stop_requested_callback (struct thread_info
*thread
, void *data
)
2907 /* If we have a stop reply for this thread, it must be stopped. */
2908 if (peek_stop_reply (thread
->ptid
))
2909 set_stop_requested (thread
->ptid
, 1);
2914 /* Stub for catch_exception. */
2916 struct start_remote_args
2920 /* The current target. */
2921 struct target_ops
*target
;
2923 /* Non-zero if this is an extended-remote target. */
2927 /* Send interrupt_sequence to remote target. */
2929 send_interrupt_sequence ()
2931 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
2932 serial_write (remote_desc
, "\x03", 1);
2933 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
2934 serial_send_break (remote_desc
);
2935 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
2937 serial_send_break (remote_desc
);
2938 serial_write (remote_desc
, "g", 1);
2941 internal_error (__FILE__
, __LINE__
,
2942 _("Invalid value for interrupt_sequence_mode: %s."),
2943 interrupt_sequence_mode
);
2947 remote_start_remote (struct ui_out
*uiout
, void *opaque
)
2949 struct start_remote_args
*args
= opaque
;
2950 struct remote_state
*rs
= get_remote_state ();
2951 struct packet_config
*noack_config
;
2952 char *wait_status
= NULL
;
2954 immediate_quit
++; /* Allow user to interrupt it. */
2956 /* Ack any packet which the remote side has already sent. */
2957 serial_write (remote_desc
, "+", 1);
2959 if (interrupt_on_connect
)
2960 send_interrupt_sequence ();
2962 /* The first packet we send to the target is the optional "supported
2963 packets" request. If the target can answer this, it will tell us
2964 which later probes to skip. */
2965 remote_query_supported ();
2967 /* Next, we possibly activate noack mode.
2969 If the QStartNoAckMode packet configuration is set to AUTO,
2970 enable noack mode if the stub reported a wish for it with
2973 If set to TRUE, then enable noack mode even if the stub didn't
2974 report it in qSupported. If the stub doesn't reply OK, the
2975 session ends with an error.
2977 If FALSE, then don't activate noack mode, regardless of what the
2978 stub claimed should be the default with qSupported. */
2980 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
2982 if (noack_config
->detect
== AUTO_BOOLEAN_TRUE
2983 || (noack_config
->detect
== AUTO_BOOLEAN_AUTO
2984 && noack_config
->support
== PACKET_ENABLE
))
2986 putpkt ("QStartNoAckMode");
2987 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2988 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
2992 if (args
->extended_p
)
2994 /* Tell the remote that we are using the extended protocol. */
2996 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2999 /* Next, if the target can specify a description, read it. We do
3000 this before anything involving memory or registers. */
3001 target_find_description ();
3003 /* Next, now that we know something about the target, update the
3004 address spaces in the program spaces. */
3005 update_address_spaces ();
3007 /* On OSs where the list of libraries is global to all
3008 processes, we fetch them early. */
3009 if (gdbarch_has_global_solist (target_gdbarch
))
3010 solib_add (NULL
, args
->from_tty
, args
->target
, auto_solib_add
);
3014 if (!rs
->non_stop_aware
)
3015 error (_("Non-stop mode requested, but remote does not support non-stop"));
3017 putpkt ("QNonStop:1");
3018 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3020 if (strcmp (rs
->buf
, "OK") != 0)
3021 error ("Remote refused setting non-stop mode with: %s", rs
->buf
);
3023 /* Find about threads and processes the stub is already
3024 controlling. We default to adding them in the running state.
3025 The '?' query below will then tell us about which threads are
3027 remote_threads_info (args
->target
);
3029 else if (rs
->non_stop_aware
)
3031 /* Don't assume that the stub can operate in all-stop mode.
3032 Request it explicitely. */
3033 putpkt ("QNonStop:0");
3034 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3036 if (strcmp (rs
->buf
, "OK") != 0)
3037 error ("Remote refused setting all-stop mode with: %s", rs
->buf
);
3040 /* Check whether the target is running now. */
3042 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3046 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
3048 if (!args
->extended_p
)
3049 error (_("The target is not running (try extended-remote?)"));
3051 /* We're connected, but not running. Drop out before we
3052 call start_remote. */
3057 /* Save the reply for later. */
3058 wait_status
= alloca (strlen (rs
->buf
) + 1);
3059 strcpy (wait_status
, rs
->buf
);
3062 /* Let the stub know that we want it to return the thread. */
3063 set_continue_thread (minus_one_ptid
);
3065 /* Without this, some commands which require an active target
3066 (such as kill) won't work. This variable serves (at least)
3067 double duty as both the pid of the target process (if it has
3068 such), and as a flag indicating that a target is active.
3069 These functions should be split out into seperate variables,
3070 especially since GDB will someday have a notion of debugging
3071 several processes. */
3072 inferior_ptid
= magic_null_ptid
;
3074 /* Now, if we have thread information, update inferior_ptid. */
3075 inferior_ptid
= remote_current_thread (inferior_ptid
);
3077 remote_add_inferior (ptid_get_pid (inferior_ptid
), -1);
3079 /* Always add the main thread. */
3080 add_thread_silent (inferior_ptid
);
3082 get_offsets (); /* Get text, data & bss offsets. */
3084 /* If we could not find a description using qXfer, and we know
3085 how to do it some other way, try again. This is not
3086 supported for non-stop; it could be, but it is tricky if
3087 there are no stopped threads when we connect. */
3088 if (remote_read_description_p (args
->target
)
3089 && gdbarch_target_desc (target_gdbarch
) == NULL
)
3091 target_clear_description ();
3092 target_find_description ();
3095 /* Use the previously fetched status. */
3096 gdb_assert (wait_status
!= NULL
);
3097 strcpy (rs
->buf
, wait_status
);
3098 rs
->cached_wait_status
= 1;
3101 start_remote (args
->from_tty
); /* Initialize gdb process mechanisms. */
3105 /* Clear WFI global state. Do this before finding about new
3106 threads and inferiors, and setting the current inferior.
3107 Otherwise we would clear the proceed status of the current
3108 inferior when we want its stop_soon state to be preserved
3109 (see notice_new_inferior). */
3110 init_wait_for_inferior ();
3112 /* In non-stop, we will either get an "OK", meaning that there
3113 are no stopped threads at this time; or, a regular stop
3114 reply. In the latter case, there may be more than one thread
3115 stopped --- we pull them all out using the vStopped
3117 if (strcmp (rs
->buf
, "OK") != 0)
3119 struct stop_reply
*stop_reply
;
3120 struct cleanup
*old_chain
;
3122 stop_reply
= stop_reply_xmalloc ();
3123 old_chain
= make_cleanup (do_stop_reply_xfree
, stop_reply
);
3125 remote_parse_stop_reply (rs
->buf
, stop_reply
);
3126 discard_cleanups (old_chain
);
3128 /* get_pending_stop_replies acks this one, and gets the rest
3130 pending_stop_reply
= stop_reply
;
3131 remote_get_pending_stop_replies ();
3133 /* Make sure that threads that were stopped remain
3135 iterate_over_threads (set_stop_requested_callback
, NULL
);
3138 if (target_can_async_p ())
3139 target_async (inferior_event_handler
, 0);
3141 if (thread_count () == 0)
3143 if (!args
->extended_p
)
3144 error (_("The target is not running (try extended-remote?)"));
3146 /* We're connected, but not running. Drop out before we
3147 call start_remote. */
3151 /* Let the stub know that we want it to return the thread. */
3153 /* Force the stub to choose a thread. */
3154 set_general_thread (null_ptid
);
3157 inferior_ptid
= remote_current_thread (minus_one_ptid
);
3158 if (ptid_equal (inferior_ptid
, minus_one_ptid
))
3159 error (_("remote didn't report the current thread in non-stop mode"));
3161 get_offsets (); /* Get text, data & bss offsets. */
3163 /* In non-stop mode, any cached wait status will be stored in
3164 the stop reply queue. */
3165 gdb_assert (wait_status
== NULL
);
3167 /* Update the remote on signals to silently pass, or more
3168 importantly, which to not ignore, in case a previous session
3169 had set some different set of signals to be ignored. */
3170 remote_pass_signals ();
3173 /* If we connected to a live target, do some additional setup. */
3174 if (target_has_execution
)
3176 if (exec_bfd
) /* No use without an exec file. */
3177 remote_check_symbols (symfile_objfile
);
3180 /* Possibly the target has been engaged in a trace run started
3181 previously; find out where things are at. */
3182 if (remote_get_trace_status (current_trace_status ()) != -1)
3184 struct uploaded_tp
*uploaded_tps
= NULL
;
3185 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3187 if (current_trace_status ()->running
)
3188 printf_filtered (_("Trace is already running on the target.\n"));
3190 /* Get trace state variables first, they may be checked when
3191 parsing uploaded commands. */
3193 remote_upload_trace_state_variables (&uploaded_tsvs
);
3195 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3197 remote_upload_tracepoints (&uploaded_tps
);
3199 merge_uploaded_tracepoints (&uploaded_tps
);
3202 /* If breakpoints are global, insert them now. */
3203 if (gdbarch_has_global_breakpoints (target_gdbarch
)
3204 && breakpoints_always_inserted_mode ())
3205 insert_breakpoints ();
3208 /* Open a connection to a remote debugger.
3209 NAME is the filename used for communication. */
3212 remote_open (char *name
, int from_tty
)
3214 remote_open_1 (name
, from_tty
, &remote_ops
, 0);
3217 /* Open a connection to a remote debugger using the extended
3218 remote gdb protocol. NAME is the filename used for communication. */
3221 extended_remote_open (char *name
, int from_tty
)
3223 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */);
3226 /* Generic code for opening a connection to a remote target. */
3229 init_all_packet_configs (void)
3232 for (i
= 0; i
< PACKET_MAX
; i
++)
3233 update_packet_config (&remote_protocol_packets
[i
]);
3236 /* Symbol look-up. */
3239 remote_check_symbols (struct objfile
*objfile
)
3241 struct remote_state
*rs
= get_remote_state ();
3242 char *msg
, *reply
, *tmp
;
3243 struct minimal_symbol
*sym
;
3246 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
3249 /* Make sure the remote is pointing at the right process. */
3250 set_general_process ();
3252 /* Allocate a message buffer. We can't reuse the input buffer in RS,
3253 because we need both at the same time. */
3254 msg
= alloca (get_remote_packet_size ());
3256 /* Invite target to request symbol lookups. */
3258 putpkt ("qSymbol::");
3259 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3260 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
3263 while (strncmp (reply
, "qSymbol:", 8) == 0)
3266 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
3268 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
3270 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
3273 int addr_size
= gdbarch_addr_bit (target_gdbarch
) / 8;
3274 CORE_ADDR sym_addr
= SYMBOL_VALUE_ADDRESS (sym
);
3276 /* If this is a function address, return the start of code
3277 instead of any data function descriptor. */
3278 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch
,
3282 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
3283 phex_nz (sym_addr
, addr_size
), &reply
[8]);
3287 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3292 static struct serial
*
3293 remote_serial_open (char *name
)
3295 static int udp_warning
= 0;
3297 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
3298 of in ser-tcp.c, because it is the remote protocol assuming that the
3299 serial connection is reliable and not the serial connection promising
3301 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
3304 The remote protocol may be unreliable over UDP.\n\
3305 Some events may be lost, rendering further debugging impossible."));
3309 return serial_open (name
);
3312 /* This type describes each known response to the qSupported
3314 struct protocol_feature
3316 /* The name of this protocol feature. */
3319 /* The default for this protocol feature. */
3320 enum packet_support default_support
;
3322 /* The function to call when this feature is reported, or after
3323 qSupported processing if the feature is not supported.
3324 The first argument points to this structure. The second
3325 argument indicates whether the packet requested support be
3326 enabled, disabled, or probed (or the default, if this function
3327 is being called at the end of processing and this feature was
3328 not reported). The third argument may be NULL; if not NULL, it
3329 is a NUL-terminated string taken from the packet following
3330 this feature's name and an equals sign. */
3331 void (*func
) (const struct protocol_feature
*, enum packet_support
,
3334 /* The corresponding packet for this feature. Only used if
3335 FUNC is remote_supported_packet. */
3340 remote_supported_packet (const struct protocol_feature
*feature
,
3341 enum packet_support support
,
3342 const char *argument
)
3346 warning (_("Remote qSupported response supplied an unexpected value for"
3347 " \"%s\"."), feature
->name
);
3351 if (remote_protocol_packets
[feature
->packet
].support
3352 == PACKET_SUPPORT_UNKNOWN
)
3353 remote_protocol_packets
[feature
->packet
].support
= support
;
3357 remote_packet_size (const struct protocol_feature
*feature
,
3358 enum packet_support support
, const char *value
)
3360 struct remote_state
*rs
= get_remote_state ();
3365 if (support
!= PACKET_ENABLE
)
3368 if (value
== NULL
|| *value
== '\0')
3370 warning (_("Remote target reported \"%s\" without a size."),
3376 packet_size
= strtol (value
, &value_end
, 16);
3377 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
3379 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
3380 feature
->name
, value
);
3384 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
3386 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
3387 packet_size
, MAX_REMOTE_PACKET_SIZE
);
3388 packet_size
= MAX_REMOTE_PACKET_SIZE
;
3391 /* Record the new maximum packet size. */
3392 rs
->explicit_packet_size
= packet_size
;
3396 remote_multi_process_feature (const struct protocol_feature
*feature
,
3397 enum packet_support support
, const char *value
)
3399 struct remote_state
*rs
= get_remote_state ();
3400 rs
->multi_process_aware
= (support
== PACKET_ENABLE
);
3404 remote_non_stop_feature (const struct protocol_feature
*feature
,
3405 enum packet_support support
, const char *value
)
3407 struct remote_state
*rs
= get_remote_state ();
3408 rs
->non_stop_aware
= (support
== PACKET_ENABLE
);
3412 remote_cond_tracepoint_feature (const struct protocol_feature
*feature
,
3413 enum packet_support support
,
3416 struct remote_state
*rs
= get_remote_state ();
3417 rs
->cond_tracepoints
= (support
== PACKET_ENABLE
);
3421 remote_fast_tracepoint_feature (const struct protocol_feature
*feature
,
3422 enum packet_support support
,
3425 struct remote_state
*rs
= get_remote_state ();
3426 rs
->fast_tracepoints
= (support
== PACKET_ENABLE
);
3430 remote_disconnected_tracing_feature (const struct protocol_feature
*feature
,
3431 enum packet_support support
,
3434 struct remote_state
*rs
= get_remote_state ();
3435 rs
->disconnected_tracing
= (support
== PACKET_ENABLE
);
3438 static struct protocol_feature remote_protocol_features
[] = {
3439 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
3440 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
3441 PACKET_qXfer_auxv
},
3442 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
3443 PACKET_qXfer_features
},
3444 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
3445 PACKET_qXfer_libraries
},
3446 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
3447 PACKET_qXfer_memory_map
},
3448 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
3449 PACKET_qXfer_spu_read
},
3450 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
3451 PACKET_qXfer_spu_write
},
3452 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
3453 PACKET_qXfer_osdata
},
3454 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
3455 PACKET_qXfer_threads
},
3456 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
3457 PACKET_QPassSignals
},
3458 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
3459 PACKET_QStartNoAckMode
},
3460 { "multiprocess", PACKET_DISABLE
, remote_multi_process_feature
, -1 },
3461 { "QNonStop", PACKET_DISABLE
, remote_non_stop_feature
, -1 },
3462 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
3463 PACKET_qXfer_siginfo_read
},
3464 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
3465 PACKET_qXfer_siginfo_write
},
3466 { "ConditionalTracepoints", PACKET_DISABLE
, remote_cond_tracepoint_feature
,
3467 PACKET_ConditionalTracepoints
},
3468 { "FastTracepoints", PACKET_DISABLE
, remote_fast_tracepoint_feature
,
3469 PACKET_FastTracepoints
},
3470 { "DisconnectedTracing", PACKET_DISABLE
, remote_disconnected_tracing_feature
,
3472 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
3474 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
3476 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
3477 PACKET_TracepointSource
},
3480 static char *remote_support_xml
;
3482 /* Register string appended to "xmlRegisters=" in qSupported query. */
3485 register_remote_support_xml (const char *xml ATTRIBUTE_UNUSED
)
3487 #if defined(HAVE_LIBEXPAT)
3488 if (remote_support_xml
== NULL
)
3489 remote_support_xml
= concat ("xmlRegisters=", xml
, NULL
);
3492 char *copy
= xstrdup (remote_support_xml
+ 13);
3493 char *p
= strtok (copy
, ",");
3497 if (strcmp (p
, xml
) == 0)
3504 while ((p
= strtok (NULL
, ",")) != NULL
);
3507 p
= concat (remote_support_xml
, ",", xml
, NULL
);
3508 xfree (remote_support_xml
);
3509 remote_support_xml
= p
;
3515 remote_query_supported_append (char *msg
, const char *append
)
3519 char *p
= concat (msg
, ";", append
, NULL
);
3524 return xstrdup (append
);
3528 remote_query_supported (void)
3530 struct remote_state
*rs
= get_remote_state ();
3533 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
3535 /* The packet support flags are handled differently for this packet
3536 than for most others. We treat an error, a disabled packet, and
3537 an empty response identically: any features which must be reported
3538 to be used will be automatically disabled. An empty buffer
3539 accomplishes this, since that is also the representation for a list
3540 containing no features. */
3543 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
3546 const char *qsupported
= gdbarch_qsupported (target_gdbarch
);
3549 q
= remote_query_supported_append (q
, "multiprocess+");
3552 q
= remote_query_supported_append (q
, qsupported
);
3554 if (remote_support_xml
)
3555 q
= remote_query_supported_append (q
, remote_support_xml
);
3559 char *p
= concat ("qSupported:", q
, NULL
);
3565 putpkt ("qSupported");
3567 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3569 /* If an error occured, warn, but do not return - just reset the
3570 buffer to empty and go on to disable features. */
3571 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
3574 warning (_("Remote failure reply: %s"), rs
->buf
);
3579 memset (seen
, 0, sizeof (seen
));
3584 enum packet_support is_supported
;
3585 char *p
, *end
, *name_end
, *value
;
3587 /* First separate out this item from the rest of the packet. If
3588 there's another item after this, we overwrite the separator
3589 (terminated strings are much easier to work with). */
3591 end
= strchr (p
, ';');
3594 end
= p
+ strlen (p
);
3604 warning (_("empty item in \"qSupported\" response"));
3609 name_end
= strchr (p
, '=');
3612 /* This is a name=value entry. */
3613 is_supported
= PACKET_ENABLE
;
3614 value
= name_end
+ 1;
3623 is_supported
= PACKET_ENABLE
;
3627 is_supported
= PACKET_DISABLE
;
3631 is_supported
= PACKET_SUPPORT_UNKNOWN
;
3635 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p
);
3641 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
3642 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
3644 const struct protocol_feature
*feature
;
3647 feature
= &remote_protocol_features
[i
];
3648 feature
->func (feature
, is_supported
, value
);
3653 /* If we increased the packet size, make sure to increase the global
3654 buffer size also. We delay this until after parsing the entire
3655 qSupported packet, because this is the same buffer we were
3657 if (rs
->buf_size
< rs
->explicit_packet_size
)
3659 rs
->buf_size
= rs
->explicit_packet_size
;
3660 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
3663 /* Handle the defaults for unmentioned features. */
3664 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
3667 const struct protocol_feature
*feature
;
3669 feature
= &remote_protocol_features
[i
];
3670 feature
->func (feature
, feature
->default_support
, NULL
);
3676 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
, int extended_p
)
3678 struct remote_state
*rs
= get_remote_state ();
3681 error (_("To open a remote debug connection, you need to specify what\n"
3682 "serial device is attached to the remote system\n"
3683 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
3685 /* See FIXME above. */
3686 if (!target_async_permitted
)
3687 wait_forever_enabled_p
= 1;
3689 /* If we're connected to a running target, target_preopen will kill it.
3690 But if we're connected to a target system with no running process,
3691 then we will still be connected when it returns. Ask this question
3692 first, before target_preopen has a chance to kill anything. */
3693 if (remote_desc
!= NULL
&& !have_inferiors ())
3696 || query (_("Already connected to a remote target. Disconnect? ")))
3699 error (_("Still connected."));
3702 target_preopen (from_tty
);
3704 unpush_target (target
);
3706 /* This time without a query. If we were connected to an
3707 extended-remote target and target_preopen killed the running
3708 process, we may still be connected. If we are starting "target
3709 remote" now, the extended-remote target will not have been
3710 removed by unpush_target. */
3711 if (remote_desc
!= NULL
&& !have_inferiors ())
3714 /* Make sure we send the passed signals list the next time we resume. */
3715 xfree (last_pass_packet
);
3716 last_pass_packet
= NULL
;
3718 remote_fileio_reset ();
3719 reopen_exec_file ();
3722 remote_desc
= remote_serial_open (name
);
3724 perror_with_name (name
);
3726 if (baud_rate
!= -1)
3728 if (serial_setbaudrate (remote_desc
, baud_rate
))
3730 /* The requested speed could not be set. Error out to
3731 top level after closing remote_desc. Take care to
3732 set remote_desc to NULL to avoid closing remote_desc
3734 serial_close (remote_desc
);
3736 perror_with_name (name
);
3740 serial_raw (remote_desc
);
3742 /* If there is something sitting in the buffer we might take it as a
3743 response to a command, which would be bad. */
3744 serial_flush_input (remote_desc
);
3748 puts_filtered ("Remote debugging using ");
3749 puts_filtered (name
);
3750 puts_filtered ("\n");
3752 push_target (target
); /* Switch to using remote target now. */
3754 /* Register extra event sources in the event loop. */
3755 remote_async_inferior_event_token
3756 = create_async_event_handler (remote_async_inferior_event_handler
,
3758 remote_async_get_pending_events_token
3759 = create_async_event_handler (remote_async_get_pending_events_handler
,
3762 /* Reset the target state; these things will be queried either by
3763 remote_query_supported or as they are needed. */
3764 init_all_packet_configs ();
3765 rs
->cached_wait_status
= 0;
3766 rs
->explicit_packet_size
= 0;
3768 rs
->multi_process_aware
= 0;
3769 rs
->extended
= extended_p
;
3770 rs
->non_stop_aware
= 0;
3771 rs
->waiting_for_stop_reply
= 0;
3772 rs
->ctrlc_pending_p
= 0;
3774 general_thread
= not_sent_ptid
;
3775 continue_thread
= not_sent_ptid
;
3777 /* Probe for ability to use "ThreadInfo" query, as required. */
3778 use_threadinfo_query
= 1;
3779 use_threadextra_query
= 1;
3781 if (target_async_permitted
)
3783 /* With this target we start out by owning the terminal. */
3784 remote_async_terminal_ours_p
= 1;
3786 /* FIXME: cagney/1999-09-23: During the initial connection it is
3787 assumed that the target is already ready and able to respond to
3788 requests. Unfortunately remote_start_remote() eventually calls
3789 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
3790 around this. Eventually a mechanism that allows
3791 wait_for_inferior() to expect/get timeouts will be
3793 wait_forever_enabled_p
= 0;
3796 /* First delete any symbols previously loaded from shared libraries. */
3797 no_shared_libraries (NULL
, 0);
3800 init_thread_list ();
3802 /* Start the remote connection. If error() or QUIT, discard this
3803 target (we'd otherwise be in an inconsistent state) and then
3804 propogate the error on up the exception chain. This ensures that
3805 the caller doesn't stumble along blindly assuming that the
3806 function succeeded. The CLI doesn't have this problem but other
3807 UI's, such as MI do.
3809 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
3810 this function should return an error indication letting the
3811 caller restore the previous state. Unfortunately the command
3812 ``target remote'' is directly wired to this function making that
3813 impossible. On a positive note, the CLI side of this problem has
3814 been fixed - the function set_cmd_context() makes it possible for
3815 all the ``target ....'' commands to share a common callback
3816 function. See cli-dump.c. */
3818 struct gdb_exception ex
;
3819 struct start_remote_args args
;
3821 args
.from_tty
= from_tty
;
3822 args
.target
= target
;
3823 args
.extended_p
= extended_p
;
3825 ex
= catch_exception (uiout
, remote_start_remote
, &args
, RETURN_MASK_ALL
);
3828 /* Pop the partially set up target - unless something else did
3829 already before throwing the exception. */
3830 if (remote_desc
!= NULL
)
3832 if (target_async_permitted
)
3833 wait_forever_enabled_p
= 1;
3834 throw_exception (ex
);
3838 if (target_async_permitted
)
3839 wait_forever_enabled_p
= 1;
3842 /* This takes a program previously attached to and detaches it. After
3843 this is done, GDB can be used to debug some other program. We
3844 better not have left any breakpoints in the target program or it'll
3845 die when it hits one. */
3848 remote_detach_1 (char *args
, int from_tty
, int extended
)
3850 int pid
= ptid_get_pid (inferior_ptid
);
3851 struct remote_state
*rs
= get_remote_state ();
3854 error (_("Argument given to \"detach\" when remotely debugging."));
3856 if (!target_has_execution
)
3857 error (_("No process to detach from."));
3859 /* Tell the remote target to detach. */
3860 if (remote_multi_process_p (rs
))
3861 sprintf (rs
->buf
, "D;%x", pid
);
3863 strcpy (rs
->buf
, "D");
3866 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3868 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
3870 else if (rs
->buf
[0] == '\0')
3871 error (_("Remote doesn't know how to detach"));
3873 error (_("Can't detach process."));
3877 if (remote_multi_process_p (rs
))
3878 printf_filtered (_("Detached from remote %s.\n"),
3879 target_pid_to_str (pid_to_ptid (pid
)));
3883 puts_filtered (_("Detached from remote process.\n"));
3885 puts_filtered (_("Ending remote debugging.\n"));
3889 discard_pending_stop_replies (pid
);
3890 target_mourn_inferior ();
3894 remote_detach (struct target_ops
*ops
, char *args
, int from_tty
)
3896 remote_detach_1 (args
, from_tty
, 0);
3900 extended_remote_detach (struct target_ops
*ops
, char *args
, int from_tty
)
3902 remote_detach_1 (args
, from_tty
, 1);
3905 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
3908 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
3911 error (_("Argument given to \"disconnect\" when remotely debugging."));
3913 /* Make sure we unpush even the extended remote targets; mourn
3914 won't do it. So call remote_mourn_1 directly instead of
3915 target_mourn_inferior. */
3916 remote_mourn_1 (target
);
3919 puts_filtered ("Ending remote debugging.\n");
3922 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
3923 be chatty about it. */
3926 extended_remote_attach_1 (struct target_ops
*target
, char *args
, int from_tty
)
3928 struct remote_state
*rs
= get_remote_state ();
3930 char *wait_status
= NULL
;
3932 pid
= parse_pid_to_attach (args
);
3934 /* Remote PID can be freely equal to getpid, do not check it here the same
3935 way as in other targets. */
3937 if (remote_protocol_packets
[PACKET_vAttach
].support
== PACKET_DISABLE
)
3938 error (_("This target does not support attaching to a process"));
3940 sprintf (rs
->buf
, "vAttach;%x", pid
);
3942 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3944 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vAttach
]) == PACKET_OK
)
3947 printf_unfiltered (_("Attached to %s\n"),
3948 target_pid_to_str (pid_to_ptid (pid
)));
3952 /* Save the reply for later. */
3953 wait_status
= alloca (strlen (rs
->buf
) + 1);
3954 strcpy (wait_status
, rs
->buf
);
3956 else if (strcmp (rs
->buf
, "OK") != 0)
3957 error (_("Attaching to %s failed with: %s"),
3958 target_pid_to_str (pid_to_ptid (pid
)),
3961 else if (remote_protocol_packets
[PACKET_vAttach
].support
== PACKET_DISABLE
)
3962 error (_("This target does not support attaching to a process"));
3964 error (_("Attaching to %s failed"),
3965 target_pid_to_str (pid_to_ptid (pid
)));
3967 set_current_inferior (remote_add_inferior (pid
, 1));
3969 inferior_ptid
= pid_to_ptid (pid
);
3973 struct thread_info
*thread
;
3975 /* Get list of threads. */
3976 remote_threads_info (target
);
3978 thread
= first_thread_of_process (pid
);
3980 inferior_ptid
= thread
->ptid
;
3982 inferior_ptid
= pid_to_ptid (pid
);
3984 /* Invalidate our notion of the remote current thread. */
3985 record_currthread (minus_one_ptid
);
3989 /* Now, if we have thread information, update inferior_ptid. */
3990 inferior_ptid
= remote_current_thread (inferior_ptid
);
3992 /* Add the main thread to the thread list. */
3993 add_thread_silent (inferior_ptid
);
3996 /* Next, if the target can specify a description, read it. We do
3997 this before anything involving memory or registers. */
3998 target_find_description ();
4002 /* Use the previously fetched status. */
4003 gdb_assert (wait_status
!= NULL
);
4005 if (target_can_async_p ())
4007 struct stop_reply
*stop_reply
;
4008 struct cleanup
*old_chain
;
4010 stop_reply
= stop_reply_xmalloc ();
4011 old_chain
= make_cleanup (do_stop_reply_xfree
, stop_reply
);
4012 remote_parse_stop_reply (wait_status
, stop_reply
);
4013 discard_cleanups (old_chain
);
4014 push_stop_reply (stop_reply
);
4016 target_async (inferior_event_handler
, 0);
4020 gdb_assert (wait_status
!= NULL
);
4021 strcpy (rs
->buf
, wait_status
);
4022 rs
->cached_wait_status
= 1;
4026 gdb_assert (wait_status
== NULL
);
4030 extended_remote_attach (struct target_ops
*ops
, char *args
, int from_tty
)
4032 extended_remote_attach_1 (ops
, args
, from_tty
);
4035 /* Convert hex digit A to a number. */
4040 if (a
>= '0' && a
<= '9')
4042 else if (a
>= 'a' && a
<= 'f')
4043 return a
- 'a' + 10;
4044 else if (a
>= 'A' && a
<= 'F')
4045 return a
- 'A' + 10;
4047 error (_("Reply contains invalid hex digit %d"), a
);
4051 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
4055 for (i
= 0; i
< count
; i
++)
4057 if (hex
[0] == 0 || hex
[1] == 0)
4059 /* Hex string is short, or of uneven length.
4060 Return the count that has been converted so far. */
4063 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
4069 /* Convert number NIB to a hex digit. */
4077 return 'a' + nib
- 10;
4081 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
4084 /* May use a length, or a nul-terminated string as input. */
4086 count
= strlen ((char *) bin
);
4088 for (i
= 0; i
< count
; i
++)
4090 *hex
++ = tohex ((*bin
>> 4) & 0xf);
4091 *hex
++ = tohex (*bin
++ & 0xf);
4097 /* Check for the availability of vCont. This function should also check
4101 remote_vcont_probe (struct remote_state
*rs
)
4105 strcpy (rs
->buf
, "vCont?");
4107 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4110 /* Make sure that the features we assume are supported. */
4111 if (strncmp (buf
, "vCont", 5) == 0)
4114 int support_s
, support_S
, support_c
, support_C
;
4120 rs
->support_vCont_t
= 0;
4121 while (p
&& *p
== ';')
4124 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4126 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4128 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4130 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4132 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
4133 rs
->support_vCont_t
= 1;
4135 p
= strchr (p
, ';');
4138 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
4139 BUF will make packet_ok disable the packet. */
4140 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
4144 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
4147 /* Helper function for building "vCont" resumptions. Write a
4148 resumption to P. ENDP points to one-passed-the-end of the buffer
4149 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
4150 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
4151 resumed thread should be single-stepped and/or signalled. If PTID
4152 equals minus_one_ptid, then all threads are resumed; if PTID
4153 represents a process, then all threads of the process are resumed;
4154 the thread to be stepped and/or signalled is given in the global
4158 append_resumption (char *p
, char *endp
,
4159 ptid_t ptid
, int step
, enum target_signal siggnal
)
4161 struct remote_state
*rs
= get_remote_state ();
4163 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
4164 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
4166 p
+= xsnprintf (p
, endp
- p
, ";s");
4167 else if (siggnal
!= TARGET_SIGNAL_0
)
4168 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
4170 p
+= xsnprintf (p
, endp
- p
, ";c");
4172 if (remote_multi_process_p (rs
) && ptid_is_pid (ptid
))
4176 /* All (-1) threads of process. */
4177 nptid
= ptid_build (ptid_get_pid (ptid
), 0, -1);
4179 p
+= xsnprintf (p
, endp
- p
, ":");
4180 p
= write_ptid (p
, endp
, nptid
);
4182 else if (!ptid_equal (ptid
, minus_one_ptid
))
4184 p
+= xsnprintf (p
, endp
- p
, ":");
4185 p
= write_ptid (p
, endp
, ptid
);
4191 /* Resume the remote inferior by using a "vCont" packet. The thread
4192 to be resumed is PTID; STEP and SIGGNAL indicate whether the
4193 resumed thread should be single-stepped and/or signalled. If PTID
4194 equals minus_one_ptid, then all threads are resumed; the thread to
4195 be stepped and/or signalled is given in the global INFERIOR_PTID.
4196 This function returns non-zero iff it resumes the inferior.
4198 This function issues a strict subset of all possible vCont commands at the
4202 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
4204 struct remote_state
*rs
= get_remote_state ();
4208 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
4209 remote_vcont_probe (rs
);
4211 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
4215 endp
= rs
->buf
+ get_remote_packet_size ();
4217 /* If we could generate a wider range of packets, we'd have to worry
4218 about overflowing BUF. Should there be a generic
4219 "multi-part-packet" packet? */
4221 p
+= xsnprintf (p
, endp
- p
, "vCont");
4223 if (ptid_equal (ptid
, magic_null_ptid
))
4225 /* MAGIC_NULL_PTID means that we don't have any active threads,
4226 so we don't have any TID numbers the inferior will
4227 understand. Make sure to only send forms that do not specify
4229 p
= append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
4231 else if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
4233 /* Resume all threads (of all processes, or of a single
4234 process), with preference for INFERIOR_PTID. This assumes
4235 inferior_ptid belongs to the set of all threads we are about
4237 if (step
|| siggnal
!= TARGET_SIGNAL_0
)
4239 /* Step inferior_ptid, with or without signal. */
4240 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
4243 /* And continue others without a signal. */
4244 p
= append_resumption (p
, endp
, ptid
, /*step=*/ 0, TARGET_SIGNAL_0
);
4248 /* Scheduler locking; resume only PTID. */
4249 p
= append_resumption (p
, endp
, ptid
, step
, siggnal
);
4252 gdb_assert (strlen (rs
->buf
) < get_remote_packet_size ());
4257 /* In non-stop, the stub replies to vCont with "OK". The stop
4258 reply will be reported asynchronously by means of a `%Stop'
4260 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4261 if (strcmp (rs
->buf
, "OK") != 0)
4262 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
);
4268 /* Tell the remote machine to resume. */
4270 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
4272 static int last_sent_step
;
4275 remote_resume (struct target_ops
*ops
,
4276 ptid_t ptid
, int step
, enum target_signal siggnal
)
4278 struct remote_state
*rs
= get_remote_state ();
4281 last_sent_signal
= siggnal
;
4282 last_sent_step
= step
;
4284 /* Update the inferior on signals to silently pass, if they've changed. */
4285 remote_pass_signals ();
4287 /* The vCont packet doesn't need to specify threads via Hc. */
4288 /* No reverse support (yet) for vCont. */
4289 if (execution_direction
!= EXEC_REVERSE
)
4290 if (remote_vcont_resume (ptid
, step
, siggnal
))
4293 /* All other supported resume packets do use Hc, so set the continue
4295 if (ptid_equal (ptid
, minus_one_ptid
))
4296 set_continue_thread (any_thread_ptid
);
4298 set_continue_thread (ptid
);
4301 if (execution_direction
== EXEC_REVERSE
)
4303 /* We don't pass signals to the target in reverse exec mode. */
4304 if (info_verbose
&& siggnal
!= TARGET_SIGNAL_0
)
4305 warning (" - Can't pass signal %d to target in reverse: ignored.\n",
4309 && remote_protocol_packets
[PACKET_bs
].support
== PACKET_DISABLE
)
4310 error (_("Remote reverse-step not supported."));
4312 && remote_protocol_packets
[PACKET_bc
].support
== PACKET_DISABLE
)
4313 error (_("Remote reverse-continue not supported."));
4315 strcpy (buf
, step
? "bs" : "bc");
4317 else if (siggnal
!= TARGET_SIGNAL_0
)
4319 buf
[0] = step
? 'S' : 'C';
4320 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
4321 buf
[2] = tohex (((int) siggnal
) & 0xf);
4325 strcpy (buf
, step
? "s" : "c");
4330 /* We are about to start executing the inferior, let's register it
4331 with the event loop. NOTE: this is the one place where all the
4332 execution commands end up. We could alternatively do this in each
4333 of the execution commands in infcmd.c. */
4334 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
4335 into infcmd.c in order to allow inferior function calls to work
4336 NOT asynchronously. */
4337 if (target_can_async_p ())
4338 target_async (inferior_event_handler
, 0);
4340 /* We've just told the target to resume. The remote server will
4341 wait for the inferior to stop, and then send a stop reply. In
4342 the mean time, we can't start another command/query ourselves
4343 because the stub wouldn't be ready to process it. This applies
4344 only to the base all-stop protocol, however. In non-stop (which
4345 only supports vCont), the stub replies with an "OK", and is
4346 immediate able to process further serial input. */
4348 rs
->waiting_for_stop_reply
= 1;
4352 /* Set up the signal handler for SIGINT, while the target is
4353 executing, ovewriting the 'regular' SIGINT signal handler. */
4355 initialize_sigint_signal_handler (void)
4357 signal (SIGINT
, handle_remote_sigint
);
4360 /* Signal handler for SIGINT, while the target is executing. */
4362 handle_remote_sigint (int sig
)
4364 signal (sig
, handle_remote_sigint_twice
);
4365 mark_async_signal_handler_wrapper (sigint_remote_token
);
4368 /* Signal handler for SIGINT, installed after SIGINT has already been
4369 sent once. It will take effect the second time that the user sends
4372 handle_remote_sigint_twice (int sig
)
4374 signal (sig
, handle_remote_sigint
);
4375 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
4378 /* Perform the real interruption of the target execution, in response
4381 async_remote_interrupt (gdb_client_data arg
)
4384 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
4386 target_stop (inferior_ptid
);
4389 /* Perform interrupt, if the first attempt did not succeed. Just give
4390 up on the target alltogether. */
4392 async_remote_interrupt_twice (gdb_client_data arg
)
4395 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
4400 /* Reinstall the usual SIGINT handlers, after the target has
4403 cleanup_sigint_signal_handler (void *dummy
)
4405 signal (SIGINT
, handle_sigint
);
4408 /* Send ^C to target to halt it. Target will respond, and send us a
4410 static void (*ofunc
) (int);
4412 /* The command line interface's stop routine. This function is installed
4413 as a signal handler for SIGINT. The first time a user requests a
4414 stop, we call remote_stop to send a break or ^C. If there is no
4415 response from the target (it didn't stop when the user requested it),
4416 we ask the user if he'd like to detach from the target. */
4418 remote_interrupt (int signo
)
4420 /* If this doesn't work, try more severe steps. */
4421 signal (signo
, remote_interrupt_twice
);
4423 gdb_call_async_signal_handler (sigint_remote_token
, 1);
4426 /* The user typed ^C twice. */
4429 remote_interrupt_twice (int signo
)
4431 signal (signo
, ofunc
);
4432 gdb_call_async_signal_handler (sigint_remote_twice_token
, 1);
4433 signal (signo
, remote_interrupt
);
4436 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
4437 thread, all threads of a remote process, or all threads of all
4441 remote_stop_ns (ptid_t ptid
)
4443 struct remote_state
*rs
= get_remote_state ();
4445 char *endp
= rs
->buf
+ get_remote_packet_size ();
4447 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
4448 remote_vcont_probe (rs
);
4450 if (!rs
->support_vCont_t
)
4451 error (_("Remote server does not support stopping threads"));
4453 if (ptid_equal (ptid
, minus_one_ptid
)
4454 || (!remote_multi_process_p (rs
) && ptid_is_pid (ptid
)))
4455 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
4460 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
4462 if (ptid_is_pid (ptid
))
4463 /* All (-1) threads of process. */
4464 nptid
= ptid_build (ptid_get_pid (ptid
), 0, -1);
4467 /* Small optimization: if we already have a stop reply for
4468 this thread, no use in telling the stub we want this
4470 if (peek_stop_reply (ptid
))
4476 p
= write_ptid (p
, endp
, nptid
);
4479 /* In non-stop, we get an immediate OK reply. The stop reply will
4480 come in asynchronously by notification. */
4482 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4483 if (strcmp (rs
->buf
, "OK") != 0)
4484 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
), rs
->buf
);
4487 /* All-stop version of target_stop. Sends a break or a ^C to stop the
4488 remote target. It is undefined which thread of which process
4489 reports the stop. */
4492 remote_stop_as (ptid_t ptid
)
4494 struct remote_state
*rs
= get_remote_state ();
4496 rs
->ctrlc_pending_p
= 1;
4498 /* If the inferior is stopped already, but the core didn't know
4499 about it yet, just ignore the request. The cached wait status
4500 will be collected in remote_wait. */
4501 if (rs
->cached_wait_status
)
4504 /* Send interrupt_sequence to remote target. */
4505 send_interrupt_sequence ();
4508 /* This is the generic stop called via the target vector. When a target
4509 interrupt is requested, either by the command line or the GUI, we
4510 will eventually end up here. */
4513 remote_stop (ptid_t ptid
)
4516 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
4519 remote_stop_ns (ptid
);
4521 remote_stop_as (ptid
);
4524 /* Ask the user what to do when an interrupt is received. */
4527 interrupt_query (void)
4529 target_terminal_ours ();
4531 if (target_can_async_p ())
4533 signal (SIGINT
, handle_sigint
);
4534 deprecated_throw_reason (RETURN_QUIT
);
4538 if (query (_("Interrupted while waiting for the program.\n\
4539 Give up (and stop debugging it)? ")))
4542 deprecated_throw_reason (RETURN_QUIT
);
4546 target_terminal_inferior ();
4549 /* Enable/disable target terminal ownership. Most targets can use
4550 terminal groups to control terminal ownership. Remote targets are
4551 different in that explicit transfer of ownership to/from GDB/target
4555 remote_terminal_inferior (void)
4557 if (!target_async_permitted
)
4558 /* Nothing to do. */
4561 /* FIXME: cagney/1999-09-27: Make calls to target_terminal_*()
4562 idempotent. The event-loop GDB talking to an asynchronous target
4563 with a synchronous command calls this function from both
4564 event-top.c and infrun.c/infcmd.c. Once GDB stops trying to
4565 transfer the terminal to the target when it shouldn't this guard
4567 if (!remote_async_terminal_ours_p
)
4569 delete_file_handler (input_fd
);
4570 remote_async_terminal_ours_p
= 0;
4571 initialize_sigint_signal_handler ();
4572 /* NOTE: At this point we could also register our selves as the
4573 recipient of all input. Any characters typed could then be
4574 passed on down to the target. */
4578 remote_terminal_ours (void)
4580 if (!target_async_permitted
)
4581 /* Nothing to do. */
4584 /* See FIXME in remote_terminal_inferior. */
4585 if (remote_async_terminal_ours_p
)
4587 cleanup_sigint_signal_handler (NULL
);
4588 add_file_handler (input_fd
, stdin_event_handler
, 0);
4589 remote_async_terminal_ours_p
= 1;
4593 remote_console_output (char *msg
)
4597 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
4600 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
4603 fputs_unfiltered (tb
, gdb_stdtarg
);
4605 gdb_flush (gdb_stdtarg
);
4608 typedef struct cached_reg
4611 gdb_byte data
[MAX_REGISTER_SIZE
];
4614 DEF_VEC_O(cached_reg_t
);
4618 struct stop_reply
*next
;
4622 struct target_waitstatus ws
;
4624 VEC(cached_reg_t
) *regcache
;
4626 int stopped_by_watchpoint_p
;
4627 CORE_ADDR watch_data_address
;
4635 /* The list of already fetched and acknowledged stop events. */
4636 static struct stop_reply
*stop_reply_queue
;
4638 static struct stop_reply
*
4639 stop_reply_xmalloc (void)
4641 struct stop_reply
*r
= XMALLOC (struct stop_reply
);
4647 stop_reply_xfree (struct stop_reply
*r
)
4651 VEC_free (cached_reg_t
, r
->regcache
);
4656 /* Discard all pending stop replies of inferior PID. If PID is -1,
4657 discard everything. */
4660 discard_pending_stop_replies (int pid
)
4662 struct stop_reply
*prev
= NULL
, *reply
, *next
;
4664 /* Discard the in-flight notification. */
4665 if (pending_stop_reply
!= NULL
4667 || ptid_get_pid (pending_stop_reply
->ptid
) == pid
))
4669 stop_reply_xfree (pending_stop_reply
);
4670 pending_stop_reply
= NULL
;
4673 /* Discard the stop replies we have already pulled with
4675 for (reply
= stop_reply_queue
; reply
; reply
= next
)
4679 || ptid_get_pid (reply
->ptid
) == pid
)
4681 if (reply
== stop_reply_queue
)
4682 stop_reply_queue
= reply
->next
;
4684 prev
->next
= reply
->next
;
4686 stop_reply_xfree (reply
);
4693 /* Cleanup wrapper. */
4696 do_stop_reply_xfree (void *arg
)
4698 struct stop_reply
*r
= arg
;
4699 stop_reply_xfree (r
);
4702 /* Look for a queued stop reply belonging to PTID. If one is found,
4703 remove it from the queue, and return it. Returns NULL if none is
4704 found. If there are still queued events left to process, tell the
4705 event loop to get back to target_wait soon. */
4707 static struct stop_reply
*
4708 queued_stop_reply (ptid_t ptid
)
4710 struct stop_reply
*it
;
4711 struct stop_reply
**it_link
;
4713 it
= stop_reply_queue
;
4714 it_link
= &stop_reply_queue
;
4717 if (ptid_match (it
->ptid
, ptid
))
4719 *it_link
= it
->next
;
4724 it_link
= &it
->next
;
4728 if (stop_reply_queue
)
4729 /* There's still at least an event left. */
4730 mark_async_event_handler (remote_async_inferior_event_token
);
4735 /* Push a fully parsed stop reply in the stop reply queue. Since we
4736 know that we now have at least one queued event left to pass to the
4737 core side, tell the event loop to get back to target_wait soon. */
4740 push_stop_reply (struct stop_reply
*new_event
)
4742 struct stop_reply
*event
;
4744 if (stop_reply_queue
)
4746 for (event
= stop_reply_queue
;
4747 event
&& event
->next
;
4748 event
= event
->next
)
4751 event
->next
= new_event
;
4754 stop_reply_queue
= new_event
;
4756 mark_async_event_handler (remote_async_inferior_event_token
);
4759 /* Returns true if we have a stop reply for PTID. */
4762 peek_stop_reply (ptid_t ptid
)
4764 struct stop_reply
*it
;
4766 for (it
= stop_reply_queue
; it
; it
= it
->next
)
4767 if (ptid_equal (ptid
, it
->ptid
))
4769 if (it
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
4776 /* Parse the stop reply in BUF. Either the function succeeds, and the
4777 result is stored in EVENT, or throws an error. */
4780 remote_parse_stop_reply (char *buf
, struct stop_reply
*event
)
4782 struct remote_arch_state
*rsa
= get_remote_arch_state ();
4786 event
->ptid
= null_ptid
;
4787 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
4788 event
->ws
.value
.integer
= 0;
4789 event
->solibs_changed
= 0;
4790 event
->replay_event
= 0;
4791 event
->stopped_by_watchpoint_p
= 0;
4792 event
->regcache
= NULL
;
4797 case 'T': /* Status with PC, SP, FP, ... */
4798 /* Expedited reply, containing Signal, {regno, reg} repeat. */
4799 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
4801 n... = register number
4802 r... = register contents
4805 p
= &buf
[3]; /* after Txx */
4813 /* If the packet contains a register number, save it in
4814 pnum and set p1 to point to the character following it.
4815 Otherwise p1 points to p. */
4817 /* If this packet is an awatch packet, don't parse the 'a'
4818 as a register number. */
4820 if (strncmp (p
, "awatch", strlen("awatch")) != 0
4821 && strncmp (p
, "core", strlen ("core") != 0))
4823 /* Read the ``P'' register number. */
4824 pnum
= strtol (p
, &p_temp
, 16);
4830 if (p1
== p
) /* No register number present here. */
4832 p1
= strchr (p
, ':');
4834 error (_("Malformed packet(a) (missing colon): %s\n\
4837 if (strncmp (p
, "thread", p1
- p
) == 0)
4838 event
->ptid
= read_ptid (++p1
, &p
);
4839 else if ((strncmp (p
, "watch", p1
- p
) == 0)
4840 || (strncmp (p
, "rwatch", p1
- p
) == 0)
4841 || (strncmp (p
, "awatch", p1
- p
) == 0))
4843 event
->stopped_by_watchpoint_p
= 1;
4844 p
= unpack_varlen_hex (++p1
, &addr
);
4845 event
->watch_data_address
= (CORE_ADDR
) addr
;
4847 else if (strncmp (p
, "library", p1
- p
) == 0)
4851 while (*p_temp
&& *p_temp
!= ';')
4854 event
->solibs_changed
= 1;
4857 else if (strncmp (p
, "replaylog", p1
- p
) == 0)
4859 /* NO_HISTORY event.
4860 p1 will indicate "begin" or "end", but
4861 it makes no difference for now, so ignore it. */
4862 event
->replay_event
= 1;
4863 p_temp
= strchr (p1
+ 1, ';');
4867 else if (strncmp (p
, "core", p1
- p
) == 0)
4870 p
= unpack_varlen_hex (++p1
, &c
);
4875 /* Silently skip unknown optional info. */
4876 p_temp
= strchr (p1
+ 1, ';');
4883 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
4884 cached_reg_t cached_reg
;
4889 error (_("Malformed packet(b) (missing colon): %s\n\
4895 error (_("Remote sent bad register number %s: %s\n\
4897 hex_string (pnum
), p
, buf
);
4899 cached_reg
.num
= reg
->regnum
;
4901 fieldsize
= hex2bin (p
, cached_reg
.data
,
4902 register_size (target_gdbarch
,
4905 if (fieldsize
< register_size (target_gdbarch
,
4907 warning (_("Remote reply is too short: %s"), buf
);
4909 VEC_safe_push (cached_reg_t
, event
->regcache
, &cached_reg
);
4913 error (_("Remote register badly formatted: %s\nhere: %s"),
4918 case 'S': /* Old style status, just signal only. */
4919 if (event
->solibs_changed
)
4920 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
4921 else if (event
->replay_event
)
4922 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
4925 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
4926 event
->ws
.value
.sig
= (enum target_signal
)
4927 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
4930 case 'W': /* Target exited. */
4937 /* GDB used to accept only 2 hex chars here. Stubs should
4938 only send more if they detect GDB supports multi-process
4940 p
= unpack_varlen_hex (&buf
[1], &value
);
4944 /* The remote process exited. */
4945 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
4946 event
->ws
.value
.integer
= value
;
4950 /* The remote process exited with a signal. */
4951 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
4952 event
->ws
.value
.sig
= (enum target_signal
) value
;
4955 /* If no process is specified, assume inferior_ptid. */
4956 pid
= ptid_get_pid (inferior_ptid
);
4965 else if (strncmp (p
,
4966 "process:", sizeof ("process:") - 1) == 0)
4969 p
+= sizeof ("process:") - 1;
4970 unpack_varlen_hex (p
, &upid
);
4974 error (_("unknown stop reply packet: %s"), buf
);
4977 error (_("unknown stop reply packet: %s"), buf
);
4978 event
->ptid
= pid_to_ptid (pid
);
4983 if (non_stop
&& ptid_equal (event
->ptid
, null_ptid
))
4984 error (_("No process or thread specified in stop reply: %s"), buf
);
4987 /* When the stub wants to tell GDB about a new stop reply, it sends a
4988 stop notification (%Stop). Those can come it at any time, hence,
4989 we have to make sure that any pending putpkt/getpkt sequence we're
4990 making is finished, before querying the stub for more events with
4991 vStopped. E.g., if we started a vStopped sequence immediatelly
4992 upon receiving the %Stop notification, something like this could
5000 1.6) <-- (registers reply to step #1.3)
5002 Obviously, the reply in step #1.6 would be unexpected to a vStopped
5005 To solve this, whenever we parse a %Stop notification sucessfully,
5006 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
5007 doing whatever we were doing:
5013 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
5014 2.5) <-- (registers reply to step #2.3)
5016 Eventualy after step #2.5, we return to the event loop, which
5017 notices there's an event on the
5018 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
5019 associated callback --- the function below. At this point, we're
5020 always safe to start a vStopped sequence. :
5023 2.7) <-- T05 thread:2
5029 remote_get_pending_stop_replies (void)
5031 struct remote_state
*rs
= get_remote_state ();
5033 if (pending_stop_reply
)
5036 putpkt ("vStopped");
5038 /* Now we can rely on it. */
5039 push_stop_reply (pending_stop_reply
);
5040 pending_stop_reply
= NULL
;
5044 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5045 if (strcmp (rs
->buf
, "OK") == 0)
5049 struct cleanup
*old_chain
;
5050 struct stop_reply
*stop_reply
= stop_reply_xmalloc ();
5052 old_chain
= make_cleanup (do_stop_reply_xfree
, stop_reply
);
5053 remote_parse_stop_reply (rs
->buf
, stop_reply
);
5056 putpkt ("vStopped");
5058 if (stop_reply
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
5060 /* Now we can rely on it. */
5061 discard_cleanups (old_chain
);
5062 push_stop_reply (stop_reply
);
5065 /* We got an unknown stop reply. */
5066 do_cleanups (old_chain
);
5073 /* Called when it is decided that STOP_REPLY holds the info of the
5074 event that is to be returned to the core. This function always
5075 destroys STOP_REPLY. */
5078 process_stop_reply (struct stop_reply
*stop_reply
,
5079 struct target_waitstatus
*status
)
5082 struct thread_info
*info
;
5084 *status
= stop_reply
->ws
;
5085 ptid
= stop_reply
->ptid
;
5087 /* If no thread/process was reported by the stub, assume the current
5089 if (ptid_equal (ptid
, null_ptid
))
5090 ptid
= inferior_ptid
;
5092 if (status
->kind
!= TARGET_WAITKIND_EXITED
5093 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
5095 /* Expedited registers. */
5096 if (stop_reply
->regcache
)
5098 struct regcache
*regcache
5099 = get_thread_arch_regcache (ptid
, target_gdbarch
);
5104 VEC_iterate(cached_reg_t
, stop_reply
->regcache
, ix
, reg
);
5106 regcache_raw_supply (regcache
, reg
->num
, reg
->data
);
5107 VEC_free (cached_reg_t
, stop_reply
->regcache
);
5110 remote_stopped_by_watchpoint_p
= stop_reply
->stopped_by_watchpoint_p
;
5111 remote_watch_data_address
= stop_reply
->watch_data_address
;
5113 remote_notice_new_inferior (ptid
, 0);
5114 demand_private_info (ptid
)->core
= stop_reply
->core
;
5117 stop_reply_xfree (stop_reply
);
5121 /* The non-stop mode version of target_wait. */
5124 remote_wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
5126 struct remote_state
*rs
= get_remote_state ();
5127 struct stop_reply
*stop_reply
;
5130 /* If in non-stop mode, get out of getpkt even if a
5131 notification is received. */
5133 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
5140 case 'E': /* Error of some sort. */
5141 /* We're out of sync with the target now. Did it continue
5142 or not? We can't tell which thread it was in non-stop,
5143 so just ignore this. */
5144 warning (_("Remote failure reply: %s"), rs
->buf
);
5146 case 'O': /* Console output. */
5147 remote_console_output (rs
->buf
+ 1);
5150 warning (_("Invalid remote reply: %s"), rs
->buf
);
5154 /* Acknowledge a pending stop reply that may have arrived in the
5156 if (pending_stop_reply
!= NULL
)
5157 remote_get_pending_stop_replies ();
5159 /* If indeed we noticed a stop reply, we're done. */
5160 stop_reply
= queued_stop_reply (ptid
);
5161 if (stop_reply
!= NULL
)
5162 return process_stop_reply (stop_reply
, status
);
5164 /* Still no event. If we're just polling for an event, then
5165 return to the event loop. */
5166 if (options
& TARGET_WNOHANG
)
5168 status
->kind
= TARGET_WAITKIND_IGNORE
;
5169 return minus_one_ptid
;
5172 /* Otherwise do a blocking wait. */
5173 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
5178 /* Wait until the remote machine stops, then return, storing status in
5179 STATUS just as `wait' would. */
5182 remote_wait_as (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
5184 struct remote_state
*rs
= get_remote_state ();
5185 ptid_t event_ptid
= null_ptid
;
5187 struct stop_reply
*stop_reply
;
5191 status
->kind
= TARGET_WAITKIND_IGNORE
;
5192 status
->value
.integer
= 0;
5194 stop_reply
= queued_stop_reply (ptid
);
5195 if (stop_reply
!= NULL
)
5196 return process_stop_reply (stop_reply
, status
);
5198 if (rs
->cached_wait_status
)
5199 /* Use the cached wait status, but only once. */
5200 rs
->cached_wait_status
= 0;
5205 if (!target_is_async_p ())
5207 ofunc
= signal (SIGINT
, remote_interrupt
);
5208 /* If the user hit C-c before this packet, or between packets,
5209 pretend that it was hit right here. */
5213 remote_interrupt (SIGINT
);
5217 /* FIXME: cagney/1999-09-27: If we're in async mode we should
5218 _never_ wait for ever -> test on target_is_async_p().
5219 However, before we do that we need to ensure that the caller
5220 knows how to take the target into/out of async mode. */
5221 ret
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
5222 if (!target_is_async_p ())
5223 signal (SIGINT
, ofunc
);
5228 remote_stopped_by_watchpoint_p
= 0;
5230 /* We got something. */
5231 rs
->waiting_for_stop_reply
= 0;
5233 /* Assume that the target has acknowledged Ctrl-C unless we receive
5234 an 'F' or 'O' packet. */
5235 if (buf
[0] != 'F' && buf
[0] != 'O')
5236 rs
->ctrlc_pending_p
= 0;
5240 case 'E': /* Error of some sort. */
5241 /* We're out of sync with the target now. Did it continue or
5242 not? Not is more likely, so report a stop. */
5243 warning (_("Remote failure reply: %s"), buf
);
5244 status
->kind
= TARGET_WAITKIND_STOPPED
;
5245 status
->value
.sig
= TARGET_SIGNAL_0
;
5247 case 'F': /* File-I/O request. */
5248 remote_fileio_request (buf
, rs
->ctrlc_pending_p
);
5249 rs
->ctrlc_pending_p
= 0;
5251 case 'T': case 'S': case 'X': case 'W':
5253 struct stop_reply
*stop_reply
;
5254 struct cleanup
*old_chain
;
5256 stop_reply
= stop_reply_xmalloc ();
5257 old_chain
= make_cleanup (do_stop_reply_xfree
, stop_reply
);
5258 remote_parse_stop_reply (buf
, stop_reply
);
5259 discard_cleanups (old_chain
);
5260 event_ptid
= process_stop_reply (stop_reply
, status
);
5263 case 'O': /* Console output. */
5264 remote_console_output (buf
+ 1);
5266 /* The target didn't really stop; keep waiting. */
5267 rs
->waiting_for_stop_reply
= 1;
5271 if (last_sent_signal
!= TARGET_SIGNAL_0
)
5273 /* Zero length reply means that we tried 'S' or 'C' and the
5274 remote system doesn't support it. */
5275 target_terminal_ours_for_output ();
5277 ("Can't send signals to this remote system. %s not sent.\n",
5278 target_signal_to_name (last_sent_signal
));
5279 last_sent_signal
= TARGET_SIGNAL_0
;
5280 target_terminal_inferior ();
5282 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
5283 putpkt ((char *) buf
);
5285 /* We just told the target to resume, so a stop reply is in
5287 rs
->waiting_for_stop_reply
= 1;
5290 /* else fallthrough */
5292 warning (_("Invalid remote reply: %s"), buf
);
5294 rs
->waiting_for_stop_reply
= 1;
5298 if (status
->kind
== TARGET_WAITKIND_IGNORE
)
5300 /* Nothing interesting happened. If we're doing a non-blocking
5301 poll, we're done. Otherwise, go back to waiting. */
5302 if (options
& TARGET_WNOHANG
)
5303 return minus_one_ptid
;
5307 else if (status
->kind
!= TARGET_WAITKIND_EXITED
5308 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
5310 if (!ptid_equal (event_ptid
, null_ptid
))
5311 record_currthread (event_ptid
);
5313 event_ptid
= inferior_ptid
;
5316 /* A process exit. Invalidate our notion of current thread. */
5317 record_currthread (minus_one_ptid
);
5322 /* Wait until the remote machine stops, then return, storing status in
5323 STATUS just as `wait' would. */
5326 remote_wait (struct target_ops
*ops
,
5327 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
5332 event_ptid
= remote_wait_ns (ptid
, status
, options
);
5334 event_ptid
= remote_wait_as (ptid
, status
, options
);
5336 if (target_can_async_p ())
5338 /* If there are are events left in the queue tell the event loop
5340 if (stop_reply_queue
)
5341 mark_async_event_handler (remote_async_inferior_event_token
);
5347 /* Fetch a single register using a 'p' packet. */
5350 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
5352 struct remote_state
*rs
= get_remote_state ();
5354 char regp
[MAX_REGISTER_SIZE
];
5357 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
5360 if (reg
->pnum
== -1)
5365 p
+= hexnumstr (p
, reg
->pnum
);
5368 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5372 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
5376 case PACKET_UNKNOWN
:
5379 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
5380 gdbarch_register_name (get_regcache_arch (regcache
),
5385 /* If this register is unfetchable, tell the regcache. */
5388 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
5392 /* Otherwise, parse and supply the value. */
5398 error (_("fetch_register_using_p: early buf termination"));
5400 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
5403 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
5407 /* Fetch the registers included in the target's 'g' packet. */
5410 send_g_packet (void)
5412 struct remote_state
*rs
= get_remote_state ();
5415 sprintf (rs
->buf
, "g");
5416 remote_send (&rs
->buf
, &rs
->buf_size
);
5418 /* We can get out of synch in various cases. If the first character
5419 in the buffer is not a hex character, assume that has happened
5420 and try to fetch another packet to read. */
5421 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
5422 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
5423 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
5424 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
5427 fprintf_unfiltered (gdb_stdlog
,
5428 "Bad register packet; fetching a new packet\n");
5429 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5432 buf_len
= strlen (rs
->buf
);
5434 /* Sanity check the received packet. */
5435 if (buf_len
% 2 != 0)
5436 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
5442 process_g_packet (struct regcache
*regcache
)
5444 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
5445 struct remote_state
*rs
= get_remote_state ();
5446 struct remote_arch_state
*rsa
= get_remote_arch_state ();
5451 buf_len
= strlen (rs
->buf
);
5453 /* Further sanity checks, with knowledge of the architecture. */
5454 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
5455 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
5457 /* Save the size of the packet sent to us by the target. It is used
5458 as a heuristic when determining the max size of packets that the
5459 target can safely receive. */
5460 if (rsa
->actual_register_packet_size
== 0)
5461 rsa
->actual_register_packet_size
= buf_len
;
5463 /* If this is smaller than we guessed the 'g' packet would be,
5464 update our records. A 'g' reply that doesn't include a register's
5465 value implies either that the register is not available, or that
5466 the 'p' packet must be used. */
5467 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
5469 rsa
->sizeof_g_packet
= buf_len
/ 2;
5471 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
5473 if (rsa
->regs
[i
].pnum
== -1)
5476 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
5477 rsa
->regs
[i
].in_g_packet
= 0;
5479 rsa
->regs
[i
].in_g_packet
= 1;
5483 regs
= alloca (rsa
->sizeof_g_packet
);
5485 /* Unimplemented registers read as all bits zero. */
5486 memset (regs
, 0, rsa
->sizeof_g_packet
);
5488 /* Reply describes registers byte by byte, each byte encoded as two
5489 hex characters. Suck them all up, then supply them to the
5490 register cacheing/storage mechanism. */
5493 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
5495 if (p
[0] == 0 || p
[1] == 0)
5496 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
5497 internal_error (__FILE__
, __LINE__
,
5498 "unexpected end of 'g' packet reply");
5500 if (p
[0] == 'x' && p
[1] == 'x')
5501 regs
[i
] = 0; /* 'x' */
5503 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
5509 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
5511 struct packet_reg
*r
= &rsa
->regs
[i
];
5514 if (r
->offset
* 2 >= strlen (rs
->buf
))
5515 /* This shouldn't happen - we adjusted in_g_packet above. */
5516 internal_error (__FILE__
, __LINE__
,
5517 "unexpected end of 'g' packet reply");
5518 else if (rs
->buf
[r
->offset
* 2] == 'x')
5520 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
5521 /* The register isn't available, mark it as such (at
5522 the same time setting the value to zero). */
5523 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
5526 regcache_raw_supply (regcache
, r
->regnum
,
5534 fetch_registers_using_g (struct regcache
*regcache
)
5537 process_g_packet (regcache
);
5541 remote_fetch_registers (struct target_ops
*ops
,
5542 struct regcache
*regcache
, int regnum
)
5544 struct remote_arch_state
*rsa
= get_remote_arch_state ();
5547 set_general_thread (inferior_ptid
);
5551 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
5552 gdb_assert (reg
!= NULL
);
5554 /* If this register might be in the 'g' packet, try that first -
5555 we are likely to read more than one register. If this is the
5556 first 'g' packet, we might be overly optimistic about its
5557 contents, so fall back to 'p'. */
5558 if (reg
->in_g_packet
)
5560 fetch_registers_using_g (regcache
);
5561 if (reg
->in_g_packet
)
5565 if (fetch_register_using_p (regcache
, reg
))
5568 /* This register is not available. */
5569 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
5574 fetch_registers_using_g (regcache
);
5576 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
5577 if (!rsa
->regs
[i
].in_g_packet
)
5578 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
5580 /* This register is not available. */
5581 regcache_raw_supply (regcache
, i
, NULL
);
5585 /* Prepare to store registers. Since we may send them all (using a
5586 'G' request), we have to read out the ones we don't want to change
5590 remote_prepare_to_store (struct regcache
*regcache
)
5592 struct remote_arch_state
*rsa
= get_remote_arch_state ();
5594 gdb_byte buf
[MAX_REGISTER_SIZE
];
5596 /* Make sure the entire registers array is valid. */
5597 switch (remote_protocol_packets
[PACKET_P
].support
)
5599 case PACKET_DISABLE
:
5600 case PACKET_SUPPORT_UNKNOWN
:
5601 /* Make sure all the necessary registers are cached. */
5602 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
5603 if (rsa
->regs
[i
].in_g_packet
)
5604 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
5611 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
5612 packet was not recognized. */
5615 store_register_using_P (const struct regcache
*regcache
,
5616 struct packet_reg
*reg
)
5618 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
5619 struct remote_state
*rs
= get_remote_state ();
5620 /* Try storing a single register. */
5621 char *buf
= rs
->buf
;
5622 gdb_byte regp
[MAX_REGISTER_SIZE
];
5625 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
5628 if (reg
->pnum
== -1)
5631 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
5632 p
= buf
+ strlen (buf
);
5633 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
5634 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
5636 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5638 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
5643 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
5644 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
);
5645 case PACKET_UNKNOWN
:
5648 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
5652 /* Store register REGNUM, or all registers if REGNUM == -1, from the
5653 contents of the register cache buffer. FIXME: ignores errors. */
5656 store_registers_using_G (const struct regcache
*regcache
)
5658 struct remote_state
*rs
= get_remote_state ();
5659 struct remote_arch_state
*rsa
= get_remote_arch_state ();
5663 /* Extract all the registers in the regcache copying them into a
5667 regs
= alloca (rsa
->sizeof_g_packet
);
5668 memset (regs
, 0, rsa
->sizeof_g_packet
);
5669 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
5671 struct packet_reg
*r
= &rsa
->regs
[i
];
5673 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
5677 /* Command describes registers byte by byte,
5678 each byte encoded as two hex characters. */
5681 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
5683 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
5685 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5686 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
5687 error (_("Could not write registers; remote failure reply '%s'"),
5691 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
5692 of the register cache buffer. FIXME: ignores errors. */
5695 remote_store_registers (struct target_ops
*ops
,
5696 struct regcache
*regcache
, int regnum
)
5698 struct remote_arch_state
*rsa
= get_remote_arch_state ();
5701 set_general_thread (inferior_ptid
);
5705 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
5706 gdb_assert (reg
!= NULL
);
5708 /* Always prefer to store registers using the 'P' packet if
5709 possible; we often change only a small number of registers.
5710 Sometimes we change a larger number; we'd need help from a
5711 higher layer to know to use 'G'. */
5712 if (store_register_using_P (regcache
, reg
))
5715 /* For now, don't complain if we have no way to write the
5716 register. GDB loses track of unavailable registers too
5717 easily. Some day, this may be an error. We don't have
5718 any way to read the register, either... */
5719 if (!reg
->in_g_packet
)
5722 store_registers_using_G (regcache
);
5726 store_registers_using_G (regcache
);
5728 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
5729 if (!rsa
->regs
[i
].in_g_packet
)
5730 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
5731 /* See above for why we do not issue an error here. */
5736 /* Return the number of hex digits in num. */
5739 hexnumlen (ULONGEST num
)
5743 for (i
= 0; num
!= 0; i
++)
5749 /* Set BUF to the minimum number of hex digits representing NUM. */
5752 hexnumstr (char *buf
, ULONGEST num
)
5754 int len
= hexnumlen (num
);
5755 return hexnumnstr (buf
, num
, len
);
5759 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
5762 hexnumnstr (char *buf
, ULONGEST num
, int width
)
5768 for (i
= width
- 1; i
>= 0; i
--)
5770 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
5777 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
5780 remote_address_masked (CORE_ADDR addr
)
5782 int address_size
= remote_address_size
;
5783 /* If "remoteaddresssize" was not set, default to target address size. */
5785 address_size
= gdbarch_addr_bit (target_gdbarch
);
5787 if (address_size
> 0
5788 && address_size
< (sizeof (ULONGEST
) * 8))
5790 /* Only create a mask when that mask can safely be constructed
5791 in a ULONGEST variable. */
5793 mask
= (mask
<< address_size
) - 1;
5799 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
5800 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
5801 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
5802 (which may be more than *OUT_LEN due to escape characters). The
5803 total number of bytes in the output buffer will be at most
5807 remote_escape_output (const gdb_byte
*buffer
, int len
,
5808 gdb_byte
*out_buf
, int *out_len
,
5811 int input_index
, output_index
;
5814 for (input_index
= 0; input_index
< len
; input_index
++)
5816 gdb_byte b
= buffer
[input_index
];
5818 if (b
== '$' || b
== '#' || b
== '}')
5820 /* These must be escaped. */
5821 if (output_index
+ 2 > out_maxlen
)
5823 out_buf
[output_index
++] = '}';
5824 out_buf
[output_index
++] = b
^ 0x20;
5828 if (output_index
+ 1 > out_maxlen
)
5830 out_buf
[output_index
++] = b
;
5834 *out_len
= input_index
;
5835 return output_index
;
5838 /* Convert BUFFER, escaped data LEN bytes long, into binary data
5839 in OUT_BUF. Return the number of bytes written to OUT_BUF.
5840 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
5842 This function reverses remote_escape_output. It allows more
5843 escaped characters than that function does, in particular because
5844 '*' must be escaped to avoid the run-length encoding processing
5845 in reading packets. */
5848 remote_unescape_input (const gdb_byte
*buffer
, int len
,
5849 gdb_byte
*out_buf
, int out_maxlen
)
5851 int input_index
, output_index
;
5856 for (input_index
= 0; input_index
< len
; input_index
++)
5858 gdb_byte b
= buffer
[input_index
];
5860 if (output_index
+ 1 > out_maxlen
)
5862 warning (_("Received too much data from remote target;"
5863 " ignoring overflow."));
5864 return output_index
;
5869 out_buf
[output_index
++] = b
^ 0x20;
5875 out_buf
[output_index
++] = b
;
5879 error (_("Unmatched escape character in target response."));
5881 return output_index
;
5884 /* Determine whether the remote target supports binary downloading.
5885 This is accomplished by sending a no-op memory write of zero length
5886 to the target at the specified address. It does not suffice to send
5887 the whole packet, since many stubs strip the eighth bit and
5888 subsequently compute a wrong checksum, which causes real havoc with
5891 NOTE: This can still lose if the serial line is not eight-bit
5892 clean. In cases like this, the user should clear "remote
5896 check_binary_download (CORE_ADDR addr
)
5898 struct remote_state
*rs
= get_remote_state ();
5900 switch (remote_protocol_packets
[PACKET_X
].support
)
5902 case PACKET_DISABLE
:
5906 case PACKET_SUPPORT_UNKNOWN
:
5912 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5914 p
+= hexnumstr (p
, (ULONGEST
) 0);
5918 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
5919 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5921 if (rs
->buf
[0] == '\0')
5924 fprintf_unfiltered (gdb_stdlog
,
5925 "binary downloading NOT suppported by target\n");
5926 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
5931 fprintf_unfiltered (gdb_stdlog
,
5932 "binary downloading suppported by target\n");
5933 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
5940 /* Write memory data directly to the remote machine.
5941 This does not inform the data cache; the data cache uses this.
5942 HEADER is the starting part of the packet.
5943 MEMADDR is the address in the remote memory space.
5944 MYADDR is the address of the buffer in our space.
5945 LEN is the number of bytes.
5946 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
5947 should send data as binary ('X'), or hex-encoded ('M').
5949 The function creates packet of the form
5950 <HEADER><ADDRESS>,<LENGTH>:<DATA>
5952 where encoding of <DATA> is termined by PACKET_FORMAT.
5954 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
5957 Returns the number of bytes transferred, or 0 (setting errno) for
5958 error. Only transfer a single packet. */
5961 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
5962 const gdb_byte
*myaddr
, int len
,
5963 char packet_format
, int use_length
)
5965 struct remote_state
*rs
= get_remote_state ();
5975 if (packet_format
!= 'X' && packet_format
!= 'M')
5976 internal_error (__FILE__
, __LINE__
,
5977 "remote_write_bytes_aux: bad packet format");
5982 payload_size
= get_memory_write_packet_size ();
5984 /* The packet buffer will be large enough for the payload;
5985 get_memory_packet_size ensures this. */
5988 /* Compute the size of the actual payload by subtracting out the
5989 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
5991 payload_size
-= strlen ("$,:#NN");
5993 /* The comma won't be used. */
5995 header_length
= strlen (header
);
5996 payload_size
-= header_length
;
5997 payload_size
-= hexnumlen (memaddr
);
5999 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
6001 strcat (rs
->buf
, header
);
6002 p
= rs
->buf
+ strlen (header
);
6004 /* Compute a best guess of the number of bytes actually transfered. */
6005 if (packet_format
== 'X')
6007 /* Best guess at number of bytes that will fit. */
6008 todo
= min (len
, payload_size
);
6010 payload_size
-= hexnumlen (todo
);
6011 todo
= min (todo
, payload_size
);
6015 /* Num bytes that will fit. */
6016 todo
= min (len
, payload_size
/ 2);
6018 payload_size
-= hexnumlen (todo
);
6019 todo
= min (todo
, payload_size
/ 2);
6023 internal_error (__FILE__
, __LINE__
,
6024 _("minumum packet size too small to write data"));
6026 /* If we already need another packet, then try to align the end
6027 of this packet to a useful boundary. */
6028 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
6029 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
6031 /* Append "<memaddr>". */
6032 memaddr
= remote_address_masked (memaddr
);
6033 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
6040 /* Append <len>. Retain the location/size of <len>. It may need to
6041 be adjusted once the packet body has been created. */
6043 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
6051 /* Append the packet body. */
6052 if (packet_format
== 'X')
6054 /* Binary mode. Send target system values byte by byte, in
6055 increasing byte addresses. Only escape certain critical
6057 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
6060 /* If not all TODO bytes fit, then we'll need another packet. Make
6061 a second try to keep the end of the packet aligned. Don't do
6062 this if the packet is tiny. */
6063 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
6067 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
6069 if (new_nr_bytes
!= nr_bytes
)
6070 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
6075 p
+= payload_length
;
6076 if (use_length
&& nr_bytes
< todo
)
6078 /* Escape chars have filled up the buffer prematurely,
6079 and we have actually sent fewer bytes than planned.
6080 Fix-up the length field of the packet. Use the same
6081 number of characters as before. */
6082 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
6083 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
6088 /* Normal mode: Send target system values byte by byte, in
6089 increasing byte addresses. Each byte is encoded as a two hex
6091 nr_bytes
= bin2hex (myaddr
, p
, todo
);
6095 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
6096 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6098 if (rs
->buf
[0] == 'E')
6100 /* There is no correspondance between what the remote protocol
6101 uses for errors and errno codes. We would like a cleaner way
6102 of representing errors (big enough to include errno codes,
6103 bfd_error codes, and others). But for now just return EIO. */
6108 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
6109 fewer bytes than we'd planned. */
6113 /* Write memory data directly to the remote machine.
6114 This does not inform the data cache; the data cache uses this.
6115 MEMADDR is the address in the remote memory space.
6116 MYADDR is the address of the buffer in our space.
6117 LEN is the number of bytes.
6119 Returns number of bytes transferred, or 0 (setting errno) for
6120 error. Only transfer a single packet. */
6123 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
6125 char *packet_format
= 0;
6127 /* Check whether the target supports binary download. */
6128 check_binary_download (memaddr
);
6130 switch (remote_protocol_packets
[PACKET_X
].support
)
6133 packet_format
= "X";
6135 case PACKET_DISABLE
:
6136 packet_format
= "M";
6138 case PACKET_SUPPORT_UNKNOWN
:
6139 internal_error (__FILE__
, __LINE__
,
6140 _("remote_write_bytes: bad internal state"));
6142 internal_error (__FILE__
, __LINE__
, _("bad switch"));
6145 return remote_write_bytes_aux (packet_format
,
6146 memaddr
, myaddr
, len
, packet_format
[0], 1);
6149 /* Read memory data directly from the remote machine.
6150 This does not use the data cache; the data cache uses this.
6151 MEMADDR is the address in the remote memory space.
6152 MYADDR is the address of the buffer in our space.
6153 LEN is the number of bytes.
6155 Returns number of bytes transferred, or 0 for error. */
6157 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
6158 remote targets) shouldn't attempt to read the entire buffer.
6159 Instead it should read a single packet worth of data and then
6160 return the byte size of that packet to the caller. The caller (its
6161 caller and its callers caller ;-) already contains code for
6162 handling partial reads. */
6165 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
6167 struct remote_state
*rs
= get_remote_state ();
6168 int max_buf_size
; /* Max size of packet output buffer. */
6174 max_buf_size
= get_memory_read_packet_size ();
6175 /* The packet buffer will be large enough for the payload;
6176 get_memory_packet_size ensures this. */
6185 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
6187 /* construct "m"<memaddr>","<len>" */
6188 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
6189 memaddr
= remote_address_masked (memaddr
);
6192 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
6194 p
+= hexnumstr (p
, (ULONGEST
) todo
);
6198 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6200 if (rs
->buf
[0] == 'E'
6201 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
6202 && rs
->buf
[3] == '\0')
6204 /* There is no correspondance between what the remote
6205 protocol uses for errors and errno codes. We would like
6206 a cleaner way of representing errors (big enough to
6207 include errno codes, bfd_error codes, and others). But
6208 for now just return EIO. */
6213 /* Reply describes memory byte by byte,
6214 each byte encoded as two hex characters. */
6217 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
6219 /* Reply is short. This means that we were able to read
6220 only part of what we wanted to. */
6221 return i
+ (origlen
- len
);
6231 /* Remote notification handler. */
6234 handle_notification (char *buf
, size_t length
)
6236 if (strncmp (buf
, "Stop:", 5) == 0)
6238 if (pending_stop_reply
)
6240 /* We've already parsed the in-flight stop-reply, but the
6241 stub for some reason thought we didn't, possibly due to
6242 timeout on its side. Just ignore it. */
6244 fprintf_unfiltered (gdb_stdlog
, "ignoring resent notification\n");
6248 struct cleanup
*old_chain
;
6249 struct stop_reply
*reply
= stop_reply_xmalloc ();
6250 old_chain
= make_cleanup (do_stop_reply_xfree
, reply
);
6252 remote_parse_stop_reply (buf
+ 5, reply
);
6254 discard_cleanups (old_chain
);
6256 /* Be careful to only set it after parsing, since an error
6257 may be thrown then. */
6258 pending_stop_reply
= reply
;
6260 /* Notify the event loop there's a stop reply to acknowledge
6261 and that there may be more events to fetch. */
6262 mark_async_event_handler (remote_async_get_pending_events_token
);
6265 fprintf_unfiltered (gdb_stdlog
, "stop notification captured\n");
6269 /* We ignore notifications we don't recognize, for compatibility
6270 with newer stubs. */
6275 /* Read or write LEN bytes from inferior memory at MEMADDR,
6276 transferring to or from debugger address BUFFER. Write to inferior
6277 if SHOULD_WRITE is nonzero. Returns length of data written or
6278 read; 0 for error. TARGET is unused. */
6281 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
6282 int should_write
, struct mem_attrib
*attrib
,
6283 struct target_ops
*target
)
6287 set_general_thread (inferior_ptid
);
6290 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
6292 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
6297 /* Sends a packet with content determined by the printf format string
6298 FORMAT and the remaining arguments, then gets the reply. Returns
6299 whether the packet was a success, a failure, or unknown. */
6301 static enum packet_result
6302 remote_send_printf (const char *format
, ...)
6304 struct remote_state
*rs
= get_remote_state ();
6305 int max_size
= get_remote_packet_size ();
6308 va_start (ap
, format
);
6311 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
6312 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
6314 if (putpkt (rs
->buf
) < 0)
6315 error (_("Communication problem with target."));
6318 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6320 return packet_check_result (rs
->buf
);
6324 restore_remote_timeout (void *p
)
6326 int value
= *(int *)p
;
6327 remote_timeout
= value
;
6330 /* Flash writing can take quite some time. We'll set
6331 effectively infinite timeout for flash operations.
6332 In future, we'll need to decide on a better approach. */
6333 static const int remote_flash_timeout
= 1000;
6336 remote_flash_erase (struct target_ops
*ops
,
6337 ULONGEST address
, LONGEST length
)
6339 int addr_size
= gdbarch_addr_bit (target_gdbarch
) / 8;
6340 int saved_remote_timeout
= remote_timeout
;
6341 enum packet_result ret
;
6343 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
6344 &saved_remote_timeout
);
6345 remote_timeout
= remote_flash_timeout
;
6347 ret
= remote_send_printf ("vFlashErase:%s,%s",
6348 phex (address
, addr_size
),
6352 case PACKET_UNKNOWN
:
6353 error (_("Remote target does not support flash erase"));
6355 error (_("Error erasing flash with vFlashErase packet"));
6360 do_cleanups (back_to
);
6364 remote_flash_write (struct target_ops
*ops
,
6365 ULONGEST address
, LONGEST length
,
6366 const gdb_byte
*data
)
6368 int saved_remote_timeout
= remote_timeout
;
6370 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
6371 &saved_remote_timeout
);
6373 remote_timeout
= remote_flash_timeout
;
6374 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
6375 do_cleanups (back_to
);
6381 remote_flash_done (struct target_ops
*ops
)
6383 int saved_remote_timeout
= remote_timeout
;
6385 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
6386 &saved_remote_timeout
);
6388 remote_timeout
= remote_flash_timeout
;
6389 ret
= remote_send_printf ("vFlashDone");
6390 do_cleanups (back_to
);
6394 case PACKET_UNKNOWN
:
6395 error (_("Remote target does not support vFlashDone"));
6397 error (_("Error finishing flash operation"));
6404 remote_files_info (struct target_ops
*ignore
)
6406 puts_filtered ("Debugging a target over a serial line.\n");
6409 /* Stuff for dealing with the packets which are part of this protocol.
6410 See comment at top of file for details. */
6412 /* Read a single character from the remote end. */
6415 readchar (int timeout
)
6419 ch
= serial_readchar (remote_desc
, timeout
);
6424 switch ((enum serial_rc
) ch
)
6428 error (_("Remote connection closed"));
6431 perror_with_name (_("Remote communication error"));
6433 case SERIAL_TIMEOUT
:
6439 /* Send the command in *BUF to the remote machine, and read the reply
6440 into *BUF. Report an error if we get an error reply. Resize
6441 *BUF using xrealloc if necessary to hold the result, and update
6445 remote_send (char **buf
,
6449 getpkt (buf
, sizeof_buf
, 0);
6451 if ((*buf
)[0] == 'E')
6452 error (_("Remote failure reply: %s"), *buf
);
6455 /* Return a pointer to an xmalloc'ed string representing an escaped
6456 version of BUF, of len N. E.g. \n is converted to \\n, \t to \\t,
6457 etc. The caller is responsible for releasing the returned
6461 escape_buffer (const char *buf
, int n
)
6463 struct cleanup
*old_chain
;
6464 struct ui_file
*stb
;
6467 stb
= mem_fileopen ();
6468 old_chain
= make_cleanup_ui_file_delete (stb
);
6470 fputstrn_unfiltered (buf
, n
, 0, stb
);
6471 str
= ui_file_xstrdup (stb
, NULL
);
6472 do_cleanups (old_chain
);
6476 /* Display a null-terminated packet on stdout, for debugging, using C
6480 print_packet (char *buf
)
6482 puts_filtered ("\"");
6483 fputstr_filtered (buf
, '"', gdb_stdout
);
6484 puts_filtered ("\"");
6490 return putpkt_binary (buf
, strlen (buf
));
6493 /* Send a packet to the remote machine, with error checking. The data
6494 of the packet is in BUF. The string in BUF can be at most
6495 get_remote_packet_size () - 5 to account for the $, # and checksum,
6496 and for a possible /0 if we are debugging (remote_debug) and want
6497 to print the sent packet as a string. */
6500 putpkt_binary (char *buf
, int cnt
)
6502 struct remote_state
*rs
= get_remote_state ();
6504 unsigned char csum
= 0;
6505 char *buf2
= alloca (cnt
+ 6);
6511 /* Catch cases like trying to read memory or listing threads while
6512 we're waiting for a stop reply. The remote server wouldn't be
6513 ready to handle this request, so we'd hang and timeout. We don't
6514 have to worry about this in synchronous mode, because in that
6515 case it's not possible to issue a command while the target is
6516 running. This is not a problem in non-stop mode, because in that
6517 case, the stub is always ready to process serial input. */
6518 if (!non_stop
&& target_can_async_p () && rs
->waiting_for_stop_reply
)
6519 error (_("Cannot execute this command while the target is running."));
6521 /* We're sending out a new packet. Make sure we don't look at a
6522 stale cached response. */
6523 rs
->cached_wait_status
= 0;
6525 /* Copy the packet into buffer BUF2, encapsulating it
6526 and giving it a checksum. */
6531 for (i
= 0; i
< cnt
; i
++)
6537 *p
++ = tohex ((csum
>> 4) & 0xf);
6538 *p
++ = tohex (csum
& 0xf);
6540 /* Send it over and over until we get a positive ack. */
6544 int started_error_output
= 0;
6548 struct cleanup
*old_chain
;
6552 str
= escape_buffer (buf2
, p
- buf2
);
6553 old_chain
= make_cleanup (xfree
, str
);
6554 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s...", str
);
6555 gdb_flush (gdb_stdlog
);
6556 do_cleanups (old_chain
);
6558 if (serial_write (remote_desc
, buf2
, p
- buf2
))
6559 perror_with_name (_("putpkt: write failed"));
6561 /* If this is a no acks version of the remote protocol, send the
6562 packet and move on. */
6566 /* Read until either a timeout occurs (-2) or '+' is read.
6567 Handle any notification that arrives in the mean time. */
6570 ch
= readchar (remote_timeout
);
6578 case SERIAL_TIMEOUT
:
6581 if (started_error_output
)
6583 putchar_unfiltered ('\n');
6584 started_error_output
= 0;
6593 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
6597 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
6598 case SERIAL_TIMEOUT
:
6602 break; /* Retransmit buffer. */
6606 fprintf_unfiltered (gdb_stdlog
,
6607 "Packet instead of Ack, ignoring it\n");
6608 /* It's probably an old response sent because an ACK
6609 was lost. Gobble up the packet and ack it so it
6610 doesn't get retransmitted when we resend this
6613 serial_write (remote_desc
, "+", 1);
6614 continue; /* Now, go look for +. */
6621 /* If we got a notification, handle it, and go back to looking
6623 /* We've found the start of a notification. Now
6624 collect the data. */
6625 val
= read_frame (&rs
->buf
, &rs
->buf_size
);
6630 struct cleanup
*old_chain
;
6633 str
= escape_buffer (rs
->buf
, val
);
6634 old_chain
= make_cleanup (xfree
, str
);
6635 fprintf_unfiltered (gdb_stdlog
,
6636 " Notification received: %s\n",
6638 do_cleanups (old_chain
);
6640 handle_notification (rs
->buf
, val
);
6641 /* We're in sync now, rewait for the ack. */
6648 if (!started_error_output
)
6650 started_error_output
= 1;
6651 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
6653 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
6654 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
);
6663 if (!started_error_output
)
6665 started_error_output
= 1;
6666 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
6668 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
6672 break; /* Here to retransmit. */
6676 /* This is wrong. If doing a long backtrace, the user should be
6677 able to get out next time we call QUIT, without anything as
6678 violent as interrupt_query. If we want to provide a way out of
6679 here without getting to the next QUIT, it should be based on
6680 hitting ^C twice as in remote_wait. */
6691 /* Come here after finding the start of a frame when we expected an
6692 ack. Do our best to discard the rest of this packet. */
6701 c
= readchar (remote_timeout
);
6704 case SERIAL_TIMEOUT
:
6705 /* Nothing we can do. */
6708 /* Discard the two bytes of checksum and stop. */
6709 c
= readchar (remote_timeout
);
6711 c
= readchar (remote_timeout
);
6714 case '*': /* Run length encoding. */
6715 /* Discard the repeat count. */
6716 c
= readchar (remote_timeout
);
6721 /* A regular character. */
6727 /* Come here after finding the start of the frame. Collect the rest
6728 into *BUF, verifying the checksum, length, and handling run-length
6729 compression. NUL terminate the buffer. If there is not enough room,
6730 expand *BUF using xrealloc.
6732 Returns -1 on error, number of characters in buffer (ignoring the
6733 trailing NULL) on success. (could be extended to return one of the
6734 SERIAL status indications). */
6737 read_frame (char **buf_p
,
6744 struct remote_state
*rs
= get_remote_state ();
6751 c
= readchar (remote_timeout
);
6754 case SERIAL_TIMEOUT
:
6756 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
6760 fputs_filtered ("Saw new packet start in middle of old one\n",
6762 return -1; /* Start a new packet, count retries. */
6765 unsigned char pktcsum
;
6771 check_0
= readchar (remote_timeout
);
6773 check_1
= readchar (remote_timeout
);
6775 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
6778 fputs_filtered ("Timeout in checksum, retrying\n",
6782 else if (check_0
< 0 || check_1
< 0)
6785 fputs_filtered ("Communication error in checksum\n",
6790 /* Don't recompute the checksum; with no ack packets we
6791 don't have any way to indicate a packet retransmission
6796 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
6797 if (csum
== pktcsum
)
6802 struct cleanup
*old_chain
;
6805 str
= escape_buffer (buf
, bc
);
6806 old_chain
= make_cleanup (xfree
, str
);
6807 fprintf_unfiltered (gdb_stdlog
,
6809 Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
6810 pktcsum
, csum
, str
);
6811 do_cleanups (old_chain
);
6813 /* Number of characters in buffer ignoring trailing
6817 case '*': /* Run length encoding. */
6822 c
= readchar (remote_timeout
);
6824 repeat
= c
- ' ' + 3; /* Compute repeat count. */
6826 /* The character before ``*'' is repeated. */
6828 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
6830 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
6832 /* Make some more room in the buffer. */
6833 *sizeof_buf
+= repeat
;
6834 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
6838 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
6844 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
6848 if (bc
>= *sizeof_buf
- 1)
6850 /* Make some more room in the buffer. */
6852 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
6863 /* Read a packet from the remote machine, with error checking, and
6864 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
6865 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
6866 rather than timing out; this is used (in synchronous mode) to wait
6867 for a target that is is executing user code to stop. */
6868 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
6869 don't have to change all the calls to getpkt to deal with the
6870 return value, because at the moment I don't know what the right
6871 thing to do it for those. */
6879 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
6883 /* Read a packet from the remote machine, with error checking, and
6884 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
6885 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
6886 rather than timing out; this is used (in synchronous mode) to wait
6887 for a target that is is executing user code to stop. If FOREVER ==
6888 0, this function is allowed to time out gracefully and return an
6889 indication of this to the caller. Otherwise return the number of
6890 bytes read. If EXPECTING_NOTIF, consider receiving a notification
6891 enough reason to return to the caller. */
6894 getpkt_or_notif_sane_1 (char **buf
, long *sizeof_buf
, int forever
,
6895 int expecting_notif
)
6897 struct remote_state
*rs
= get_remote_state ();
6903 /* We're reading a new response. Make sure we don't look at a
6904 previously cached response. */
6905 rs
->cached_wait_status
= 0;
6907 strcpy (*buf
, "timeout");
6910 timeout
= watchdog
> 0 ? watchdog
: -1;
6911 else if (expecting_notif
)
6912 timeout
= 0; /* There should already be a char in the buffer. If
6915 timeout
= remote_timeout
;
6919 /* Process any number of notifications, and then return when
6923 /* If we get a timeout or bad checksm, retry up to MAX_TRIES
6925 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
6927 /* This can loop forever if the remote side sends us
6928 characters continuously, but if it pauses, we'll get
6929 SERIAL_TIMEOUT from readchar because of timeout. Then
6930 we'll count that as a retry.
6932 Note that even when forever is set, we will only wait
6933 forever prior to the start of a packet. After that, we
6934 expect characters to arrive at a brisk pace. They should
6935 show up within remote_timeout intervals. */
6937 c
= readchar (timeout
);
6938 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
6940 if (c
== SERIAL_TIMEOUT
)
6942 if (expecting_notif
)
6943 return -1; /* Don't complain, it's normal to not get
6944 anything in this case. */
6946 if (forever
) /* Watchdog went off? Kill the target. */
6950 error (_("Watchdog timeout has expired. Target detached."));
6953 fputs_filtered ("Timed out.\n", gdb_stdlog
);
6957 /* We've found the start of a packet or notification.
6958 Now collect the data. */
6959 val
= read_frame (buf
, sizeof_buf
);
6964 serial_write (remote_desc
, "-", 1);
6967 if (tries
> MAX_TRIES
)
6969 /* We have tried hard enough, and just can't receive the
6970 packet/notification. Give up. */
6971 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
6973 /* Skip the ack char if we're in no-ack mode. */
6974 if (!rs
->noack_mode
)
6975 serial_write (remote_desc
, "+", 1);
6979 /* If we got an ordinary packet, return that to our caller. */
6984 struct cleanup
*old_chain
;
6987 str
= escape_buffer (*buf
, val
);
6988 old_chain
= make_cleanup (xfree
, str
);
6989 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s\n", str
);
6990 do_cleanups (old_chain
);
6993 /* Skip the ack char if we're in no-ack mode. */
6994 if (!rs
->noack_mode
)
6995 serial_write (remote_desc
, "+", 1);
6999 /* If we got a notification, handle it, and go back to looking
7003 gdb_assert (c
== '%');
7007 struct cleanup
*old_chain
;
7010 str
= escape_buffer (*buf
, val
);
7011 old_chain
= make_cleanup (xfree
, str
);
7012 fprintf_unfiltered (gdb_stdlog
,
7013 " Notification received: %s\n",
7015 do_cleanups (old_chain
);
7018 handle_notification (*buf
, val
);
7020 /* Notifications require no acknowledgement. */
7022 if (expecting_notif
)
7029 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
7031 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 0);
7035 getpkt_or_notif_sane (char **buf
, long *sizeof_buf
, int forever
)
7037 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 1);
7042 remote_kill (struct target_ops
*ops
)
7044 /* Use catch_errors so the user can quit from gdb even when we
7045 aren't on speaking terms with the remote system. */
7046 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
7048 /* Don't wait for it to die. I'm not really sure it matters whether
7049 we do or not. For the existing stubs, kill is a noop. */
7050 target_mourn_inferior ();
7054 remote_vkill (int pid
, struct remote_state
*rs
)
7056 if (remote_protocol_packets
[PACKET_vKill
].support
== PACKET_DISABLE
)
7059 /* Tell the remote target to detach. */
7060 sprintf (rs
->buf
, "vKill;%x", pid
);
7062 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7064 if (packet_ok (rs
->buf
,
7065 &remote_protocol_packets
[PACKET_vKill
]) == PACKET_OK
)
7067 else if (remote_protocol_packets
[PACKET_vKill
].support
== PACKET_DISABLE
)
7074 extended_remote_kill (struct target_ops
*ops
)
7077 int pid
= ptid_get_pid (inferior_ptid
);
7078 struct remote_state
*rs
= get_remote_state ();
7080 res
= remote_vkill (pid
, rs
);
7081 if (res
== -1 && !remote_multi_process_p (rs
))
7083 /* Don't try 'k' on a multi-process aware stub -- it has no way
7084 to specify the pid. */
7088 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7089 if (rs
->buf
[0] != 'O' || rs
->buf
[0] != 'K')
7092 /* Don't wait for it to die. I'm not really sure it matters whether
7093 we do or not. For the existing stubs, kill is a noop. */
7099 error (_("Can't kill process"));
7101 target_mourn_inferior ();
7105 remote_mourn (struct target_ops
*ops
)
7107 remote_mourn_1 (ops
);
7110 /* Worker function for remote_mourn. */
7112 remote_mourn_1 (struct target_ops
*target
)
7114 unpush_target (target
);
7116 /* remote_close takes care of doing most of the clean up. */
7117 generic_mourn_inferior ();
7121 extended_remote_mourn_1 (struct target_ops
*target
)
7123 struct remote_state
*rs
= get_remote_state ();
7125 /* In case we got here due to an error, but we're going to stay
7127 rs
->waiting_for_stop_reply
= 0;
7129 /* We're no longer interested in these events. */
7130 discard_pending_stop_replies (ptid_get_pid (inferior_ptid
));
7132 /* If the current general thread belonged to the process we just
7133 detached from or has exited, the remote side current general
7134 thread becomes undefined. Considering a case like this:
7136 - We just got here due to a detach.
7137 - The process that we're detaching from happens to immediately
7138 report a global breakpoint being hit in non-stop mode, in the
7139 same thread we had selected before.
7140 - GDB attaches to this process again.
7141 - This event happens to be the next event we handle.
7143 GDB would consider that the current general thread didn't need to
7144 be set on the stub side (with Hg), since for all it knew,
7145 GENERAL_THREAD hadn't changed.
7147 Notice that although in all-stop mode, the remote server always
7148 sets the current thread to the thread reporting the stop event,
7149 that doesn't happen in non-stop mode; in non-stop, the stub *must
7150 not* change the current thread when reporting a breakpoint hit,
7151 due to the decoupling of event reporting and event handling.
7153 To keep things simple, we always invalidate our notion of the
7155 record_currthread (minus_one_ptid
);
7157 /* Unlike "target remote", we do not want to unpush the target; then
7158 the next time the user says "run", we won't be connected. */
7160 /* Call common code to mark the inferior as not running. */
7161 generic_mourn_inferior ();
7163 if (!have_inferiors ())
7165 if (!remote_multi_process_p (rs
))
7167 /* Check whether the target is running now - some remote stubs
7168 automatically restart after kill. */
7170 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7172 if (rs
->buf
[0] == 'S' || rs
->buf
[0] == 'T')
7174 /* Assume that the target has been restarted. Set inferior_ptid
7175 so that bits of core GDB realizes there's something here, e.g.,
7176 so that the user can say "kill" again. */
7177 inferior_ptid
= magic_null_ptid
;
7184 extended_remote_mourn (struct target_ops
*ops
)
7186 extended_remote_mourn_1 (ops
);
7190 extended_remote_run (char *args
)
7192 struct remote_state
*rs
= get_remote_state ();
7195 /* If the user has disabled vRun support, or we have detected that
7196 support is not available, do not try it. */
7197 if (remote_protocol_packets
[PACKET_vRun
].support
== PACKET_DISABLE
)
7200 strcpy (rs
->buf
, "vRun;");
7201 len
= strlen (rs
->buf
);
7203 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
7204 error (_("Remote file name too long for run packet"));
7205 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
+ len
, 0);
7207 gdb_assert (args
!= NULL
);
7210 struct cleanup
*back_to
;
7214 argv
= gdb_buildargv (args
);
7215 back_to
= make_cleanup ((void (*) (void *)) freeargv
, argv
);
7216 for (i
= 0; argv
[i
] != NULL
; i
++)
7218 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
7219 error (_("Argument list too long for run packet"));
7220 rs
->buf
[len
++] = ';';
7221 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
+ len
, 0);
7223 do_cleanups (back_to
);
7226 rs
->buf
[len
++] = '\0';
7229 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7231 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]) == PACKET_OK
)
7233 /* We have a wait response; we don't need it, though. All is well. */
7236 else if (remote_protocol_packets
[PACKET_vRun
].support
== PACKET_DISABLE
)
7237 /* It wasn't disabled before, but it is now. */
7241 if (remote_exec_file
[0] == '\0')
7242 error (_("Running the default executable on the remote target failed; "
7243 "try \"set remote exec-file\"?"));
7245 error (_("Running \"%s\" on the remote target failed"),
7250 /* In the extended protocol we want to be able to do things like
7251 "run" and have them basically work as expected. So we need
7252 a special create_inferior function. We support changing the
7253 executable file and the command line arguments, but not the
7257 extended_remote_create_inferior_1 (char *exec_file
, char *args
,
7258 char **env
, int from_tty
)
7260 /* If running asynchronously, register the target file descriptor
7261 with the event loop. */
7262 if (target_can_async_p ())
7263 target_async (inferior_event_handler
, 0);
7265 /* Now restart the remote server. */
7266 if (extended_remote_run (args
) == -1)
7268 /* vRun was not supported. Fail if we need it to do what the
7270 if (remote_exec_file
[0])
7271 error (_("Remote target does not support \"set remote exec-file\""));
7273 error (_("Remote target does not support \"set args\" or run <ARGS>"));
7275 /* Fall back to "R". */
7276 extended_remote_restart ();
7279 if (!have_inferiors ())
7281 /* Clean up from the last time we ran, before we mark the target
7282 running again. This will mark breakpoints uninserted, and
7283 get_offsets may insert breakpoints. */
7284 init_thread_list ();
7285 init_wait_for_inferior ();
7288 /* Now mark the inferior as running before we do anything else. */
7289 inferior_ptid
= magic_null_ptid
;
7291 /* Now, if we have thread information, update inferior_ptid. */
7292 inferior_ptid
= remote_current_thread (inferior_ptid
);
7294 remote_add_inferior (ptid_get_pid (inferior_ptid
), 0);
7295 add_thread_silent (inferior_ptid
);
7297 /* Get updated offsets, if the stub uses qOffsets. */
7302 extended_remote_create_inferior (struct target_ops
*ops
,
7303 char *exec_file
, char *args
,
7304 char **env
, int from_tty
)
7306 extended_remote_create_inferior_1 (exec_file
, args
, env
, from_tty
);
7310 /* Insert a breakpoint. On targets that have software breakpoint
7311 support, we ask the remote target to do the work; on targets
7312 which don't, we insert a traditional memory breakpoint. */
7315 remote_insert_breakpoint (struct gdbarch
*gdbarch
,
7316 struct bp_target_info
*bp_tgt
)
7318 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
7319 If it succeeds, then set the support to PACKET_ENABLE. If it
7320 fails, and the user has explicitly requested the Z support then
7321 report an error, otherwise, mark it disabled and go on. */
7323 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
7325 CORE_ADDR addr
= bp_tgt
->placed_address
;
7326 struct remote_state
*rs
;
7330 gdbarch_remote_breakpoint_from_pc (gdbarch
, &addr
, &bpsize
);
7332 rs
= get_remote_state ();
7338 addr
= (ULONGEST
) remote_address_masked (addr
);
7339 p
+= hexnumstr (p
, addr
);
7340 sprintf (p
, ",%d", bpsize
);
7343 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7345 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
7350 bp_tgt
->placed_address
= addr
;
7351 bp_tgt
->placed_size
= bpsize
;
7353 case PACKET_UNKNOWN
:
7358 return memory_insert_breakpoint (gdbarch
, bp_tgt
);
7362 remote_remove_breakpoint (struct gdbarch
*gdbarch
,
7363 struct bp_target_info
*bp_tgt
)
7365 CORE_ADDR addr
= bp_tgt
->placed_address
;
7366 struct remote_state
*rs
= get_remote_state ();
7368 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
7376 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
7377 p
+= hexnumstr (p
, addr
);
7378 sprintf (p
, ",%d", bp_tgt
->placed_size
);
7381 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7383 return (rs
->buf
[0] == 'E');
7386 return memory_remove_breakpoint (gdbarch
, bp_tgt
);
7390 watchpoint_to_Z_packet (int type
)
7395 return Z_PACKET_WRITE_WP
;
7398 return Z_PACKET_READ_WP
;
7401 return Z_PACKET_ACCESS_WP
;
7404 internal_error (__FILE__
, __LINE__
,
7405 _("hw_bp_to_z: bad watchpoint type %d"), type
);
7410 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
7412 struct remote_state
*rs
= get_remote_state ();
7414 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
7416 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
7419 sprintf (rs
->buf
, "Z%x,", packet
);
7420 p
= strchr (rs
->buf
, '\0');
7421 addr
= remote_address_masked (addr
);
7422 p
+= hexnumstr (p
, (ULONGEST
) addr
);
7423 sprintf (p
, ",%x", len
);
7426 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7428 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
7432 case PACKET_UNKNOWN
:
7437 internal_error (__FILE__
, __LINE__
,
7438 _("remote_insert_watchpoint: reached end of function"));
7443 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
7445 struct remote_state
*rs
= get_remote_state ();
7447 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
7449 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
7452 sprintf (rs
->buf
, "z%x,", packet
);
7453 p
= strchr (rs
->buf
, '\0');
7454 addr
= remote_address_masked (addr
);
7455 p
+= hexnumstr (p
, (ULONGEST
) addr
);
7456 sprintf (p
, ",%x", len
);
7458 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7460 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
7463 case PACKET_UNKNOWN
:
7468 internal_error (__FILE__
, __LINE__
,
7469 _("remote_remove_watchpoint: reached end of function"));
7473 int remote_hw_watchpoint_limit
= -1;
7474 int remote_hw_breakpoint_limit
= -1;
7477 remote_check_watch_resources (int type
, int cnt
, int ot
)
7479 if (type
== bp_hardware_breakpoint
)
7481 if (remote_hw_breakpoint_limit
== 0)
7483 else if (remote_hw_breakpoint_limit
< 0)
7485 else if (cnt
<= remote_hw_breakpoint_limit
)
7490 if (remote_hw_watchpoint_limit
== 0)
7492 else if (remote_hw_watchpoint_limit
< 0)
7496 else if (cnt
<= remote_hw_watchpoint_limit
)
7503 remote_stopped_by_watchpoint (void)
7505 return remote_stopped_by_watchpoint_p
;
7509 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
7512 if (remote_stopped_by_watchpoint ())
7514 *addr_p
= remote_watch_data_address
;
7523 remote_insert_hw_breakpoint (struct gdbarch
*gdbarch
,
7524 struct bp_target_info
*bp_tgt
)
7527 struct remote_state
*rs
;
7530 /* The length field should be set to the size of a breakpoint
7531 instruction, even though we aren't inserting one ourselves. */
7533 gdbarch_remote_breakpoint_from_pc
7534 (gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
7536 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
7539 rs
= get_remote_state ();
7546 addr
= remote_address_masked (bp_tgt
->placed_address
);
7547 p
+= hexnumstr (p
, (ULONGEST
) addr
);
7548 sprintf (p
, ",%x", bp_tgt
->placed_size
);
7551 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7553 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
7556 case PACKET_UNKNOWN
:
7561 internal_error (__FILE__
, __LINE__
,
7562 _("remote_insert_hw_breakpoint: reached end of function"));
7567 remote_remove_hw_breakpoint (struct gdbarch
*gdbarch
,
7568 struct bp_target_info
*bp_tgt
)
7571 struct remote_state
*rs
= get_remote_state ();
7574 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
7581 addr
= remote_address_masked (bp_tgt
->placed_address
);
7582 p
+= hexnumstr (p
, (ULONGEST
) addr
);
7583 sprintf (p
, ",%x", bp_tgt
->placed_size
);
7586 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7588 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
7591 case PACKET_UNKNOWN
:
7596 internal_error (__FILE__
, __LINE__
,
7597 _("remote_remove_hw_breakpoint: reached end of function"));
7600 /* Table used by the crc32 function to calcuate the checksum. */
7602 static unsigned long crc32_table
[256] =
7605 static unsigned long
7606 crc32 (const unsigned char *buf
, int len
, unsigned int crc
)
7608 if (!crc32_table
[1])
7610 /* Initialize the CRC table and the decoding table. */
7614 for (i
= 0; i
< 256; i
++)
7616 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
7617 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
7624 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
7630 /* Verify memory using the "qCRC:" request. */
7633 remote_verify_memory (struct target_ops
*ops
,
7634 const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
7636 struct remote_state
*rs
= get_remote_state ();
7637 unsigned long host_crc
, target_crc
;
7640 /* FIXME: assumes lma can fit into long. */
7641 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
7642 (long) lma
, (long) size
);
7645 /* Be clever; compute the host_crc before waiting for target
7647 host_crc
= crc32 (data
, size
, 0xffffffff);
7649 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7650 if (rs
->buf
[0] == 'E')
7653 if (rs
->buf
[0] != 'C')
7654 error (_("remote target does not support this operation"));
7656 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
7657 target_crc
= target_crc
* 16 + fromhex (*tmp
);
7659 return (host_crc
== target_crc
);
7662 /* compare-sections command
7664 With no arguments, compares each loadable section in the exec bfd
7665 with the same memory range on the target, and reports mismatches.
7666 Useful for verifying the image on the target against the exec file. */
7669 compare_sections_command (char *args
, int from_tty
)
7672 struct cleanup
*old_chain
;
7674 const char *sectname
;
7682 error (_("command cannot be used without an exec file"));
7684 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
7686 if (!(s
->flags
& SEC_LOAD
))
7687 continue; /* skip non-loadable section */
7689 size
= bfd_get_section_size (s
);
7691 continue; /* skip zero-length section */
7693 sectname
= bfd_get_section_name (exec_bfd
, s
);
7694 if (args
&& strcmp (args
, sectname
) != 0)
7695 continue; /* not the section selected by user */
7697 matched
= 1; /* do this section */
7700 sectdata
= xmalloc (size
);
7701 old_chain
= make_cleanup (xfree
, sectdata
);
7702 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
7704 res
= target_verify_memory (sectdata
, lma
, size
);
7707 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
7708 paddress (target_gdbarch
, lma
),
7709 paddress (target_gdbarch
, lma
+ size
));
7711 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
7712 paddress (target_gdbarch
, lma
),
7713 paddress (target_gdbarch
, lma
+ size
));
7715 printf_filtered ("matched.\n");
7718 printf_filtered ("MIS-MATCHED!\n");
7722 do_cleanups (old_chain
);
7725 warning (_("One or more sections of the remote executable does not match\n\
7726 the loaded file\n"));
7727 if (args
&& !matched
)
7728 printf_filtered (_("No loaded section named '%s'.\n"), args
);
7731 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
7732 into remote target. The number of bytes written to the remote
7733 target is returned, or -1 for error. */
7736 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
7737 const char *annex
, const gdb_byte
*writebuf
,
7738 ULONGEST offset
, LONGEST len
,
7739 struct packet_config
*packet
)
7743 struct remote_state
*rs
= get_remote_state ();
7744 int max_size
= get_memory_write_packet_size ();
7746 if (packet
->support
== PACKET_DISABLE
)
7749 /* Insert header. */
7750 i
= snprintf (rs
->buf
, max_size
,
7751 "qXfer:%s:write:%s:%s:",
7752 object_name
, annex
? annex
: "",
7753 phex_nz (offset
, sizeof offset
));
7754 max_size
-= (i
+ 1);
7756 /* Escape as much data as fits into rs->buf. */
7757 buf_len
= remote_escape_output
7758 (writebuf
, len
, (rs
->buf
+ i
), &max_size
, max_size
);
7760 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
7761 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
7762 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
7765 unpack_varlen_hex (rs
->buf
, &n
);
7769 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
7770 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
7771 number of bytes read is returned, or 0 for EOF, or -1 for error.
7772 The number of bytes read may be less than LEN without indicating an
7773 EOF. PACKET is checked and updated to indicate whether the remote
7774 target supports this object. */
7777 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
7779 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
7780 struct packet_config
*packet
)
7782 static char *finished_object
;
7783 static char *finished_annex
;
7784 static ULONGEST finished_offset
;
7786 struct remote_state
*rs
= get_remote_state ();
7787 LONGEST i
, n
, packet_len
;
7789 if (packet
->support
== PACKET_DISABLE
)
7792 /* Check whether we've cached an end-of-object packet that matches
7794 if (finished_object
)
7796 if (strcmp (object_name
, finished_object
) == 0
7797 && strcmp (annex
? annex
: "", finished_annex
) == 0
7798 && offset
== finished_offset
)
7801 /* Otherwise, we're now reading something different. Discard
7803 xfree (finished_object
);
7804 xfree (finished_annex
);
7805 finished_object
= NULL
;
7806 finished_annex
= NULL
;
7809 /* Request only enough to fit in a single packet. The actual data
7810 may not, since we don't know how much of it will need to be escaped;
7811 the target is free to respond with slightly less data. We subtract
7812 five to account for the response type and the protocol frame. */
7813 n
= min (get_remote_packet_size () - 5, len
);
7814 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
7815 object_name
, annex
? annex
: "",
7816 phex_nz (offset
, sizeof offset
),
7817 phex_nz (n
, sizeof n
));
7818 i
= putpkt (rs
->buf
);
7823 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
7824 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
7827 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
7828 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
7830 /* 'm' means there is (or at least might be) more data after this
7831 batch. That does not make sense unless there's at least one byte
7832 of data in this reply. */
7833 if (rs
->buf
[0] == 'm' && packet_len
== 1)
7834 error (_("Remote qXfer reply contained no data."));
7836 /* Got some data. */
7837 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
7839 /* 'l' is an EOF marker, possibly including a final block of data,
7840 or possibly empty. If we have the final block of a non-empty
7841 object, record this fact to bypass a subsequent partial read. */
7842 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
7844 finished_object
= xstrdup (object_name
);
7845 finished_annex
= xstrdup (annex
? annex
: "");
7846 finished_offset
= offset
+ i
;
7853 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
7854 const char *annex
, gdb_byte
*readbuf
,
7855 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
7857 struct remote_state
*rs
;
7862 set_general_thread (inferior_ptid
);
7864 rs
= get_remote_state ();
7866 /* Handle memory using the standard memory routines. */
7867 if (object
== TARGET_OBJECT_MEMORY
)
7872 /* If the remote target is connected but not running, we should
7873 pass this request down to a lower stratum (e.g. the executable
7875 if (!target_has_execution
)
7878 if (writebuf
!= NULL
)
7879 xfered
= remote_write_bytes (offset
, writebuf
, len
);
7881 xfered
= remote_read_bytes (offset
, readbuf
, len
);
7885 else if (xfered
== 0 && errno
== 0)
7891 /* Handle SPU memory using qxfer packets. */
7892 if (object
== TARGET_OBJECT_SPU
)
7895 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
7896 &remote_protocol_packets
7897 [PACKET_qXfer_spu_read
]);
7899 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
7900 &remote_protocol_packets
7901 [PACKET_qXfer_spu_write
]);
7904 /* Handle extra signal info using qxfer packets. */
7905 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
7908 return remote_read_qxfer (ops
, "siginfo", annex
, readbuf
, offset
, len
,
7909 &remote_protocol_packets
7910 [PACKET_qXfer_siginfo_read
]);
7912 return remote_write_qxfer (ops
, "siginfo", annex
, writebuf
, offset
, len
,
7913 &remote_protocol_packets
7914 [PACKET_qXfer_siginfo_write
]);
7917 /* Only handle flash writes. */
7918 if (writebuf
!= NULL
)
7924 case TARGET_OBJECT_FLASH
:
7925 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
7929 else if (xfered
== 0 && errno
== 0)
7939 /* Map pre-existing objects onto letters. DO NOT do this for new
7940 objects!!! Instead specify new query packets. */
7943 case TARGET_OBJECT_AVR
:
7947 case TARGET_OBJECT_AUXV
:
7948 gdb_assert (annex
== NULL
);
7949 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
7950 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
7952 case TARGET_OBJECT_AVAILABLE_FEATURES
:
7953 return remote_read_qxfer
7954 (ops
, "features", annex
, readbuf
, offset
, len
,
7955 &remote_protocol_packets
[PACKET_qXfer_features
]);
7957 case TARGET_OBJECT_LIBRARIES
:
7958 return remote_read_qxfer
7959 (ops
, "libraries", annex
, readbuf
, offset
, len
,
7960 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
7962 case TARGET_OBJECT_MEMORY_MAP
:
7963 gdb_assert (annex
== NULL
);
7964 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
7965 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
7967 case TARGET_OBJECT_OSDATA
:
7968 /* Should only get here if we're connected. */
7969 gdb_assert (remote_desc
);
7970 return remote_read_qxfer
7971 (ops
, "osdata", annex
, readbuf
, offset
, len
,
7972 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
7974 case TARGET_OBJECT_THREADS
:
7975 gdb_assert (annex
== NULL
);
7976 return remote_read_qxfer (ops
, "threads", annex
, readbuf
, offset
, len
,
7977 &remote_protocol_packets
[PACKET_qXfer_threads
]);
7983 /* Note: a zero OFFSET and LEN can be used to query the minimum
7985 if (offset
== 0 && len
== 0)
7986 return (get_remote_packet_size ());
7987 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
7988 large enough let the caller deal with it. */
7989 if (len
< get_remote_packet_size ())
7991 len
= get_remote_packet_size ();
7993 /* Except for querying the minimum buffer size, target must be open. */
7995 error (_("remote query is only available after target open"));
7997 gdb_assert (annex
!= NULL
);
7998 gdb_assert (readbuf
!= NULL
);
8004 /* We used one buffer char for the remote protocol q command and
8005 another for the query type. As the remote protocol encapsulation
8006 uses 4 chars plus one extra in case we are debugging
8007 (remote_debug), we have PBUFZIZ - 7 left to pack the query
8010 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
8012 /* Bad caller may have sent forbidden characters. */
8013 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
8018 gdb_assert (annex
[i
] == '\0');
8020 i
= putpkt (rs
->buf
);
8024 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8025 strcpy ((char *) readbuf
, rs
->buf
);
8027 return strlen ((char *) readbuf
);
8031 remote_search_memory (struct target_ops
* ops
,
8032 CORE_ADDR start_addr
, ULONGEST search_space_len
,
8033 const gdb_byte
*pattern
, ULONGEST pattern_len
,
8034 CORE_ADDR
*found_addrp
)
8036 int addr_size
= gdbarch_addr_bit (target_gdbarch
) / 8;
8037 struct remote_state
*rs
= get_remote_state ();
8038 int max_size
= get_memory_write_packet_size ();
8039 struct packet_config
*packet
=
8040 &remote_protocol_packets
[PACKET_qSearch_memory
];
8041 /* number of packet bytes used to encode the pattern,
8042 this could be more than PATTERN_LEN due to escape characters */
8043 int escaped_pattern_len
;
8044 /* amount of pattern that was encodable in the packet */
8045 int used_pattern_len
;
8048 ULONGEST found_addr
;
8050 /* Don't go to the target if we don't have to.
8051 This is done before checking packet->support to avoid the possibility that
8052 a success for this edge case means the facility works in general. */
8053 if (pattern_len
> search_space_len
)
8055 if (pattern_len
== 0)
8057 *found_addrp
= start_addr
;
8061 /* If we already know the packet isn't supported, fall back to the simple
8062 way of searching memory. */
8064 if (packet
->support
== PACKET_DISABLE
)
8066 /* Target doesn't provided special support, fall back and use the
8067 standard support (copy memory and do the search here). */
8068 return simple_search_memory (ops
, start_addr
, search_space_len
,
8069 pattern
, pattern_len
, found_addrp
);
8072 /* Insert header. */
8073 i
= snprintf (rs
->buf
, max_size
,
8074 "qSearch:memory:%s;%s;",
8075 phex_nz (start_addr
, addr_size
),
8076 phex_nz (search_space_len
, sizeof (search_space_len
)));
8077 max_size
-= (i
+ 1);
8079 /* Escape as much data as fits into rs->buf. */
8080 escaped_pattern_len
=
8081 remote_escape_output (pattern
, pattern_len
, (rs
->buf
+ i
),
8082 &used_pattern_len
, max_size
);
8084 /* Bail if the pattern is too large. */
8085 if (used_pattern_len
!= pattern_len
)
8086 error ("Pattern is too large to transmit to remote target.");
8088 if (putpkt_binary (rs
->buf
, i
+ escaped_pattern_len
) < 0
8089 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
8090 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
8092 /* The request may not have worked because the command is not
8093 supported. If so, fall back to the simple way. */
8094 if (packet
->support
== PACKET_DISABLE
)
8096 return simple_search_memory (ops
, start_addr
, search_space_len
,
8097 pattern
, pattern_len
, found_addrp
);
8102 if (rs
->buf
[0] == '0')
8104 else if (rs
->buf
[0] == '1')
8107 if (rs
->buf
[1] != ',')
8108 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
8109 unpack_varlen_hex (rs
->buf
+ 2, &found_addr
);
8110 *found_addrp
= found_addr
;
8113 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
8119 remote_rcmd (char *command
,
8120 struct ui_file
*outbuf
)
8122 struct remote_state
*rs
= get_remote_state ();
8126 error (_("remote rcmd is only available after target open"));
8128 /* Send a NULL command across as an empty command. */
8129 if (command
== NULL
)
8132 /* The query prefix. */
8133 strcpy (rs
->buf
, "qRcmd,");
8134 p
= strchr (rs
->buf
, '\0');
8136 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
8137 error (_("\"monitor\" command ``%s'' is too long."), command
);
8139 /* Encode the actual command. */
8140 bin2hex ((gdb_byte
*) command
, p
, 0);
8142 if (putpkt (rs
->buf
) < 0)
8143 error (_("Communication problem with target."));
8145 /* get/display the response */
8150 /* XXX - see also remote_get_noisy_reply(). */
8152 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8155 error (_("Target does not support this command."));
8156 if (buf
[0] == 'O' && buf
[1] != 'K')
8158 remote_console_output (buf
+ 1); /* 'O' message from stub. */
8161 if (strcmp (buf
, "OK") == 0)
8163 if (strlen (buf
) == 3 && buf
[0] == 'E'
8164 && isdigit (buf
[1]) && isdigit (buf
[2]))
8166 error (_("Protocol error with Rcmd"));
8168 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
8170 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
8171 fputc_unfiltered (c
, outbuf
);
8177 static VEC(mem_region_s
) *
8178 remote_memory_map (struct target_ops
*ops
)
8180 VEC(mem_region_s
) *result
= NULL
;
8181 char *text
= target_read_stralloc (¤t_target
,
8182 TARGET_OBJECT_MEMORY_MAP
, NULL
);
8186 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
8187 result
= parse_memory_map (text
);
8188 do_cleanups (back_to
);
8195 packet_command (char *args
, int from_tty
)
8197 struct remote_state
*rs
= get_remote_state ();
8200 error (_("command can only be used with remote target"));
8203 error (_("remote-packet command requires packet text as argument"));
8205 puts_filtered ("sending: ");
8206 print_packet (args
);
8207 puts_filtered ("\n");
8210 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8211 puts_filtered ("received: ");
8212 print_packet (rs
->buf
);
8213 puts_filtered ("\n");
8217 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
8219 static void display_thread_info (struct gdb_ext_thread_info
*info
);
8221 static void threadset_test_cmd (char *cmd
, int tty
);
8223 static void threadalive_test (char *cmd
, int tty
);
8225 static void threadlist_test_cmd (char *cmd
, int tty
);
8227 int get_and_display_threadinfo (threadref
*ref
);
8229 static void threadinfo_test_cmd (char *cmd
, int tty
);
8231 static int thread_display_step (threadref
*ref
, void *context
);
8233 static void threadlist_update_test_cmd (char *cmd
, int tty
);
8235 static void init_remote_threadtests (void);
8237 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
8240 threadset_test_cmd (char *cmd
, int tty
)
8242 int sample_thread
= SAMPLE_THREAD
;
8244 printf_filtered (_("Remote threadset test\n"));
8245 set_general_thread (sample_thread
);
8250 threadalive_test (char *cmd
, int tty
)
8252 int sample_thread
= SAMPLE_THREAD
;
8253 int pid
= ptid_get_pid (inferior_ptid
);
8254 ptid_t ptid
= ptid_build (pid
, 0, sample_thread
);
8256 if (remote_thread_alive (ptid
))
8257 printf_filtered ("PASS: Thread alive test\n");
8259 printf_filtered ("FAIL: Thread alive test\n");
8262 void output_threadid (char *title
, threadref
*ref
);
8265 output_threadid (char *title
, threadref
*ref
)
8269 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
8271 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
8275 threadlist_test_cmd (char *cmd
, int tty
)
8278 threadref nextthread
;
8279 int done
, result_count
;
8280 threadref threadlist
[3];
8282 printf_filtered ("Remote Threadlist test\n");
8283 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
8284 &result_count
, &threadlist
[0]))
8285 printf_filtered ("FAIL: threadlist test\n");
8288 threadref
*scan
= threadlist
;
8289 threadref
*limit
= scan
+ result_count
;
8291 while (scan
< limit
)
8292 output_threadid (" thread ", scan
++);
8297 display_thread_info (struct gdb_ext_thread_info
*info
)
8299 output_threadid ("Threadid: ", &info
->threadid
);
8300 printf_filtered ("Name: %s\n ", info
->shortname
);
8301 printf_filtered ("State: %s\n", info
->display
);
8302 printf_filtered ("other: %s\n\n", info
->more_display
);
8306 get_and_display_threadinfo (threadref
*ref
)
8310 struct gdb_ext_thread_info threadinfo
;
8312 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
8313 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
8314 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
8315 display_thread_info (&threadinfo
);
8320 threadinfo_test_cmd (char *cmd
, int tty
)
8322 int athread
= SAMPLE_THREAD
;
8326 int_to_threadref (&thread
, athread
);
8327 printf_filtered ("Remote Threadinfo test\n");
8328 if (!get_and_display_threadinfo (&thread
))
8329 printf_filtered ("FAIL cannot get thread info\n");
8333 thread_display_step (threadref
*ref
, void *context
)
8335 /* output_threadid(" threadstep ",ref); *//* simple test */
8336 return get_and_display_threadinfo (ref
);
8340 threadlist_update_test_cmd (char *cmd
, int tty
)
8342 printf_filtered ("Remote Threadlist update test\n");
8343 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
8347 init_remote_threadtests (void)
8349 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
8350 Fetch and print the remote list of thread identifiers, one pkt only"));
8351 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
8352 _("Fetch and display info about one thread"));
8353 add_com ("tset", class_obscure
, threadset_test_cmd
,
8354 _("Test setting to a different thread"));
8355 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
8356 _("Iterate through updating all remote thread info"));
8357 add_com ("talive", class_obscure
, threadalive_test
,
8358 _(" Remote thread alive test "));
8363 /* Convert a thread ID to a string. Returns the string in a static
8367 remote_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
8369 static char buf
[64];
8370 struct remote_state
*rs
= get_remote_state ();
8372 if (ptid_is_pid (ptid
))
8374 /* Printing an inferior target id. */
8376 /* When multi-process extensions are off, there's no way in the
8377 remote protocol to know the remote process id, if there's any
8378 at all. There's one exception --- when we're connected with
8379 target extended-remote, and we manually attached to a process
8380 with "attach PID". We don't record anywhere a flag that
8381 allows us to distinguish that case from the case of
8382 connecting with extended-remote and the stub already being
8383 attached to a process, and reporting yes to qAttached, hence
8384 no smart special casing here. */
8385 if (!remote_multi_process_p (rs
))
8387 xsnprintf (buf
, sizeof buf
, "Remote target");
8391 return normal_pid_to_str (ptid
);
8395 if (ptid_equal (magic_null_ptid
, ptid
))
8396 xsnprintf (buf
, sizeof buf
, "Thread <main>");
8397 else if (remote_multi_process_p (rs
))
8398 xsnprintf (buf
, sizeof buf
, "Thread %d.%ld",
8399 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
8401 xsnprintf (buf
, sizeof buf
, "Thread %ld",
8402 ptid_get_tid (ptid
));
8407 /* Get the address of the thread local variable in OBJFILE which is
8408 stored at OFFSET within the thread local storage for thread PTID. */
8411 remote_get_thread_local_address (struct target_ops
*ops
,
8412 ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
8414 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
8416 struct remote_state
*rs
= get_remote_state ();
8418 char *endp
= rs
->buf
+ get_remote_packet_size ();
8419 enum packet_result result
;
8421 strcpy (p
, "qGetTLSAddr:");
8423 p
= write_ptid (p
, endp
, ptid
);
8425 p
+= hexnumstr (p
, offset
);
8427 p
+= hexnumstr (p
, lm
);
8431 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8432 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
8433 if (result
== PACKET_OK
)
8437 unpack_varlen_hex (rs
->buf
, &result
);
8440 else if (result
== PACKET_UNKNOWN
)
8441 throw_error (TLS_GENERIC_ERROR
,
8442 _("Remote target doesn't support qGetTLSAddr packet"));
8444 throw_error (TLS_GENERIC_ERROR
,
8445 _("Remote target failed to process qGetTLSAddr request"));
8448 throw_error (TLS_GENERIC_ERROR
,
8449 _("TLS not supported or disabled on this target"));
8454 /* Provide thread local base, i.e. Thread Information Block address.
8455 Returns 1 if ptid is found and thread_local_base is non zero. */
8458 remote_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
8460 if (remote_protocol_packets
[PACKET_qGetTIBAddr
].support
!= PACKET_DISABLE
)
8462 struct remote_state
*rs
= get_remote_state ();
8464 char *endp
= rs
->buf
+ get_remote_packet_size ();
8465 enum packet_result result
;
8467 strcpy (p
, "qGetTIBAddr:");
8469 p
= write_ptid (p
, endp
, ptid
);
8473 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8474 result
= packet_ok (rs
->buf
,
8475 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
8476 if (result
== PACKET_OK
)
8480 unpack_varlen_hex (rs
->buf
, &result
);
8482 *addr
= (CORE_ADDR
) result
;
8485 else if (result
== PACKET_UNKNOWN
)
8486 error (_("Remote target doesn't support qGetTIBAddr packet"));
8488 error (_("Remote target failed to process qGetTIBAddr request"));
8491 error (_("qGetTIBAddr not supported or disabled on this target"));
8496 /* Support for inferring a target description based on the current
8497 architecture and the size of a 'g' packet. While the 'g' packet
8498 can have any size (since optional registers can be left off the
8499 end), some sizes are easily recognizable given knowledge of the
8500 approximate architecture. */
8502 struct remote_g_packet_guess
8505 const struct target_desc
*tdesc
;
8507 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
8508 DEF_VEC_O(remote_g_packet_guess_s
);
8510 struct remote_g_packet_data
8512 VEC(remote_g_packet_guess_s
) *guesses
;
8515 static struct gdbarch_data
*remote_g_packet_data_handle
;
8518 remote_g_packet_data_init (struct obstack
*obstack
)
8520 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
8524 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
8525 const struct target_desc
*tdesc
)
8527 struct remote_g_packet_data
*data
8528 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
8529 struct remote_g_packet_guess new_guess
, *guess
;
8532 gdb_assert (tdesc
!= NULL
);
8535 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
8537 if (guess
->bytes
== bytes
)
8538 internal_error (__FILE__
, __LINE__
,
8539 "Duplicate g packet description added for size %d",
8542 new_guess
.bytes
= bytes
;
8543 new_guess
.tdesc
= tdesc
;
8544 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
8547 /* Return 1 if remote_read_description would do anything on this target
8548 and architecture, 0 otherwise. */
8551 remote_read_description_p (struct target_ops
*target
)
8553 struct remote_g_packet_data
*data
8554 = gdbarch_data (target_gdbarch
, remote_g_packet_data_handle
);
8556 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
8562 static const struct target_desc
*
8563 remote_read_description (struct target_ops
*target
)
8565 struct remote_g_packet_data
*data
8566 = gdbarch_data (target_gdbarch
, remote_g_packet_data_handle
);
8568 /* Do not try this during initial connection, when we do not know
8569 whether there is a running but stopped thread. */
8570 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
8573 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
8575 struct remote_g_packet_guess
*guess
;
8577 int bytes
= send_g_packet ();
8580 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
8582 if (guess
->bytes
== bytes
)
8583 return guess
->tdesc
;
8585 /* We discard the g packet. A minor optimization would be to
8586 hold on to it, and fill the register cache once we have selected
8587 an architecture, but it's too tricky to do safely. */
8593 /* Remote file transfer support. This is host-initiated I/O, not
8594 target-initiated; for target-initiated, see remote-fileio.c. */
8596 /* If *LEFT is at least the length of STRING, copy STRING to
8597 *BUFFER, update *BUFFER to point to the new end of the buffer, and
8598 decrease *LEFT. Otherwise raise an error. */
8601 remote_buffer_add_string (char **buffer
, int *left
, char *string
)
8603 int len
= strlen (string
);
8606 error (_("Packet too long for target."));
8608 memcpy (*buffer
, string
, len
);
8612 /* NUL-terminate the buffer as a convenience, if there is
8618 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
8619 *BUFFER, update *BUFFER to point to the new end of the buffer, and
8620 decrease *LEFT. Otherwise raise an error. */
8623 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
8626 if (2 * len
> *left
)
8627 error (_("Packet too long for target."));
8629 bin2hex (bytes
, *buffer
, len
);
8633 /* NUL-terminate the buffer as a convenience, if there is
8639 /* If *LEFT is large enough, convert VALUE to hex and add it to
8640 *BUFFER, update *BUFFER to point to the new end of the buffer, and
8641 decrease *LEFT. Otherwise raise an error. */
8644 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
8646 int len
= hexnumlen (value
);
8649 error (_("Packet too long for target."));
8651 hexnumstr (*buffer
, value
);
8655 /* NUL-terminate the buffer as a convenience, if there is
8661 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
8662 value, *REMOTE_ERRNO to the remote error number or zero if none
8663 was included, and *ATTACHMENT to point to the start of the annex
8664 if any. The length of the packet isn't needed here; there may
8665 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
8667 Return 0 if the packet could be parsed, -1 if it could not. If
8668 -1 is returned, the other variables may not be initialized. */
8671 remote_hostio_parse_result (char *buffer
, int *retcode
,
8672 int *remote_errno
, char **attachment
)
8679 if (buffer
[0] != 'F')
8683 *retcode
= strtol (&buffer
[1], &p
, 16);
8684 if (errno
!= 0 || p
== &buffer
[1])
8687 /* Check for ",errno". */
8691 *remote_errno
= strtol (p
+ 1, &p2
, 16);
8692 if (errno
!= 0 || p
+ 1 == p2
)
8697 /* Check for ";attachment". If there is no attachment, the
8698 packet should end here. */
8701 *attachment
= p
+ 1;
8704 else if (*p
== '\0')
8710 /* Send a prepared I/O packet to the target and read its response.
8711 The prepared packet is in the global RS->BUF before this function
8712 is called, and the answer is there when we return.
8714 COMMAND_BYTES is the length of the request to send, which may include
8715 binary data. WHICH_PACKET is the packet configuration to check
8716 before attempting a packet. If an error occurs, *REMOTE_ERRNO
8717 is set to the error number and -1 is returned. Otherwise the value
8718 returned by the function is returned.
8720 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
8721 attachment is expected; an error will be reported if there's a
8722 mismatch. If one is found, *ATTACHMENT will be set to point into
8723 the packet buffer and *ATTACHMENT_LEN will be set to the
8724 attachment's length. */
8727 remote_hostio_send_command (int command_bytes
, int which_packet
,
8728 int *remote_errno
, char **attachment
,
8729 int *attachment_len
)
8731 struct remote_state
*rs
= get_remote_state ();
8732 int ret
, bytes_read
;
8733 char *attachment_tmp
;
8736 || remote_protocol_packets
[which_packet
].support
== PACKET_DISABLE
)
8738 *remote_errno
= FILEIO_ENOSYS
;
8742 putpkt_binary (rs
->buf
, command_bytes
);
8743 bytes_read
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
8745 /* If it timed out, something is wrong. Don't try to parse the
8749 *remote_errno
= FILEIO_EINVAL
;
8753 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
8756 *remote_errno
= FILEIO_EINVAL
;
8758 case PACKET_UNKNOWN
:
8759 *remote_errno
= FILEIO_ENOSYS
;
8765 if (remote_hostio_parse_result (rs
->buf
, &ret
, remote_errno
,
8768 *remote_errno
= FILEIO_EINVAL
;
8772 /* Make sure we saw an attachment if and only if we expected one. */
8773 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
8774 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
8776 *remote_errno
= FILEIO_EINVAL
;
8780 /* If an attachment was found, it must point into the packet buffer;
8781 work out how many bytes there were. */
8782 if (attachment_tmp
!= NULL
)
8784 *attachment
= attachment_tmp
;
8785 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
);
8791 /* Open FILENAME on the remote target, using FLAGS and MODE. Return a
8792 remote file descriptor, or -1 if an error occurs (and set
8796 remote_hostio_open (const char *filename
, int flags
, int mode
,
8799 struct remote_state
*rs
= get_remote_state ();
8801 int left
= get_remote_packet_size () - 1;
8803 remote_buffer_add_string (&p
, &left
, "vFile:open:");
8805 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
8807 remote_buffer_add_string (&p
, &left
, ",");
8809 remote_buffer_add_int (&p
, &left
, flags
);
8810 remote_buffer_add_string (&p
, &left
, ",");
8812 remote_buffer_add_int (&p
, &left
, mode
);
8814 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_open
,
8815 remote_errno
, NULL
, NULL
);
8818 /* Write up to LEN bytes from WRITE_BUF to FD on the remote target.
8819 Return the number of bytes written, or -1 if an error occurs (and
8820 set *REMOTE_ERRNO). */
8823 remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
8824 ULONGEST offset
, int *remote_errno
)
8826 struct remote_state
*rs
= get_remote_state ();
8828 int left
= get_remote_packet_size ();
8831 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
8833 remote_buffer_add_int (&p
, &left
, fd
);
8834 remote_buffer_add_string (&p
, &left
, ",");
8836 remote_buffer_add_int (&p
, &left
, offset
);
8837 remote_buffer_add_string (&p
, &left
, ",");
8839 p
+= remote_escape_output (write_buf
, len
, p
, &out_len
,
8840 get_remote_packet_size () - (p
- rs
->buf
));
8842 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pwrite
,
8843 remote_errno
, NULL
, NULL
);
8846 /* Read up to LEN bytes FD on the remote target into READ_BUF
8847 Return the number of bytes read, or -1 if an error occurs (and
8848 set *REMOTE_ERRNO). */
8851 remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
8852 ULONGEST offset
, int *remote_errno
)
8854 struct remote_state
*rs
= get_remote_state ();
8857 int left
= get_remote_packet_size ();
8858 int ret
, attachment_len
;
8861 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
8863 remote_buffer_add_int (&p
, &left
, fd
);
8864 remote_buffer_add_string (&p
, &left
, ",");
8866 remote_buffer_add_int (&p
, &left
, len
);
8867 remote_buffer_add_string (&p
, &left
, ",");
8869 remote_buffer_add_int (&p
, &left
, offset
);
8871 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pread
,
8872 remote_errno
, &attachment
,
8878 read_len
= remote_unescape_input (attachment
, attachment_len
,
8880 if (read_len
!= ret
)
8881 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
8886 /* Close FD on the remote target. Return 0, or -1 if an error occurs
8887 (and set *REMOTE_ERRNO). */
8890 remote_hostio_close (int fd
, int *remote_errno
)
8892 struct remote_state
*rs
= get_remote_state ();
8894 int left
= get_remote_packet_size () - 1;
8896 remote_buffer_add_string (&p
, &left
, "vFile:close:");
8898 remote_buffer_add_int (&p
, &left
, fd
);
8900 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_close
,
8901 remote_errno
, NULL
, NULL
);
8904 /* Unlink FILENAME on the remote target. Return 0, or -1 if an error
8905 occurs (and set *REMOTE_ERRNO). */
8908 remote_hostio_unlink (const char *filename
, int *remote_errno
)
8910 struct remote_state
*rs
= get_remote_state ();
8912 int left
= get_remote_packet_size () - 1;
8914 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
8916 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
8919 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_unlink
,
8920 remote_errno
, NULL
, NULL
);
8924 remote_fileio_errno_to_host (int errnum
)
8948 case FILEIO_ENOTDIR
:
8968 case FILEIO_ENAMETOOLONG
:
8969 return ENAMETOOLONG
;
8975 remote_hostio_error (int errnum
)
8977 int host_error
= remote_fileio_errno_to_host (errnum
);
8979 if (host_error
== -1)
8980 error (_("Unknown remote I/O error %d"), errnum
);
8982 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
8986 remote_hostio_close_cleanup (void *opaque
)
8988 int fd
= *(int *) opaque
;
8991 remote_hostio_close (fd
, &remote_errno
);
8996 remote_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
8998 const char *filename
= bfd_get_filename (abfd
);
8999 int fd
, remote_errno
;
9002 gdb_assert (remote_filename_p (filename
));
9004 fd
= remote_hostio_open (filename
+ 7, FILEIO_O_RDONLY
, 0, &remote_errno
);
9007 errno
= remote_fileio_errno_to_host (remote_errno
);
9008 bfd_set_error (bfd_error_system_call
);
9012 stream
= xmalloc (sizeof (int));
9018 remote_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
9020 int fd
= *(int *)stream
;
9025 /* Ignore errors on close; these may happen if the remote
9026 connection was already torn down. */
9027 remote_hostio_close (fd
, &remote_errno
);
9033 remote_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
9034 file_ptr nbytes
, file_ptr offset
)
9036 int fd
= *(int *)stream
;
9038 file_ptr pos
, bytes
;
9041 while (nbytes
> pos
)
9043 bytes
= remote_hostio_pread (fd
, (char *)buf
+ pos
, nbytes
- pos
,
9044 offset
+ pos
, &remote_errno
);
9046 /* Success, but no bytes, means end-of-file. */
9050 errno
= remote_fileio_errno_to_host (remote_errno
);
9051 bfd_set_error (bfd_error_system_call
);
9062 remote_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
9064 /* FIXME: We should probably implement remote_hostio_stat. */
9065 sb
->st_size
= INT_MAX
;
9070 remote_filename_p (const char *filename
)
9072 return strncmp (filename
, "remote:", 7) == 0;
9076 remote_bfd_open (const char *remote_file
, const char *target
)
9078 return bfd_openr_iovec (remote_file
, target
,
9079 remote_bfd_iovec_open
, NULL
,
9080 remote_bfd_iovec_pread
,
9081 remote_bfd_iovec_close
,
9082 remote_bfd_iovec_stat
);
9086 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
9088 struct cleanup
*back_to
, *close_cleanup
;
9089 int retcode
, fd
, remote_errno
, bytes
, io_size
;
9092 int bytes_in_buffer
;
9097 error (_("command can only be used with remote target"));
9099 file
= fopen (local_file
, "rb");
9101 perror_with_name (local_file
);
9102 back_to
= make_cleanup_fclose (file
);
9104 fd
= remote_hostio_open (remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
9106 0700, &remote_errno
);
9108 remote_hostio_error (remote_errno
);
9110 /* Send up to this many bytes at once. They won't all fit in the
9111 remote packet limit, so we'll transfer slightly fewer. */
9112 io_size
= get_remote_packet_size ();
9113 buffer
= xmalloc (io_size
);
9114 make_cleanup (xfree
, buffer
);
9116 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
9118 bytes_in_buffer
= 0;
9121 while (bytes_in_buffer
|| !saw_eof
)
9125 bytes
= fread (buffer
+ bytes_in_buffer
, 1, io_size
- bytes_in_buffer
,
9130 error (_("Error reading %s."), local_file
);
9133 /* EOF. Unless there is something still in the
9134 buffer from the last iteration, we are done. */
9136 if (bytes_in_buffer
== 0)
9144 bytes
+= bytes_in_buffer
;
9145 bytes_in_buffer
= 0;
9147 retcode
= remote_hostio_pwrite (fd
, buffer
, bytes
, offset
, &remote_errno
);
9150 remote_hostio_error (remote_errno
);
9151 else if (retcode
== 0)
9152 error (_("Remote write of %d bytes returned 0!"), bytes
);
9153 else if (retcode
< bytes
)
9155 /* Short write. Save the rest of the read data for the next
9157 bytes_in_buffer
= bytes
- retcode
;
9158 memmove (buffer
, buffer
+ retcode
, bytes_in_buffer
);
9164 discard_cleanups (close_cleanup
);
9165 if (remote_hostio_close (fd
, &remote_errno
))
9166 remote_hostio_error (remote_errno
);
9169 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
9170 do_cleanups (back_to
);
9174 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
9176 struct cleanup
*back_to
, *close_cleanup
;
9177 int fd
, remote_errno
, bytes
, io_size
;
9183 error (_("command can only be used with remote target"));
9185 fd
= remote_hostio_open (remote_file
, FILEIO_O_RDONLY
, 0, &remote_errno
);
9187 remote_hostio_error (remote_errno
);
9189 file
= fopen (local_file
, "wb");
9191 perror_with_name (local_file
);
9192 back_to
= make_cleanup_fclose (file
);
9194 /* Send up to this many bytes at once. They won't all fit in the
9195 remote packet limit, so we'll transfer slightly fewer. */
9196 io_size
= get_remote_packet_size ();
9197 buffer
= xmalloc (io_size
);
9198 make_cleanup (xfree
, buffer
);
9200 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
9205 bytes
= remote_hostio_pread (fd
, buffer
, io_size
, offset
, &remote_errno
);
9207 /* Success, but no bytes, means end-of-file. */
9210 remote_hostio_error (remote_errno
);
9214 bytes
= fwrite (buffer
, 1, bytes
, file
);
9216 perror_with_name (local_file
);
9219 discard_cleanups (close_cleanup
);
9220 if (remote_hostio_close (fd
, &remote_errno
))
9221 remote_hostio_error (remote_errno
);
9224 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
9225 do_cleanups (back_to
);
9229 remote_file_delete (const char *remote_file
, int from_tty
)
9231 int retcode
, remote_errno
;
9234 error (_("command can only be used with remote target"));
9236 retcode
= remote_hostio_unlink (remote_file
, &remote_errno
);
9238 remote_hostio_error (remote_errno
);
9241 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
9245 remote_put_command (char *args
, int from_tty
)
9247 struct cleanup
*back_to
;
9251 error_no_arg (_("file to put"));
9253 argv
= gdb_buildargv (args
);
9254 back_to
= make_cleanup_freeargv (argv
);
9255 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
9256 error (_("Invalid parameters to remote put"));
9258 remote_file_put (argv
[0], argv
[1], from_tty
);
9260 do_cleanups (back_to
);
9264 remote_get_command (char *args
, int from_tty
)
9266 struct cleanup
*back_to
;
9270 error_no_arg (_("file to get"));
9272 argv
= gdb_buildargv (args
);
9273 back_to
= make_cleanup_freeargv (argv
);
9274 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
9275 error (_("Invalid parameters to remote get"));
9277 remote_file_get (argv
[0], argv
[1], from_tty
);
9279 do_cleanups (back_to
);
9283 remote_delete_command (char *args
, int from_tty
)
9285 struct cleanup
*back_to
;
9289 error_no_arg (_("file to delete"));
9291 argv
= gdb_buildargv (args
);
9292 back_to
= make_cleanup_freeargv (argv
);
9293 if (argv
[0] == NULL
|| argv
[1] != NULL
)
9294 error (_("Invalid parameters to remote delete"));
9296 remote_file_delete (argv
[0], from_tty
);
9298 do_cleanups (back_to
);
9302 remote_command (char *args
, int from_tty
)
9304 help_list (remote_cmdlist
, "remote ", -1, gdb_stdout
);
9308 remote_can_execute_reverse (void)
9310 if (remote_protocol_packets
[PACKET_bs
].support
== PACKET_ENABLE
9311 || remote_protocol_packets
[PACKET_bc
].support
== PACKET_ENABLE
)
9318 remote_supports_non_stop (void)
9324 remote_supports_multi_process (void)
9326 struct remote_state
*rs
= get_remote_state ();
9327 return remote_multi_process_p (rs
);
9331 remote_supports_cond_tracepoints (void)
9333 struct remote_state
*rs
= get_remote_state ();
9334 return rs
->cond_tracepoints
;
9338 remote_supports_fast_tracepoints (void)
9340 struct remote_state
*rs
= get_remote_state ();
9341 return rs
->fast_tracepoints
;
9345 remote_trace_init (void)
9348 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9349 if (strcmp (target_buf
, "OK") != 0)
9350 error (_("Target does not support this command."));
9353 static void free_actions_list (char **actions_list
);
9354 static void free_actions_list_cleanup_wrapper (void *);
9356 free_actions_list_cleanup_wrapper (void *al
)
9358 free_actions_list (al
);
9362 free_actions_list (char **actions_list
)
9366 if (actions_list
== 0)
9369 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
9370 xfree (actions_list
[ndx
]);
9372 xfree (actions_list
);
9375 /* Recursive routine to walk through command list including loops, and
9376 download packets for each command. */
9379 remote_download_command_source (int num
, ULONGEST addr
,
9380 struct command_line
*cmds
)
9382 struct remote_state
*rs
= get_remote_state ();
9383 struct command_line
*cmd
;
9385 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
9387 QUIT
; /* allow user to bail out with ^C */
9388 strcpy (rs
->buf
, "QTDPsrc:");
9389 encode_source_string (num
, addr
, "cmd", cmd
->line
,
9390 rs
->buf
+ strlen (rs
->buf
),
9391 rs
->buf_size
- strlen (rs
->buf
));
9393 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9394 if (strcmp (target_buf
, "OK"))
9395 warning (_("Target does not support source download."));
9397 if (cmd
->control_type
== while_control
9398 || cmd
->control_type
== while_stepping_control
)
9400 remote_download_command_source (num
, addr
, *cmd
->body_list
);
9402 QUIT
; /* allow user to bail out with ^C */
9403 strcpy (rs
->buf
, "QTDPsrc:");
9404 encode_source_string (num
, addr
, "cmd", "end",
9405 rs
->buf
+ strlen (rs
->buf
),
9406 rs
->buf_size
- strlen (rs
->buf
));
9408 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9409 if (strcmp (target_buf
, "OK"))
9410 warning (_("Target does not support source download."));
9416 remote_download_tracepoint (struct breakpoint
*t
)
9418 struct bp_location
*loc
;
9423 char **stepping_actions
;
9425 struct cleanup
*old_chain
= NULL
;
9426 struct agent_expr
*aexpr
;
9427 struct cleanup
*aexpr_chain
= NULL
;
9430 /* Iterate over all the tracepoint locations. It's up to the target to
9431 notice multiple tracepoint packets with the same number but different
9432 addresses, and treat them as multiple locations. */
9433 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
9435 encode_actions (t
, loc
, &tdp_actions
, &stepping_actions
);
9436 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
9438 (void) make_cleanup (free_actions_list_cleanup_wrapper
, stepping_actions
);
9440 tpaddr
= loc
->address
;
9441 sprintf_vma (addrbuf
, tpaddr
);
9442 sprintf (buf
, "QTDP:%x:%s:%c:%lx:%x", t
->number
,
9443 addrbuf
, /* address */
9444 (t
->enable_state
== bp_enabled
? 'E' : 'D'),
9445 t
->step_count
, t
->pass_count
);
9446 /* Fast tracepoints are mostly handled by the target, but we can
9447 tell the target how big of an instruction block should be moved
9449 if (t
->type
== bp_fast_tracepoint
)
9451 /* Only test for support at download time; we may not know
9452 target capabilities at definition time. */
9453 if (remote_supports_fast_tracepoints ())
9457 if (gdbarch_fast_tracepoint_valid_at (target_gdbarch
,
9458 tpaddr
, &isize
, NULL
))
9459 sprintf (buf
+ strlen (buf
), ":F%x", isize
);
9461 /* If it passed validation at definition but fails now,
9462 something is very wrong. */
9463 internal_error (__FILE__
, __LINE__
,
9464 "Fast tracepoint not valid during download");
9467 /* Fast tracepoints are functionally identical to regular
9468 tracepoints, so don't take lack of support as a reason to
9469 give up on the trace run. */
9470 warning (_("Target does not support fast tracepoints, downloading %d as regular tracepoint"), t
->number
);
9472 /* If the tracepoint has a conditional, make it into an agent
9473 expression and append to the definition. */
9476 /* Only test support at download time, we may not know target
9477 capabilities at definition time. */
9478 if (remote_supports_cond_tracepoints ())
9480 aexpr
= gen_eval_for_expr (tpaddr
, loc
->cond
);
9481 aexpr_chain
= make_cleanup_free_agent_expr (aexpr
);
9482 sprintf (buf
+ strlen (buf
), ":X%x,", aexpr
->len
);
9483 pkt
= buf
+ strlen (buf
);
9484 for (ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
9485 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
9487 do_cleanups (aexpr_chain
);
9490 warning (_("Target does not support conditional tracepoints, ignoring tp %d cond"), t
->number
);
9493 if (t
->commands
|| *default_collect
)
9496 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9497 if (strcmp (target_buf
, "OK"))
9498 error (_("Target does not support tracepoints."));
9500 /* do_single_steps (t); */
9503 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
9505 QUIT
; /* allow user to bail out with ^C */
9506 sprintf (buf
, "QTDP:-%x:%s:%s%c",
9507 t
->number
, addrbuf
, /* address */
9509 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
9512 remote_get_noisy_reply (&target_buf
,
9514 if (strcmp (target_buf
, "OK"))
9515 error (_("Error on target while setting tracepoints."));
9518 if (stepping_actions
)
9520 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
9522 QUIT
; /* allow user to bail out with ^C */
9523 sprintf (buf
, "QTDP:-%x:%s:%s%s%s",
9524 t
->number
, addrbuf
, /* address */
9525 ((ndx
== 0) ? "S" : ""),
9526 stepping_actions
[ndx
],
9527 (stepping_actions
[ndx
+ 1] ? "-" : ""));
9529 remote_get_noisy_reply (&target_buf
,
9531 if (strcmp (target_buf
, "OK"))
9532 error (_("Error on target while setting tracepoints."));
9536 if (remote_protocol_packets
[PACKET_TracepointSource
].support
== PACKET_ENABLE
)
9540 strcpy (buf
, "QTDPsrc:");
9541 encode_source_string (t
->number
, loc
->address
,
9542 "at", t
->addr_string
, buf
+ strlen (buf
),
9543 2048 - strlen (buf
));
9546 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9547 if (strcmp (target_buf
, "OK"))
9548 warning (_("Target does not support source download."));
9552 strcpy (buf
, "QTDPsrc:");
9553 encode_source_string (t
->number
, loc
->address
,
9554 "cond", t
->cond_string
, buf
+ strlen (buf
),
9555 2048 - strlen (buf
));
9557 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9558 if (strcmp (target_buf
, "OK"))
9559 warning (_("Target does not support source download."));
9561 remote_download_command_source (t
->number
, loc
->address
,
9562 breakpoint_commands (t
));
9565 do_cleanups (old_chain
);
9570 remote_download_trace_state_variable (struct trace_state_variable
*tsv
)
9572 struct remote_state
*rs
= get_remote_state ();
9575 sprintf (rs
->buf
, "QTDV:%x:%s:%x:",
9576 tsv
->number
, phex ((ULONGEST
) tsv
->initial_value
, 8), tsv
->builtin
);
9577 p
= rs
->buf
+ strlen (rs
->buf
);
9578 if ((p
- rs
->buf
) + strlen (tsv
->name
) * 2 >= get_remote_packet_size ())
9579 error (_("Trace state variable name too long for tsv definition packet"));
9580 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
->name
), p
, 0);
9583 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9584 if (*target_buf
== '\0')
9585 error (_("Target does not support this command."));
9586 if (strcmp (target_buf
, "OK") != 0)
9587 error (_("Error on target while downloading trace state variable."));
9591 remote_trace_set_readonly_regions (void)
9599 return; /* No information to give. */
9601 strcpy (target_buf
, "QTro");
9602 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
9604 char tmp1
[40], tmp2
[40];
9606 if ((s
->flags
& SEC_LOAD
) == 0 ||
9607 /* (s->flags & SEC_CODE) == 0 || */
9608 (s
->flags
& SEC_READONLY
) == 0)
9613 size
= bfd_get_section_size (s
);
9614 sprintf_vma (tmp1
, lma
);
9615 sprintf_vma (tmp2
, lma
+ size
);
9616 sprintf (target_buf
+ strlen (target_buf
),
9617 ":%s,%s", tmp1
, tmp2
);
9621 putpkt (target_buf
);
9622 getpkt (&target_buf
, &target_buf_size
, 0);
9627 remote_trace_start (void)
9630 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9631 if (*target_buf
== '\0')
9632 error (_("Target does not support this command."));
9633 if (strcmp (target_buf
, "OK") != 0)
9634 error (_("Bogus reply from target: %s"), target_buf
);
9638 remote_get_trace_status (struct trace_status
*ts
)
9640 char *p
, *p1
, *p_temp
;
9642 /* FIXME we need to get register block size some other way */
9643 extern int trace_regblock_size
;
9644 trace_regblock_size
= get_remote_arch_state ()->sizeof_g_packet
;
9646 putpkt ("qTStatus");
9647 p
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9649 /* If the remote target doesn't do tracing, flag it. */
9653 /* We're working with a live target. */
9656 /* Set some defaults. */
9657 ts
->running_known
= 0;
9658 ts
->stop_reason
= trace_stop_reason_unknown
;
9659 ts
->traceframe_count
= -1;
9660 ts
->buffer_free
= 0;
9663 error (_("Bogus trace status reply from target: %s"), target_buf
);
9665 parse_trace_status (p
, ts
);
9671 remote_trace_stop (void)
9674 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9675 if (*target_buf
== '\0')
9676 error (_("Target does not support this command."));
9677 if (strcmp (target_buf
, "OK") != 0)
9678 error (_("Bogus reply from target: %s"), target_buf
);
9682 remote_trace_find (enum trace_find_type type
, int num
,
9683 ULONGEST addr1
, ULONGEST addr2
,
9686 struct remote_state
*rs
= get_remote_state ();
9688 int target_frameno
= -1, target_tracept
= -1;
9691 strcpy (p
, "QTFrame:");
9692 p
= strchr (p
, '\0');
9696 sprintf (p
, "%x", num
);
9699 sprintf (p
, "pc:%s", phex_nz (addr1
, 0));
9702 sprintf (p
, "tdp:%x", num
);
9705 sprintf (p
, "range:%s:%s", phex_nz (addr1
, 0), phex_nz (addr2
, 0));
9708 sprintf (p
, "outside:%s:%s", phex_nz (addr1
, 0), phex_nz (addr2
, 0));
9711 error ("Unknown trace find type %d", type
);
9715 reply
= remote_get_noisy_reply (&(rs
->buf
), &sizeof_pkt
);
9717 error (_("Target does not support this command."));
9719 while (reply
&& *reply
)
9724 target_frameno
= (int) strtol (p
, &reply
, 16);
9726 error (_("Unable to parse trace frame number"));
9727 if (target_frameno
== -1)
9732 target_tracept
= (int) strtol (p
, &reply
, 16);
9734 error (_("Unable to parse tracepoint number"));
9736 case 'O': /* "OK"? */
9737 if (reply
[1] == 'K' && reply
[2] == '\0')
9740 error (_("Bogus reply from target: %s"), reply
);
9743 error (_("Bogus reply from target: %s"), reply
);
9746 *tpp
= target_tracept
;
9747 return target_frameno
;
9751 remote_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
9753 struct remote_state
*rs
= get_remote_state ();
9757 sprintf (rs
->buf
, "qTV:%x", tsvnum
);
9759 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9760 if (reply
&& *reply
)
9764 unpack_varlen_hex (reply
+ 1, &uval
);
9765 *val
= (LONGEST
) uval
;
9773 remote_save_trace_data (const char *filename
)
9775 struct remote_state
*rs
= get_remote_state ();
9779 strcpy (p
, "QTSave:");
9781 if ((p
- rs
->buf
) + strlen (filename
) * 2 >= get_remote_packet_size ())
9782 error (_("Remote file name too long for trace save packet"));
9783 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, 0);
9786 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9788 error (_("Target does not support this command."));
9789 if (strcmp (reply
, "OK") != 0)
9790 error (_("Bogus reply from target: %s"), reply
);
9794 /* This is basically a memory transfer, but needs to be its own packet
9795 because we don't know how the target actually organizes its trace
9796 memory, plus we want to be able to ask for as much as possible, but
9797 not be unhappy if we don't get as much as we ask for. */
9800 remote_get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
9802 struct remote_state
*rs
= get_remote_state ();
9808 strcpy (p
, "qTBuffer:");
9810 p
+= hexnumstr (p
, offset
);
9812 p
+= hexnumstr (p
, len
);
9816 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9817 if (reply
&& *reply
)
9819 /* 'l' by itself means we're at the end of the buffer and
9820 there is nothing more to get. */
9824 /* Convert the reply into binary. Limit the number of bytes to
9825 convert according to our passed-in buffer size, rather than
9826 what was returned in the packet; if the target is
9827 unexpectedly generous and gives us a bigger reply than we
9828 asked for, we don't want to crash. */
9829 rslt
= hex2bin (target_buf
, buf
, len
);
9833 /* Something went wrong, flag as an error. */
9838 remote_set_disconnected_tracing (int val
)
9840 struct remote_state
*rs
= get_remote_state ();
9842 if (rs
->disconnected_tracing
)
9846 sprintf (rs
->buf
, "QTDisconnected:%x", val
);
9848 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9850 error (_("Target does not support this command."));
9851 if (strcmp (reply
, "OK") != 0)
9852 error (_("Bogus reply from target: %s"), reply
);
9855 warning (_("Target does not support disconnected tracing."));
9859 remote_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
9861 struct thread_info
*info
= find_thread_ptid (ptid
);
9862 if (info
&& info
->private)
9863 return info
->private->core
;
9868 remote_set_circular_trace_buffer (int val
)
9870 struct remote_state
*rs
= get_remote_state ();
9873 sprintf (rs
->buf
, "QTBuffer:circular:%x", val
);
9875 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9877 error (_("Target does not support this command."));
9878 if (strcmp (reply
, "OK") != 0)
9879 error (_("Bogus reply from target: %s"), reply
);
9883 init_remote_ops (void)
9885 remote_ops
.to_shortname
= "remote";
9886 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
9888 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
9889 Specify the serial device it is connected to\n\
9890 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
9891 remote_ops
.to_open
= remote_open
;
9892 remote_ops
.to_close
= remote_close
;
9893 remote_ops
.to_detach
= remote_detach
;
9894 remote_ops
.to_disconnect
= remote_disconnect
;
9895 remote_ops
.to_resume
= remote_resume
;
9896 remote_ops
.to_wait
= remote_wait
;
9897 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
9898 remote_ops
.to_store_registers
= remote_store_registers
;
9899 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
9900 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
9901 remote_ops
.to_files_info
= remote_files_info
;
9902 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
9903 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
9904 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
9905 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
9906 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
9907 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
9908 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
9909 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
9910 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
9911 remote_ops
.to_kill
= remote_kill
;
9912 remote_ops
.to_load
= generic_load
;
9913 remote_ops
.to_mourn_inferior
= remote_mourn
;
9914 remote_ops
.to_notice_signals
= remote_notice_signals
;
9915 remote_ops
.to_thread_alive
= remote_thread_alive
;
9916 remote_ops
.to_find_new_threads
= remote_threads_info
;
9917 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
9918 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
9919 remote_ops
.to_get_ada_task_ptid
= remote_get_ada_task_ptid
;
9920 remote_ops
.to_stop
= remote_stop
;
9921 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
9922 remote_ops
.to_rcmd
= remote_rcmd
;
9923 remote_ops
.to_log_command
= serial_log_command
;
9924 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
9925 remote_ops
.to_stratum
= process_stratum
;
9926 remote_ops
.to_has_all_memory
= default_child_has_all_memory
;
9927 remote_ops
.to_has_memory
= default_child_has_memory
;
9928 remote_ops
.to_has_stack
= default_child_has_stack
;
9929 remote_ops
.to_has_registers
= default_child_has_registers
;
9930 remote_ops
.to_has_execution
= default_child_has_execution
;
9931 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
9932 remote_ops
.to_can_execute_reverse
= remote_can_execute_reverse
;
9933 remote_ops
.to_magic
= OPS_MAGIC
;
9934 remote_ops
.to_memory_map
= remote_memory_map
;
9935 remote_ops
.to_flash_erase
= remote_flash_erase
;
9936 remote_ops
.to_flash_done
= remote_flash_done
;
9937 remote_ops
.to_read_description
= remote_read_description
;
9938 remote_ops
.to_search_memory
= remote_search_memory
;
9939 remote_ops
.to_can_async_p
= remote_can_async_p
;
9940 remote_ops
.to_is_async_p
= remote_is_async_p
;
9941 remote_ops
.to_async
= remote_async
;
9942 remote_ops
.to_async_mask
= remote_async_mask
;
9943 remote_ops
.to_terminal_inferior
= remote_terminal_inferior
;
9944 remote_ops
.to_terminal_ours
= remote_terminal_ours
;
9945 remote_ops
.to_supports_non_stop
= remote_supports_non_stop
;
9946 remote_ops
.to_supports_multi_process
= remote_supports_multi_process
;
9947 remote_ops
.to_trace_init
= remote_trace_init
;
9948 remote_ops
.to_download_tracepoint
= remote_download_tracepoint
;
9949 remote_ops
.to_download_trace_state_variable
= remote_download_trace_state_variable
;
9950 remote_ops
.to_trace_set_readonly_regions
= remote_trace_set_readonly_regions
;
9951 remote_ops
.to_trace_start
= remote_trace_start
;
9952 remote_ops
.to_get_trace_status
= remote_get_trace_status
;
9953 remote_ops
.to_trace_stop
= remote_trace_stop
;
9954 remote_ops
.to_trace_find
= remote_trace_find
;
9955 remote_ops
.to_get_trace_state_variable_value
= remote_get_trace_state_variable_value
;
9956 remote_ops
.to_save_trace_data
= remote_save_trace_data
;
9957 remote_ops
.to_upload_tracepoints
= remote_upload_tracepoints
;
9958 remote_ops
.to_upload_trace_state_variables
= remote_upload_trace_state_variables
;
9959 remote_ops
.to_get_raw_trace_data
= remote_get_raw_trace_data
;
9960 remote_ops
.to_set_disconnected_tracing
= remote_set_disconnected_tracing
;
9961 remote_ops
.to_set_circular_trace_buffer
= remote_set_circular_trace_buffer
;
9962 remote_ops
.to_core_of_thread
= remote_core_of_thread
;
9963 remote_ops
.to_verify_memory
= remote_verify_memory
;
9964 remote_ops
.to_get_tib_address
= remote_get_tib_address
;
9967 /* Set up the extended remote vector by making a copy of the standard
9968 remote vector and adding to it. */
9971 init_extended_remote_ops (void)
9973 extended_remote_ops
= remote_ops
;
9975 extended_remote_ops
.to_shortname
= "extended-remote";
9976 extended_remote_ops
.to_longname
=
9977 "Extended remote serial target in gdb-specific protocol";
9978 extended_remote_ops
.to_doc
=
9979 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
9980 Specify the serial device it is connected to (e.g. /dev/ttya).";
9981 extended_remote_ops
.to_open
= extended_remote_open
;
9982 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
9983 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
9984 extended_remote_ops
.to_detach
= extended_remote_detach
;
9985 extended_remote_ops
.to_attach
= extended_remote_attach
;
9986 extended_remote_ops
.to_kill
= extended_remote_kill
;
9990 remote_can_async_p (void)
9992 if (!target_async_permitted
)
9993 /* We only enable async when the user specifically asks for it. */
9996 /* We're async whenever the serial device is. */
9997 return remote_async_mask_value
&& serial_can_async_p (remote_desc
);
10001 remote_is_async_p (void)
10003 if (!target_async_permitted
)
10004 /* We only enable async when the user specifically asks for it. */
10007 /* We're async whenever the serial device is. */
10008 return remote_async_mask_value
&& serial_is_async_p (remote_desc
);
10011 /* Pass the SERIAL event on and up to the client. One day this code
10012 will be able to delay notifying the client of an event until the
10013 point where an entire packet has been received. */
10015 static void (*async_client_callback
) (enum inferior_event_type event_type
,
10017 static void *async_client_context
;
10018 static serial_event_ftype remote_async_serial_handler
;
10021 remote_async_serial_handler (struct serial
*scb
, void *context
)
10023 /* Don't propogate error information up to the client. Instead let
10024 the client find out about the error by querying the target. */
10025 async_client_callback (INF_REG_EVENT
, async_client_context
);
10029 remote_async_inferior_event_handler (gdb_client_data data
)
10031 inferior_event_handler (INF_REG_EVENT
, NULL
);
10035 remote_async_get_pending_events_handler (gdb_client_data data
)
10037 remote_get_pending_stop_replies ();
10041 remote_async (void (*callback
) (enum inferior_event_type event_type
,
10042 void *context
), void *context
)
10044 if (remote_async_mask_value
== 0)
10045 internal_error (__FILE__
, __LINE__
,
10046 _("Calling remote_async when async is masked"));
10048 if (callback
!= NULL
)
10050 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
10051 async_client_callback
= callback
;
10052 async_client_context
= context
;
10055 serial_async (remote_desc
, NULL
, NULL
);
10059 remote_async_mask (int new_mask
)
10061 int curr_mask
= remote_async_mask_value
;
10062 remote_async_mask_value
= new_mask
;
10067 set_remote_cmd (char *args
, int from_tty
)
10069 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
10073 show_remote_cmd (char *args
, int from_tty
)
10075 /* We can't just use cmd_show_list here, because we want to skip
10076 the redundant "show remote Z-packet" and the legacy aliases. */
10077 struct cleanup
*showlist_chain
;
10078 struct cmd_list_element
*list
= remote_show_cmdlist
;
10080 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
10081 for (; list
!= NULL
; list
= list
->next
)
10082 if (strcmp (list
->name
, "Z-packet") == 0)
10084 else if (list
->type
== not_set_cmd
)
10085 /* Alias commands are exactly like the original, except they
10086 don't have the normal type. */
10090 struct cleanup
*option_chain
10091 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
10092 ui_out_field_string (uiout
, "name", list
->name
);
10093 ui_out_text (uiout
, ": ");
10094 if (list
->type
== show_cmd
)
10095 do_setshow_command ((char *) NULL
, from_tty
, list
);
10097 cmd_func (list
, NULL
, from_tty
);
10098 /* Close the tuple. */
10099 do_cleanups (option_chain
);
10102 /* Close the tuple. */
10103 do_cleanups (showlist_chain
);
10107 /* Function to be called whenever a new objfile (shlib) is detected. */
10109 remote_new_objfile (struct objfile
*objfile
)
10111 if (remote_desc
!= 0) /* Have a remote connection. */
10112 remote_check_symbols (objfile
);
10115 /* Pull all the tracepoints defined on the target and create local
10116 data structures representing them. We don't want to create real
10117 tracepoints yet, we don't want to mess up the user's existing
10121 remote_upload_tracepoints (struct uploaded_tp
**utpp
)
10123 struct remote_state
*rs
= get_remote_state ();
10126 /* Ask for a first packet of tracepoint definition. */
10128 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10130 while (*p
&& *p
!= 'l')
10132 parse_tracepoint_definition (p
, utpp
);
10133 /* Ask for another packet of tracepoint definition. */
10135 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10142 remote_upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
10144 struct remote_state
*rs
= get_remote_state ();
10147 /* Ask for a first packet of variable definition. */
10149 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10151 while (*p
&& *p
!= 'l')
10153 parse_tsv_definition (p
, utsvp
);
10154 /* Ask for another packet of variable definition. */
10156 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10163 _initialize_remote (void)
10165 struct remote_state
*rs
;
10166 struct cmd_list_element
*cmd
;
10169 /* architecture specific data */
10170 remote_gdbarch_data_handle
=
10171 gdbarch_data_register_post_init (init_remote_state
);
10172 remote_g_packet_data_handle
=
10173 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
10175 /* Initialize the per-target state. At the moment there is only one
10176 of these, not one per target. Only one target is active at a
10177 time. The default buffer size is unimportant; it will be expanded
10178 whenever a larger buffer is needed. */
10179 rs
= get_remote_state_raw ();
10180 rs
->buf_size
= 400;
10181 rs
->buf
= xmalloc (rs
->buf_size
);
10183 init_remote_ops ();
10184 add_target (&remote_ops
);
10186 init_extended_remote_ops ();
10187 add_target (&extended_remote_ops
);
10189 /* Hook into new objfile notification. */
10190 observer_attach_new_objfile (remote_new_objfile
);
10192 /* Set up signal handlers. */
10193 sigint_remote_token
=
10194 create_async_signal_handler (async_remote_interrupt
, NULL
);
10195 sigint_remote_twice_token
=
10196 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
10199 init_remote_threadtests ();
10202 /* set/show remote ... */
10204 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
10205 Remote protocol specific variables\n\
10206 Configure various remote-protocol specific variables such as\n\
10207 the packets being used"),
10208 &remote_set_cmdlist
, "set remote ",
10209 0 /* allow-unknown */, &setlist
);
10210 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
10211 Remote protocol specific variables\n\
10212 Configure various remote-protocol specific variables such as\n\
10213 the packets being used"),
10214 &remote_show_cmdlist
, "show remote ",
10215 0 /* allow-unknown */, &showlist
);
10217 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
10218 Compare section data on target to the exec file.\n\
10219 Argument is a single section name (default: all loaded sections)."),
10222 add_cmd ("packet", class_maintenance
, packet_command
, _("\
10223 Send an arbitrary packet to a remote target.\n\
10224 maintenance packet TEXT\n\
10225 If GDB is talking to an inferior via the GDB serial protocol, then\n\
10226 this command sends the string TEXT to the inferior, and displays the\n\
10227 response packet. GDB supplies the initial `$' character, and the\n\
10228 terminating `#' character and checksum."),
10231 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
10232 Set whether to send break if interrupted."), _("\
10233 Show whether to send break if interrupted."), _("\
10234 If set, a break, instead of a cntrl-c, is sent to the remote target."),
10235 set_remotebreak
, show_remotebreak
,
10236 &setlist
, &showlist
);
10237 cmd_name
= "remotebreak";
10238 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
10239 deprecate_cmd (cmd
, "set remote interrupt-sequence");
10240 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
10241 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
10242 deprecate_cmd (cmd
, "show remote interrupt-sequence");
10244 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
10245 interrupt_sequence_modes
, &interrupt_sequence_mode
, _("\
10246 Set interrupt sequence to remote target."), _("\
10247 Show interrupt sequence to remote target."), _("\
10248 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
10249 NULL
, show_interrupt_sequence
,
10250 &remote_set_cmdlist
,
10251 &remote_show_cmdlist
);
10253 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
10254 &interrupt_on_connect
, _("\
10255 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
10256 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
10257 If set, interrupt sequence is sent to remote target."),
10259 &remote_set_cmdlist
, &remote_show_cmdlist
);
10261 /* Install commands for configuring memory read/write packets. */
10263 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
10264 Set the maximum number of bytes per memory write packet (deprecated)."),
10266 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
10267 Show the maximum number of bytes per memory write packet (deprecated)."),
10269 add_cmd ("memory-write-packet-size", no_class
,
10270 set_memory_write_packet_size
, _("\
10271 Set the maximum number of bytes per memory-write packet.\n\
10272 Specify the number of bytes in a packet or 0 (zero) for the\n\
10273 default packet size. The actual limit is further reduced\n\
10274 dependent on the target. Specify ``fixed'' to disable the\n\
10275 further restriction and ``limit'' to enable that restriction."),
10276 &remote_set_cmdlist
);
10277 add_cmd ("memory-read-packet-size", no_class
,
10278 set_memory_read_packet_size
, _("\
10279 Set the maximum number of bytes per memory-read packet.\n\
10280 Specify the number of bytes in a packet or 0 (zero) for the\n\
10281 default packet size. The actual limit is further reduced\n\
10282 dependent on the target. Specify ``fixed'' to disable the\n\
10283 further restriction and ``limit'' to enable that restriction."),
10284 &remote_set_cmdlist
);
10285 add_cmd ("memory-write-packet-size", no_class
,
10286 show_memory_write_packet_size
,
10287 _("Show the maximum number of bytes per memory-write packet."),
10288 &remote_show_cmdlist
);
10289 add_cmd ("memory-read-packet-size", no_class
,
10290 show_memory_read_packet_size
,
10291 _("Show the maximum number of bytes per memory-read packet."),
10292 &remote_show_cmdlist
);
10294 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
10295 &remote_hw_watchpoint_limit
, _("\
10296 Set the maximum number of target hardware watchpoints."), _("\
10297 Show the maximum number of target hardware watchpoints."), _("\
10298 Specify a negative limit for unlimited."),
10299 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
10300 &remote_set_cmdlist
, &remote_show_cmdlist
);
10301 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
10302 &remote_hw_breakpoint_limit
, _("\
10303 Set the maximum number of target hardware breakpoints."), _("\
10304 Show the maximum number of target hardware breakpoints."), _("\
10305 Specify a negative limit for unlimited."),
10306 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
10307 &remote_set_cmdlist
, &remote_show_cmdlist
);
10309 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
10310 &remote_address_size
, _("\
10311 Set the maximum size of the address (in bits) in a memory packet."), _("\
10312 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
10314 NULL
, /* FIXME: i18n: */
10315 &setlist
, &showlist
);
10317 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
10318 "X", "binary-download", 1);
10320 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
10321 "vCont", "verbose-resume", 0);
10323 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
10324 "QPassSignals", "pass-signals", 0);
10326 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
10327 "qSymbol", "symbol-lookup", 0);
10329 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
10330 "P", "set-register", 1);
10332 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
10333 "p", "fetch-register", 1);
10335 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
10336 "Z0", "software-breakpoint", 0);
10338 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
10339 "Z1", "hardware-breakpoint", 0);
10341 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
10342 "Z2", "write-watchpoint", 0);
10344 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
10345 "Z3", "read-watchpoint", 0);
10347 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
10348 "Z4", "access-watchpoint", 0);
10350 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
10351 "qXfer:auxv:read", "read-aux-vector", 0);
10353 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
10354 "qXfer:features:read", "target-features", 0);
10356 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
10357 "qXfer:libraries:read", "library-info", 0);
10359 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
10360 "qXfer:memory-map:read", "memory-map", 0);
10362 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
10363 "qXfer:spu:read", "read-spu-object", 0);
10365 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
10366 "qXfer:spu:write", "write-spu-object", 0);
10368 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
10369 "qXfer:osdata:read", "osdata", 0);
10371 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
10372 "qXfer:threads:read", "threads", 0);
10374 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
10375 "qXfer:siginfo:read", "read-siginfo-object", 0);
10377 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
10378 "qXfer:siginfo:write", "write-siginfo-object", 0);
10380 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
10381 "qGetTLSAddr", "get-thread-local-storage-address",
10384 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
10385 "qGetTIBAddr", "get-thread-information-block-address",
10388 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
10389 "bc", "reverse-continue", 0);
10391 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
10392 "bs", "reverse-step", 0);
10394 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
10395 "qSupported", "supported-packets", 0);
10397 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
10398 "qSearch:memory", "search-memory", 0);
10400 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
10401 "vFile:open", "hostio-open", 0);
10403 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
10404 "vFile:pread", "hostio-pread", 0);
10406 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
10407 "vFile:pwrite", "hostio-pwrite", 0);
10409 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
10410 "vFile:close", "hostio-close", 0);
10412 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
10413 "vFile:unlink", "hostio-unlink", 0);
10415 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
10416 "vAttach", "attach", 0);
10418 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
10421 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
10422 "QStartNoAckMode", "noack", 0);
10424 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
10425 "vKill", "kill", 0);
10427 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
10428 "qAttached", "query-attached", 0);
10430 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
10431 "ConditionalTracepoints", "conditional-tracepoints", 0);
10432 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
10433 "FastTracepoints", "fast-tracepoints", 0);
10435 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
10436 "TracepointSource", "TracepointSource", 0);
10438 /* Keep the old ``set remote Z-packet ...'' working. Each individual
10439 Z sub-packet has its own set and show commands, but users may
10440 have sets to this variable in their .gdbinit files (or in their
10442 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
10443 &remote_Z_packet_detect
, _("\
10444 Set use of remote protocol `Z' packets"), _("\
10445 Show use of remote protocol `Z' packets "), _("\
10446 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
10448 set_remote_protocol_Z_packet_cmd
,
10449 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
10450 &remote_set_cmdlist
, &remote_show_cmdlist
);
10452 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
10453 Manipulate files on the remote system\n\
10454 Transfer files to and from the remote target system."),
10455 &remote_cmdlist
, "remote ",
10456 0 /* allow-unknown */, &cmdlist
);
10458 add_cmd ("put", class_files
, remote_put_command
,
10459 _("Copy a local file to the remote system."),
10462 add_cmd ("get", class_files
, remote_get_command
,
10463 _("Copy a remote file to the local system."),
10466 add_cmd ("delete", class_files
, remote_delete_command
,
10467 _("Delete a remote file."),
10470 remote_exec_file
= xstrdup ("");
10471 add_setshow_string_noescape_cmd ("exec-file", class_files
,
10472 &remote_exec_file
, _("\
10473 Set the remote pathname for \"run\""), _("\
10474 Show the remote pathname for \"run\""), NULL
, NULL
, NULL
,
10475 &remote_set_cmdlist
, &remote_show_cmdlist
);
10477 /* Eventually initialize fileio. See fileio.c */
10478 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);
10480 /* Take advantage of the fact that the LWP field is not used, to tag
10481 special ptids with it set to != 0. */
10482 magic_null_ptid
= ptid_build (42000, 1, -1);
10483 not_sent_ptid
= ptid_build (42000, 1, -2);
10484 any_thread_ptid
= ptid_build (42000, 1, 0);
10486 target_buf_size
= 2048;
10487 target_buf
= xmalloc (target_buf_size
);