1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* See the GDB User Guide for details of the GDB remote protocol. */
30 /*#include "terminal.h" */
33 #include "gdb-stabs.h"
34 #include "gdbthread.h"
36 #include "remote-notif.h"
41 #include "cli/cli-decode.h"
42 #include "cli/cli-setshow.h"
43 #include "target-descriptions.h"
45 #include "filestuff.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"
73 /* Temp hacks for tracepoint encoding migration. */
74 static char *target_buf;
75 static long target_buf_size;
77 /* The size to align memory write packets, when practical. The protocol
78 does not guarantee any alignment, and gdb will generate short
79 writes and unaligned writes, but even as a best-effort attempt this
80 can improve bulk transfers. For instance, if a write is misaligned
81 relative to the target's data bus, the stub may need to make an extra
82 round trip fetching data from the target. This doesn't make a
83 huge difference, but it's easy to do, so we try to be helpful.
85 The alignment chosen is arbitrary; usually data bus width is
86 important here, not the possibly larger cache line size. */
87 enum { REMOTE_ALIGN_WRITES = 16 };
89 /* Prototypes for local functions. */
90 static void async_cleanup_sigint_signal_handler (void *dummy);
91 static int getpkt_sane (char **buf, long *sizeof_buf, int forever);
92 static int getpkt_or_notif_sane (char **buf, long *sizeof_buf,
93 int forever, int *is_notif);
95 static void async_handle_remote_sigint (int);
96 static void async_handle_remote_sigint_twice (int);
98 static void remote_files_info (struct target_ops *ignore);
100 static void remote_prepare_to_store (struct target_ops *self,
101 struct regcache *regcache);
103 static void remote_open_1 (const char *, int, struct target_ops *,
106 static void remote_close (struct target_ops *self);
110 static int remote_vkill (int pid, struct remote_state *rs);
112 static void remote_mourn (struct target_ops *ops);
114 static void extended_remote_restart (void);
116 static void extended_remote_mourn (struct target_ops *);
118 static void remote_send (char **buf, long *sizeof_buf_p);
120 static int readchar (int timeout);
122 static void remote_serial_write (const char *str, int len);
124 static void remote_kill (struct target_ops *ops);
126 static int remote_can_async_p (struct target_ops *);
128 static int remote_is_async_p (struct target_ops *);
130 static void remote_async (struct target_ops *ops, int enable);
132 static void sync_remote_interrupt_twice (int signo);
134 static void interrupt_query (void);
136 static void set_general_thread (struct ptid ptid);
137 static void set_continue_thread (struct ptid ptid);
139 static void get_offsets (void);
141 static void skip_frame (void);
143 static long read_frame (char **buf_p, long *sizeof_buf);
145 static int hexnumlen (ULONGEST num);
147 static void init_remote_ops (void);
149 static void init_extended_remote_ops (void);
151 static void remote_stop (struct target_ops *self, ptid_t);
153 static int stubhex (int ch);
155 static int hexnumstr (char *, ULONGEST);
157 static int hexnumnstr (char *, ULONGEST, int);
159 static CORE_ADDR remote_address_masked (CORE_ADDR);
161 static void print_packet (const char *);
163 static void compare_sections_command (char *, int);
165 static void packet_command (char *, int);
167 static int stub_unpack_int (char *buff, int fieldlength);
169 static ptid_t remote_current_thread (ptid_t oldptid);
171 static int putpkt_binary (const char *buf, int cnt);
173 static void check_binary_download (CORE_ADDR addr);
175 struct packet_config;
177 static void show_packet_config_cmd (struct packet_config *config);
179 static void show_remote_protocol_packet_cmd (struct ui_file *file,
181 struct cmd_list_element *c,
184 static char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);
185 static ptid_t read_ptid (char *buf, char **obuf);
187 static void remote_set_permissions (struct target_ops *self);
189 static int remote_get_trace_status (struct target_ops *self,
190 struct trace_status *ts);
192 static int remote_upload_tracepoints (struct target_ops *self,
193 struct uploaded_tp **utpp);
195 static int remote_upload_trace_state_variables (struct target_ops *self,
196 struct uploaded_tsv **utsvp);
198 static void remote_query_supported (void);
200 static void remote_check_symbols (void);
202 void _initialize_remote (void);
205 static void stop_reply_xfree (struct stop_reply *);
206 static void remote_parse_stop_reply (char *, struct stop_reply *);
207 static void push_stop_reply (struct stop_reply *);
208 static void discard_pending_stop_replies_in_queue (struct remote_state *);
209 static int peek_stop_reply (ptid_t ptid);
211 struct threads_listing_context;
212 static void remove_new_fork_children (struct threads_listing_context *);
214 static void remote_async_inferior_event_handler (gdb_client_data);
216 static void remote_terminal_ours (struct target_ops *self);
218 static int remote_read_description_p (struct target_ops *target);
220 static void remote_console_output (char *msg);
222 static int remote_supports_cond_breakpoints (struct target_ops *self);
224 static int remote_can_run_breakpoint_commands (struct target_ops *self);
226 static void remote_btrace_reset (void);
230 static struct cmd_list_element *remote_cmdlist;
232 /* For "set remote" and "show remote". */
234 static struct cmd_list_element *remote_set_cmdlist;
235 static struct cmd_list_element *remote_show_cmdlist;
237 /* Stub vCont actions support.
239 Each field is a boolean flag indicating whether the stub reports
240 support for the corresponding action. */
242 struct vCont_action_support
251 /* Controls whether GDB is willing to use range stepping. */
253 static int use_range_stepping = 1;
255 #define OPAQUETHREADBYTES 8
257 /* a 64 bit opaque identifier */
258 typedef unsigned char threadref[OPAQUETHREADBYTES];
260 /* About this many threadisds fit in a packet. */
262 #define MAXTHREADLISTRESULTS 32
264 /* Description of the remote protocol state for the currently
265 connected target. This is per-target state, and independent of the
266 selected architecture. */
270 /* A buffer to use for incoming packets, and its current size. The
271 buffer is grown dynamically for larger incoming packets.
272 Outgoing packets may also be constructed in this buffer.
273 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
274 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
279 /* True if we're going through initial connection setup (finding out
280 about the remote side's threads, relocating symbols, etc.). */
283 /* If we negotiated packet size explicitly (and thus can bypass
284 heuristics for the largest packet size that will not overflow
285 a buffer in the stub), this will be set to that packet size.
286 Otherwise zero, meaning to use the guessed size. */
287 long explicit_packet_size;
289 /* remote_wait is normally called when the target is running and
290 waits for a stop reply packet. But sometimes we need to call it
291 when the target is already stopped. We can send a "?" packet
292 and have remote_wait read the response. Or, if we already have
293 the response, we can stash it in BUF and tell remote_wait to
294 skip calling getpkt. This flag is set when BUF contains a
295 stop reply packet and the target is not waiting. */
296 int cached_wait_status;
298 /* True, if in no ack mode. That is, neither GDB nor the stub will
299 expect acks from each other. The connection is assumed to be
303 /* True if we're connected in extended remote mode. */
306 /* True if we resumed the target and we're waiting for the target to
307 stop. In the mean time, we can't start another command/query.
308 The remote server wouldn't be ready to process it, so we'd
309 timeout waiting for a reply that would never come and eventually
310 we'd close the connection. This can happen in asynchronous mode
311 because we allow GDB commands while the target is running. */
312 int waiting_for_stop_reply;
314 /* The status of the stub support for the various vCont actions. */
315 struct vCont_action_support supports_vCont;
317 /* Nonzero if the user has pressed Ctrl-C, but the target hasn't
318 responded to that. */
321 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
322 remote_open knows that we don't have a file open when the program
324 struct serial *remote_desc;
326 /* These are the threads which we last sent to the remote system. The
327 TID member will be -1 for all or -2 for not sent yet. */
328 ptid_t general_thread;
329 ptid_t continue_thread;
331 /* This is the traceframe which we last selected on the remote system.
332 It will be -1 if no traceframe is selected. */
333 int remote_traceframe_number;
335 char *last_pass_packet;
337 /* The last QProgramSignals packet sent to the target. We bypass
338 sending a new program signals list down to the target if the new
339 packet is exactly the same as the last we sent. IOW, we only let
340 the target know about program signals list changes. */
341 char *last_program_signals_packet;
343 enum gdb_signal last_sent_signal;
347 char *finished_object;
348 char *finished_annex;
349 ULONGEST finished_offset;
351 /* Should we try the 'ThreadInfo' query packet?
353 This variable (NOT available to the user: auto-detect only!)
354 determines whether GDB will use the new, simpler "ThreadInfo"
355 query or the older, more complex syntax for thread queries.
356 This is an auto-detect variable (set to true at each connect,
357 and set to false when the target fails to recognize it). */
358 int use_threadinfo_query;
359 int use_threadextra_query;
361 /* This is set to the data address of the access causing the target
362 to stop for a watchpoint. */
363 CORE_ADDR remote_watch_data_address;
365 /* Whether the target stopped for a breakpoint/watchpoint. */
366 enum target_stop_reason stop_reason;
368 threadref echo_nextthread;
369 threadref nextthread;
370 threadref resultthreadlist[MAXTHREADLISTRESULTS];
372 /* The state of remote notification. */
373 struct remote_notif_state *notif_state;
375 /* The branch trace configuration. */
376 struct btrace_config btrace_config;
378 /* The argument to the last "vFile:setfs:" packet we sent, used
379 to avoid sending repeated unnecessary "vFile:setfs:" packets.
380 Initialized to -1 to indicate that no "vFile:setfs:" packet
381 has yet been sent. */
385 /* Private data that we'll store in (struct thread_info)->private. */
386 struct private_thread_info
393 free_private_thread_info (struct private_thread_info *info)
399 /* This data could be associated with a target, but we do not always
400 have access to the current target when we need it, so for now it is
401 static. This will be fine for as long as only one target is in use
403 static struct remote_state *remote_state;
405 static struct remote_state *
406 get_remote_state_raw (void)
411 /* Allocate a new struct remote_state with xmalloc, initialize it, and
414 static struct remote_state *
415 new_remote_state (void)
417 struct remote_state *result = XCNEW (struct remote_state);
419 /* The default buffer size is unimportant; it will be expanded
420 whenever a larger buffer is needed. */
421 result->buf_size = 400;
422 result->buf = xmalloc (result->buf_size);
423 result->remote_traceframe_number = -1;
424 result->last_sent_signal = GDB_SIGNAL_0;
430 /* Description of the remote protocol for a given architecture. */
434 long offset; /* Offset into G packet. */
435 long regnum; /* GDB's internal register number. */
436 LONGEST pnum; /* Remote protocol register number. */
437 int in_g_packet; /* Always part of G packet. */
438 /* long size in bytes; == register_size (target_gdbarch (), regnum);
440 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
444 struct remote_arch_state
446 /* Description of the remote protocol registers. */
447 long sizeof_g_packet;
449 /* Description of the remote protocol registers indexed by REGNUM
450 (making an array gdbarch_num_regs in size). */
451 struct packet_reg *regs;
453 /* This is the size (in chars) of the first response to the ``g''
454 packet. It is used as a heuristic when determining the maximum
455 size of memory-read and memory-write packets. A target will
456 typically only reserve a buffer large enough to hold the ``g''
457 packet. The size does not include packet overhead (headers and
459 long actual_register_packet_size;
461 /* This is the maximum size (in chars) of a non read/write packet.
462 It is also used as a cap on the size of read/write packets. */
463 long remote_packet_size;
466 /* Utility: generate error from an incoming stub packet. */
468 trace_error (char *buf)
471 return; /* not an error msg */
474 case '1': /* malformed packet error */
475 if (*++buf == '0') /* general case: */
476 error (_("remote.c: error in outgoing packet."));
478 error (_("remote.c: error in outgoing packet at field #%ld."),
479 strtol (buf, NULL, 16));
481 error (_("Target returns error code '%s'."), buf);
485 /* Utility: wait for reply from stub, while accepting "O" packets. */
487 remote_get_noisy_reply (char **buf_p,
490 do /* Loop on reply from remote stub. */
494 QUIT; /* Allow user to bail out with ^C. */
495 getpkt (buf_p, sizeof_buf, 0);
499 else if (startswith (buf, "qRelocInsn:"))
502 CORE_ADDR from, to, org_to;
504 int adjusted_size = 0;
507 p = buf + strlen ("qRelocInsn:");
508 pp = unpack_varlen_hex (p, &ul);
510 error (_("invalid qRelocInsn packet: %s"), buf);
514 unpack_varlen_hex (p, &ul);
521 gdbarch_relocate_instruction (target_gdbarch (), &to, from);
524 CATCH (ex, RETURN_MASK_ALL)
526 if (ex.error == MEMORY_ERROR)
528 /* Propagate memory errors silently back to the
529 target. The stub may have limited the range of
530 addresses we can write to, for example. */
534 /* Something unexpectedly bad happened. Be verbose
535 so we can tell what, and propagate the error back
536 to the stub, so it doesn't get stuck waiting for
538 exception_fprintf (gdb_stderr, ex,
539 _("warning: relocating instruction: "));
547 adjusted_size = to - org_to;
549 xsnprintf (buf, *sizeof_buf, "qRelocInsn:%x", adjusted_size);
553 else if (buf[0] == 'O' && buf[1] != 'K')
554 remote_console_output (buf + 1); /* 'O' message from stub */
556 return buf; /* Here's the actual reply. */
561 /* Handle for retreving the remote protocol data from gdbarch. */
562 static struct gdbarch_data *remote_gdbarch_data_handle;
564 static struct remote_arch_state *
565 get_remote_arch_state (void)
567 return gdbarch_data (target_gdbarch (), remote_gdbarch_data_handle);
570 /* Fetch the global remote target state. */
572 static struct remote_state *
573 get_remote_state (void)
575 /* Make sure that the remote architecture state has been
576 initialized, because doing so might reallocate rs->buf. Any
577 function which calls getpkt also needs to be mindful of changes
578 to rs->buf, but this call limits the number of places which run
580 get_remote_arch_state ();
582 return get_remote_state_raw ();
586 compare_pnums (const void *lhs_, const void *rhs_)
588 const struct packet_reg * const *lhs = lhs_;
589 const struct packet_reg * const *rhs = rhs_;
591 if ((*lhs)->pnum < (*rhs)->pnum)
593 else if ((*lhs)->pnum == (*rhs)->pnum)
600 map_regcache_remote_table (struct gdbarch *gdbarch, struct packet_reg *regs)
602 int regnum, num_remote_regs, offset;
603 struct packet_reg **remote_regs;
605 for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
607 struct packet_reg *r = ®s[regnum];
609 if (register_size (gdbarch, regnum) == 0)
610 /* Do not try to fetch zero-sized (placeholder) registers. */
613 r->pnum = gdbarch_remote_register_number (gdbarch, regnum);
618 /* Define the g/G packet format as the contents of each register
619 with a remote protocol number, in order of ascending protocol
622 remote_regs = alloca (gdbarch_num_regs (gdbarch)
623 * sizeof (struct packet_reg *));
624 for (num_remote_regs = 0, regnum = 0;
625 regnum < gdbarch_num_regs (gdbarch);
627 if (regs[regnum].pnum != -1)
628 remote_regs[num_remote_regs++] = ®s[regnum];
630 qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
633 for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++)
635 remote_regs[regnum]->in_g_packet = 1;
636 remote_regs[regnum]->offset = offset;
637 offset += register_size (gdbarch, remote_regs[regnum]->regnum);
643 /* Given the architecture described by GDBARCH, return the remote
644 protocol register's number and the register's offset in the g/G
645 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
646 If the target does not have a mapping for REGNUM, return false,
647 otherwise, return true. */
650 remote_register_number_and_offset (struct gdbarch *gdbarch, int regnum,
651 int *pnum, int *poffset)
654 struct packet_reg *regs;
655 struct cleanup *old_chain;
657 gdb_assert (regnum < gdbarch_num_regs (gdbarch));
659 regs = xcalloc (gdbarch_num_regs (gdbarch), sizeof (struct packet_reg));
660 old_chain = make_cleanup (xfree, regs);
662 sizeof_g_packet = map_regcache_remote_table (gdbarch, regs);
664 *pnum = regs[regnum].pnum;
665 *poffset = regs[regnum].offset;
667 do_cleanups (old_chain);
673 init_remote_state (struct gdbarch *gdbarch)
675 struct remote_state *rs = get_remote_state_raw ();
676 struct remote_arch_state *rsa;
678 rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
680 /* Use the architecture to build a regnum<->pnum table, which will be
681 1:1 unless a feature set specifies otherwise. */
682 rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch,
683 gdbarch_num_regs (gdbarch),
686 /* Record the maximum possible size of the g packet - it may turn out
688 rsa->sizeof_g_packet = map_regcache_remote_table (gdbarch, rsa->regs);
690 /* Default maximum number of characters in a packet body. Many
691 remote stubs have a hardwired buffer size of 400 bytes
692 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
693 as the maximum packet-size to ensure that the packet and an extra
694 NUL character can always fit in the buffer. This stops GDB
695 trashing stubs that try to squeeze an extra NUL into what is
696 already a full buffer (As of 1999-12-04 that was most stubs). */
697 rsa->remote_packet_size = 400 - 1;
699 /* This one is filled in when a ``g'' packet is received. */
700 rsa->actual_register_packet_size = 0;
702 /* Should rsa->sizeof_g_packet needs more space than the
703 default, adjust the size accordingly. Remember that each byte is
704 encoded as two characters. 32 is the overhead for the packet
705 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
706 (``$NN:G...#NN'') is a better guess, the below has been padded a
708 if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2))
709 rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32);
711 /* Make sure that the packet buffer is plenty big enough for
712 this architecture. */
713 if (rs->buf_size < rsa->remote_packet_size)
715 rs->buf_size = 2 * rsa->remote_packet_size;
716 rs->buf = xrealloc (rs->buf, rs->buf_size);
722 /* Return the current allowed size of a remote packet. This is
723 inferred from the current architecture, and should be used to
724 limit the length of outgoing packets. */
726 get_remote_packet_size (void)
728 struct remote_state *rs = get_remote_state ();
729 struct remote_arch_state *rsa = get_remote_arch_state ();
731 if (rs->explicit_packet_size)
732 return rs->explicit_packet_size;
734 return rsa->remote_packet_size;
737 static struct packet_reg *
738 packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum)
740 if (regnum < 0 && regnum >= gdbarch_num_regs (target_gdbarch ()))
744 struct packet_reg *r = &rsa->regs[regnum];
746 gdb_assert (r->regnum == regnum);
751 static struct packet_reg *
752 packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)
756 for (i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++)
758 struct packet_reg *r = &rsa->regs[i];
766 static struct target_ops remote_ops;
768 static struct target_ops extended_remote_ops;
770 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
771 ``forever'' still use the normal timeout mechanism. This is
772 currently used by the ASYNC code to guarentee that target reads
773 during the initial connect always time-out. Once getpkt has been
774 modified to return a timeout indication and, in turn
775 remote_wait()/wait_for_inferior() have gained a timeout parameter
777 static int wait_forever_enabled_p = 1;
779 /* Allow the user to specify what sequence to send to the remote
780 when he requests a program interruption: Although ^C is usually
781 what remote systems expect (this is the default, here), it is
782 sometimes preferable to send a break. On other systems such
783 as the Linux kernel, a break followed by g, which is Magic SysRq g
784 is required in order to interrupt the execution. */
785 const char interrupt_sequence_control_c[] = "Ctrl-C";
786 const char interrupt_sequence_break[] = "BREAK";
787 const char interrupt_sequence_break_g[] = "BREAK-g";
788 static const char *const interrupt_sequence_modes[] =
790 interrupt_sequence_control_c,
791 interrupt_sequence_break,
792 interrupt_sequence_break_g,
795 static const char *interrupt_sequence_mode = interrupt_sequence_control_c;
798 show_interrupt_sequence (struct ui_file *file, int from_tty,
799 struct cmd_list_element *c,
802 if (interrupt_sequence_mode == interrupt_sequence_control_c)
803 fprintf_filtered (file,
804 _("Send the ASCII ETX character (Ctrl-c) "
805 "to the remote target to interrupt the "
806 "execution of the program.\n"));
807 else if (interrupt_sequence_mode == interrupt_sequence_break)
808 fprintf_filtered (file,
809 _("send a break signal to the remote target "
810 "to interrupt the execution of the program.\n"));
811 else if (interrupt_sequence_mode == interrupt_sequence_break_g)
812 fprintf_filtered (file,
813 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
814 "the remote target to interrupt the execution "
815 "of Linux kernel.\n"));
817 internal_error (__FILE__, __LINE__,
818 _("Invalid value for interrupt_sequence_mode: %s."),
819 interrupt_sequence_mode);
822 /* This boolean variable specifies whether interrupt_sequence is sent
823 to the remote target when gdb connects to it.
824 This is mostly needed when you debug the Linux kernel: The Linux kernel
825 expects BREAK g which is Magic SysRq g for connecting gdb. */
826 static int interrupt_on_connect = 0;
828 /* This variable is used to implement the "set/show remotebreak" commands.
829 Since these commands are now deprecated in favor of "set/show remote
830 interrupt-sequence", it no longer has any effect on the code. */
831 static int remote_break;
834 set_remotebreak (char *args, int from_tty, struct cmd_list_element *c)
837 interrupt_sequence_mode = interrupt_sequence_break;
839 interrupt_sequence_mode = interrupt_sequence_control_c;
843 show_remotebreak (struct ui_file *file, int from_tty,
844 struct cmd_list_element *c,
849 /* This variable sets the number of bits in an address that are to be
850 sent in a memory ("M" or "m") packet. Normally, after stripping
851 leading zeros, the entire address would be sent. This variable
852 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
853 initial implementation of remote.c restricted the address sent in
854 memory packets to ``host::sizeof long'' bytes - (typically 32
855 bits). Consequently, for 64 bit targets, the upper 32 bits of an
856 address was never sent. Since fixing this bug may cause a break in
857 some remote targets this variable is principly provided to
858 facilitate backward compatibility. */
860 static unsigned int remote_address_size;
862 /* Temporary to track who currently owns the terminal. See
863 remote_terminal_* for more details. */
865 static int remote_async_terminal_ours_p;
867 /* The executable file to use for "run" on the remote side. */
869 static char *remote_exec_file = "";
872 /* User configurable variables for the number of characters in a
873 memory read/write packet. MIN (rsa->remote_packet_size,
874 rsa->sizeof_g_packet) is the default. Some targets need smaller
875 values (fifo overruns, et.al.) and some users need larger values
876 (speed up transfers). The variables ``preferred_*'' (the user
877 request), ``current_*'' (what was actually set) and ``forced_*''
878 (Positive - a soft limit, negative - a hard limit). */
880 struct memory_packet_config
887 /* Compute the current size of a read/write packet. Since this makes
888 use of ``actual_register_packet_size'' the computation is dynamic. */
891 get_memory_packet_size (struct memory_packet_config *config)
893 struct remote_state *rs = get_remote_state ();
894 struct remote_arch_state *rsa = get_remote_arch_state ();
896 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
897 law?) that some hosts don't cope very well with large alloca()
898 calls. Eventually the alloca() code will be replaced by calls to
899 xmalloc() and make_cleanups() allowing this restriction to either
900 be lifted or removed. */
901 #ifndef MAX_REMOTE_PACKET_SIZE
902 #define MAX_REMOTE_PACKET_SIZE 16384
904 /* NOTE: 20 ensures we can write at least one byte. */
905 #ifndef MIN_REMOTE_PACKET_SIZE
906 #define MIN_REMOTE_PACKET_SIZE 20
911 if (config->size <= 0)
912 what_they_get = MAX_REMOTE_PACKET_SIZE;
914 what_they_get = config->size;
918 what_they_get = get_remote_packet_size ();
919 /* Limit the packet to the size specified by the user. */
921 && what_they_get > config->size)
922 what_they_get = config->size;
924 /* Limit it to the size of the targets ``g'' response unless we have
925 permission from the stub to use a larger packet size. */
926 if (rs->explicit_packet_size == 0
927 && rsa->actual_register_packet_size > 0
928 && what_they_get > rsa->actual_register_packet_size)
929 what_they_get = rsa->actual_register_packet_size;
931 if (what_they_get > MAX_REMOTE_PACKET_SIZE)
932 what_they_get = MAX_REMOTE_PACKET_SIZE;
933 if (what_they_get < MIN_REMOTE_PACKET_SIZE)
934 what_they_get = MIN_REMOTE_PACKET_SIZE;
936 /* Make sure there is room in the global buffer for this packet
937 (including its trailing NUL byte). */
938 if (rs->buf_size < what_they_get + 1)
940 rs->buf_size = 2 * what_they_get;
941 rs->buf = xrealloc (rs->buf, 2 * what_they_get);
944 return what_they_get;
947 /* Update the size of a read/write packet. If they user wants
948 something really big then do a sanity check. */
951 set_memory_packet_size (char *args, struct memory_packet_config *config)
953 int fixed_p = config->fixed_p;
954 long size = config->size;
957 error (_("Argument required (integer, `fixed' or `limited')."));
958 else if (strcmp (args, "hard") == 0
959 || strcmp (args, "fixed") == 0)
961 else if (strcmp (args, "soft") == 0
962 || strcmp (args, "limit") == 0)
968 size = strtoul (args, &end, 0);
970 error (_("Invalid %s (bad syntax)."), config->name);
972 /* Instead of explicitly capping the size of a packet to
973 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
974 instead allowed to set the size to something arbitrarily
976 if (size > MAX_REMOTE_PACKET_SIZE)
977 error (_("Invalid %s (too large)."), config->name);
981 if (fixed_p && !config->fixed_p)
983 if (! query (_("The target may not be able to correctly handle a %s\n"
984 "of %ld bytes. Change the packet size? "),
986 error (_("Packet size not changed."));
988 /* Update the config. */
989 config->fixed_p = fixed_p;
994 show_memory_packet_size (struct memory_packet_config *config)
996 printf_filtered (_("The %s is %ld. "), config->name, config->size);
998 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
999 get_memory_packet_size (config));
1001 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1002 get_memory_packet_size (config));
1005 static struct memory_packet_config memory_write_packet_config =
1007 "memory-write-packet-size",
1011 set_memory_write_packet_size (char *args, int from_tty)
1013 set_memory_packet_size (args, &memory_write_packet_config);
1017 show_memory_write_packet_size (char *args, int from_tty)
1019 show_memory_packet_size (&memory_write_packet_config);
1023 get_memory_write_packet_size (void)
1025 return get_memory_packet_size (&memory_write_packet_config);
1028 static struct memory_packet_config memory_read_packet_config =
1030 "memory-read-packet-size",
1034 set_memory_read_packet_size (char *args, int from_tty)
1036 set_memory_packet_size (args, &memory_read_packet_config);
1040 show_memory_read_packet_size (char *args, int from_tty)
1042 show_memory_packet_size (&memory_read_packet_config);
1046 get_memory_read_packet_size (void)
1048 long size = get_memory_packet_size (&memory_read_packet_config);
1050 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1051 extra buffer size argument before the memory read size can be
1052 increased beyond this. */
1053 if (size > get_remote_packet_size ())
1054 size = get_remote_packet_size ();
1059 /* Generic configuration support for packets the stub optionally
1060 supports. Allows the user to specify the use of the packet as well
1061 as allowing GDB to auto-detect support in the remote stub. */
1065 PACKET_SUPPORT_UNKNOWN = 0,
1070 struct packet_config
1075 /* If auto, GDB auto-detects support for this packet or feature,
1076 either through qSupported, or by trying the packet and looking
1077 at the response. If true, GDB assumes the target supports this
1078 packet. If false, the packet is disabled. Configs that don't
1079 have an associated command always have this set to auto. */
1080 enum auto_boolean detect;
1082 /* Does the target support this packet? */
1083 enum packet_support support;
1086 /* Analyze a packet's return value and update the packet config
1096 static enum packet_support packet_config_support (struct packet_config *config);
1097 static enum packet_support packet_support (int packet);
1100 show_packet_config_cmd (struct packet_config *config)
1102 char *support = "internal-error";
1104 switch (packet_config_support (config))
1107 support = "enabled";
1109 case PACKET_DISABLE:
1110 support = "disabled";
1112 case PACKET_SUPPORT_UNKNOWN:
1113 support = "unknown";
1116 switch (config->detect)
1118 case AUTO_BOOLEAN_AUTO:
1119 printf_filtered (_("Support for the `%s' packet "
1120 "is auto-detected, currently %s.\n"),
1121 config->name, support);
1123 case AUTO_BOOLEAN_TRUE:
1124 case AUTO_BOOLEAN_FALSE:
1125 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1126 config->name, support);
1132 add_packet_config_cmd (struct packet_config *config, const char *name,
1133 const char *title, int legacy)
1139 config->name = name;
1140 config->title = title;
1141 set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
1143 show_doc = xstrprintf ("Show current use of remote "
1144 "protocol `%s' (%s) packet",
1146 /* set/show TITLE-packet {auto,on,off} */
1147 cmd_name = xstrprintf ("%s-packet", title);
1148 add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
1149 &config->detect, set_doc,
1150 show_doc, NULL, /* help_doc */
1152 show_remote_protocol_packet_cmd,
1153 &remote_set_cmdlist, &remote_show_cmdlist);
1154 /* The command code copies the documentation strings. */
1157 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1162 legacy_name = xstrprintf ("%s-packet", name);
1163 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1164 &remote_set_cmdlist);
1165 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1166 &remote_show_cmdlist);
1170 static enum packet_result
1171 packet_check_result (const char *buf)
1175 /* The stub recognized the packet request. Check that the
1176 operation succeeded. */
1178 && isxdigit (buf[1]) && isxdigit (buf[2])
1180 /* "Enn" - definitly an error. */
1181 return PACKET_ERROR;
1183 /* Always treat "E." as an error. This will be used for
1184 more verbose error messages, such as E.memtypes. */
1185 if (buf[0] == 'E' && buf[1] == '.')
1186 return PACKET_ERROR;
1188 /* The packet may or may not be OK. Just assume it is. */
1192 /* The stub does not support the packet. */
1193 return PACKET_UNKNOWN;
1196 static enum packet_result
1197 packet_ok (const char *buf, struct packet_config *config)
1199 enum packet_result result;
1201 if (config->detect != AUTO_BOOLEAN_TRUE
1202 && config->support == PACKET_DISABLE)
1203 internal_error (__FILE__, __LINE__,
1204 _("packet_ok: attempt to use a disabled packet"));
1206 result = packet_check_result (buf);
1211 /* The stub recognized the packet request. */
1212 if (config->support == PACKET_SUPPORT_UNKNOWN)
1215 fprintf_unfiltered (gdb_stdlog,
1216 "Packet %s (%s) is supported\n",
1217 config->name, config->title);
1218 config->support = PACKET_ENABLE;
1221 case PACKET_UNKNOWN:
1222 /* The stub does not support the packet. */
1223 if (config->detect == AUTO_BOOLEAN_AUTO
1224 && config->support == PACKET_ENABLE)
1226 /* If the stub previously indicated that the packet was
1227 supported then there is a protocol error. */
1228 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1229 config->name, config->title);
1231 else if (config->detect == AUTO_BOOLEAN_TRUE)
1233 /* The user set it wrong. */
1234 error (_("Enabled packet %s (%s) not recognized by stub"),
1235 config->name, config->title);
1239 fprintf_unfiltered (gdb_stdlog,
1240 "Packet %s (%s) is NOT supported\n",
1241 config->name, config->title);
1242 config->support = PACKET_DISABLE;
1263 PACKET_vFile_pwrite,
1265 PACKET_vFile_unlink,
1266 PACKET_vFile_readlink,
1269 PACKET_qXfer_features,
1270 PACKET_qXfer_exec_file,
1271 PACKET_qXfer_libraries,
1272 PACKET_qXfer_libraries_svr4,
1273 PACKET_qXfer_memory_map,
1274 PACKET_qXfer_spu_read,
1275 PACKET_qXfer_spu_write,
1276 PACKET_qXfer_osdata,
1277 PACKET_qXfer_threads,
1278 PACKET_qXfer_statictrace_read,
1279 PACKET_qXfer_traceframe_info,
1285 PACKET_QPassSignals,
1286 PACKET_QProgramSignals,
1288 PACKET_qSearch_memory,
1291 PACKET_QStartNoAckMode,
1293 PACKET_qXfer_siginfo_read,
1294 PACKET_qXfer_siginfo_write,
1297 /* Support for conditional tracepoints. */
1298 PACKET_ConditionalTracepoints,
1300 /* Support for target-side breakpoint conditions. */
1301 PACKET_ConditionalBreakpoints,
1303 /* Support for target-side breakpoint commands. */
1304 PACKET_BreakpointCommands,
1306 /* Support for fast tracepoints. */
1307 PACKET_FastTracepoints,
1309 /* Support for static tracepoints. */
1310 PACKET_StaticTracepoints,
1312 /* Support for installing tracepoints while a trace experiment is
1314 PACKET_InstallInTrace,
1318 PACKET_TracepointSource,
1321 PACKET_QDisableRandomization,
1323 PACKET_QTBuffer_size,
1327 PACKET_qXfer_btrace,
1329 /* Support for the QNonStop packet. */
1332 /* Support for multi-process extensions. */
1333 PACKET_multiprocess_feature,
1335 /* Support for enabling and disabling tracepoints while a trace
1336 experiment is running. */
1337 PACKET_EnableDisableTracepoints_feature,
1339 /* Support for collecting strings using the tracenz bytecode. */
1340 PACKET_tracenz_feature,
1342 /* Support for continuing to run a trace experiment while GDB is
1344 PACKET_DisconnectedTracing_feature,
1346 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
1347 PACKET_augmented_libraries_svr4_read_feature,
1349 /* Support for the qXfer:btrace-conf:read packet. */
1350 PACKET_qXfer_btrace_conf,
1352 /* Support for the Qbtrace-conf:bts:size packet. */
1353 PACKET_Qbtrace_conf_bts_size,
1355 /* Support for swbreak+ feature. */
1356 PACKET_swbreak_feature,
1358 /* Support for hwbreak+ feature. */
1359 PACKET_hwbreak_feature,
1361 /* Support for fork events. */
1362 PACKET_fork_event_feature,
1364 /* Support for vfork events. */
1365 PACKET_vfork_event_feature,
1367 /* Support for the Qbtrace-conf:pt:size packet. */
1368 PACKET_Qbtrace_conf_pt_size,
1373 static struct packet_config remote_protocol_packets[PACKET_MAX];
1375 /* Returns the packet's corresponding "set remote foo-packet" command
1376 state. See struct packet_config for more details. */
1378 static enum auto_boolean
1379 packet_set_cmd_state (int packet)
1381 return remote_protocol_packets[packet].detect;
1384 /* Returns whether a given packet or feature is supported. This takes
1385 into account the state of the corresponding "set remote foo-packet"
1386 command, which may be used to bypass auto-detection. */
1388 static enum packet_support
1389 packet_config_support (struct packet_config *config)
1391 switch (config->detect)
1393 case AUTO_BOOLEAN_TRUE:
1394 return PACKET_ENABLE;
1395 case AUTO_BOOLEAN_FALSE:
1396 return PACKET_DISABLE;
1397 case AUTO_BOOLEAN_AUTO:
1398 return config->support;
1400 gdb_assert_not_reached (_("bad switch"));
1404 /* Same as packet_config_support, but takes the packet's enum value as
1407 static enum packet_support
1408 packet_support (int packet)
1410 struct packet_config *config = &remote_protocol_packets[packet];
1412 return packet_config_support (config);
1416 show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty,
1417 struct cmd_list_element *c,
1420 struct packet_config *packet;
1422 for (packet = remote_protocol_packets;
1423 packet < &remote_protocol_packets[PACKET_MAX];
1426 if (&packet->detect == c->var)
1428 show_packet_config_cmd (packet);
1432 internal_error (__FILE__, __LINE__, _("Could not find config for %s"),
1436 /* Should we try one of the 'Z' requests? */
1440 Z_PACKET_SOFTWARE_BP,
1441 Z_PACKET_HARDWARE_BP,
1448 /* For compatibility with older distributions. Provide a ``set remote
1449 Z-packet ...'' command that updates all the Z packet types. */
1451 static enum auto_boolean remote_Z_packet_detect;
1454 set_remote_protocol_Z_packet_cmd (char *args, int from_tty,
1455 struct cmd_list_element *c)
1459 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
1460 remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
1464 show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty,
1465 struct cmd_list_element *c,
1470 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
1472 show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]);
1476 /* Returns true if the multi-process extensions are in effect. */
1479 remote_multi_process_p (struct remote_state *rs)
1481 return packet_support (PACKET_multiprocess_feature) == PACKET_ENABLE;
1484 /* Returns true if fork events are supported. */
1487 remote_fork_event_p (struct remote_state *rs)
1489 return packet_support (PACKET_fork_event_feature) == PACKET_ENABLE;
1492 /* Returns true if vfork events are supported. */
1495 remote_vfork_event_p (struct remote_state *rs)
1497 return packet_support (PACKET_vfork_event_feature) == PACKET_ENABLE;
1500 /* Insert fork catchpoint target routine. If fork events are enabled
1501 then return success, nothing more to do. */
1504 remote_insert_fork_catchpoint (struct target_ops *ops, int pid)
1506 struct remote_state *rs = get_remote_state ();
1508 return !remote_fork_event_p (rs);
1511 /* Remove fork catchpoint target routine. Nothing to do, just
1515 remote_remove_fork_catchpoint (struct target_ops *ops, int pid)
1520 /* Insert vfork catchpoint target routine. If vfork events are enabled
1521 then return success, nothing more to do. */
1524 remote_insert_vfork_catchpoint (struct target_ops *ops, int pid)
1526 struct remote_state *rs = get_remote_state ();
1528 return !remote_vfork_event_p (rs);
1531 /* Remove vfork catchpoint target routine. Nothing to do, just
1535 remote_remove_vfork_catchpoint (struct target_ops *ops, int pid)
1540 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1541 static struct async_signal_handler *async_sigint_remote_twice_token;
1542 static struct async_signal_handler *async_sigint_remote_token;
1545 /* Asynchronous signal handle registered as event loop source for
1546 when we have pending events ready to be passed to the core. */
1548 static struct async_event_handler *remote_async_inferior_event_token;
1552 static ptid_t magic_null_ptid;
1553 static ptid_t not_sent_ptid;
1554 static ptid_t any_thread_ptid;
1556 /* Find out if the stub attached to PID (and hence GDB should offer to
1557 detach instead of killing it when bailing out). */
1560 remote_query_attached (int pid)
1562 struct remote_state *rs = get_remote_state ();
1563 size_t size = get_remote_packet_size ();
1565 if (packet_support (PACKET_qAttached) == PACKET_DISABLE)
1568 if (remote_multi_process_p (rs))
1569 xsnprintf (rs->buf, size, "qAttached:%x", pid);
1571 xsnprintf (rs->buf, size, "qAttached");
1574 getpkt (&rs->buf, &rs->buf_size, 0);
1576 switch (packet_ok (rs->buf,
1577 &remote_protocol_packets[PACKET_qAttached]))
1580 if (strcmp (rs->buf, "1") == 0)
1584 warning (_("Remote failure reply: %s"), rs->buf);
1586 case PACKET_UNKNOWN:
1593 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
1594 has been invented by GDB, instead of reported by the target. Since
1595 we can be connected to a remote system before before knowing about
1596 any inferior, mark the target with execution when we find the first
1597 inferior. If ATTACHED is 1, then we had just attached to this
1598 inferior. If it is 0, then we just created this inferior. If it
1599 is -1, then try querying the remote stub to find out if it had
1600 attached to the inferior or not. If TRY_OPEN_EXEC is true then
1601 attempt to open this inferior's executable as the main executable
1602 if no main executable is open already. */
1604 static struct inferior *
1605 remote_add_inferior (int fake_pid_p, int pid, int attached,
1608 struct inferior *inf;
1610 /* Check whether this process we're learning about is to be
1611 considered attached, or if is to be considered to have been
1612 spawned by the stub. */
1614 attached = remote_query_attached (pid);
1616 if (gdbarch_has_global_solist (target_gdbarch ()))
1618 /* If the target shares code across all inferiors, then every
1619 attach adds a new inferior. */
1620 inf = add_inferior (pid);
1622 /* ... and every inferior is bound to the same program space.
1623 However, each inferior may still have its own address
1625 inf->aspace = maybe_new_address_space ();
1626 inf->pspace = current_program_space;
1630 /* In the traditional debugging scenario, there's a 1-1 match
1631 between program/address spaces. We simply bind the inferior
1632 to the program space's address space. */
1633 inf = current_inferior ();
1634 inferior_appeared (inf, pid);
1637 inf->attach_flag = attached;
1638 inf->fake_pid_p = fake_pid_p;
1640 /* If no main executable is currently open then attempt to
1641 open the file that was executed to create this inferior. */
1642 if (try_open_exec && get_exec_file (0) == NULL)
1643 exec_file_locate_attach (pid, 1);
1648 /* Add thread PTID to GDB's thread list. Tag it as executing/running
1649 according to RUNNING. */
1652 remote_add_thread (ptid_t ptid, int running)
1654 struct remote_state *rs = get_remote_state ();
1656 /* GDB historically didn't pull threads in the initial connection
1657 setup. If the remote target doesn't even have a concept of
1658 threads (e.g., a bare-metal target), even if internally we
1659 consider that a single-threaded target, mentioning a new thread
1660 might be confusing to the user. Be silent then, preserving the
1661 age old behavior. */
1662 if (rs->starting_up)
1663 add_thread_silent (ptid);
1667 set_executing (ptid, running);
1668 set_running (ptid, running);
1671 /* Come here when we learn about a thread id from the remote target.
1672 It may be the first time we hear about such thread, so take the
1673 opportunity to add it to GDB's thread list. In case this is the
1674 first time we're noticing its corresponding inferior, add it to
1675 GDB's inferior list as well. */
1678 remote_notice_new_inferior (ptid_t currthread, int running)
1680 /* If this is a new thread, add it to GDB's thread list.
1681 If we leave it up to WFI to do this, bad things will happen. */
1683 if (in_thread_list (currthread) && is_exited (currthread))
1685 /* We're seeing an event on a thread id we knew had exited.
1686 This has to be a new thread reusing the old id. Add it. */
1687 remote_add_thread (currthread, running);
1691 if (!in_thread_list (currthread))
1693 struct inferior *inf = NULL;
1694 int pid = ptid_get_pid (currthread);
1696 if (ptid_is_pid (inferior_ptid)
1697 && pid == ptid_get_pid (inferior_ptid))
1699 /* inferior_ptid has no thread member yet. This can happen
1700 with the vAttach -> remote_wait,"TAAthread:" path if the
1701 stub doesn't support qC. This is the first stop reported
1702 after an attach, so this is the main thread. Update the
1703 ptid in the thread list. */
1704 if (in_thread_list (pid_to_ptid (pid)))
1705 thread_change_ptid (inferior_ptid, currthread);
1708 remote_add_thread (currthread, running);
1709 inferior_ptid = currthread;
1714 if (ptid_equal (magic_null_ptid, inferior_ptid))
1716 /* inferior_ptid is not set yet. This can happen with the
1717 vRun -> remote_wait,"TAAthread:" path if the stub
1718 doesn't support qC. This is the first stop reported
1719 after an attach, so this is the main thread. Update the
1720 ptid in the thread list. */
1721 thread_change_ptid (inferior_ptid, currthread);
1725 /* When connecting to a target remote, or to a target
1726 extended-remote which already was debugging an inferior, we
1727 may not know about it yet. Add it before adding its child
1728 thread, so notifications are emitted in a sensible order. */
1729 if (!in_inferior_list (ptid_get_pid (currthread)))
1731 struct remote_state *rs = get_remote_state ();
1732 int fake_pid_p = !remote_multi_process_p (rs);
1734 inf = remote_add_inferior (fake_pid_p,
1735 ptid_get_pid (currthread), -1, 1);
1738 /* This is really a new thread. Add it. */
1739 remote_add_thread (currthread, running);
1741 /* If we found a new inferior, let the common code do whatever
1742 it needs to with it (e.g., read shared libraries, insert
1743 breakpoints), unless we're just setting up an all-stop
1747 struct remote_state *rs = get_remote_state ();
1749 if (non_stop || !rs->starting_up)
1750 notice_new_inferior (currthread, running, 0);
1755 /* Return the private thread data, creating it if necessary. */
1757 static struct private_thread_info *
1758 demand_private_info (ptid_t ptid)
1760 struct thread_info *info = find_thread_ptid (ptid);
1766 info->priv = xmalloc (sizeof (*(info->priv)));
1767 info->private_dtor = free_private_thread_info;
1768 info->priv->core = -1;
1769 info->priv->extra = 0;
1775 /* Call this function as a result of
1776 1) A halt indication (T packet) containing a thread id
1777 2) A direct query of currthread
1778 3) Successful execution of set thread */
1781 record_currthread (struct remote_state *rs, ptid_t currthread)
1783 rs->general_thread = currthread;
1786 /* If 'QPassSignals' is supported, tell the remote stub what signals
1787 it can simply pass through to the inferior without reporting. */
1790 remote_pass_signals (struct target_ops *self,
1791 int numsigs, unsigned char *pass_signals)
1793 if (packet_support (PACKET_QPassSignals) != PACKET_DISABLE)
1795 char *pass_packet, *p;
1797 struct remote_state *rs = get_remote_state ();
1799 gdb_assert (numsigs < 256);
1800 for (i = 0; i < numsigs; i++)
1802 if (pass_signals[i])
1805 pass_packet = xmalloc (count * 3 + strlen ("QPassSignals:") + 1);
1806 strcpy (pass_packet, "QPassSignals:");
1807 p = pass_packet + strlen (pass_packet);
1808 for (i = 0; i < numsigs; i++)
1810 if (pass_signals[i])
1813 *p++ = tohex (i >> 4);
1814 *p++ = tohex (i & 15);
1823 if (!rs->last_pass_packet || strcmp (rs->last_pass_packet, pass_packet))
1825 putpkt (pass_packet);
1826 getpkt (&rs->buf, &rs->buf_size, 0);
1827 packet_ok (rs->buf, &remote_protocol_packets[PACKET_QPassSignals]);
1828 if (rs->last_pass_packet)
1829 xfree (rs->last_pass_packet);
1830 rs->last_pass_packet = pass_packet;
1833 xfree (pass_packet);
1837 /* If 'QProgramSignals' is supported, tell the remote stub what
1838 signals it should pass through to the inferior when detaching. */
1841 remote_program_signals (struct target_ops *self,
1842 int numsigs, unsigned char *signals)
1844 if (packet_support (PACKET_QProgramSignals) != PACKET_DISABLE)
1848 struct remote_state *rs = get_remote_state ();
1850 gdb_assert (numsigs < 256);
1851 for (i = 0; i < numsigs; i++)
1856 packet = xmalloc (count * 3 + strlen ("QProgramSignals:") + 1);
1857 strcpy (packet, "QProgramSignals:");
1858 p = packet + strlen (packet);
1859 for (i = 0; i < numsigs; i++)
1861 if (signal_pass_state (i))
1864 *p++ = tohex (i >> 4);
1865 *p++ = tohex (i & 15);
1874 if (!rs->last_program_signals_packet
1875 || strcmp (rs->last_program_signals_packet, packet) != 0)
1878 getpkt (&rs->buf, &rs->buf_size, 0);
1879 packet_ok (rs->buf, &remote_protocol_packets[PACKET_QProgramSignals]);
1880 xfree (rs->last_program_signals_packet);
1881 rs->last_program_signals_packet = packet;
1888 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
1889 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
1890 thread. If GEN is set, set the general thread, if not, then set
1891 the step/continue thread. */
1893 set_thread (struct ptid ptid, int gen)
1895 struct remote_state *rs = get_remote_state ();
1896 ptid_t state = gen ? rs->general_thread : rs->continue_thread;
1897 char *buf = rs->buf;
1898 char *endbuf = rs->buf + get_remote_packet_size ();
1900 if (ptid_equal (state, ptid))
1904 *buf++ = gen ? 'g' : 'c';
1905 if (ptid_equal (ptid, magic_null_ptid))
1906 xsnprintf (buf, endbuf - buf, "0");
1907 else if (ptid_equal (ptid, any_thread_ptid))
1908 xsnprintf (buf, endbuf - buf, "0");
1909 else if (ptid_equal (ptid, minus_one_ptid))
1910 xsnprintf (buf, endbuf - buf, "-1");
1912 write_ptid (buf, endbuf, ptid);
1914 getpkt (&rs->buf, &rs->buf_size, 0);
1916 rs->general_thread = ptid;
1918 rs->continue_thread = ptid;
1922 set_general_thread (struct ptid ptid)
1924 set_thread (ptid, 1);
1928 set_continue_thread (struct ptid ptid)
1930 set_thread (ptid, 0);
1933 /* Change the remote current process. Which thread within the process
1934 ends up selected isn't important, as long as it is the same process
1935 as what INFERIOR_PTID points to.
1937 This comes from that fact that there is no explicit notion of
1938 "selected process" in the protocol. The selected process for
1939 general operations is the process the selected general thread
1943 set_general_process (void)
1945 struct remote_state *rs = get_remote_state ();
1947 /* If the remote can't handle multiple processes, don't bother. */
1948 if (!rs->extended || !remote_multi_process_p (rs))
1951 /* We only need to change the remote current thread if it's pointing
1952 at some other process. */
1953 if (ptid_get_pid (rs->general_thread) != ptid_get_pid (inferior_ptid))
1954 set_general_thread (inferior_ptid);
1958 /* Return nonzero if this is the main thread that we made up ourselves
1959 to model non-threaded targets as single-threaded. */
1962 remote_thread_always_alive (struct target_ops *ops, ptid_t ptid)
1964 struct remote_state *rs = get_remote_state ();
1967 if (ptid_equal (ptid, magic_null_ptid))
1968 /* The main thread is always alive. */
1971 if (ptid_get_pid (ptid) != 0 && ptid_get_lwp (ptid) == 0)
1972 /* The main thread is always alive. This can happen after a
1973 vAttach, if the remote side doesn't support
1980 /* Return nonzero if the thread PTID is still alive on the remote
1984 remote_thread_alive (struct target_ops *ops, ptid_t ptid)
1986 struct remote_state *rs = get_remote_state ();
1989 /* Check if this is a thread that we made up ourselves to model
1990 non-threaded targets as single-threaded. */
1991 if (remote_thread_always_alive (ops, ptid))
1995 endp = rs->buf + get_remote_packet_size ();
1998 write_ptid (p, endp, ptid);
2001 getpkt (&rs->buf, &rs->buf_size, 0);
2002 return (rs->buf[0] == 'O' && rs->buf[1] == 'K');
2005 /* About these extended threadlist and threadinfo packets. They are
2006 variable length packets but, the fields within them are often fixed
2007 length. They are redundent enough to send over UDP as is the
2008 remote protocol in general. There is a matching unit test module
2011 /* WARNING: This threadref data structure comes from the remote O.S.,
2012 libstub protocol encoding, and remote.c. It is not particularly
2015 /* Right now, the internal structure is int. We want it to be bigger.
2016 Plan to fix this. */
2018 typedef int gdb_threadref; /* Internal GDB thread reference. */
2020 /* gdb_ext_thread_info is an internal GDB data structure which is
2021 equivalent to the reply of the remote threadinfo packet. */
2023 struct gdb_ext_thread_info
2025 threadref threadid; /* External form of thread reference. */
2026 int active; /* Has state interesting to GDB?
2028 char display[256]; /* Brief state display, name,
2029 blocked/suspended. */
2030 char shortname[32]; /* To be used to name threads. */
2031 char more_display[256]; /* Long info, statistics, queue depth,
2035 /* The volume of remote transfers can be limited by submitting
2036 a mask containing bits specifying the desired information.
2037 Use a union of these values as the 'selection' parameter to
2038 get_thread_info. FIXME: Make these TAG names more thread specific. */
2040 #define TAG_THREADID 1
2041 #define TAG_EXISTS 2
2042 #define TAG_DISPLAY 4
2043 #define TAG_THREADNAME 8
2044 #define TAG_MOREDISPLAY 16
2046 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2048 static char *unpack_nibble (char *buf, int *val);
2050 static char *unpack_byte (char *buf, int *value);
2052 static char *pack_int (char *buf, int value);
2054 static char *unpack_int (char *buf, int *value);
2056 static char *unpack_string (char *src, char *dest, int length);
2058 static char *pack_threadid (char *pkt, threadref *id);
2060 static char *unpack_threadid (char *inbuf, threadref *id);
2062 void int_to_threadref (threadref *id, int value);
2064 static int threadref_to_int (threadref *ref);
2066 static void copy_threadref (threadref *dest, threadref *src);
2068 static int threadmatch (threadref *dest, threadref *src);
2070 static char *pack_threadinfo_request (char *pkt, int mode,
2073 static int remote_unpack_thread_info_response (char *pkt,
2074 threadref *expectedref,
2075 struct gdb_ext_thread_info
2079 static int remote_get_threadinfo (threadref *threadid,
2080 int fieldset, /*TAG mask */
2081 struct gdb_ext_thread_info *info);
2083 static char *pack_threadlist_request (char *pkt, int startflag,
2085 threadref *nextthread);
2087 static int parse_threadlist_response (char *pkt,
2089 threadref *original_echo,
2090 threadref *resultlist,
2093 static int remote_get_threadlist (int startflag,
2094 threadref *nextthread,
2098 threadref *threadlist);
2100 typedef int (*rmt_thread_action) (threadref *ref, void *context);
2102 static int remote_threadlist_iterator (rmt_thread_action stepfunction,
2103 void *context, int looplimit);
2105 static int remote_newthread_step (threadref *ref, void *context);
2108 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2109 buffer we're allowed to write to. Returns
2110 BUF+CHARACTERS_WRITTEN. */
2113 write_ptid (char *buf, const char *endbuf, ptid_t ptid)
2116 struct remote_state *rs = get_remote_state ();
2118 if (remote_multi_process_p (rs))
2120 pid = ptid_get_pid (ptid);
2122 buf += xsnprintf (buf, endbuf - buf, "p-%x.", -pid);
2124 buf += xsnprintf (buf, endbuf - buf, "p%x.", pid);
2126 tid = ptid_get_lwp (ptid);
2128 buf += xsnprintf (buf, endbuf - buf, "-%x", -tid);
2130 buf += xsnprintf (buf, endbuf - buf, "%x", tid);
2135 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
2136 passed the last parsed char. Returns null_ptid on error. */
2139 read_ptid (char *buf, char **obuf)
2143 ULONGEST pid = 0, tid = 0;
2147 /* Multi-process ptid. */
2148 pp = unpack_varlen_hex (p + 1, &pid);
2150 error (_("invalid remote ptid: %s"), p);
2153 pp = unpack_varlen_hex (p + 1, &tid);
2156 return ptid_build (pid, tid, 0);
2159 /* No multi-process. Just a tid. */
2160 pp = unpack_varlen_hex (p, &tid);
2162 /* Return null_ptid when no thread id is found. */
2170 /* Since the stub is not sending a process id, then default to
2171 what's in inferior_ptid, unless it's null at this point. If so,
2172 then since there's no way to know the pid of the reported
2173 threads, use the magic number. */
2174 if (ptid_equal (inferior_ptid, null_ptid))
2175 pid = ptid_get_pid (magic_null_ptid);
2177 pid = ptid_get_pid (inferior_ptid);
2181 return ptid_build (pid, tid, 0);
2187 if (ch >= 'a' && ch <= 'f')
2188 return ch - 'a' + 10;
2189 if (ch >= '0' && ch <= '9')
2191 if (ch >= 'A' && ch <= 'F')
2192 return ch - 'A' + 10;
2197 stub_unpack_int (char *buff, int fieldlength)
2204 nibble = stubhex (*buff++);
2208 retval = retval << 4;
2214 unpack_nibble (char *buf, int *val)
2216 *val = fromhex (*buf++);
2221 unpack_byte (char *buf, int *value)
2223 *value = stub_unpack_int (buf, 2);
2228 pack_int (char *buf, int value)
2230 buf = pack_hex_byte (buf, (value >> 24) & 0xff);
2231 buf = pack_hex_byte (buf, (value >> 16) & 0xff);
2232 buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
2233 buf = pack_hex_byte (buf, (value & 0xff));
2238 unpack_int (char *buf, int *value)
2240 *value = stub_unpack_int (buf, 8);
2244 #if 0 /* Currently unused, uncomment when needed. */
2245 static char *pack_string (char *pkt, char *string);
2248 pack_string (char *pkt, char *string)
2253 len = strlen (string);
2255 len = 200; /* Bigger than most GDB packets, junk??? */
2256 pkt = pack_hex_byte (pkt, len);
2260 if ((ch == '\0') || (ch == '#'))
2261 ch = '*'; /* Protect encapsulation. */
2266 #endif /* 0 (unused) */
2269 unpack_string (char *src, char *dest, int length)
2278 pack_threadid (char *pkt, threadref *id)
2281 unsigned char *altid;
2283 altid = (unsigned char *) id;
2284 limit = pkt + BUF_THREAD_ID_SIZE;
2286 pkt = pack_hex_byte (pkt, *altid++);
2292 unpack_threadid (char *inbuf, threadref *id)
2295 char *limit = inbuf + BUF_THREAD_ID_SIZE;
2298 altref = (char *) id;
2300 while (inbuf < limit)
2302 x = stubhex (*inbuf++);
2303 y = stubhex (*inbuf++);
2304 *altref++ = (x << 4) | y;
2309 /* Externally, threadrefs are 64 bits but internally, they are still
2310 ints. This is due to a mismatch of specifications. We would like
2311 to use 64bit thread references internally. This is an adapter
2315 int_to_threadref (threadref *id, int value)
2317 unsigned char *scan;
2319 scan = (unsigned char *) id;
2325 *scan++ = (value >> 24) & 0xff;
2326 *scan++ = (value >> 16) & 0xff;
2327 *scan++ = (value >> 8) & 0xff;
2328 *scan++ = (value & 0xff);
2332 threadref_to_int (threadref *ref)
2335 unsigned char *scan;
2341 value = (value << 8) | ((*scan++) & 0xff);
2346 copy_threadref (threadref *dest, threadref *src)
2349 unsigned char *csrc, *cdest;
2351 csrc = (unsigned char *) src;
2352 cdest = (unsigned char *) dest;
2359 threadmatch (threadref *dest, threadref *src)
2361 /* Things are broken right now, so just assume we got a match. */
2363 unsigned char *srcp, *destp;
2365 srcp = (char *) src;
2366 destp = (char *) dest;
2370 result &= (*srcp++ == *destp++) ? 1 : 0;
2377 threadid:1, # always request threadid
2384 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
2387 pack_threadinfo_request (char *pkt, int mode, threadref *id)
2389 *pkt++ = 'q'; /* Info Query */
2390 *pkt++ = 'P'; /* process or thread info */
2391 pkt = pack_int (pkt, mode); /* mode */
2392 pkt = pack_threadid (pkt, id); /* threadid */
2393 *pkt = '\0'; /* terminate */
2397 /* These values tag the fields in a thread info response packet. */
2398 /* Tagging the fields allows us to request specific fields and to
2399 add more fields as time goes by. */
2401 #define TAG_THREADID 1 /* Echo the thread identifier. */
2402 #define TAG_EXISTS 2 /* Is this process defined enough to
2403 fetch registers and its stack? */
2404 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
2405 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
2406 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
2410 remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
2411 struct gdb_ext_thread_info *info)
2413 struct remote_state *rs = get_remote_state ();
2417 char *limit = pkt + rs->buf_size; /* Plausible parsing limit. */
2420 /* info->threadid = 0; FIXME: implement zero_threadref. */
2422 info->display[0] = '\0';
2423 info->shortname[0] = '\0';
2424 info->more_display[0] = '\0';
2426 /* Assume the characters indicating the packet type have been
2428 pkt = unpack_int (pkt, &mask); /* arg mask */
2429 pkt = unpack_threadid (pkt, &ref);
2432 warning (_("Incomplete response to threadinfo request."));
2433 if (!threadmatch (&ref, expectedref))
2434 { /* This is an answer to a different request. */
2435 warning (_("ERROR RMT Thread info mismatch."));
2438 copy_threadref (&info->threadid, &ref);
2440 /* Loop on tagged fields , try to bail if somthing goes wrong. */
2442 /* Packets are terminated with nulls. */
2443 while ((pkt < limit) && mask && *pkt)
2445 pkt = unpack_int (pkt, &tag); /* tag */
2446 pkt = unpack_byte (pkt, &length); /* length */
2447 if (!(tag & mask)) /* Tags out of synch with mask. */
2449 warning (_("ERROR RMT: threadinfo tag mismatch."));
2453 if (tag == TAG_THREADID)
2457 warning (_("ERROR RMT: length of threadid is not 16."));
2461 pkt = unpack_threadid (pkt, &ref);
2462 mask = mask & ~TAG_THREADID;
2465 if (tag == TAG_EXISTS)
2467 info->active = stub_unpack_int (pkt, length);
2469 mask = mask & ~(TAG_EXISTS);
2472 warning (_("ERROR RMT: 'exists' length too long."));
2478 if (tag == TAG_THREADNAME)
2480 pkt = unpack_string (pkt, &info->shortname[0], length);
2481 mask = mask & ~TAG_THREADNAME;
2484 if (tag == TAG_DISPLAY)
2486 pkt = unpack_string (pkt, &info->display[0], length);
2487 mask = mask & ~TAG_DISPLAY;
2490 if (tag == TAG_MOREDISPLAY)
2492 pkt = unpack_string (pkt, &info->more_display[0], length);
2493 mask = mask & ~TAG_MOREDISPLAY;
2496 warning (_("ERROR RMT: unknown thread info tag."));
2497 break; /* Not a tag we know about. */
2503 remote_get_threadinfo (threadref *threadid, int fieldset, /* TAG mask */
2504 struct gdb_ext_thread_info *info)
2506 struct remote_state *rs = get_remote_state ();
2509 pack_threadinfo_request (rs->buf, fieldset, threadid);
2511 getpkt (&rs->buf, &rs->buf_size, 0);
2513 if (rs->buf[0] == '\0')
2516 result = remote_unpack_thread_info_response (rs->buf + 2,
2521 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
2524 pack_threadlist_request (char *pkt, int startflag, int threadcount,
2525 threadref *nextthread)
2527 *pkt++ = 'q'; /* info query packet */
2528 *pkt++ = 'L'; /* Process LIST or threadLIST request */
2529 pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */
2530 pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */
2531 pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */
2536 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
2539 parse_threadlist_response (char *pkt, int result_limit,
2540 threadref *original_echo, threadref *resultlist,
2543 struct remote_state *rs = get_remote_state ();
2545 int count, resultcount, done;
2548 /* Assume the 'q' and 'M chars have been stripped. */
2549 limit = pkt + (rs->buf_size - BUF_THREAD_ID_SIZE);
2550 /* done parse past here */
2551 pkt = unpack_byte (pkt, &count); /* count field */
2552 pkt = unpack_nibble (pkt, &done);
2553 /* The first threadid is the argument threadid. */
2554 pkt = unpack_threadid (pkt, original_echo); /* should match query packet */
2555 while ((count-- > 0) && (pkt < limit))
2557 pkt = unpack_threadid (pkt, resultlist++);
2558 if (resultcount++ >= result_limit)
2566 /* Fetch the next batch of threads from the remote. Returns -1 if the
2567 qL packet is not supported, 0 on error and 1 on success. */
2570 remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
2571 int *done, int *result_count, threadref *threadlist)
2573 struct remote_state *rs = get_remote_state ();
2576 /* Trancate result limit to be smaller than the packet size. */
2577 if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10)
2578 >= get_remote_packet_size ())
2579 result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
2581 pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
2583 getpkt (&rs->buf, &rs->buf_size, 0);
2584 if (*rs->buf == '\0')
2586 /* Packet not supported. */
2591 parse_threadlist_response (rs->buf + 2, result_limit,
2592 &rs->echo_nextthread, threadlist, done);
2594 if (!threadmatch (&rs->echo_nextthread, nextthread))
2596 /* FIXME: This is a good reason to drop the packet. */
2597 /* Possably, there is a duplicate response. */
2599 retransmit immediatly - race conditions
2600 retransmit after timeout - yes
2602 wait for packet, then exit
2604 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
2605 return 0; /* I choose simply exiting. */
2607 if (*result_count <= 0)
2611 warning (_("RMT ERROR : failed to get remote thread list."));
2614 return result; /* break; */
2616 if (*result_count > result_limit)
2619 warning (_("RMT ERROR: threadlist response longer than requested."));
2625 /* Fetch the list of remote threads, with the qL packet, and call
2626 STEPFUNCTION for each thread found. Stops iterating and returns 1
2627 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
2628 STEPFUNCTION returns false. If the packet is not supported,
2632 remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
2635 struct remote_state *rs = get_remote_state ();
2636 int done, i, result_count;
2644 if (loopcount++ > looplimit)
2647 warning (_("Remote fetch threadlist -infinite loop-."));
2650 result = remote_get_threadlist (startflag, &rs->nextthread,
2651 MAXTHREADLISTRESULTS,
2652 &done, &result_count,
2653 rs->resultthreadlist);
2656 /* Clear for later iterations. */
2658 /* Setup to resume next batch of thread references, set nextthread. */
2659 if (result_count >= 1)
2660 copy_threadref (&rs->nextthread,
2661 &rs->resultthreadlist[result_count - 1]);
2663 while (result_count--)
2665 if (!(*stepfunction) (&rs->resultthreadlist[i++], context))
2675 /* A thread found on the remote target. */
2677 typedef struct thread_item
2679 /* The thread's PTID. */
2682 /* The thread's extra info. May be NULL. */
2685 /* The core the thread was running on. -1 if not known. */
2688 DEF_VEC_O(thread_item_t);
2690 /* Context passed around to the various methods listing remote
2691 threads. As new threads are found, they're added to the ITEMS
2694 struct threads_listing_context
2696 /* The threads found on the remote target. */
2697 VEC (thread_item_t) *items;
2700 /* Discard the contents of the constructed thread listing context. */
2703 clear_threads_listing_context (void *p)
2705 struct threads_listing_context *context = p;
2707 struct thread_item *item;
2709 for (i = 0; VEC_iterate (thread_item_t, context->items, i, item); ++i)
2710 xfree (item->extra);
2712 VEC_free (thread_item_t, context->items);
2715 /* Remove the thread specified as the related_pid field of WS
2716 from the CONTEXT list. */
2719 threads_listing_context_remove (struct target_waitstatus *ws,
2720 struct threads_listing_context *context)
2722 struct thread_item *item;
2724 ptid_t child_ptid = ws->value.related_pid;
2726 for (i = 0; VEC_iterate (thread_item_t, context->items, i, item); ++i)
2728 if (ptid_equal (item->ptid, child_ptid))
2730 VEC_ordered_remove (thread_item_t, context->items, i);
2737 remote_newthread_step (threadref *ref, void *data)
2739 struct threads_listing_context *context = data;
2740 struct thread_item item;
2741 int pid = ptid_get_pid (inferior_ptid);
2743 item.ptid = ptid_build (pid, threadref_to_int (ref), 0);
2747 VEC_safe_push (thread_item_t, context->items, &item);
2749 return 1; /* continue iterator */
2752 #define CRAZY_MAX_THREADS 1000
2755 remote_current_thread (ptid_t oldpid)
2757 struct remote_state *rs = get_remote_state ();
2760 getpkt (&rs->buf, &rs->buf_size, 0);
2761 if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
2766 result = read_ptid (&rs->buf[2], &obuf);
2767 if (*obuf != '\0' && remote_debug)
2768 fprintf_unfiltered (gdb_stdlog,
2769 "warning: garbage in qC reply\n");
2777 /* List remote threads using the deprecated qL packet. */
2780 remote_get_threads_with_ql (struct target_ops *ops,
2781 struct threads_listing_context *context)
2783 if (remote_threadlist_iterator (remote_newthread_step, context,
2784 CRAZY_MAX_THREADS) >= 0)
2790 #if defined(HAVE_LIBEXPAT)
2793 start_thread (struct gdb_xml_parser *parser,
2794 const struct gdb_xml_element *element,
2795 void *user_data, VEC(gdb_xml_value_s) *attributes)
2797 struct threads_listing_context *data = user_data;
2799 struct thread_item item;
2801 struct gdb_xml_value *attr;
2803 id = xml_find_attribute (attributes, "id")->value;
2804 item.ptid = read_ptid (id, NULL);
2806 attr = xml_find_attribute (attributes, "core");
2808 item.core = *(ULONGEST *) attr->value;
2814 VEC_safe_push (thread_item_t, data->items, &item);
2818 end_thread (struct gdb_xml_parser *parser,
2819 const struct gdb_xml_element *element,
2820 void *user_data, const char *body_text)
2822 struct threads_listing_context *data = user_data;
2824 if (body_text && *body_text)
2825 VEC_last (thread_item_t, data->items)->extra = xstrdup (body_text);
2828 const struct gdb_xml_attribute thread_attributes[] = {
2829 { "id", GDB_XML_AF_NONE, NULL, NULL },
2830 { "core", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
2831 { NULL, GDB_XML_AF_NONE, NULL, NULL }
2834 const struct gdb_xml_element thread_children[] = {
2835 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2838 const struct gdb_xml_element threads_children[] = {
2839 { "thread", thread_attributes, thread_children,
2840 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
2841 start_thread, end_thread },
2842 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2845 const struct gdb_xml_element threads_elements[] = {
2846 { "threads", NULL, threads_children,
2847 GDB_XML_EF_NONE, NULL, NULL },
2848 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2853 /* List remote threads using qXfer:threads:read. */
2856 remote_get_threads_with_qxfer (struct target_ops *ops,
2857 struct threads_listing_context *context)
2859 #if defined(HAVE_LIBEXPAT)
2860 if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
2862 char *xml = target_read_stralloc (ops, TARGET_OBJECT_THREADS, NULL);
2863 struct cleanup *back_to = make_cleanup (xfree, xml);
2865 if (xml != NULL && *xml != '\0')
2867 gdb_xml_parse_quick (_("threads"), "threads.dtd",
2868 threads_elements, xml, context);
2871 do_cleanups (back_to);
2879 /* List remote threads using qfThreadInfo/qsThreadInfo. */
2882 remote_get_threads_with_qthreadinfo (struct target_ops *ops,
2883 struct threads_listing_context *context)
2885 struct remote_state *rs = get_remote_state ();
2887 if (rs->use_threadinfo_query)
2891 putpkt ("qfThreadInfo");
2892 getpkt (&rs->buf, &rs->buf_size, 0);
2894 if (bufp[0] != '\0') /* q packet recognized */
2896 while (*bufp++ == 'm') /* reply contains one or more TID */
2900 struct thread_item item;
2902 item.ptid = read_ptid (bufp, &bufp);
2906 VEC_safe_push (thread_item_t, context->items, &item);
2908 while (*bufp++ == ','); /* comma-separated list */
2909 putpkt ("qsThreadInfo");
2910 getpkt (&rs->buf, &rs->buf_size, 0);
2917 /* Packet not recognized. */
2918 rs->use_threadinfo_query = 0;
2925 /* Implement the to_update_thread_list function for the remote
2929 remote_update_thread_list (struct target_ops *ops)
2931 struct remote_state *rs = get_remote_state ();
2932 struct threads_listing_context context;
2933 struct cleanup *old_chain;
2936 context.items = NULL;
2937 old_chain = make_cleanup (clear_threads_listing_context, &context);
2939 /* We have a few different mechanisms to fetch the thread list. Try
2940 them all, starting with the most preferred one first, falling
2941 back to older methods. */
2942 if (remote_get_threads_with_qxfer (ops, &context)
2943 || remote_get_threads_with_qthreadinfo (ops, &context)
2944 || remote_get_threads_with_ql (ops, &context))
2947 struct thread_item *item;
2948 struct thread_info *tp, *tmp;
2952 if (VEC_empty (thread_item_t, context.items)
2953 && remote_thread_always_alive (ops, inferior_ptid))
2955 /* Some targets don't really support threads, but still
2956 reply an (empty) thread list in response to the thread
2957 listing packets, instead of replying "packet not
2958 supported". Exit early so we don't delete the main
2960 do_cleanups (old_chain);
2964 /* CONTEXT now holds the current thread list on the remote
2965 target end. Delete GDB-side threads no longer found on the
2967 ALL_THREADS_SAFE (tp, tmp)
2970 VEC_iterate (thread_item_t, context.items, i, item);
2973 if (ptid_equal (item->ptid, tp->ptid))
2977 if (i == VEC_length (thread_item_t, context.items))
2980 delete_thread (tp->ptid);
2984 /* Remove any unreported fork child threads from CONTEXT so
2985 that we don't interfere with follow fork, which is where
2986 creation of such threads is handled. */
2987 remove_new_fork_children (&context);
2989 /* And now add threads we don't know about yet to our list. */
2991 VEC_iterate (thread_item_t, context.items, i, item);
2994 if (!ptid_equal (item->ptid, null_ptid))
2996 struct private_thread_info *info;
2997 /* In non-stop mode, we assume new found threads are
2998 running until proven otherwise with a stop reply. In
2999 all-stop, we can only get here if all threads are
3001 int running = non_stop ? 1 : 0;
3003 remote_notice_new_inferior (item->ptid, running);
3005 info = demand_private_info (item->ptid);
3006 info->core = item->core;
3007 info->extra = item->extra;
3015 /* If no thread listing method is supported, then query whether
3016 each known thread is alive, one by one, with the T packet.
3017 If the target doesn't support threads at all, then this is a
3018 no-op. See remote_thread_alive. */
3022 do_cleanups (old_chain);
3026 * Collect a descriptive string about the given thread.
3027 * The target may say anything it wants to about the thread
3028 * (typically info about its blocked / runnable state, name, etc.).
3029 * This string will appear in the info threads display.
3031 * Optional: targets are not required to implement this function.
3035 remote_threads_extra_info (struct target_ops *self, struct thread_info *tp)
3037 struct remote_state *rs = get_remote_state ();
3041 struct gdb_ext_thread_info threadinfo;
3042 static char display_buf[100]; /* arbitrary... */
3043 int n = 0; /* position in display_buf */
3045 if (rs->remote_desc == 0) /* paranoia */
3046 internal_error (__FILE__, __LINE__,
3047 _("remote_threads_extra_info"));
3049 if (ptid_equal (tp->ptid, magic_null_ptid)
3050 || (ptid_get_pid (tp->ptid) != 0 && ptid_get_lwp (tp->ptid) == 0))
3051 /* This is the main thread which was added by GDB. The remote
3052 server doesn't know about it. */
3055 if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
3057 struct thread_info *info = find_thread_ptid (tp->ptid);
3059 if (info && info->priv)
3060 return info->priv->extra;
3065 if (rs->use_threadextra_query)
3068 char *endb = rs->buf + get_remote_packet_size ();
3070 xsnprintf (b, endb - b, "qThreadExtraInfo,");
3072 write_ptid (b, endb, tp->ptid);
3075 getpkt (&rs->buf, &rs->buf_size, 0);
3076 if (rs->buf[0] != 0)
3078 n = min (strlen (rs->buf) / 2, sizeof (display_buf));
3079 result = hex2bin (rs->buf, (gdb_byte *) display_buf, n);
3080 display_buf [result] = '\0';
3085 /* If the above query fails, fall back to the old method. */
3086 rs->use_threadextra_query = 0;
3087 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
3088 | TAG_MOREDISPLAY | TAG_DISPLAY;
3089 int_to_threadref (&id, ptid_get_lwp (tp->ptid));
3090 if (remote_get_threadinfo (&id, set, &threadinfo))
3091 if (threadinfo.active)
3093 if (*threadinfo.shortname)
3094 n += xsnprintf (&display_buf[0], sizeof (display_buf) - n,
3095 " Name: %s,", threadinfo.shortname);
3096 if (*threadinfo.display)
3097 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
3098 " State: %s,", threadinfo.display);
3099 if (*threadinfo.more_display)
3100 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
3101 " Priority: %s", threadinfo.more_display);
3105 /* For purely cosmetic reasons, clear up trailing commas. */
3106 if (',' == display_buf[n-1])
3107 display_buf[n-1] = ' ';
3116 remote_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR addr,
3117 struct static_tracepoint_marker *marker)
3119 struct remote_state *rs = get_remote_state ();
3122 xsnprintf (p, get_remote_packet_size (), "qTSTMat:");
3124 p += hexnumstr (p, addr);
3126 getpkt (&rs->buf, &rs->buf_size, 0);
3130 error (_("Remote failure reply: %s"), p);
3134 parse_static_tracepoint_marker_definition (p, &p, marker);
3141 static VEC(static_tracepoint_marker_p) *
3142 remote_static_tracepoint_markers_by_strid (struct target_ops *self,
3145 struct remote_state *rs = get_remote_state ();
3146 VEC(static_tracepoint_marker_p) *markers = NULL;
3147 struct static_tracepoint_marker *marker = NULL;
3148 struct cleanup *old_chain;
3151 /* Ask for a first packet of static tracepoint marker
3154 getpkt (&rs->buf, &rs->buf_size, 0);
3157 error (_("Remote failure reply: %s"), p);
3159 old_chain = make_cleanup (free_current_marker, &marker);
3164 marker = XCNEW (struct static_tracepoint_marker);
3168 parse_static_tracepoint_marker_definition (p, &p, marker);
3170 if (strid == NULL || strcmp (strid, marker->str_id) == 0)
3172 VEC_safe_push (static_tracepoint_marker_p,
3178 release_static_tracepoint_marker (marker);
3179 memset (marker, 0, sizeof (*marker));
3182 while (*p++ == ','); /* comma-separated list */
3183 /* Ask for another packet of static tracepoint definition. */
3185 getpkt (&rs->buf, &rs->buf_size, 0);
3189 do_cleanups (old_chain);
3194 /* Implement the to_get_ada_task_ptid function for the remote targets. */
3197 remote_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
3199 return ptid_build (ptid_get_pid (inferior_ptid), lwp, 0);
3203 /* Restart the remote side; this is an extended protocol operation. */
3206 extended_remote_restart (void)
3208 struct remote_state *rs = get_remote_state ();
3210 /* Send the restart command; for reasons I don't understand the
3211 remote side really expects a number after the "R". */
3212 xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0);
3215 remote_fileio_reset ();
3218 /* Clean up connection to a remote debugger. */
3221 remote_close (struct target_ops *self)
3223 struct remote_state *rs = get_remote_state ();
3225 if (rs->remote_desc == NULL)
3226 return; /* already closed */
3228 /* Make sure we leave stdin registered in the event loop, and we
3229 don't leave the async SIGINT signal handler installed. */
3230 remote_terminal_ours (self);
3232 serial_close (rs->remote_desc);
3233 rs->remote_desc = NULL;
3235 /* We don't have a connection to the remote stub anymore. Get rid
3236 of all the inferiors and their threads we were controlling.
3237 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
3238 will be unable to find the thread corresponding to (pid, 0, 0). */
3239 inferior_ptid = null_ptid;
3240 discard_all_inferiors ();
3242 /* We are closing the remote target, so we should discard
3243 everything of this target. */
3244 discard_pending_stop_replies_in_queue (rs);
3246 if (remote_async_inferior_event_token)
3247 delete_async_event_handler (&remote_async_inferior_event_token);
3249 remote_notif_state_xfree (rs->notif_state);
3251 trace_reset_local_state ();
3254 /* Query the remote side for the text, data and bss offsets. */
3259 struct remote_state *rs = get_remote_state ();
3262 int lose, num_segments = 0, do_sections, do_segments;
3263 CORE_ADDR text_addr, data_addr, bss_addr, segments[2];
3264 struct section_offsets *offs;
3265 struct symfile_segment_data *data;
3267 if (symfile_objfile == NULL)
3270 putpkt ("qOffsets");
3271 getpkt (&rs->buf, &rs->buf_size, 0);
3274 if (buf[0] == '\000')
3275 return; /* Return silently. Stub doesn't support
3279 warning (_("Remote failure reply: %s"), buf);
3283 /* Pick up each field in turn. This used to be done with scanf, but
3284 scanf will make trouble if CORE_ADDR size doesn't match
3285 conversion directives correctly. The following code will work
3286 with any size of CORE_ADDR. */
3287 text_addr = data_addr = bss_addr = 0;
3291 if (startswith (ptr, "Text="))
3294 /* Don't use strtol, could lose on big values. */
3295 while (*ptr && *ptr != ';')
3296 text_addr = (text_addr << 4) + fromhex (*ptr++);
3298 if (startswith (ptr, ";Data="))
3301 while (*ptr && *ptr != ';')
3302 data_addr = (data_addr << 4) + fromhex (*ptr++);
3307 if (!lose && startswith (ptr, ";Bss="))
3310 while (*ptr && *ptr != ';')
3311 bss_addr = (bss_addr << 4) + fromhex (*ptr++);
3313 if (bss_addr != data_addr)
3314 warning (_("Target reported unsupported offsets: %s"), buf);
3319 else if (startswith (ptr, "TextSeg="))
3322 /* Don't use strtol, could lose on big values. */
3323 while (*ptr && *ptr != ';')
3324 text_addr = (text_addr << 4) + fromhex (*ptr++);
3327 if (startswith (ptr, ";DataSeg="))
3330 while (*ptr && *ptr != ';')
3331 data_addr = (data_addr << 4) + fromhex (*ptr++);
3339 error (_("Malformed response to offset query, %s"), buf);
3340 else if (*ptr != '\0')
3341 warning (_("Target reported unsupported offsets: %s"), buf);
3343 offs = ((struct section_offsets *)
3344 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)));
3345 memcpy (offs, symfile_objfile->section_offsets,
3346 SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections));
3348 data = get_symfile_segment_data (symfile_objfile->obfd);
3349 do_segments = (data != NULL);
3350 do_sections = num_segments == 0;
3352 if (num_segments > 0)
3354 segments[0] = text_addr;
3355 segments[1] = data_addr;
3357 /* If we have two segments, we can still try to relocate everything
3358 by assuming that the .text and .data offsets apply to the whole
3359 text and data segments. Convert the offsets given in the packet
3360 to base addresses for symfile_map_offsets_to_segments. */
3361 else if (data && data->num_segments == 2)
3363 segments[0] = data->segment_bases[0] + text_addr;
3364 segments[1] = data->segment_bases[1] + data_addr;
3367 /* If the object file has only one segment, assume that it is text
3368 rather than data; main programs with no writable data are rare,
3369 but programs with no code are useless. Of course the code might
3370 have ended up in the data segment... to detect that we would need
3371 the permissions here. */
3372 else if (data && data->num_segments == 1)
3374 segments[0] = data->segment_bases[0] + text_addr;
3377 /* There's no way to relocate by segment. */
3383 int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, data,
3384 offs, num_segments, segments);
3386 if (ret == 0 && !do_sections)
3387 error (_("Can not handle qOffsets TextSeg "
3388 "response with this symbol file"));
3395 free_symfile_segment_data (data);
3399 offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
3401 /* This is a temporary kludge to force data and bss to use the
3402 same offsets because that's what nlmconv does now. The real
3403 solution requires changes to the stub and remote.c that I
3404 don't have time to do right now. */
3406 offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
3407 offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
3410 objfile_relocate (symfile_objfile, offs);
3413 /* Callback for iterate_over_threads. Set the STOP_REQUESTED flags in
3414 threads we know are stopped already. This is used during the
3415 initial remote connection in non-stop mode --- threads that are
3416 reported as already being stopped are left stopped. */
3419 set_stop_requested_callback (struct thread_info *thread, void *data)
3421 /* If we have a stop reply for this thread, it must be stopped. */
3422 if (peek_stop_reply (thread->ptid))
3423 set_stop_requested (thread->ptid, 1);
3428 /* Send interrupt_sequence to remote target. */
3430 send_interrupt_sequence (void)
3432 struct remote_state *rs = get_remote_state ();
3434 if (interrupt_sequence_mode == interrupt_sequence_control_c)
3435 remote_serial_write ("\x03", 1);
3436 else if (interrupt_sequence_mode == interrupt_sequence_break)
3437 serial_send_break (rs->remote_desc);
3438 else if (interrupt_sequence_mode == interrupt_sequence_break_g)
3440 serial_send_break (rs->remote_desc);
3441 remote_serial_write ("g", 1);
3444 internal_error (__FILE__, __LINE__,
3445 _("Invalid value for interrupt_sequence_mode: %s."),
3446 interrupt_sequence_mode);
3450 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
3451 and extract the PTID. Returns NULL_PTID if not found. */
3454 stop_reply_extract_thread (char *stop_reply)
3456 if (stop_reply[0] == 'T' && strlen (stop_reply) > 3)
3460 /* Txx r:val ; r:val (...) */
3463 /* Look for "register" named "thread". */
3468 p1 = strchr (p, ':');
3472 if (strncmp (p, "thread", p1 - p) == 0)
3473 return read_ptid (++p1, &p);
3475 p1 = strchr (p, ';');
3487 /* Determine the remote side's current thread. If we have a stop
3488 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
3489 "thread" register we can extract the current thread from. If not,
3490 ask the remote which is the current thread with qC. The former
3491 method avoids a roundtrip. */
3494 get_current_thread (char *wait_status)
3496 ptid_t ptid = null_ptid;
3498 /* Note we don't use remote_parse_stop_reply as that makes use of
3499 the target architecture, which we haven't yet fully determined at
3501 if (wait_status != NULL)
3502 ptid = stop_reply_extract_thread (wait_status);
3503 if (ptid_equal (ptid, null_ptid))
3504 ptid = remote_current_thread (inferior_ptid);
3509 /* Query the remote target for which is the current thread/process,
3510 add it to our tables, and update INFERIOR_PTID. The caller is
3511 responsible for setting the state such that the remote end is ready
3512 to return the current thread.
3514 This function is called after handling the '?' or 'vRun' packets,
3515 whose response is a stop reply from which we can also try
3516 extracting the thread. If the target doesn't support the explicit
3517 qC query, we infer the current thread from that stop reply, passed
3518 in in WAIT_STATUS, which may be NULL. */
3521 add_current_inferior_and_thread (char *wait_status)
3523 struct remote_state *rs = get_remote_state ();
3527 inferior_ptid = null_ptid;
3529 /* Now, if we have thread information, update inferior_ptid. */
3530 ptid = get_current_thread (wait_status);
3532 if (!ptid_equal (ptid, null_ptid))
3534 if (!remote_multi_process_p (rs))
3537 inferior_ptid = ptid;
3541 /* Without this, some commands which require an active target
3542 (such as kill) won't work. This variable serves (at least)
3543 double duty as both the pid of the target process (if it has
3544 such), and as a flag indicating that a target is active. */
3545 inferior_ptid = magic_null_ptid;
3549 remote_add_inferior (fake_pid_p, ptid_get_pid (inferior_ptid), -1, 1);
3551 /* Add the main thread. */
3552 add_thread_silent (inferior_ptid);
3556 remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
3558 struct remote_state *rs = get_remote_state ();
3559 struct packet_config *noack_config;
3560 char *wait_status = NULL;
3562 immediate_quit++; /* Allow user to interrupt it. */
3565 if (interrupt_on_connect)
3566 send_interrupt_sequence ();
3568 /* Ack any packet which the remote side has already sent. */
3569 serial_write (rs->remote_desc, "+", 1);
3571 /* Signal other parts that we're going through the initial setup,
3572 and so things may not be stable yet. */
3573 rs->starting_up = 1;
3575 /* The first packet we send to the target is the optional "supported
3576 packets" request. If the target can answer this, it will tell us
3577 which later probes to skip. */
3578 remote_query_supported ();
3580 /* If the stub wants to get a QAllow, compose one and send it. */
3581 if (packet_support (PACKET_QAllow) != PACKET_DISABLE)
3582 remote_set_permissions (target);
3584 /* Next, we possibly activate noack mode.
3586 If the QStartNoAckMode packet configuration is set to AUTO,
3587 enable noack mode if the stub reported a wish for it with
3590 If set to TRUE, then enable noack mode even if the stub didn't
3591 report it in qSupported. If the stub doesn't reply OK, the
3592 session ends with an error.
3594 If FALSE, then don't activate noack mode, regardless of what the
3595 stub claimed should be the default with qSupported. */
3597 noack_config = &remote_protocol_packets[PACKET_QStartNoAckMode];
3598 if (packet_config_support (noack_config) != PACKET_DISABLE)
3600 putpkt ("QStartNoAckMode");
3601 getpkt (&rs->buf, &rs->buf_size, 0);
3602 if (packet_ok (rs->buf, noack_config) == PACKET_OK)
3608 /* Tell the remote that we are using the extended protocol. */
3610 getpkt (&rs->buf, &rs->buf_size, 0);
3613 /* Let the target know which signals it is allowed to pass down to
3615 update_signals_program_target ();
3617 /* Next, if the target can specify a description, read it. We do
3618 this before anything involving memory or registers. */
3619 target_find_description ();
3621 /* Next, now that we know something about the target, update the
3622 address spaces in the program spaces. */
3623 update_address_spaces ();
3625 /* On OSs where the list of libraries is global to all
3626 processes, we fetch them early. */
3627 if (gdbarch_has_global_solist (target_gdbarch ()))
3628 solib_add (NULL, from_tty, target, auto_solib_add);
3632 if (packet_support (PACKET_QNonStop) != PACKET_ENABLE)
3633 error (_("Non-stop mode requested, but remote "
3634 "does not support non-stop"));
3636 putpkt ("QNonStop:1");
3637 getpkt (&rs->buf, &rs->buf_size, 0);
3639 if (strcmp (rs->buf, "OK") != 0)
3640 error (_("Remote refused setting non-stop mode with: %s"), rs->buf);
3642 /* Find about threads and processes the stub is already
3643 controlling. We default to adding them in the running state.
3644 The '?' query below will then tell us about which threads are
3646 remote_update_thread_list (target);
3648 else if (packet_support (PACKET_QNonStop) == PACKET_ENABLE)
3650 /* Don't assume that the stub can operate in all-stop mode.
3651 Request it explicitly. */
3652 putpkt ("QNonStop:0");
3653 getpkt (&rs->buf, &rs->buf_size, 0);
3655 if (strcmp (rs->buf, "OK") != 0)
3656 error (_("Remote refused setting all-stop mode with: %s"), rs->buf);
3659 /* Upload TSVs regardless of whether the target is running or not. The
3660 remote stub, such as GDBserver, may have some predefined or builtin
3661 TSVs, even if the target is not running. */
3662 if (remote_get_trace_status (target, current_trace_status ()) != -1)
3664 struct uploaded_tsv *uploaded_tsvs = NULL;
3666 remote_upload_trace_state_variables (target, &uploaded_tsvs);
3667 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3670 /* Check whether the target is running now. */
3672 getpkt (&rs->buf, &rs->buf_size, 0);
3678 struct inferior *inf;
3680 if (rs->buf[0] == 'W' || rs->buf[0] == 'X')
3683 error (_("The target is not running (try extended-remote?)"));
3685 /* We're connected, but not running. Drop out before we
3686 call start_remote. */
3687 rs->starting_up = 0;
3692 /* Save the reply for later. */
3693 wait_status = alloca (strlen (rs->buf) + 1);
3694 strcpy (wait_status, rs->buf);
3697 /* Fetch thread list. */
3698 target_update_thread_list ();
3700 /* Let the stub know that we want it to return the thread. */
3701 set_continue_thread (minus_one_ptid);
3703 if (thread_count () == 0)
3705 /* Target has no concept of threads at all. GDB treats
3706 non-threaded target as single-threaded; add a main
3708 add_current_inferior_and_thread (wait_status);
3712 /* We have thread information; select the thread the target
3713 says should be current. If we're reconnecting to a
3714 multi-threaded program, this will ideally be the thread
3715 that last reported an event before GDB disconnected. */
3716 inferior_ptid = get_current_thread (wait_status);
3717 if (ptid_equal (inferior_ptid, null_ptid))
3719 /* Odd... The target was able to list threads, but not
3720 tell us which thread was current (no "thread"
3721 register in T stop reply?). Just pick the first
3722 thread in the thread list then. */
3725 fprintf_unfiltered (gdb_stdlog,
3726 "warning: couldn't determine remote "
3727 "current thread; picking first in list.\n");
3729 inferior_ptid = thread_list->ptid;
3733 /* init_wait_for_inferior should be called before get_offsets in order
3734 to manage `inserted' flag in bp loc in a correct state.
3735 breakpoint_init_inferior, called from init_wait_for_inferior, set
3736 `inserted' flag to 0, while before breakpoint_re_set, called from
3737 start_remote, set `inserted' flag to 1. In the initialization of
3738 inferior, breakpoint_init_inferior should be called first, and then
3739 breakpoint_re_set can be called. If this order is broken, state of
3740 `inserted' flag is wrong, and cause some problems on breakpoint
3742 init_wait_for_inferior ();
3744 get_offsets (); /* Get text, data & bss offsets. */
3746 /* If we could not find a description using qXfer, and we know
3747 how to do it some other way, try again. This is not
3748 supported for non-stop; it could be, but it is tricky if
3749 there are no stopped threads when we connect. */
3750 if (remote_read_description_p (target)
3751 && gdbarch_target_desc (target_gdbarch ()) == NULL)
3753 target_clear_description ();
3754 target_find_description ();
3757 /* Use the previously fetched status. */
3758 gdb_assert (wait_status != NULL);
3759 strcpy (rs->buf, wait_status);
3760 rs->cached_wait_status = 1;
3763 start_remote (from_tty); /* Initialize gdb process mechanisms. */
3767 /* Clear WFI global state. Do this before finding about new
3768 threads and inferiors, and setting the current inferior.
3769 Otherwise we would clear the proceed status of the current
3770 inferior when we want its stop_soon state to be preserved
3771 (see notice_new_inferior). */
3772 init_wait_for_inferior ();
3774 /* In non-stop, we will either get an "OK", meaning that there
3775 are no stopped threads at this time; or, a regular stop
3776 reply. In the latter case, there may be more than one thread
3777 stopped --- we pull them all out using the vStopped
3779 if (strcmp (rs->buf, "OK") != 0)
3781 struct notif_client *notif = ¬if_client_stop;
3783 /* remote_notif_get_pending_replies acks this one, and gets
3785 rs->notif_state->pending_event[notif_client_stop.id]
3786 = remote_notif_parse (notif, rs->buf);
3787 remote_notif_get_pending_events (notif);
3789 /* Make sure that threads that were stopped remain
3791 iterate_over_threads (set_stop_requested_callback, NULL);
3794 if (target_can_async_p ())
3797 if (thread_count () == 0)
3800 error (_("The target is not running (try extended-remote?)"));
3802 /* We're connected, but not running. Drop out before we
3803 call start_remote. */
3804 rs->starting_up = 0;
3808 /* Let the stub know that we want it to return the thread. */
3810 /* Force the stub to choose a thread. */
3811 set_general_thread (null_ptid);
3814 inferior_ptid = remote_current_thread (minus_one_ptid);
3815 if (ptid_equal (inferior_ptid, minus_one_ptid))
3816 error (_("remote didn't report the current thread in non-stop mode"));
3818 get_offsets (); /* Get text, data & bss offsets. */
3820 /* In non-stop mode, any cached wait status will be stored in
3821 the stop reply queue. */
3822 gdb_assert (wait_status == NULL);
3824 /* Report all signals during attach/startup. */
3825 remote_pass_signals (target, 0, NULL);
3828 /* If we connected to a live target, do some additional setup. */
3829 if (target_has_execution)
3831 if (symfile_objfile) /* No use without a symbol-file. */
3832 remote_check_symbols ();
3835 /* Possibly the target has been engaged in a trace run started
3836 previously; find out where things are at. */
3837 if (remote_get_trace_status (target, current_trace_status ()) != -1)
3839 struct uploaded_tp *uploaded_tps = NULL;
3841 if (current_trace_status ()->running)
3842 printf_filtered (_("Trace is already running on the target.\n"));
3844 remote_upload_tracepoints (target, &uploaded_tps);
3846 merge_uploaded_tracepoints (&uploaded_tps);
3849 /* The thread and inferior lists are now synchronized with the
3850 target, our symbols have been relocated, and we're merged the
3851 target's tracepoints with ours. We're done with basic start
3853 rs->starting_up = 0;
3855 /* Maybe breakpoints are global and need to be inserted now. */
3856 if (breakpoints_should_be_inserted_now ())
3857 insert_breakpoints ();
3860 /* Open a connection to a remote debugger.
3861 NAME is the filename used for communication. */
3864 remote_open (const char *name, int from_tty)
3866 remote_open_1 (name, from_tty, &remote_ops, 0);
3869 /* Open a connection to a remote debugger using the extended
3870 remote gdb protocol. NAME is the filename used for communication. */
3873 extended_remote_open (const char *name, int from_tty)
3875 remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */);
3878 /* Reset all packets back to "unknown support". Called when opening a
3879 new connection to a remote target. */
3882 reset_all_packet_configs_support (void)
3886 for (i = 0; i < PACKET_MAX; i++)
3887 remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN;
3890 /* Initialize all packet configs. */
3893 init_all_packet_configs (void)
3897 for (i = 0; i < PACKET_MAX; i++)
3899 remote_protocol_packets[i].detect = AUTO_BOOLEAN_AUTO;
3900 remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN;
3904 /* Symbol look-up. */
3907 remote_check_symbols (void)
3909 struct remote_state *rs = get_remote_state ();
3910 char *msg, *reply, *tmp;
3911 struct bound_minimal_symbol sym;
3914 /* The remote side has no concept of inferiors that aren't running
3915 yet, it only knows about running processes. If we're connected
3916 but our current inferior is not running, we should not invite the
3917 remote target to request symbol lookups related to its
3918 (unrelated) current process. */
3919 if (!target_has_execution)
3922 if (packet_support (PACKET_qSymbol) == PACKET_DISABLE)
3925 /* Make sure the remote is pointing at the right process. Note
3926 there's no way to select "no process". */
3927 set_general_process ();
3929 /* Allocate a message buffer. We can't reuse the input buffer in RS,
3930 because we need both at the same time. */
3931 msg = alloca (get_remote_packet_size ());
3933 /* Invite target to request symbol lookups. */
3935 putpkt ("qSymbol::");
3936 getpkt (&rs->buf, &rs->buf_size, 0);
3937 packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSymbol]);
3940 while (startswith (reply, "qSymbol:"))
3942 struct bound_minimal_symbol sym;
3945 end = hex2bin (tmp, (gdb_byte *) msg, strlen (tmp) / 2);
3947 sym = lookup_minimal_symbol (msg, NULL, NULL);
3948 if (sym.minsym == NULL)
3949 xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
3952 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
3953 CORE_ADDR sym_addr = BMSYMBOL_VALUE_ADDRESS (sym);
3955 /* If this is a function address, return the start of code
3956 instead of any data function descriptor. */
3957 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
3961 xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
3962 phex_nz (sym_addr, addr_size), &reply[8]);
3966 getpkt (&rs->buf, &rs->buf_size, 0);
3971 static struct serial *
3972 remote_serial_open (const char *name)
3974 static int udp_warning = 0;
3976 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
3977 of in ser-tcp.c, because it is the remote protocol assuming that the
3978 serial connection is reliable and not the serial connection promising
3980 if (!udp_warning && startswith (name, "udp:"))
3982 warning (_("The remote protocol may be unreliable over UDP.\n"
3983 "Some events may be lost, rendering further debugging "
3988 return serial_open (name);
3991 /* Inform the target of our permission settings. The permission flags
3992 work without this, but if the target knows the settings, it can do
3993 a couple things. First, it can add its own check, to catch cases
3994 that somehow manage to get by the permissions checks in target
3995 methods. Second, if the target is wired to disallow particular
3996 settings (for instance, a system in the field that is not set up to
3997 be able to stop at a breakpoint), it can object to any unavailable
4001 remote_set_permissions (struct target_ops *self)
4003 struct remote_state *rs = get_remote_state ();
4005 xsnprintf (rs->buf, get_remote_packet_size (), "QAllow:"
4006 "WriteReg:%x;WriteMem:%x;"
4007 "InsertBreak:%x;InsertTrace:%x;"
4008 "InsertFastTrace:%x;Stop:%x",
4009 may_write_registers, may_write_memory,
4010 may_insert_breakpoints, may_insert_tracepoints,
4011 may_insert_fast_tracepoints, may_stop);
4013 getpkt (&rs->buf, &rs->buf_size, 0);
4015 /* If the target didn't like the packet, warn the user. Do not try
4016 to undo the user's settings, that would just be maddening. */
4017 if (strcmp (rs->buf, "OK") != 0)
4018 warning (_("Remote refused setting permissions with: %s"), rs->buf);
4021 /* This type describes each known response to the qSupported
4023 struct protocol_feature
4025 /* The name of this protocol feature. */
4028 /* The default for this protocol feature. */
4029 enum packet_support default_support;
4031 /* The function to call when this feature is reported, or after
4032 qSupported processing if the feature is not supported.
4033 The first argument points to this structure. The second
4034 argument indicates whether the packet requested support be
4035 enabled, disabled, or probed (or the default, if this function
4036 is being called at the end of processing and this feature was
4037 not reported). The third argument may be NULL; if not NULL, it
4038 is a NUL-terminated string taken from the packet following
4039 this feature's name and an equals sign. */
4040 void (*func) (const struct protocol_feature *, enum packet_support,
4043 /* The corresponding packet for this feature. Only used if
4044 FUNC is remote_supported_packet. */
4049 remote_supported_packet (const struct protocol_feature *feature,
4050 enum packet_support support,
4051 const char *argument)
4055 warning (_("Remote qSupported response supplied an unexpected value for"
4056 " \"%s\"."), feature->name);
4060 remote_protocol_packets[feature->packet].support = support;
4064 remote_packet_size (const struct protocol_feature *feature,
4065 enum packet_support support, const char *value)
4067 struct remote_state *rs = get_remote_state ();
4072 if (support != PACKET_ENABLE)
4075 if (value == NULL || *value == '\0')
4077 warning (_("Remote target reported \"%s\" without a size."),
4083 packet_size = strtol (value, &value_end, 16);
4084 if (errno != 0 || *value_end != '\0' || packet_size < 0)
4086 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
4087 feature->name, value);
4091 if (packet_size > MAX_REMOTE_PACKET_SIZE)
4093 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
4094 packet_size, MAX_REMOTE_PACKET_SIZE);
4095 packet_size = MAX_REMOTE_PACKET_SIZE;
4098 /* Record the new maximum packet size. */
4099 rs->explicit_packet_size = packet_size;
4102 static const struct protocol_feature remote_protocol_features[] = {
4103 { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
4104 { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
4105 PACKET_qXfer_auxv },
4106 { "qXfer:exec-file:read", PACKET_DISABLE, remote_supported_packet,
4107 PACKET_qXfer_exec_file },
4108 { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet,
4109 PACKET_qXfer_features },
4110 { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet,
4111 PACKET_qXfer_libraries },
4112 { "qXfer:libraries-svr4:read", PACKET_DISABLE, remote_supported_packet,
4113 PACKET_qXfer_libraries_svr4 },
4114 { "augmented-libraries-svr4-read", PACKET_DISABLE,
4115 remote_supported_packet, PACKET_augmented_libraries_svr4_read_feature },
4116 { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
4117 PACKET_qXfer_memory_map },
4118 { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
4119 PACKET_qXfer_spu_read },
4120 { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet,
4121 PACKET_qXfer_spu_write },
4122 { "qXfer:osdata:read", PACKET_DISABLE, remote_supported_packet,
4123 PACKET_qXfer_osdata },
4124 { "qXfer:threads:read", PACKET_DISABLE, remote_supported_packet,
4125 PACKET_qXfer_threads },
4126 { "qXfer:traceframe-info:read", PACKET_DISABLE, remote_supported_packet,
4127 PACKET_qXfer_traceframe_info },
4128 { "QPassSignals", PACKET_DISABLE, remote_supported_packet,
4129 PACKET_QPassSignals },
4130 { "QProgramSignals", PACKET_DISABLE, remote_supported_packet,
4131 PACKET_QProgramSignals },
4132 { "QStartNoAckMode", PACKET_DISABLE, remote_supported_packet,
4133 PACKET_QStartNoAckMode },
4134 { "multiprocess", PACKET_DISABLE, remote_supported_packet,
4135 PACKET_multiprocess_feature },
4136 { "QNonStop", PACKET_DISABLE, remote_supported_packet, PACKET_QNonStop },
4137 { "qXfer:siginfo:read", PACKET_DISABLE, remote_supported_packet,
4138 PACKET_qXfer_siginfo_read },
4139 { "qXfer:siginfo:write", PACKET_DISABLE, remote_supported_packet,
4140 PACKET_qXfer_siginfo_write },
4141 { "ConditionalTracepoints", PACKET_DISABLE, remote_supported_packet,
4142 PACKET_ConditionalTracepoints },
4143 { "ConditionalBreakpoints", PACKET_DISABLE, remote_supported_packet,
4144 PACKET_ConditionalBreakpoints },
4145 { "BreakpointCommands", PACKET_DISABLE, remote_supported_packet,
4146 PACKET_BreakpointCommands },
4147 { "FastTracepoints", PACKET_DISABLE, remote_supported_packet,
4148 PACKET_FastTracepoints },
4149 { "StaticTracepoints", PACKET_DISABLE, remote_supported_packet,
4150 PACKET_StaticTracepoints },
4151 {"InstallInTrace", PACKET_DISABLE, remote_supported_packet,
4152 PACKET_InstallInTrace},
4153 { "DisconnectedTracing", PACKET_DISABLE, remote_supported_packet,
4154 PACKET_DisconnectedTracing_feature },
4155 { "ReverseContinue", PACKET_DISABLE, remote_supported_packet,
4157 { "ReverseStep", PACKET_DISABLE, remote_supported_packet,
4159 { "TracepointSource", PACKET_DISABLE, remote_supported_packet,
4160 PACKET_TracepointSource },
4161 { "QAllow", PACKET_DISABLE, remote_supported_packet,
4163 { "EnableDisableTracepoints", PACKET_DISABLE, remote_supported_packet,
4164 PACKET_EnableDisableTracepoints_feature },
4165 { "qXfer:fdpic:read", PACKET_DISABLE, remote_supported_packet,
4166 PACKET_qXfer_fdpic },
4167 { "qXfer:uib:read", PACKET_DISABLE, remote_supported_packet,
4169 { "QDisableRandomization", PACKET_DISABLE, remote_supported_packet,
4170 PACKET_QDisableRandomization },
4171 { "QAgent", PACKET_DISABLE, remote_supported_packet, PACKET_QAgent},
4172 { "QTBuffer:size", PACKET_DISABLE,
4173 remote_supported_packet, PACKET_QTBuffer_size},
4174 { "tracenz", PACKET_DISABLE, remote_supported_packet, PACKET_tracenz_feature },
4175 { "Qbtrace:off", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_off },
4176 { "Qbtrace:bts", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_bts },
4177 { "Qbtrace:pt", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_pt },
4178 { "qXfer:btrace:read", PACKET_DISABLE, remote_supported_packet,
4179 PACKET_qXfer_btrace },
4180 { "qXfer:btrace-conf:read", PACKET_DISABLE, remote_supported_packet,
4181 PACKET_qXfer_btrace_conf },
4182 { "Qbtrace-conf:bts:size", PACKET_DISABLE, remote_supported_packet,
4183 PACKET_Qbtrace_conf_bts_size },
4184 { "swbreak", PACKET_DISABLE, remote_supported_packet, PACKET_swbreak_feature },
4185 { "hwbreak", PACKET_DISABLE, remote_supported_packet, PACKET_hwbreak_feature },
4186 { "fork-events", PACKET_DISABLE, remote_supported_packet,
4187 PACKET_fork_event_feature },
4188 { "vfork-events", PACKET_DISABLE, remote_supported_packet,
4189 PACKET_vfork_event_feature },
4190 { "Qbtrace-conf:pt:size", PACKET_DISABLE, remote_supported_packet,
4191 PACKET_Qbtrace_conf_pt_size }
4194 static char *remote_support_xml;
4196 /* Register string appended to "xmlRegisters=" in qSupported query. */
4199 register_remote_support_xml (const char *xml)
4201 #if defined(HAVE_LIBEXPAT)
4202 if (remote_support_xml == NULL)
4203 remote_support_xml = concat ("xmlRegisters=", xml, (char *) NULL);
4206 char *copy = xstrdup (remote_support_xml + 13);
4207 char *p = strtok (copy, ",");
4211 if (strcmp (p, xml) == 0)
4218 while ((p = strtok (NULL, ",")) != NULL);
4221 remote_support_xml = reconcat (remote_support_xml,
4222 remote_support_xml, ",", xml,
4229 remote_query_supported_append (char *msg, const char *append)
4232 return reconcat (msg, msg, ";", append, (char *) NULL);
4234 return xstrdup (append);
4238 remote_query_supported (void)
4240 struct remote_state *rs = get_remote_state ();
4243 unsigned char seen [ARRAY_SIZE (remote_protocol_features)];
4245 /* The packet support flags are handled differently for this packet
4246 than for most others. We treat an error, a disabled packet, and
4247 an empty response identically: any features which must be reported
4248 to be used will be automatically disabled. An empty buffer
4249 accomplishes this, since that is also the representation for a list
4250 containing no features. */
4253 if (packet_support (PACKET_qSupported) != PACKET_DISABLE)
4256 struct cleanup *old_chain = make_cleanup (free_current_contents, &q);
4258 q = remote_query_supported_append (q, "multiprocess+");
4260 if (packet_set_cmd_state (PACKET_swbreak_feature) != AUTO_BOOLEAN_FALSE)
4261 q = remote_query_supported_append (q, "swbreak+");
4262 if (packet_set_cmd_state (PACKET_hwbreak_feature) != AUTO_BOOLEAN_FALSE)
4263 q = remote_query_supported_append (q, "hwbreak+");
4265 if (remote_support_xml)
4266 q = remote_query_supported_append (q, remote_support_xml);
4268 q = remote_query_supported_append (q, "qRelocInsn+");
4272 if (packet_set_cmd_state (PACKET_fork_event_feature)
4273 != AUTO_BOOLEAN_FALSE)
4274 q = remote_query_supported_append (q, "fork-events+");
4275 if (packet_set_cmd_state (PACKET_vfork_event_feature)
4276 != AUTO_BOOLEAN_FALSE)
4277 q = remote_query_supported_append (q, "vfork-events+");
4280 q = reconcat (q, "qSupported:", q, (char *) NULL);
4283 do_cleanups (old_chain);
4285 getpkt (&rs->buf, &rs->buf_size, 0);
4287 /* If an error occured, warn, but do not return - just reset the
4288 buffer to empty and go on to disable features. */
4289 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported])
4292 warning (_("Remote failure reply: %s"), rs->buf);
4297 memset (seen, 0, sizeof (seen));
4302 enum packet_support is_supported;
4303 char *p, *end, *name_end, *value;
4305 /* First separate out this item from the rest of the packet. If
4306 there's another item after this, we overwrite the separator
4307 (terminated strings are much easier to work with). */
4309 end = strchr (p, ';');
4312 end = p + strlen (p);
4322 warning (_("empty item in \"qSupported\" response"));
4327 name_end = strchr (p, '=');
4330 /* This is a name=value entry. */
4331 is_supported = PACKET_ENABLE;
4332 value = name_end + 1;
4341 is_supported = PACKET_ENABLE;
4345 is_supported = PACKET_DISABLE;
4349 is_supported = PACKET_SUPPORT_UNKNOWN;
4353 warning (_("unrecognized item \"%s\" "
4354 "in \"qSupported\" response"), p);
4360 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
4361 if (strcmp (remote_protocol_features[i].name, p) == 0)
4363 const struct protocol_feature *feature;
4366 feature = &remote_protocol_features[i];
4367 feature->func (feature, is_supported, value);
4372 /* If we increased the packet size, make sure to increase the global
4373 buffer size also. We delay this until after parsing the entire
4374 qSupported packet, because this is the same buffer we were
4376 if (rs->buf_size < rs->explicit_packet_size)
4378 rs->buf_size = rs->explicit_packet_size;
4379 rs->buf = xrealloc (rs->buf, rs->buf_size);
4382 /* Handle the defaults for unmentioned features. */
4383 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
4386 const struct protocol_feature *feature;
4388 feature = &remote_protocol_features[i];
4389 feature->func (feature, feature->default_support, NULL);
4393 /* Remove any of the remote.c targets from target stack. Upper targets depend
4394 on it so remove them first. */
4397 remote_unpush_target (void)
4399 pop_all_targets_above (process_stratum - 1);
4403 remote_open_1 (const char *name, int from_tty,
4404 struct target_ops *target, int extended_p)
4406 struct remote_state *rs = get_remote_state ();
4409 error (_("To open a remote debug connection, you need to specify what\n"
4410 "serial device is attached to the remote system\n"
4411 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
4413 /* See FIXME above. */
4414 if (!target_async_permitted)
4415 wait_forever_enabled_p = 1;
4417 /* If we're connected to a running target, target_preopen will kill it.
4418 Ask this question first, before target_preopen has a chance to kill
4420 if (rs->remote_desc != NULL && !have_inferiors ())
4423 && !query (_("Already connected to a remote target. Disconnect? ")))
4424 error (_("Still connected."));
4427 /* Here the possibly existing remote target gets unpushed. */
4428 target_preopen (from_tty);
4430 /* Make sure we send the passed signals list the next time we resume. */
4431 xfree (rs->last_pass_packet);
4432 rs->last_pass_packet = NULL;
4434 /* Make sure we send the program signals list the next time we
4436 xfree (rs->last_program_signals_packet);
4437 rs->last_program_signals_packet = NULL;
4439 remote_fileio_reset ();
4440 reopen_exec_file ();
4443 rs->remote_desc = remote_serial_open (name);
4444 if (!rs->remote_desc)
4445 perror_with_name (name);
4447 if (baud_rate != -1)
4449 if (serial_setbaudrate (rs->remote_desc, baud_rate))
4451 /* The requested speed could not be set. Error out to
4452 top level after closing remote_desc. Take care to
4453 set remote_desc to NULL to avoid closing remote_desc
4455 serial_close (rs->remote_desc);
4456 rs->remote_desc = NULL;
4457 perror_with_name (name);
4461 serial_setparity (rs->remote_desc, serial_parity);
4462 serial_raw (rs->remote_desc);
4464 /* If there is something sitting in the buffer we might take it as a
4465 response to a command, which would be bad. */
4466 serial_flush_input (rs->remote_desc);
4470 puts_filtered ("Remote debugging using ");
4471 puts_filtered (name);
4472 puts_filtered ("\n");
4474 push_target (target); /* Switch to using remote target now. */
4476 /* Register extra event sources in the event loop. */
4477 remote_async_inferior_event_token
4478 = create_async_event_handler (remote_async_inferior_event_handler,
4480 rs->notif_state = remote_notif_state_allocate ();
4482 /* Reset the target state; these things will be queried either by
4483 remote_query_supported or as they are needed. */
4484 reset_all_packet_configs_support ();
4485 rs->cached_wait_status = 0;
4486 rs->explicit_packet_size = 0;
4488 rs->extended = extended_p;
4489 rs->waiting_for_stop_reply = 0;
4490 rs->ctrlc_pending_p = 0;
4492 rs->general_thread = not_sent_ptid;
4493 rs->continue_thread = not_sent_ptid;
4494 rs->remote_traceframe_number = -1;
4496 /* Probe for ability to use "ThreadInfo" query, as required. */
4497 rs->use_threadinfo_query = 1;
4498 rs->use_threadextra_query = 1;
4500 if (target_async_permitted)
4502 /* With this target we start out by owning the terminal. */
4503 remote_async_terminal_ours_p = 1;
4505 /* FIXME: cagney/1999-09-23: During the initial connection it is
4506 assumed that the target is already ready and able to respond to
4507 requests. Unfortunately remote_start_remote() eventually calls
4508 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
4509 around this. Eventually a mechanism that allows
4510 wait_for_inferior() to expect/get timeouts will be
4512 wait_forever_enabled_p = 0;
4515 /* First delete any symbols previously loaded from shared libraries. */
4516 no_shared_libraries (NULL, 0);
4519 init_thread_list ();
4521 /* Start the remote connection. If error() or QUIT, discard this
4522 target (we'd otherwise be in an inconsistent state) and then
4523 propogate the error on up the exception chain. This ensures that
4524 the caller doesn't stumble along blindly assuming that the
4525 function succeeded. The CLI doesn't have this problem but other
4526 UI's, such as MI do.
4528 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
4529 this function should return an error indication letting the
4530 caller restore the previous state. Unfortunately the command
4531 ``target remote'' is directly wired to this function making that
4532 impossible. On a positive note, the CLI side of this problem has
4533 been fixed - the function set_cmd_context() makes it possible for
4534 all the ``target ....'' commands to share a common callback
4535 function. See cli-dump.c. */
4540 remote_start_remote (from_tty, target, extended_p);
4542 CATCH (ex, RETURN_MASK_ALL)
4544 /* Pop the partially set up target - unless something else did
4545 already before throwing the exception. */
4546 if (rs->remote_desc != NULL)
4547 remote_unpush_target ();
4548 if (target_async_permitted)
4549 wait_forever_enabled_p = 1;
4550 throw_exception (ex);
4555 remote_btrace_reset ();
4557 if (target_async_permitted)
4558 wait_forever_enabled_p = 1;
4561 /* Detach the specified process. */
4564 remote_detach_pid (int pid)
4566 struct remote_state *rs = get_remote_state ();
4568 if (remote_multi_process_p (rs))
4569 xsnprintf (rs->buf, get_remote_packet_size (), "D;%x", pid);
4571 strcpy (rs->buf, "D");
4574 getpkt (&rs->buf, &rs->buf_size, 0);
4576 if (rs->buf[0] == 'O' && rs->buf[1] == 'K')
4578 else if (rs->buf[0] == '\0')
4579 error (_("Remote doesn't know how to detach"));
4581 error (_("Can't detach process."));
4584 /* This detaches a program to which we previously attached, using
4585 inferior_ptid to identify the process. After this is done, GDB
4586 can be used to debug some other program. We better not have left
4587 any breakpoints in the target program or it'll die when it hits
4591 remote_detach_1 (const char *args, int from_tty)
4593 int pid = ptid_get_pid (inferior_ptid);
4594 struct remote_state *rs = get_remote_state ();
4595 struct thread_info *tp = find_thread_ptid (inferior_ptid);
4599 error (_("Argument given to \"detach\" when remotely debugging."));
4601 if (!target_has_execution)
4602 error (_("No process to detach from."));
4606 char *exec_file = get_exec_file (0);
4607 if (exec_file == NULL)
4609 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
4610 target_pid_to_str (pid_to_ptid (pid)));
4611 gdb_flush (gdb_stdout);
4614 /* Tell the remote target to detach. */
4615 remote_detach_pid (pid);
4617 if (from_tty && !rs->extended)
4618 puts_filtered (_("Ending remote debugging.\n"));
4620 /* Check to see if we are detaching a fork parent. Note that if we
4621 are detaching a fork child, tp == NULL. */
4622 is_fork_parent = (tp != NULL
4623 && tp->pending_follow.kind == TARGET_WAITKIND_FORKED);
4625 /* If doing detach-on-fork, we don't mourn, because that will delete
4626 breakpoints that should be available for the followed inferior. */
4627 if (!is_fork_parent)
4628 target_mourn_inferior ();
4631 inferior_ptid = null_ptid;
4632 detach_inferior (pid);
4637 remote_detach (struct target_ops *ops, const char *args, int from_tty)
4639 remote_detach_1 (args, from_tty);
4643 extended_remote_detach (struct target_ops *ops, const char *args, int from_tty)
4645 remote_detach_1 (args, from_tty);
4648 /* Target follow-fork function for remote targets. On entry, and
4649 at return, the current inferior is the fork parent.
4651 Note that although this is currently only used for extended-remote,
4652 it is named remote_follow_fork in anticipation of using it for the
4653 remote target as well. */
4656 remote_follow_fork (struct target_ops *ops, int follow_child,
4659 struct remote_state *rs = get_remote_state ();
4660 enum target_waitkind kind = inferior_thread ()->pending_follow.kind;
4662 if ((kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs))
4663 || (kind == TARGET_WAITKIND_VFORKED && remote_vfork_event_p (rs)))
4665 /* When following the parent and detaching the child, we detach
4666 the child here. For the case of following the child and
4667 detaching the parent, the detach is done in the target-
4668 independent follow fork code in infrun.c. We can't use
4669 target_detach when detaching an unfollowed child because
4670 the client side doesn't know anything about the child. */
4671 if (detach_fork && !follow_child)
4673 /* Detach the fork child. */
4677 child_ptid = inferior_thread ()->pending_follow.value.related_pid;
4678 child_pid = ptid_get_pid (child_ptid);
4680 remote_detach_pid (child_pid);
4681 detach_inferior (child_pid);
4687 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
4690 remote_disconnect (struct target_ops *target, const char *args, int from_tty)
4693 error (_("Argument given to \"disconnect\" when remotely debugging."));
4695 /* Make sure we unpush even the extended remote targets; mourn
4696 won't do it. So call remote_mourn directly instead of
4697 target_mourn_inferior. */
4698 remote_mourn (target);
4701 puts_filtered ("Ending remote debugging.\n");
4704 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
4705 be chatty about it. */
4708 extended_remote_attach (struct target_ops *target, const char *args,
4711 struct remote_state *rs = get_remote_state ();
4713 char *wait_status = NULL;
4715 pid = parse_pid_to_attach (args);
4717 /* Remote PID can be freely equal to getpid, do not check it here the same
4718 way as in other targets. */
4720 if (packet_support (PACKET_vAttach) == PACKET_DISABLE)
4721 error (_("This target does not support attaching to a process"));
4725 char *exec_file = get_exec_file (0);
4728 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
4729 target_pid_to_str (pid_to_ptid (pid)));
4731 printf_unfiltered (_("Attaching to %s\n"),
4732 target_pid_to_str (pid_to_ptid (pid)));
4734 gdb_flush (gdb_stdout);
4737 xsnprintf (rs->buf, get_remote_packet_size (), "vAttach;%x", pid);
4739 getpkt (&rs->buf, &rs->buf_size, 0);
4741 switch (packet_ok (rs->buf,
4742 &remote_protocol_packets[PACKET_vAttach]))
4747 /* Save the reply for later. */
4748 wait_status = alloca (strlen (rs->buf) + 1);
4749 strcpy (wait_status, rs->buf);
4751 else if (strcmp (rs->buf, "OK") != 0)
4752 error (_("Attaching to %s failed with: %s"),
4753 target_pid_to_str (pid_to_ptid (pid)),
4756 case PACKET_UNKNOWN:
4757 error (_("This target does not support attaching to a process"));
4759 error (_("Attaching to %s failed"),
4760 target_pid_to_str (pid_to_ptid (pid)));
4763 set_current_inferior (remote_add_inferior (0, pid, 1, 0));
4765 inferior_ptid = pid_to_ptid (pid);
4769 struct thread_info *thread;
4771 /* Get list of threads. */
4772 remote_update_thread_list (target);
4774 thread = first_thread_of_process (pid);
4776 inferior_ptid = thread->ptid;
4778 inferior_ptid = pid_to_ptid (pid);
4780 /* Invalidate our notion of the remote current thread. */
4781 record_currthread (rs, minus_one_ptid);
4785 /* Now, if we have thread information, update inferior_ptid. */
4786 inferior_ptid = remote_current_thread (inferior_ptid);
4788 /* Add the main thread to the thread list. */
4789 add_thread_silent (inferior_ptid);
4792 /* Next, if the target can specify a description, read it. We do
4793 this before anything involving memory or registers. */
4794 target_find_description ();
4798 /* Use the previously fetched status. */
4799 gdb_assert (wait_status != NULL);
4801 if (target_can_async_p ())
4803 struct notif_event *reply
4804 = remote_notif_parse (¬if_client_stop, wait_status);
4806 push_stop_reply ((struct stop_reply *) reply);
4812 gdb_assert (wait_status != NULL);
4813 strcpy (rs->buf, wait_status);
4814 rs->cached_wait_status = 1;
4818 gdb_assert (wait_status == NULL);
4821 /* Implementation of the to_post_attach method. */
4824 extended_remote_post_attach (struct target_ops *ops, int pid)
4826 /* In certain cases GDB might not have had the chance to start
4827 symbol lookup up until now. This could happen if the debugged
4828 binary is not using shared libraries, the vsyscall page is not
4829 present (on Linux) and the binary itself hadn't changed since the
4830 debugging process was started. */
4831 if (symfile_objfile != NULL)
4832 remote_check_symbols();
4836 /* Check for the availability of vCont. This function should also check
4840 remote_vcont_probe (struct remote_state *rs)
4844 strcpy (rs->buf, "vCont?");
4846 getpkt (&rs->buf, &rs->buf_size, 0);
4849 /* Make sure that the features we assume are supported. */
4850 if (startswith (buf, "vCont"))
4853 int support_s, support_S, support_c, support_C;
4859 rs->supports_vCont.t = 0;
4860 rs->supports_vCont.r = 0;
4861 while (p && *p == ';')
4864 if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0))
4866 else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0))
4868 else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0))
4870 else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0))
4872 else if (*p == 't' && (*(p + 1) == ';' || *(p + 1) == 0))
4873 rs->supports_vCont.t = 1;
4874 else if (*p == 'r' && (*(p + 1) == ';' || *(p + 1) == 0))
4875 rs->supports_vCont.r = 1;
4877 p = strchr (p, ';');
4880 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
4881 BUF will make packet_ok disable the packet. */
4882 if (!support_s || !support_S || !support_c || !support_C)
4886 packet_ok (buf, &remote_protocol_packets[PACKET_vCont]);
4889 /* Helper function for building "vCont" resumptions. Write a
4890 resumption to P. ENDP points to one-passed-the-end of the buffer
4891 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
4892 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
4893 resumed thread should be single-stepped and/or signalled. If PTID
4894 equals minus_one_ptid, then all threads are resumed; if PTID
4895 represents a process, then all threads of the process are resumed;
4896 the thread to be stepped and/or signalled is given in the global
4900 append_resumption (char *p, char *endp,
4901 ptid_t ptid, int step, enum gdb_signal siggnal)
4903 struct remote_state *rs = get_remote_state ();
4905 if (step && siggnal != GDB_SIGNAL_0)
4906 p += xsnprintf (p, endp - p, ";S%02x", siggnal);
4908 /* GDB is willing to range step. */
4909 && use_range_stepping
4910 /* Target supports range stepping. */
4911 && rs->supports_vCont.r
4912 /* We don't currently support range stepping multiple
4913 threads with a wildcard (though the protocol allows it,
4914 so stubs shouldn't make an active effort to forbid
4916 && !(remote_multi_process_p (rs) && ptid_is_pid (ptid)))
4918 struct thread_info *tp;
4920 if (ptid_equal (ptid, minus_one_ptid))
4922 /* If we don't know about the target thread's tid, then
4923 we're resuming magic_null_ptid (see caller). */
4924 tp = find_thread_ptid (magic_null_ptid);
4927 tp = find_thread_ptid (ptid);
4928 gdb_assert (tp != NULL);
4930 if (tp->control.may_range_step)
4932 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
4934 p += xsnprintf (p, endp - p, ";r%s,%s",
4935 phex_nz (tp->control.step_range_start,
4937 phex_nz (tp->control.step_range_end,
4941 p += xsnprintf (p, endp - p, ";s");
4944 p += xsnprintf (p, endp - p, ";s");
4945 else if (siggnal != GDB_SIGNAL_0)
4946 p += xsnprintf (p, endp - p, ";C%02x", siggnal);
4948 p += xsnprintf (p, endp - p, ";c");
4950 if (remote_multi_process_p (rs) && ptid_is_pid (ptid))
4954 /* All (-1) threads of process. */
4955 nptid = ptid_build (ptid_get_pid (ptid), -1, 0);
4957 p += xsnprintf (p, endp - p, ":");
4958 p = write_ptid (p, endp, nptid);
4960 else if (!ptid_equal (ptid, minus_one_ptid))
4962 p += xsnprintf (p, endp - p, ":");
4963 p = write_ptid (p, endp, ptid);
4969 /* Append a vCont continue-with-signal action for threads that have a
4970 non-zero stop signal. */
4973 append_pending_thread_resumptions (char *p, char *endp, ptid_t ptid)
4975 struct thread_info *thread;
4977 ALL_NON_EXITED_THREADS (thread)
4978 if (ptid_match (thread->ptid, ptid)
4979 && !ptid_equal (inferior_ptid, thread->ptid)
4980 && thread->suspend.stop_signal != GDB_SIGNAL_0)
4982 p = append_resumption (p, endp, thread->ptid,
4983 0, thread->suspend.stop_signal);
4984 thread->suspend.stop_signal = GDB_SIGNAL_0;
4990 /* Resume the remote inferior by using a "vCont" packet. The thread
4991 to be resumed is PTID; STEP and SIGGNAL indicate whether the
4992 resumed thread should be single-stepped and/or signalled. If PTID
4993 equals minus_one_ptid, then all threads are resumed; the thread to
4994 be stepped and/or signalled is given in the global INFERIOR_PTID.
4995 This function returns non-zero iff it resumes the inferior.
4997 This function issues a strict subset of all possible vCont commands at the
5001 remote_vcont_resume (ptid_t ptid, int step, enum gdb_signal siggnal)
5003 struct remote_state *rs = get_remote_state ();
5007 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
5008 remote_vcont_probe (rs);
5010 if (packet_support (PACKET_vCont) == PACKET_DISABLE)
5014 endp = rs->buf + get_remote_packet_size ();
5016 /* If we could generate a wider range of packets, we'd have to worry
5017 about overflowing BUF. Should there be a generic
5018 "multi-part-packet" packet? */
5020 p += xsnprintf (p, endp - p, "vCont");
5022 if (ptid_equal (ptid, magic_null_ptid))
5024 /* MAGIC_NULL_PTID means that we don't have any active threads,
5025 so we don't have any TID numbers the inferior will
5026 understand. Make sure to only send forms that do not specify
5028 append_resumption (p, endp, minus_one_ptid, step, siggnal);
5030 else if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
5032 /* Resume all threads (of all processes, or of a single
5033 process), with preference for INFERIOR_PTID. This assumes
5034 inferior_ptid belongs to the set of all threads we are about
5036 if (step || siggnal != GDB_SIGNAL_0)
5038 /* Step inferior_ptid, with or without signal. */
5039 p = append_resumption (p, endp, inferior_ptid, step, siggnal);
5042 /* Also pass down any pending signaled resumption for other
5043 threads not the current. */
5044 p = append_pending_thread_resumptions (p, endp, ptid);
5046 /* And continue others without a signal. */
5047 append_resumption (p, endp, ptid, /*step=*/ 0, GDB_SIGNAL_0);
5051 /* Scheduler locking; resume only PTID. */
5052 append_resumption (p, endp, ptid, step, siggnal);
5055 gdb_assert (strlen (rs->buf) < get_remote_packet_size ());
5060 /* In non-stop, the stub replies to vCont with "OK". The stop
5061 reply will be reported asynchronously by means of a `%Stop'
5063 getpkt (&rs->buf, &rs->buf_size, 0);
5064 if (strcmp (rs->buf, "OK") != 0)
5065 error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf);
5071 /* Tell the remote machine to resume. */
5074 remote_resume (struct target_ops *ops,
5075 ptid_t ptid, int step, enum gdb_signal siggnal)
5077 struct remote_state *rs = get_remote_state ();
5080 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
5081 (explained in remote-notif.c:handle_notification) so
5082 remote_notif_process is not called. We need find a place where
5083 it is safe to start a 'vNotif' sequence. It is good to do it
5084 before resuming inferior, because inferior was stopped and no RSP
5085 traffic at that moment. */
5087 remote_notif_process (rs->notif_state, ¬if_client_stop);
5089 rs->last_sent_signal = siggnal;
5090 rs->last_sent_step = step;
5092 /* The vCont packet doesn't need to specify threads via Hc. */
5093 /* No reverse support (yet) for vCont. */
5094 if (execution_direction != EXEC_REVERSE)
5095 if (remote_vcont_resume (ptid, step, siggnal))
5098 /* All other supported resume packets do use Hc, so set the continue
5100 if (ptid_equal (ptid, minus_one_ptid))
5101 set_continue_thread (any_thread_ptid);
5103 set_continue_thread (ptid);
5106 if (execution_direction == EXEC_REVERSE)
5108 /* We don't pass signals to the target in reverse exec mode. */
5109 if (info_verbose && siggnal != GDB_SIGNAL_0)
5110 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
5113 if (step && packet_support (PACKET_bs) == PACKET_DISABLE)
5114 error (_("Remote reverse-step not supported."));
5115 if (!step && packet_support (PACKET_bc) == PACKET_DISABLE)
5116 error (_("Remote reverse-continue not supported."));
5118 strcpy (buf, step ? "bs" : "bc");
5120 else if (siggnal != GDB_SIGNAL_0)
5122 buf[0] = step ? 'S' : 'C';
5123 buf[1] = tohex (((int) siggnal >> 4) & 0xf);
5124 buf[2] = tohex (((int) siggnal) & 0xf);
5128 strcpy (buf, step ? "s" : "c");
5133 /* We are about to start executing the inferior, let's register it
5134 with the event loop. NOTE: this is the one place where all the
5135 execution commands end up. We could alternatively do this in each
5136 of the execution commands in infcmd.c. */
5137 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
5138 into infcmd.c in order to allow inferior function calls to work
5139 NOT asynchronously. */
5140 if (target_can_async_p ())
5143 /* We've just told the target to resume. The remote server will
5144 wait for the inferior to stop, and then send a stop reply. In
5145 the mean time, we can't start another command/query ourselves
5146 because the stub wouldn't be ready to process it. This applies
5147 only to the base all-stop protocol, however. In non-stop (which
5148 only supports vCont), the stub replies with an "OK", and is
5149 immediate able to process further serial input. */
5151 rs->waiting_for_stop_reply = 1;
5155 /* Set up the signal handler for SIGINT, while the target is
5156 executing, ovewriting the 'regular' SIGINT signal handler. */
5158 async_initialize_sigint_signal_handler (void)
5160 signal (SIGINT, async_handle_remote_sigint);
5163 /* Signal handler for SIGINT, while the target is executing. */
5165 async_handle_remote_sigint (int sig)
5167 signal (sig, async_handle_remote_sigint_twice);
5168 /* Note we need to go through gdb_call_async_signal_handler in order
5169 to wake up the event loop on Windows. */
5170 gdb_call_async_signal_handler (async_sigint_remote_token, 0);
5173 /* Signal handler for SIGINT, installed after SIGINT has already been
5174 sent once. It will take effect the second time that the user sends
5177 async_handle_remote_sigint_twice (int sig)
5179 signal (sig, async_handle_remote_sigint);
5180 /* See note in async_handle_remote_sigint. */
5181 gdb_call_async_signal_handler (async_sigint_remote_twice_token, 0);
5184 /* Perform the real interruption of the target execution, in response
5187 async_remote_interrupt (gdb_client_data arg)
5190 fprintf_unfiltered (gdb_stdlog, "async_remote_interrupt called\n");
5192 target_stop (inferior_ptid);
5195 /* Perform interrupt, if the first attempt did not succeed. Just give
5196 up on the target alltogether. */
5198 async_remote_interrupt_twice (gdb_client_data arg)
5201 fprintf_unfiltered (gdb_stdlog, "async_remote_interrupt_twice called\n");
5206 /* Reinstall the usual SIGINT handlers, after the target has
5209 async_cleanup_sigint_signal_handler (void *dummy)
5211 signal (SIGINT, handle_sigint);
5214 /* Send ^C to target to halt it. Target will respond, and send us a
5216 static void (*ofunc) (int);
5218 /* The command line interface's interrupt routine. This function is installed
5219 as a signal handler for SIGINT. The first time a user requests an
5220 interrupt, we call remote_interrupt to send a break or ^C. If there is no
5221 response from the target (it didn't stop when the user requested it),
5222 we ask the user if he'd like to detach from the target. */
5225 sync_remote_interrupt (int signo)
5227 /* If this doesn't work, try more severe steps. */
5228 signal (signo, sync_remote_interrupt_twice);
5230 gdb_call_async_signal_handler (async_sigint_remote_token, 1);
5233 /* The user typed ^C twice. */
5236 sync_remote_interrupt_twice (int signo)
5238 signal (signo, ofunc);
5239 gdb_call_async_signal_handler (async_sigint_remote_twice_token, 1);
5240 signal (signo, sync_remote_interrupt);
5243 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
5244 thread, all threads of a remote process, or all threads of all
5248 remote_stop_ns (ptid_t ptid)
5250 struct remote_state *rs = get_remote_state ();
5252 char *endp = rs->buf + get_remote_packet_size ();
5254 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
5255 remote_vcont_probe (rs);
5257 if (!rs->supports_vCont.t)
5258 error (_("Remote server does not support stopping threads"));
5260 if (ptid_equal (ptid, minus_one_ptid)
5261 || (!remote_multi_process_p (rs) && ptid_is_pid (ptid)))
5262 p += xsnprintf (p, endp - p, "vCont;t");
5267 p += xsnprintf (p, endp - p, "vCont;t:");
5269 if (ptid_is_pid (ptid))
5270 /* All (-1) threads of process. */
5271 nptid = ptid_build (ptid_get_pid (ptid), -1, 0);
5274 /* Small optimization: if we already have a stop reply for
5275 this thread, no use in telling the stub we want this
5277 if (peek_stop_reply (ptid))
5283 write_ptid (p, endp, nptid);
5286 /* In non-stop, we get an immediate OK reply. The stop reply will
5287 come in asynchronously by notification. */
5289 getpkt (&rs->buf, &rs->buf_size, 0);
5290 if (strcmp (rs->buf, "OK") != 0)
5291 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid), rs->buf);
5294 /* All-stop version of target_interrupt. Sends a break or a ^C to
5295 interrupt the remote target. It is undefined which thread of which
5296 process reports the interrupt. */
5299 remote_interrupt_as (ptid_t ptid)
5301 struct remote_state *rs = get_remote_state ();
5303 rs->ctrlc_pending_p = 1;
5305 /* If the inferior is stopped already, but the core didn't know
5306 about it yet, just ignore the request. The cached wait status
5307 will be collected in remote_wait. */
5308 if (rs->cached_wait_status)
5311 /* Send interrupt_sequence to remote target. */
5312 send_interrupt_sequence ();
5315 /* Implement the to_stop function for the remote targets. */
5318 remote_stop (struct target_ops *self, ptid_t ptid)
5321 fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
5324 remote_stop_ns (ptid);
5327 /* We don't currently have a way to transparently pause the
5328 remote target in all-stop mode. Interrupt it instead. */
5329 remote_interrupt_as (ptid);
5333 /* Implement the to_interrupt function for the remote targets. */
5336 remote_interrupt (struct target_ops *self, ptid_t ptid)
5339 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
5343 /* We don't currently have a way to ^C the remote target in
5344 non-stop mode. Stop it (with no signal) instead. */
5345 remote_stop_ns (ptid);
5348 remote_interrupt_as (ptid);
5351 /* Ask the user what to do when an interrupt is received. */
5354 interrupt_query (void)
5356 target_terminal_ours ();
5358 if (target_is_async_p ())
5360 signal (SIGINT, handle_sigint);
5365 if (query (_("Interrupted while waiting for the program.\n\
5366 Give up (and stop debugging it)? ")))
5368 remote_unpush_target ();
5373 target_terminal_inferior ();
5376 /* Enable/disable target terminal ownership. Most targets can use
5377 terminal groups to control terminal ownership. Remote targets are
5378 different in that explicit transfer of ownership to/from GDB/target
5382 remote_terminal_inferior (struct target_ops *self)
5384 if (!target_async_permitted)
5385 /* Nothing to do. */
5388 /* FIXME: cagney/1999-09-27: Make calls to target_terminal_*()
5389 idempotent. The event-loop GDB talking to an asynchronous target
5390 with a synchronous command calls this function from both
5391 event-top.c and infrun.c/infcmd.c. Once GDB stops trying to
5392 transfer the terminal to the target when it shouldn't this guard
5394 if (!remote_async_terminal_ours_p)
5396 delete_file_handler (input_fd);
5397 remote_async_terminal_ours_p = 0;
5398 async_initialize_sigint_signal_handler ();
5399 /* NOTE: At this point we could also register our selves as the
5400 recipient of all input. Any characters typed could then be
5401 passed on down to the target. */
5405 remote_terminal_ours (struct target_ops *self)
5407 if (!target_async_permitted)
5408 /* Nothing to do. */
5411 /* See FIXME in remote_terminal_inferior. */
5412 if (remote_async_terminal_ours_p)
5414 async_cleanup_sigint_signal_handler (NULL);
5415 add_file_handler (input_fd, stdin_event_handler, 0);
5416 remote_async_terminal_ours_p = 1;
5420 remote_console_output (char *msg)
5424 for (p = msg; p[0] && p[1]; p += 2)
5427 char c = fromhex (p[0]) * 16 + fromhex (p[1]);
5431 fputs_unfiltered (tb, gdb_stdtarg);
5433 gdb_flush (gdb_stdtarg);
5436 typedef struct cached_reg
5439 gdb_byte data[MAX_REGISTER_SIZE];
5442 DEF_VEC_O(cached_reg_t);
5444 typedef struct stop_reply
5446 struct notif_event base;
5448 /* The identifier of the thread about this event */
5451 /* The remote state this event is associated with. When the remote
5452 connection, represented by a remote_state object, is closed,
5453 all the associated stop_reply events should be released. */
5454 struct remote_state *rs;
5456 struct target_waitstatus ws;
5458 /* Expedited registers. This makes remote debugging a bit more
5459 efficient for those targets that provide critical registers as
5460 part of their normal status mechanism (as another roundtrip to
5461 fetch them is avoided). */
5462 VEC(cached_reg_t) *regcache;
5464 enum target_stop_reason stop_reason;
5466 CORE_ADDR watch_data_address;
5471 DECLARE_QUEUE_P (stop_reply_p);
5472 DEFINE_QUEUE_P (stop_reply_p);
5473 /* The list of already fetched and acknowledged stop events. This
5474 queue is used for notification Stop, and other notifications
5475 don't need queue for their events, because the notification events
5476 of Stop can't be consumed immediately, so that events should be
5477 queued first, and be consumed by remote_wait_{ns,as} one per
5478 time. Other notifications can consume their events immediately,
5479 so queue is not needed for them. */
5480 static QUEUE (stop_reply_p) *stop_reply_queue;
5483 stop_reply_xfree (struct stop_reply *r)
5485 notif_event_xfree ((struct notif_event *) r);
5489 remote_notif_stop_parse (struct notif_client *self, char *buf,
5490 struct notif_event *event)
5492 remote_parse_stop_reply (buf, (struct stop_reply *) event);
5496 remote_notif_stop_ack (struct notif_client *self, char *buf,
5497 struct notif_event *event)
5499 struct stop_reply *stop_reply = (struct stop_reply *) event;
5502 putpkt ((char *) self->ack_command);
5504 if (stop_reply->ws.kind == TARGET_WAITKIND_IGNORE)
5505 /* We got an unknown stop reply. */
5506 error (_("Unknown stop reply"));
5508 push_stop_reply (stop_reply);
5512 remote_notif_stop_can_get_pending_events (struct notif_client *self)
5514 /* We can't get pending events in remote_notif_process for
5515 notification stop, and we have to do this in remote_wait_ns
5516 instead. If we fetch all queued events from stub, remote stub
5517 may exit and we have no chance to process them back in
5519 mark_async_event_handler (remote_async_inferior_event_token);
5524 stop_reply_dtr (struct notif_event *event)
5526 struct stop_reply *r = (struct stop_reply *) event;
5528 VEC_free (cached_reg_t, r->regcache);
5531 static struct notif_event *
5532 remote_notif_stop_alloc_reply (void)
5534 struct notif_event *r
5535 = (struct notif_event *) XNEW (struct stop_reply);
5537 r->dtr = stop_reply_dtr;
5542 /* A client of notification Stop. */
5544 struct notif_client notif_client_stop =
5548 remote_notif_stop_parse,
5549 remote_notif_stop_ack,
5550 remote_notif_stop_can_get_pending_events,
5551 remote_notif_stop_alloc_reply,
5555 /* A parameter to pass data in and out. */
5557 struct queue_iter_param
5560 struct stop_reply *output;
5563 /* Determine if THREAD is a pending fork parent thread. ARG contains
5564 the pid of the process that owns the threads we want to check, or
5565 -1 if we want to check all threads. */
5568 is_pending_fork_parent (struct target_waitstatus *ws, int event_pid,
5571 if (ws->kind == TARGET_WAITKIND_FORKED
5572 || ws->kind == TARGET_WAITKIND_VFORKED)
5574 if (event_pid == -1 || event_pid == ptid_get_pid (thread_ptid))
5581 /* Check whether EVENT is a fork event, and if it is, remove the
5582 fork child from the context list passed in DATA. */
5585 remove_child_of_pending_fork (QUEUE (stop_reply_p) *q,
5586 QUEUE_ITER (stop_reply_p) *iter,
5590 struct queue_iter_param *param = data;
5591 struct threads_listing_context *context = param->input;
5593 if (event->ws.kind == TARGET_WAITKIND_FORKED
5594 || event->ws.kind == TARGET_WAITKIND_VFORKED)
5596 threads_listing_context_remove (&event->ws, context);
5602 /* If CONTEXT contains any fork child threads that have not been
5603 reported yet, remove them from the CONTEXT list. If such a
5604 thread exists it is because we are stopped at a fork catchpoint
5605 and have not yet called follow_fork, which will set up the
5606 host-side data structures for the new process. */
5609 remove_new_fork_children (struct threads_listing_context *context)
5611 struct thread_info * thread;
5613 struct notif_client *notif = ¬if_client_stop;
5614 struct queue_iter_param param;
5616 /* For any threads stopped at a fork event, remove the corresponding
5617 fork child threads from the CONTEXT list. */
5618 ALL_NON_EXITED_THREADS (thread)
5620 struct target_waitstatus *ws = &thread->pending_follow;
5622 if (is_pending_fork_parent (ws, pid, thread->ptid))
5624 threads_listing_context_remove (ws, context);
5628 /* Check for any pending fork events (not reported or processed yet)
5629 in process PID and remove those fork child threads from the
5630 CONTEXT list as well. */
5631 remote_notif_get_pending_events (notif);
5632 param.input = context;
5633 param.output = NULL;
5634 QUEUE_iterate (stop_reply_p, stop_reply_queue,
5635 remove_child_of_pending_fork, ¶m);
5638 /* Remove stop replies in the queue if its pid is equal to the given
5642 remove_stop_reply_for_inferior (QUEUE (stop_reply_p) *q,
5643 QUEUE_ITER (stop_reply_p) *iter,
5647 struct queue_iter_param *param = data;
5648 struct inferior *inf = param->input;
5650 if (ptid_get_pid (event->ptid) == inf->pid)
5652 stop_reply_xfree (event);
5653 QUEUE_remove_elem (stop_reply_p, q, iter);
5659 /* Discard all pending stop replies of inferior INF. */
5662 discard_pending_stop_replies (struct inferior *inf)
5665 struct queue_iter_param param;
5666 struct stop_reply *reply;
5667 struct remote_state *rs = get_remote_state ();
5668 struct remote_notif_state *rns = rs->notif_state;
5670 /* This function can be notified when an inferior exists. When the
5671 target is not remote, the notification state is NULL. */
5672 if (rs->remote_desc == NULL)
5675 reply = (struct stop_reply *) rns->pending_event[notif_client_stop.id];
5677 /* Discard the in-flight notification. */
5678 if (reply != NULL && ptid_get_pid (reply->ptid) == inf->pid)
5680 stop_reply_xfree (reply);
5681 rns->pending_event[notif_client_stop.id] = NULL;
5685 param.output = NULL;
5686 /* Discard the stop replies we have already pulled with
5688 QUEUE_iterate (stop_reply_p, stop_reply_queue,
5689 remove_stop_reply_for_inferior, ¶m);
5692 /* If its remote state is equal to the given remote state,
5693 remove EVENT from the stop reply queue. */
5696 remove_stop_reply_of_remote_state (QUEUE (stop_reply_p) *q,
5697 QUEUE_ITER (stop_reply_p) *iter,
5701 struct queue_iter_param *param = data;
5702 struct remote_state *rs = param->input;
5704 if (event->rs == rs)
5706 stop_reply_xfree (event);
5707 QUEUE_remove_elem (stop_reply_p, q, iter);
5713 /* Discard the stop replies for RS in stop_reply_queue. */
5716 discard_pending_stop_replies_in_queue (struct remote_state *rs)
5718 struct queue_iter_param param;
5721 param.output = NULL;
5722 /* Discard the stop replies we have already pulled with
5724 QUEUE_iterate (stop_reply_p, stop_reply_queue,
5725 remove_stop_reply_of_remote_state, ¶m);
5728 /* A parameter to pass data in and out. */
5731 remote_notif_remove_once_on_match (QUEUE (stop_reply_p) *q,
5732 QUEUE_ITER (stop_reply_p) *iter,
5736 struct queue_iter_param *param = data;
5737 ptid_t *ptid = param->input;
5739 if (ptid_match (event->ptid, *ptid))
5741 param->output = event;
5742 QUEUE_remove_elem (stop_reply_p, q, iter);
5749 /* Remove the first reply in 'stop_reply_queue' which matches
5752 static struct stop_reply *
5753 remote_notif_remove_queued_reply (ptid_t ptid)
5755 struct queue_iter_param param;
5757 param.input = &ptid;
5758 param.output = NULL;
5760 QUEUE_iterate (stop_reply_p, stop_reply_queue,
5761 remote_notif_remove_once_on_match, ¶m);
5763 fprintf_unfiltered (gdb_stdlog,
5764 "notif: discard queued event: 'Stop' in %s\n",
5765 target_pid_to_str (ptid));
5767 return param.output;
5770 /* Look for a queued stop reply belonging to PTID. If one is found,
5771 remove it from the queue, and return it. Returns NULL if none is
5772 found. If there are still queued events left to process, tell the
5773 event loop to get back to target_wait soon. */
5775 static struct stop_reply *
5776 queued_stop_reply (ptid_t ptid)
5778 struct stop_reply *r = remote_notif_remove_queued_reply (ptid);
5780 if (!QUEUE_is_empty (stop_reply_p, stop_reply_queue))
5781 /* There's still at least an event left. */
5782 mark_async_event_handler (remote_async_inferior_event_token);
5787 /* Push a fully parsed stop reply in the stop reply queue. Since we
5788 know that we now have at least one queued event left to pass to the
5789 core side, tell the event loop to get back to target_wait soon. */
5792 push_stop_reply (struct stop_reply *new_event)
5794 QUEUE_enque (stop_reply_p, stop_reply_queue, new_event);
5797 fprintf_unfiltered (gdb_stdlog,
5798 "notif: push 'Stop' %s to queue %d\n",
5799 target_pid_to_str (new_event->ptid),
5800 QUEUE_length (stop_reply_p,
5803 mark_async_event_handler (remote_async_inferior_event_token);
5807 stop_reply_match_ptid_and_ws (QUEUE (stop_reply_p) *q,
5808 QUEUE_ITER (stop_reply_p) *iter,
5809 struct stop_reply *event,
5812 ptid_t *ptid = data;
5814 return !(ptid_equal (*ptid, event->ptid)
5815 && event->ws.kind == TARGET_WAITKIND_STOPPED);
5818 /* Returns true if we have a stop reply for PTID. */
5821 peek_stop_reply (ptid_t ptid)
5823 return !QUEUE_iterate (stop_reply_p, stop_reply_queue,
5824 stop_reply_match_ptid_and_ws, &ptid);
5827 /* Skip PACKET until the next semi-colon (or end of string). */
5830 skip_to_semicolon (char *p)
5832 while (*p != '\0' && *p != ';')
5837 /* Parse the stop reply in BUF. Either the function succeeds, and the
5838 result is stored in EVENT, or throws an error. */
5841 remote_parse_stop_reply (char *buf, struct stop_reply *event)
5843 struct remote_arch_state *rsa = get_remote_arch_state ();
5847 event->ptid = null_ptid;
5848 event->rs = get_remote_state ();
5849 event->ws.kind = TARGET_WAITKIND_IGNORE;
5850 event->ws.value.integer = 0;
5851 event->stop_reason = TARGET_STOPPED_BY_NO_REASON;
5852 event->regcache = NULL;
5857 case 'T': /* Status with PC, SP, FP, ... */
5858 /* Expedited reply, containing Signal, {regno, reg} repeat. */
5859 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
5861 n... = register number
5862 r... = register contents
5865 p = &buf[3]; /* after Txx */
5871 p1 = strchr (p, ':');
5873 error (_("Malformed packet(a) (missing colon): %s\n\
5877 error (_("Malformed packet(a) (missing register number): %s\n\
5881 /* Some "registers" are actually extended stop information.
5882 Note if you're adding a new entry here: GDB 7.9 and
5883 earlier assume that all register "numbers" that start
5884 with an hex digit are real register numbers. Make sure
5885 the server only sends such a packet if it knows the
5886 client understands it. */
5888 if (strncmp (p, "thread", p1 - p) == 0)
5889 event->ptid = read_ptid (++p1, &p);
5890 else if ((strncmp (p, "watch", p1 - p) == 0)
5891 || (strncmp (p, "rwatch", p1 - p) == 0)
5892 || (strncmp (p, "awatch", p1 - p) == 0))
5894 event->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
5895 p = unpack_varlen_hex (++p1, &addr);
5896 event->watch_data_address = (CORE_ADDR) addr;
5898 else if (strncmp (p, "swbreak", p1 - p) == 0)
5900 event->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
5902 /* Make sure the stub doesn't forget to indicate support
5904 if (packet_support (PACKET_swbreak_feature) != PACKET_ENABLE)
5905 error (_("Unexpected swbreak stop reason"));
5907 /* The value part is documented as "must be empty",
5908 though we ignore it, in case we ever decide to make
5909 use of it in a backward compatible way. */
5910 p = skip_to_semicolon (p1 + 1);
5912 else if (strncmp (p, "hwbreak", p1 - p) == 0)
5914 event->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
5916 /* Make sure the stub doesn't forget to indicate support
5918 if (packet_support (PACKET_hwbreak_feature) != PACKET_ENABLE)
5919 error (_("Unexpected hwbreak stop reason"));
5922 p = skip_to_semicolon (p1 + 1);
5924 else if (strncmp (p, "library", p1 - p) == 0)
5926 event->ws.kind = TARGET_WAITKIND_LOADED;
5927 p = skip_to_semicolon (p1 + 1);
5929 else if (strncmp (p, "replaylog", p1 - p) == 0)
5931 event->ws.kind = TARGET_WAITKIND_NO_HISTORY;
5932 /* p1 will indicate "begin" or "end", but it makes
5933 no difference for now, so ignore it. */
5934 p = skip_to_semicolon (p1 + 1);
5936 else if (strncmp (p, "core", p1 - p) == 0)
5940 p = unpack_varlen_hex (++p1, &c);
5943 else if (strncmp (p, "fork", p1 - p) == 0)
5945 event->ws.value.related_pid = read_ptid (++p1, &p);
5946 event->ws.kind = TARGET_WAITKIND_FORKED;
5948 else if (strncmp (p, "vfork", p1 - p) == 0)
5950 event->ws.value.related_pid = read_ptid (++p1, &p);
5951 event->ws.kind = TARGET_WAITKIND_VFORKED;
5953 else if (strncmp (p, "vforkdone", p1 - p) == 0)
5955 event->ws.kind = TARGET_WAITKIND_VFORK_DONE;
5956 p = skip_to_semicolon (p1 + 1);
5963 /* Maybe a real ``P'' register number. */
5964 p_temp = unpack_varlen_hex (p, &pnum);
5965 /* If the first invalid character is the colon, we got a
5966 register number. Otherwise, it's an unknown stop
5970 struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
5971 cached_reg_t cached_reg;
5974 error (_("Remote sent bad register number %s: %s\n\
5976 hex_string (pnum), p, buf);
5978 cached_reg.num = reg->regnum;
5981 fieldsize = hex2bin (p, cached_reg.data,
5982 register_size (target_gdbarch (),
5985 if (fieldsize < register_size (target_gdbarch (),
5987 warning (_("Remote reply is too short: %s"), buf);
5989 VEC_safe_push (cached_reg_t, event->regcache, &cached_reg);
5993 /* Not a number. Silently skip unknown optional
5995 p = skip_to_semicolon (p1 + 1);
6000 error (_("Remote register badly formatted: %s\nhere: %s"),
6005 if (event->ws.kind != TARGET_WAITKIND_IGNORE)
6009 case 'S': /* Old style status, just signal only. */
6013 event->ws.kind = TARGET_WAITKIND_STOPPED;
6014 sig = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
6015 if (GDB_SIGNAL_FIRST <= sig && sig < GDB_SIGNAL_LAST)
6016 event->ws.value.sig = (enum gdb_signal) sig;
6018 event->ws.value.sig = GDB_SIGNAL_UNKNOWN;
6021 case 'W': /* Target exited. */
6028 /* GDB used to accept only 2 hex chars here. Stubs should
6029 only send more if they detect GDB supports multi-process
6031 p = unpack_varlen_hex (&buf[1], &value);
6035 /* The remote process exited. */
6036 event->ws.kind = TARGET_WAITKIND_EXITED;
6037 event->ws.value.integer = value;
6041 /* The remote process exited with a signal. */
6042 event->ws.kind = TARGET_WAITKIND_SIGNALLED;
6043 if (GDB_SIGNAL_FIRST <= value && value < GDB_SIGNAL_LAST)
6044 event->ws.value.sig = (enum gdb_signal) value;
6046 event->ws.value.sig = GDB_SIGNAL_UNKNOWN;
6049 /* If no process is specified, assume inferior_ptid. */
6050 pid = ptid_get_pid (inferior_ptid);
6059 else if (startswith (p, "process:"))
6063 p += sizeof ("process:") - 1;
6064 unpack_varlen_hex (p, &upid);
6068 error (_("unknown stop reply packet: %s"), buf);
6071 error (_("unknown stop reply packet: %s"), buf);
6072 event->ptid = pid_to_ptid (pid);
6077 if (non_stop && ptid_equal (event->ptid, null_ptid))
6078 error (_("No process or thread specified in stop reply: %s"), buf);
6081 /* When the stub wants to tell GDB about a new notification reply, it
6082 sends a notification (%Stop, for example). Those can come it at
6083 any time, hence, we have to make sure that any pending
6084 putpkt/getpkt sequence we're making is finished, before querying
6085 the stub for more events with the corresponding ack command
6086 (vStopped, for example). E.g., if we started a vStopped sequence
6087 immediately upon receiving the notification, something like this
6095 1.6) <-- (registers reply to step #1.3)
6097 Obviously, the reply in step #1.6 would be unexpected to a vStopped
6100 To solve this, whenever we parse a %Stop notification successfully,
6101 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
6102 doing whatever we were doing:
6108 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
6109 2.5) <-- (registers reply to step #2.3)
6111 Eventualy after step #2.5, we return to the event loop, which
6112 notices there's an event on the
6113 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
6114 associated callback --- the function below. At this point, we're
6115 always safe to start a vStopped sequence. :
6118 2.7) <-- T05 thread:2
6124 remote_notif_get_pending_events (struct notif_client *nc)
6126 struct remote_state *rs = get_remote_state ();
6128 if (rs->notif_state->pending_event[nc->id] != NULL)
6131 fprintf_unfiltered (gdb_stdlog,
6132 "notif: process: '%s' ack pending event\n",
6136 nc->ack (nc, rs->buf, rs->notif_state->pending_event[nc->id]);
6137 rs->notif_state->pending_event[nc->id] = NULL;
6141 getpkt (&rs->buf, &rs->buf_size, 0);
6142 if (strcmp (rs->buf, "OK") == 0)
6145 remote_notif_ack (nc, rs->buf);
6151 fprintf_unfiltered (gdb_stdlog,
6152 "notif: process: '%s' no pending reply\n",
6157 /* Called when it is decided that STOP_REPLY holds the info of the
6158 event that is to be returned to the core. This function always
6159 destroys STOP_REPLY. */
6162 process_stop_reply (struct stop_reply *stop_reply,
6163 struct target_waitstatus *status)
6167 *status = stop_reply->ws;
6168 ptid = stop_reply->ptid;
6170 /* If no thread/process was reported by the stub, assume the current
6172 if (ptid_equal (ptid, null_ptid))
6173 ptid = inferior_ptid;
6175 if (status->kind != TARGET_WAITKIND_EXITED
6176 && status->kind != TARGET_WAITKIND_SIGNALLED)
6178 struct remote_state *rs = get_remote_state ();
6180 /* Expedited registers. */
6181 if (stop_reply->regcache)
6183 struct regcache *regcache
6184 = get_thread_arch_regcache (ptid, target_gdbarch ());
6189 VEC_iterate(cached_reg_t, stop_reply->regcache, ix, reg);
6191 regcache_raw_supply (regcache, reg->num, reg->data);
6192 VEC_free (cached_reg_t, stop_reply->regcache);
6195 rs->stop_reason = stop_reply->stop_reason;
6196 rs->remote_watch_data_address = stop_reply->watch_data_address;
6198 remote_notice_new_inferior (ptid, 0);
6199 demand_private_info (ptid)->core = stop_reply->core;
6202 stop_reply_xfree (stop_reply);
6206 /* The non-stop mode version of target_wait. */
6209 remote_wait_ns (ptid_t ptid, struct target_waitstatus *status, int options)
6211 struct remote_state *rs = get_remote_state ();
6212 struct stop_reply *stop_reply;
6216 /* If in non-stop mode, get out of getpkt even if a
6217 notification is received. */
6219 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
6220 0 /* forever */, &is_notif);
6223 if (ret != -1 && !is_notif)
6226 case 'E': /* Error of some sort. */
6227 /* We're out of sync with the target now. Did it continue
6228 or not? We can't tell which thread it was in non-stop,
6229 so just ignore this. */
6230 warning (_("Remote failure reply: %s"), rs->buf);
6232 case 'O': /* Console output. */
6233 remote_console_output (rs->buf + 1);
6236 warning (_("Invalid remote reply: %s"), rs->buf);
6240 /* Acknowledge a pending stop reply that may have arrived in the
6242 if (rs->notif_state->pending_event[notif_client_stop.id] != NULL)
6243 remote_notif_get_pending_events (¬if_client_stop);
6245 /* If indeed we noticed a stop reply, we're done. */
6246 stop_reply = queued_stop_reply (ptid);
6247 if (stop_reply != NULL)
6248 return process_stop_reply (stop_reply, status);
6250 /* Still no event. If we're just polling for an event, then
6251 return to the event loop. */
6252 if (options & TARGET_WNOHANG)
6254 status->kind = TARGET_WAITKIND_IGNORE;
6255 return minus_one_ptid;
6258 /* Otherwise do a blocking wait. */
6259 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
6260 1 /* forever */, &is_notif);
6264 /* Wait until the remote machine stops, then return, storing status in
6265 STATUS just as `wait' would. */
6268 remote_wait_as (ptid_t ptid, struct target_waitstatus *status, int options)
6270 struct remote_state *rs = get_remote_state ();
6271 ptid_t event_ptid = null_ptid;
6273 struct stop_reply *stop_reply;
6277 status->kind = TARGET_WAITKIND_IGNORE;
6278 status->value.integer = 0;
6280 stop_reply = queued_stop_reply (ptid);
6281 if (stop_reply != NULL)
6282 return process_stop_reply (stop_reply, status);
6284 if (rs->cached_wait_status)
6285 /* Use the cached wait status, but only once. */
6286 rs->cached_wait_status = 0;
6291 int forever = ((options & TARGET_WNOHANG) == 0
6292 && wait_forever_enabled_p);
6294 if (!rs->waiting_for_stop_reply)
6296 status->kind = TARGET_WAITKIND_NO_RESUMED;
6297 return minus_one_ptid;
6300 if (!target_is_async_p ())
6302 ofunc = signal (SIGINT, sync_remote_interrupt);
6303 /* If the user hit C-c before this packet, or between packets,
6304 pretend that it was hit right here. */
6305 if (check_quit_flag ())
6308 sync_remote_interrupt (SIGINT);
6312 /* FIXME: cagney/1999-09-27: If we're in async mode we should
6313 _never_ wait for ever -> test on target_is_async_p().
6314 However, before we do that we need to ensure that the caller
6315 knows how to take the target into/out of async mode. */
6316 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
6317 forever, &is_notif);
6319 if (!target_is_async_p ())
6320 signal (SIGINT, ofunc);
6322 /* GDB gets a notification. Return to core as this event is
6324 if (ret != -1 && is_notif)
6325 return minus_one_ptid;
6327 if (ret == -1 && (options & TARGET_WNOHANG) != 0)
6328 return minus_one_ptid;
6333 rs->stop_reason = TARGET_STOPPED_BY_NO_REASON;
6335 /* We got something. */
6336 rs->waiting_for_stop_reply = 0;
6338 /* Assume that the target has acknowledged Ctrl-C unless we receive
6339 an 'F' or 'O' packet. */
6340 if (buf[0] != 'F' && buf[0] != 'O')
6341 rs->ctrlc_pending_p = 0;
6345 case 'E': /* Error of some sort. */
6346 /* We're out of sync with the target now. Did it continue or
6347 not? Not is more likely, so report a stop. */
6348 warning (_("Remote failure reply: %s"), buf);
6349 status->kind = TARGET_WAITKIND_STOPPED;
6350 status->value.sig = GDB_SIGNAL_0;
6352 case 'F': /* File-I/O request. */
6353 remote_fileio_request (buf, rs->ctrlc_pending_p);
6354 rs->ctrlc_pending_p = 0;
6356 case 'T': case 'S': case 'X': case 'W':
6358 struct stop_reply *stop_reply
6359 = (struct stop_reply *) remote_notif_parse (¬if_client_stop,
6362 event_ptid = process_stop_reply (stop_reply, status);
6365 case 'O': /* Console output. */
6366 remote_console_output (buf + 1);
6368 /* The target didn't really stop; keep waiting. */
6369 rs->waiting_for_stop_reply = 1;
6373 if (rs->last_sent_signal != GDB_SIGNAL_0)
6375 /* Zero length reply means that we tried 'S' or 'C' and the
6376 remote system doesn't support it. */
6377 target_terminal_ours_for_output ();
6379 ("Can't send signals to this remote system. %s not sent.\n",
6380 gdb_signal_to_name (rs->last_sent_signal));
6381 rs->last_sent_signal = GDB_SIGNAL_0;
6382 target_terminal_inferior ();
6384 strcpy ((char *) buf, rs->last_sent_step ? "s" : "c");
6385 putpkt ((char *) buf);
6387 /* We just told the target to resume, so a stop reply is in
6389 rs->waiting_for_stop_reply = 1;
6392 /* else fallthrough */
6394 warning (_("Invalid remote reply: %s"), buf);
6396 rs->waiting_for_stop_reply = 1;
6400 if (status->kind == TARGET_WAITKIND_IGNORE)
6402 /* Nothing interesting happened. If we're doing a non-blocking
6403 poll, we're done. Otherwise, go back to waiting. */
6404 if (options & TARGET_WNOHANG)
6405 return minus_one_ptid;
6409 else if (status->kind != TARGET_WAITKIND_EXITED
6410 && status->kind != TARGET_WAITKIND_SIGNALLED)
6412 if (!ptid_equal (event_ptid, null_ptid))
6413 record_currthread (rs, event_ptid);
6415 event_ptid = inferior_ptid;
6418 /* A process exit. Invalidate our notion of current thread. */
6419 record_currthread (rs, minus_one_ptid);
6424 /* Wait until the remote machine stops, then return, storing status in
6425 STATUS just as `wait' would. */
6428 remote_wait (struct target_ops *ops,
6429 ptid_t ptid, struct target_waitstatus *status, int options)
6434 event_ptid = remote_wait_ns (ptid, status, options);
6436 event_ptid = remote_wait_as (ptid, status, options);
6438 if (target_is_async_p ())
6440 /* If there are are events left in the queue tell the event loop
6442 if (!QUEUE_is_empty (stop_reply_p, stop_reply_queue))
6443 mark_async_event_handler (remote_async_inferior_event_token);
6449 /* Fetch a single register using a 'p' packet. */
6452 fetch_register_using_p (struct regcache *regcache, struct packet_reg *reg)
6454 struct remote_state *rs = get_remote_state ();
6456 char regp[MAX_REGISTER_SIZE];
6459 if (packet_support (PACKET_p) == PACKET_DISABLE)
6462 if (reg->pnum == -1)
6467 p += hexnumstr (p, reg->pnum);
6470 getpkt (&rs->buf, &rs->buf_size, 0);
6474 switch (packet_ok (buf, &remote_protocol_packets[PACKET_p]))
6478 case PACKET_UNKNOWN:
6481 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
6482 gdbarch_register_name (get_regcache_arch (regcache),
6487 /* If this register is unfetchable, tell the regcache. */
6490 regcache_raw_supply (regcache, reg->regnum, NULL);
6494 /* Otherwise, parse and supply the value. */
6500 error (_("fetch_register_using_p: early buf termination"));
6502 regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
6505 regcache_raw_supply (regcache, reg->regnum, regp);
6509 /* Fetch the registers included in the target's 'g' packet. */
6512 send_g_packet (void)
6514 struct remote_state *rs = get_remote_state ();
6517 xsnprintf (rs->buf, get_remote_packet_size (), "g");
6518 remote_send (&rs->buf, &rs->buf_size);
6520 /* We can get out of synch in various cases. If the first character
6521 in the buffer is not a hex character, assume that has happened
6522 and try to fetch another packet to read. */
6523 while ((rs->buf[0] < '0' || rs->buf[0] > '9')
6524 && (rs->buf[0] < 'A' || rs->buf[0] > 'F')
6525 && (rs->buf[0] < 'a' || rs->buf[0] > 'f')
6526 && rs->buf[0] != 'x') /* New: unavailable register value. */
6529 fprintf_unfiltered (gdb_stdlog,
6530 "Bad register packet; fetching a new packet\n");
6531 getpkt (&rs->buf, &rs->buf_size, 0);
6534 buf_len = strlen (rs->buf);
6536 /* Sanity check the received packet. */
6537 if (buf_len % 2 != 0)
6538 error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf);
6544 process_g_packet (struct regcache *regcache)
6546 struct gdbarch *gdbarch = get_regcache_arch (regcache);
6547 struct remote_state *rs = get_remote_state ();
6548 struct remote_arch_state *rsa = get_remote_arch_state ();
6553 buf_len = strlen (rs->buf);
6555 /* Further sanity checks, with knowledge of the architecture. */
6556 if (buf_len > 2 * rsa->sizeof_g_packet)
6557 error (_("Remote 'g' packet reply is too long: %s"), rs->buf);
6559 /* Save the size of the packet sent to us by the target. It is used
6560 as a heuristic when determining the max size of packets that the
6561 target can safely receive. */
6562 if (rsa->actual_register_packet_size == 0)
6563 rsa->actual_register_packet_size = buf_len;
6565 /* If this is smaller than we guessed the 'g' packet would be,
6566 update our records. A 'g' reply that doesn't include a register's
6567 value implies either that the register is not available, or that
6568 the 'p' packet must be used. */
6569 if (buf_len < 2 * rsa->sizeof_g_packet)
6571 rsa->sizeof_g_packet = buf_len / 2;
6573 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
6575 if (rsa->regs[i].pnum == -1)
6578 if (rsa->regs[i].offset >= rsa->sizeof_g_packet)
6579 rsa->regs[i].in_g_packet = 0;
6581 rsa->regs[i].in_g_packet = 1;
6585 regs = alloca (rsa->sizeof_g_packet);
6587 /* Unimplemented registers read as all bits zero. */
6588 memset (regs, 0, rsa->sizeof_g_packet);
6590 /* Reply describes registers byte by byte, each byte encoded as two
6591 hex characters. Suck them all up, then supply them to the
6592 register cacheing/storage mechanism. */
6595 for (i = 0; i < rsa->sizeof_g_packet; i++)
6597 if (p[0] == 0 || p[1] == 0)
6598 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
6599 internal_error (__FILE__, __LINE__,
6600 _("unexpected end of 'g' packet reply"));
6602 if (p[0] == 'x' && p[1] == 'x')
6603 regs[i] = 0; /* 'x' */
6605 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
6609 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
6611 struct packet_reg *r = &rsa->regs[i];
6615 if (r->offset * 2 >= strlen (rs->buf))
6616 /* This shouldn't happen - we adjusted in_g_packet above. */
6617 internal_error (__FILE__, __LINE__,
6618 _("unexpected end of 'g' packet reply"));
6619 else if (rs->buf[r->offset * 2] == 'x')
6621 gdb_assert (r->offset * 2 < strlen (rs->buf));
6622 /* The register isn't available, mark it as such (at
6623 the same time setting the value to zero). */
6624 regcache_raw_supply (regcache, r->regnum, NULL);
6627 regcache_raw_supply (regcache, r->regnum,
6634 fetch_registers_using_g (struct regcache *regcache)
6637 process_g_packet (regcache);
6640 /* Make the remote selected traceframe match GDB's selected
6644 set_remote_traceframe (void)
6647 struct remote_state *rs = get_remote_state ();
6649 if (rs->remote_traceframe_number == get_traceframe_number ())
6652 /* Avoid recursion, remote_trace_find calls us again. */
6653 rs->remote_traceframe_number = get_traceframe_number ();
6655 newnum = target_trace_find (tfind_number,
6656 get_traceframe_number (), 0, 0, NULL);
6658 /* Should not happen. If it does, all bets are off. */
6659 if (newnum != get_traceframe_number ())
6660 warning (_("could not set remote traceframe"));
6664 remote_fetch_registers (struct target_ops *ops,
6665 struct regcache *regcache, int regnum)
6667 struct remote_arch_state *rsa = get_remote_arch_state ();
6670 set_remote_traceframe ();
6671 set_general_thread (inferior_ptid);
6675 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
6677 gdb_assert (reg != NULL);
6679 /* If this register might be in the 'g' packet, try that first -
6680 we are likely to read more than one register. If this is the
6681 first 'g' packet, we might be overly optimistic about its
6682 contents, so fall back to 'p'. */
6683 if (reg->in_g_packet)
6685 fetch_registers_using_g (regcache);
6686 if (reg->in_g_packet)
6690 if (fetch_register_using_p (regcache, reg))
6693 /* This register is not available. */
6694 regcache_raw_supply (regcache, reg->regnum, NULL);
6699 fetch_registers_using_g (regcache);
6701 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
6702 if (!rsa->regs[i].in_g_packet)
6703 if (!fetch_register_using_p (regcache, &rsa->regs[i]))
6705 /* This register is not available. */
6706 regcache_raw_supply (regcache, i, NULL);
6710 /* Prepare to store registers. Since we may send them all (using a
6711 'G' request), we have to read out the ones we don't want to change
6715 remote_prepare_to_store (struct target_ops *self, struct regcache *regcache)
6717 struct remote_arch_state *rsa = get_remote_arch_state ();
6719 gdb_byte buf[MAX_REGISTER_SIZE];
6721 /* Make sure the entire registers array is valid. */
6722 switch (packet_support (PACKET_P))
6724 case PACKET_DISABLE:
6725 case PACKET_SUPPORT_UNKNOWN:
6726 /* Make sure all the necessary registers are cached. */
6727 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
6728 if (rsa->regs[i].in_g_packet)
6729 regcache_raw_read (regcache, rsa->regs[i].regnum, buf);
6736 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
6737 packet was not recognized. */
6740 store_register_using_P (const struct regcache *regcache,
6741 struct packet_reg *reg)
6743 struct gdbarch *gdbarch = get_regcache_arch (regcache);
6744 struct remote_state *rs = get_remote_state ();
6745 /* Try storing a single register. */
6746 char *buf = rs->buf;
6747 gdb_byte regp[MAX_REGISTER_SIZE];
6750 if (packet_support (PACKET_P) == PACKET_DISABLE)
6753 if (reg->pnum == -1)
6756 xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0));
6757 p = buf + strlen (buf);
6758 regcache_raw_collect (regcache, reg->regnum, regp);
6759 bin2hex (regp, p, register_size (gdbarch, reg->regnum));
6761 getpkt (&rs->buf, &rs->buf_size, 0);
6763 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P]))
6768 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
6769 gdbarch_register_name (gdbarch, reg->regnum), rs->buf);
6770 case PACKET_UNKNOWN:
6773 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
6777 /* Store register REGNUM, or all registers if REGNUM == -1, from the
6778 contents of the register cache buffer. FIXME: ignores errors. */
6781 store_registers_using_G (const struct regcache *regcache)
6783 struct remote_state *rs = get_remote_state ();
6784 struct remote_arch_state *rsa = get_remote_arch_state ();
6788 /* Extract all the registers in the regcache copying them into a
6793 regs = alloca (rsa->sizeof_g_packet);
6794 memset (regs, 0, rsa->sizeof_g_packet);
6795 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
6797 struct packet_reg *r = &rsa->regs[i];
6800 regcache_raw_collect (regcache, r->regnum, regs + r->offset);
6804 /* Command describes registers byte by byte,
6805 each byte encoded as two hex characters. */
6808 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
6810 bin2hex (regs, p, rsa->sizeof_g_packet);
6812 getpkt (&rs->buf, &rs->buf_size, 0);
6813 if (packet_check_result (rs->buf) == PACKET_ERROR)
6814 error (_("Could not write registers; remote failure reply '%s'"),
6818 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
6819 of the register cache buffer. FIXME: ignores errors. */
6822 remote_store_registers (struct target_ops *ops,
6823 struct regcache *regcache, int regnum)
6825 struct remote_arch_state *rsa = get_remote_arch_state ();
6828 set_remote_traceframe ();
6829 set_general_thread (inferior_ptid);
6833 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
6835 gdb_assert (reg != NULL);
6837 /* Always prefer to store registers using the 'P' packet if
6838 possible; we often change only a small number of registers.
6839 Sometimes we change a larger number; we'd need help from a
6840 higher layer to know to use 'G'. */
6841 if (store_register_using_P (regcache, reg))
6844 /* For now, don't complain if we have no way to write the
6845 register. GDB loses track of unavailable registers too
6846 easily. Some day, this may be an error. We don't have
6847 any way to read the register, either... */
6848 if (!reg->in_g_packet)
6851 store_registers_using_G (regcache);
6855 store_registers_using_G (regcache);
6857 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
6858 if (!rsa->regs[i].in_g_packet)
6859 if (!store_register_using_P (regcache, &rsa->regs[i]))
6860 /* See above for why we do not issue an error here. */
6865 /* Return the number of hex digits in num. */
6868 hexnumlen (ULONGEST num)
6872 for (i = 0; num != 0; i++)
6878 /* Set BUF to the minimum number of hex digits representing NUM. */
6881 hexnumstr (char *buf, ULONGEST num)
6883 int len = hexnumlen (num);
6885 return hexnumnstr (buf, num, len);
6889 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
6892 hexnumnstr (char *buf, ULONGEST num, int width)
6898 for (i = width - 1; i >= 0; i--)
6900 buf[i] = "0123456789abcdef"[(num & 0xf)];
6907 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
6910 remote_address_masked (CORE_ADDR addr)
6912 unsigned int address_size = remote_address_size;
6914 /* If "remoteaddresssize" was not set, default to target address size. */
6916 address_size = gdbarch_addr_bit (target_gdbarch ());
6918 if (address_size > 0
6919 && address_size < (sizeof (ULONGEST) * 8))
6921 /* Only create a mask when that mask can safely be constructed
6922 in a ULONGEST variable. */
6925 mask = (mask << address_size) - 1;
6931 /* Determine whether the remote target supports binary downloading.
6932 This is accomplished by sending a no-op memory write of zero length
6933 to the target at the specified address. It does not suffice to send
6934 the whole packet, since many stubs strip the eighth bit and
6935 subsequently compute a wrong checksum, which causes real havoc with
6938 NOTE: This can still lose if the serial line is not eight-bit
6939 clean. In cases like this, the user should clear "remote
6943 check_binary_download (CORE_ADDR addr)
6945 struct remote_state *rs = get_remote_state ();
6947 switch (packet_support (PACKET_X))
6949 case PACKET_DISABLE:
6953 case PACKET_SUPPORT_UNKNOWN:
6959 p += hexnumstr (p, (ULONGEST) addr);
6961 p += hexnumstr (p, (ULONGEST) 0);
6965 putpkt_binary (rs->buf, (int) (p - rs->buf));
6966 getpkt (&rs->buf, &rs->buf_size, 0);
6968 if (rs->buf[0] == '\0')
6971 fprintf_unfiltered (gdb_stdlog,
6972 "binary downloading NOT "
6973 "supported by target\n");
6974 remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
6979 fprintf_unfiltered (gdb_stdlog,
6980 "binary downloading supported by target\n");
6981 remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
6988 /* Helper function to resize the payload in order to try to get a good
6989 alignment. We try to write an amount of data such that the next write will
6990 start on an address aligned on REMOTE_ALIGN_WRITES. */
6993 align_for_efficient_write (int todo, CORE_ADDR memaddr)
6995 return ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr;
6998 /* Write memory data directly to the remote machine.
6999 This does not inform the data cache; the data cache uses this.
7000 HEADER is the starting part of the packet.
7001 MEMADDR is the address in the remote memory space.
7002 MYADDR is the address of the buffer in our space.
7003 LEN_UNITS is the number of addressable units to write.
7004 UNIT_SIZE is the length in bytes of an addressable unit.
7005 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
7006 should send data as binary ('X'), or hex-encoded ('M').
7008 The function creates packet of the form
7009 <HEADER><ADDRESS>,<LENGTH>:<DATA>
7011 where encoding of <DATA> is terminated by PACKET_FORMAT.
7013 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
7016 Return the transferred status, error or OK (an
7017 'enum target_xfer_status' value). Save the number of addressable units
7018 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
7020 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
7021 exchange between gdb and the stub could look like (?? in place of the
7027 -> $M1000,3:eeeeffffeeee#??
7031 <- eeeeffffeeeedddd */
7033 static enum target_xfer_status
7034 remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
7035 const gdb_byte *myaddr, ULONGEST len_units,
7036 int unit_size, ULONGEST *xfered_len_units,
7037 char packet_format, int use_length)
7039 struct remote_state *rs = get_remote_state ();
7045 int payload_capacity_bytes;
7046 int payload_length_bytes;
7048 if (packet_format != 'X' && packet_format != 'M')
7049 internal_error (__FILE__, __LINE__,
7050 _("remote_write_bytes_aux: bad packet format"));
7053 return TARGET_XFER_EOF;
7055 payload_capacity_bytes = get_memory_write_packet_size ();
7057 /* The packet buffer will be large enough for the payload;
7058 get_memory_packet_size ensures this. */
7061 /* Compute the size of the actual payload by subtracting out the
7062 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
7064 payload_capacity_bytes -= strlen ("$,:#NN");
7066 /* The comma won't be used. */
7067 payload_capacity_bytes += 1;
7068 payload_capacity_bytes -= strlen (header);
7069 payload_capacity_bytes -= hexnumlen (memaddr);
7071 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
7073 strcat (rs->buf, header);
7074 p = rs->buf + strlen (header);
7076 /* Compute a best guess of the number of bytes actually transfered. */
7077 if (packet_format == 'X')
7079 /* Best guess at number of bytes that will fit. */
7080 todo_units = min (len_units, payload_capacity_bytes / unit_size);
7082 payload_capacity_bytes -= hexnumlen (todo_units);
7083 todo_units = min (todo_units, payload_capacity_bytes / unit_size);
7087 /* Number of bytes that will fit. */
7088 todo_units = min (len_units, (payload_capacity_bytes / unit_size) / 2);
7090 payload_capacity_bytes -= hexnumlen (todo_units);
7091 todo_units = min (todo_units, (payload_capacity_bytes / unit_size) / 2);
7094 if (todo_units <= 0)
7095 internal_error (__FILE__, __LINE__,
7096 _("minimum packet size too small to write data"));
7098 /* If we already need another packet, then try to align the end
7099 of this packet to a useful boundary. */
7100 if (todo_units > 2 * REMOTE_ALIGN_WRITES && todo_units < len_units)
7101 todo_units = align_for_efficient_write (todo_units, memaddr);
7103 /* Append "<memaddr>". */
7104 memaddr = remote_address_masked (memaddr);
7105 p += hexnumstr (p, (ULONGEST) memaddr);
7112 /* Append the length and retain its location and size. It may need to be
7113 adjusted once the packet body has been created. */
7115 plenlen = hexnumstr (p, (ULONGEST) todo_units);
7123 /* Append the packet body. */
7124 if (packet_format == 'X')
7126 /* Binary mode. Send target system values byte by byte, in
7127 increasing byte addresses. Only escape certain critical
7129 payload_length_bytes =
7130 remote_escape_output (myaddr, todo_units, unit_size, (gdb_byte *) p,
7131 &units_written, payload_capacity_bytes);
7133 /* If not all TODO units fit, then we'll need another packet. Make
7134 a second try to keep the end of the packet aligned. Don't do
7135 this if the packet is tiny. */
7136 if (units_written < todo_units && units_written > 2 * REMOTE_ALIGN_WRITES)
7140 new_todo_units = align_for_efficient_write (units_written, memaddr);
7142 if (new_todo_units != units_written)
7143 payload_length_bytes =
7144 remote_escape_output (myaddr, new_todo_units, unit_size,
7145 (gdb_byte *) p, &units_written,
7146 payload_capacity_bytes);
7149 p += payload_length_bytes;
7150 if (use_length && units_written < todo_units)
7152 /* Escape chars have filled up the buffer prematurely,
7153 and we have actually sent fewer units than planned.
7154 Fix-up the length field of the packet. Use the same
7155 number of characters as before. */
7156 plen += hexnumnstr (plen, (ULONGEST) units_written,
7158 *plen = ':'; /* overwrite \0 from hexnumnstr() */
7163 /* Normal mode: Send target system values byte by byte, in
7164 increasing byte addresses. Each byte is encoded as a two hex
7166 p += 2 * bin2hex (myaddr, p, todo_units * unit_size);
7167 units_written = todo_units;
7170 putpkt_binary (rs->buf, (int) (p - rs->buf));
7171 getpkt (&rs->buf, &rs->buf_size, 0);
7173 if (rs->buf[0] == 'E')
7174 return TARGET_XFER_E_IO;
7176 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
7177 send fewer units than we'd planned. */
7178 *xfered_len_units = (ULONGEST) units_written;
7179 return TARGET_XFER_OK;
7182 /* Write memory data directly to the remote machine.
7183 This does not inform the data cache; the data cache uses this.
7184 MEMADDR is the address in the remote memory space.
7185 MYADDR is the address of the buffer in our space.
7186 LEN is the number of bytes.
7188 Return the transferred status, error or OK (an
7189 'enum target_xfer_status' value). Save the number of bytes
7190 transferred in *XFERED_LEN. Only transfer a single packet. */
7192 static enum target_xfer_status
7193 remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, ULONGEST len,
7194 int unit_size, ULONGEST *xfered_len)
7196 char *packet_format = 0;
7198 /* Check whether the target supports binary download. */
7199 check_binary_download (memaddr);
7201 switch (packet_support (PACKET_X))
7204 packet_format = "X";
7206 case PACKET_DISABLE:
7207 packet_format = "M";
7209 case PACKET_SUPPORT_UNKNOWN:
7210 internal_error (__FILE__, __LINE__,
7211 _("remote_write_bytes: bad internal state"));
7213 internal_error (__FILE__, __LINE__, _("bad switch"));
7216 return remote_write_bytes_aux (packet_format,
7217 memaddr, myaddr, len, unit_size, xfered_len,
7218 packet_format[0], 1);
7221 /* Read memory data directly from the remote machine.
7222 This does not use the data cache; the data cache uses this.
7223 MEMADDR is the address in the remote memory space.
7224 MYADDR is the address of the buffer in our space.
7225 LEN_UNITS is the number of addressable memory units to read..
7226 UNIT_SIZE is the length in bytes of an addressable unit.
7228 Return the transferred status, error or OK (an
7229 'enum target_xfer_status' value). Save the number of bytes
7230 transferred in *XFERED_LEN_UNITS.
7232 See the comment of remote_write_bytes_aux for an example of
7233 memory read/write exchange between gdb and the stub. */
7235 static enum target_xfer_status
7236 remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len_units,
7237 int unit_size, ULONGEST *xfered_len_units)
7239 struct remote_state *rs = get_remote_state ();
7240 int buf_size_bytes; /* Max size of packet output buffer. */
7245 buf_size_bytes = get_memory_read_packet_size ();
7246 /* The packet buffer will be large enough for the payload;
7247 get_memory_packet_size ensures this. */
7249 /* Number of units that will fit. */
7250 todo_units = min (len_units, (buf_size_bytes / unit_size) / 2);
7252 /* Construct "m"<memaddr>","<len>". */
7253 memaddr = remote_address_masked (memaddr);
7256 p += hexnumstr (p, (ULONGEST) memaddr);
7258 p += hexnumstr (p, (ULONGEST) todo_units);
7261 getpkt (&rs->buf, &rs->buf_size, 0);
7262 if (rs->buf[0] == 'E'
7263 && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
7264 && rs->buf[3] == '\0')
7265 return TARGET_XFER_E_IO;
7266 /* Reply describes memory byte by byte, each byte encoded as two hex
7269 decoded_bytes = hex2bin (p, myaddr, todo_units * unit_size);
7270 /* Return what we have. Let higher layers handle partial reads. */
7271 *xfered_len_units = (ULONGEST) (decoded_bytes / unit_size);
7272 return TARGET_XFER_OK;
7275 /* Using the set of read-only target sections of remote, read live
7278 For interface/parameters/return description see target.h,
7281 static enum target_xfer_status
7282 remote_xfer_live_readonly_partial (struct target_ops *ops, gdb_byte *readbuf,
7283 ULONGEST memaddr, ULONGEST len,
7284 int unit_size, ULONGEST *xfered_len)
7286 struct target_section *secp;
7287 struct target_section_table *table;
7289 secp = target_section_by_addr (ops, memaddr);
7291 && (bfd_get_section_flags (secp->the_bfd_section->owner,
7292 secp->the_bfd_section)
7295 struct target_section *p;
7296 ULONGEST memend = memaddr + len;
7298 table = target_get_section_table (ops);
7300 for (p = table->sections; p < table->sections_end; p++)
7302 if (memaddr >= p->addr)
7304 if (memend <= p->endaddr)
7306 /* Entire transfer is within this section. */
7307 return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
7310 else if (memaddr >= p->endaddr)
7312 /* This section ends before the transfer starts. */
7317 /* This section overlaps the transfer. Just do half. */
7318 len = p->endaddr - memaddr;
7319 return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
7326 return TARGET_XFER_EOF;
7329 /* Similar to remote_read_bytes_1, but it reads from the remote stub
7330 first if the requested memory is unavailable in traceframe.
7331 Otherwise, fall back to remote_read_bytes_1. */
7333 static enum target_xfer_status
7334 remote_read_bytes (struct target_ops *ops, CORE_ADDR memaddr,
7335 gdb_byte *myaddr, ULONGEST len, int unit_size,
7336 ULONGEST *xfered_len)
7339 return TARGET_XFER_EOF;
7341 if (get_traceframe_number () != -1)
7343 VEC(mem_range_s) *available;
7345 /* If we fail to get the set of available memory, then the
7346 target does not support querying traceframe info, and so we
7347 attempt reading from the traceframe anyway (assuming the
7348 target implements the old QTro packet then). */
7349 if (traceframe_available_memory (&available, memaddr, len))
7351 struct cleanup *old_chain;
7353 old_chain = make_cleanup (VEC_cleanup(mem_range_s), &available);
7355 if (VEC_empty (mem_range_s, available)
7356 || VEC_index (mem_range_s, available, 0)->start != memaddr)
7358 enum target_xfer_status res;
7360 /* Don't read into the traceframe's available
7362 if (!VEC_empty (mem_range_s, available))
7364 LONGEST oldlen = len;
7366 len = VEC_index (mem_range_s, available, 0)->start - memaddr;
7367 gdb_assert (len <= oldlen);
7370 do_cleanups (old_chain);
7372 /* This goes through the topmost target again. */
7373 res = remote_xfer_live_readonly_partial (ops, myaddr, memaddr,
7374 len, unit_size, xfered_len);
7375 if (res == TARGET_XFER_OK)
7376 return TARGET_XFER_OK;
7379 /* No use trying further, we know some memory starting
7380 at MEMADDR isn't available. */
7382 return TARGET_XFER_UNAVAILABLE;
7386 /* Don't try to read more than how much is available, in
7387 case the target implements the deprecated QTro packet to
7388 cater for older GDBs (the target's knowledge of read-only
7389 sections may be outdated by now). */
7390 len = VEC_index (mem_range_s, available, 0)->length;
7392 do_cleanups (old_chain);
7396 return remote_read_bytes_1 (memaddr, myaddr, len, unit_size, xfered_len);
7401 /* Sends a packet with content determined by the printf format string
7402 FORMAT and the remaining arguments, then gets the reply. Returns
7403 whether the packet was a success, a failure, or unknown. */
7405 static enum packet_result remote_send_printf (const char *format, ...)
7406 ATTRIBUTE_PRINTF (1, 2);
7408 static enum packet_result
7409 remote_send_printf (const char *format, ...)
7411 struct remote_state *rs = get_remote_state ();
7412 int max_size = get_remote_packet_size ();
7415 va_start (ap, format);
7418 if (vsnprintf (rs->buf, max_size, format, ap) >= max_size)
7419 internal_error (__FILE__, __LINE__, _("Too long remote packet."));
7421 if (putpkt (rs->buf) < 0)
7422 error (_("Communication problem with target."));
7425 getpkt (&rs->buf, &rs->buf_size, 0);
7427 return packet_check_result (rs->buf);
7431 restore_remote_timeout (void *p)
7433 int value = *(int *)p;
7435 remote_timeout = value;
7438 /* Flash writing can take quite some time. We'll set
7439 effectively infinite timeout for flash operations.
7440 In future, we'll need to decide on a better approach. */
7441 static const int remote_flash_timeout = 1000;
7444 remote_flash_erase (struct target_ops *ops,
7445 ULONGEST address, LONGEST length)
7447 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
7448 int saved_remote_timeout = remote_timeout;
7449 enum packet_result ret;
7450 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
7451 &saved_remote_timeout);
7453 remote_timeout = remote_flash_timeout;
7455 ret = remote_send_printf ("vFlashErase:%s,%s",
7456 phex (address, addr_size),
7460 case PACKET_UNKNOWN:
7461 error (_("Remote target does not support flash erase"));
7463 error (_("Error erasing flash with vFlashErase packet"));
7468 do_cleanups (back_to);
7471 static enum target_xfer_status
7472 remote_flash_write (struct target_ops *ops, ULONGEST address,
7473 ULONGEST length, ULONGEST *xfered_len,
7474 const gdb_byte *data)
7476 int saved_remote_timeout = remote_timeout;
7477 enum target_xfer_status ret;
7478 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
7479 &saved_remote_timeout);
7481 remote_timeout = remote_flash_timeout;
7482 ret = remote_write_bytes_aux ("vFlashWrite:", address, data, length, 1,
7484 do_cleanups (back_to);
7490 remote_flash_done (struct target_ops *ops)
7492 int saved_remote_timeout = remote_timeout;
7494 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
7495 &saved_remote_timeout);
7497 remote_timeout = remote_flash_timeout;
7498 ret = remote_send_printf ("vFlashDone");
7499 do_cleanups (back_to);
7503 case PACKET_UNKNOWN:
7504 error (_("Remote target does not support vFlashDone"));
7506 error (_("Error finishing flash operation"));
7513 remote_files_info (struct target_ops *ignore)
7515 puts_filtered ("Debugging a target over a serial line.\n");
7518 /* Stuff for dealing with the packets which are part of this protocol.
7519 See comment at top of file for details. */
7521 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
7522 error to higher layers. Called when a serial error is detected.
7523 The exception message is STRING, followed by a colon and a blank,
7524 the system error message for errno at function entry and final dot
7525 for output compatibility with throw_perror_with_name. */
7528 unpush_and_perror (const char *string)
7530 int saved_errno = errno;
7532 remote_unpush_target ();
7533 throw_error (TARGET_CLOSE_ERROR, "%s: %s.", string,
7534 safe_strerror (saved_errno));
7537 /* Read a single character from the remote end. */
7540 readchar (int timeout)
7543 struct remote_state *rs = get_remote_state ();
7545 ch = serial_readchar (rs->remote_desc, timeout);
7550 switch ((enum serial_rc) ch)
7553 remote_unpush_target ();
7554 throw_error (TARGET_CLOSE_ERROR, _("Remote connection closed"));
7557 unpush_and_perror (_("Remote communication error. "
7558 "Target disconnected."));
7560 case SERIAL_TIMEOUT:
7566 /* Wrapper for serial_write that closes the target and throws if
7570 remote_serial_write (const char *str, int len)
7572 struct remote_state *rs = get_remote_state ();
7574 if (serial_write (rs->remote_desc, str, len))
7576 unpush_and_perror (_("Remote communication error. "
7577 "Target disconnected."));
7581 /* Send the command in *BUF to the remote machine, and read the reply
7582 into *BUF. Report an error if we get an error reply. Resize
7583 *BUF using xrealloc if necessary to hold the result, and update
7587 remote_send (char **buf,
7591 getpkt (buf, sizeof_buf, 0);
7593 if ((*buf)[0] == 'E')
7594 error (_("Remote failure reply: %s"), *buf);
7597 /* Return a pointer to an xmalloc'ed string representing an escaped
7598 version of BUF, of len N. E.g. \n is converted to \\n, \t to \\t,
7599 etc. The caller is responsible for releasing the returned
7603 escape_buffer (const char *buf, int n)
7605 struct cleanup *old_chain;
7606 struct ui_file *stb;
7609 stb = mem_fileopen ();
7610 old_chain = make_cleanup_ui_file_delete (stb);
7612 fputstrn_unfiltered (buf, n, '\\', stb);
7613 str = ui_file_xstrdup (stb, NULL);
7614 do_cleanups (old_chain);
7618 /* Display a null-terminated packet on stdout, for debugging, using C
7622 print_packet (const char *buf)
7624 puts_filtered ("\"");
7625 fputstr_filtered (buf, '"', gdb_stdout);
7626 puts_filtered ("\"");
7630 putpkt (const char *buf)
7632 return putpkt_binary (buf, strlen (buf));
7635 /* Send a packet to the remote machine, with error checking. The data
7636 of the packet is in BUF. The string in BUF can be at most
7637 get_remote_packet_size () - 5 to account for the $, # and checksum,
7638 and for a possible /0 if we are debugging (remote_debug) and want
7639 to print the sent packet as a string. */
7642 putpkt_binary (const char *buf, int cnt)
7644 struct remote_state *rs = get_remote_state ();
7646 unsigned char csum = 0;
7647 char *buf2 = alloca (cnt + 6);
7654 /* Catch cases like trying to read memory or listing threads while
7655 we're waiting for a stop reply. The remote server wouldn't be
7656 ready to handle this request, so we'd hang and timeout. We don't
7657 have to worry about this in synchronous mode, because in that
7658 case it's not possible to issue a command while the target is
7659 running. This is not a problem in non-stop mode, because in that
7660 case, the stub is always ready to process serial input. */
7661 if (!non_stop && target_is_async_p () && rs->waiting_for_stop_reply)
7663 error (_("Cannot execute this command while the target is running.\n"
7664 "Use the \"interrupt\" command to stop the target\n"
7665 "and then try again."));
7668 /* We're sending out a new packet. Make sure we don't look at a
7669 stale cached response. */
7670 rs->cached_wait_status = 0;
7672 /* Copy the packet into buffer BUF2, encapsulating it
7673 and giving it a checksum. */
7678 for (i = 0; i < cnt; i++)
7684 *p++ = tohex ((csum >> 4) & 0xf);
7685 *p++ = tohex (csum & 0xf);
7687 /* Send it over and over until we get a positive ack. */
7691 int started_error_output = 0;
7695 struct cleanup *old_chain;
7699 str = escape_buffer (buf2, p - buf2);
7700 old_chain = make_cleanup (xfree, str);
7701 fprintf_unfiltered (gdb_stdlog, "Sending packet: %s...", str);
7702 gdb_flush (gdb_stdlog);
7703 do_cleanups (old_chain);
7705 remote_serial_write (buf2, p - buf2);
7707 /* If this is a no acks version of the remote protocol, send the
7708 packet and move on. */
7712 /* Read until either a timeout occurs (-2) or '+' is read.
7713 Handle any notification that arrives in the mean time. */
7716 ch = readchar (remote_timeout);
7724 case SERIAL_TIMEOUT:
7727 if (started_error_output)
7729 putchar_unfiltered ('\n');
7730 started_error_output = 0;
7739 fprintf_unfiltered (gdb_stdlog, "Ack\n");
7743 fprintf_unfiltered (gdb_stdlog, "Nak\n");
7745 case SERIAL_TIMEOUT:
7749 break; /* Retransmit buffer. */
7753 fprintf_unfiltered (gdb_stdlog,
7754 "Packet instead of Ack, ignoring it\n");
7755 /* It's probably an old response sent because an ACK
7756 was lost. Gobble up the packet and ack it so it
7757 doesn't get retransmitted when we resend this
7760 remote_serial_write ("+", 1);
7761 continue; /* Now, go look for +. */
7768 /* If we got a notification, handle it, and go back to looking
7770 /* We've found the start of a notification. Now
7771 collect the data. */
7772 val = read_frame (&rs->buf, &rs->buf_size);
7777 struct cleanup *old_chain;
7780 str = escape_buffer (rs->buf, val);
7781 old_chain = make_cleanup (xfree, str);
7782 fprintf_unfiltered (gdb_stdlog,
7783 " Notification received: %s\n",
7785 do_cleanups (old_chain);
7787 handle_notification (rs->notif_state, rs->buf);
7788 /* We're in sync now, rewait for the ack. */
7795 if (!started_error_output)
7797 started_error_output = 1;
7798 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
7800 fputc_unfiltered (ch & 0177, gdb_stdlog);
7801 fprintf_unfiltered (gdb_stdlog, "%s", rs->buf);
7810 if (!started_error_output)
7812 started_error_output = 1;
7813 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
7815 fputc_unfiltered (ch & 0177, gdb_stdlog);
7819 break; /* Here to retransmit. */
7823 /* This is wrong. If doing a long backtrace, the user should be
7824 able to get out next time we call QUIT, without anything as
7825 violent as interrupt_query. If we want to provide a way out of
7826 here without getting to the next QUIT, it should be based on
7827 hitting ^C twice as in remote_wait. */
7838 /* Come here after finding the start of a frame when we expected an
7839 ack. Do our best to discard the rest of this packet. */
7848 c = readchar (remote_timeout);
7851 case SERIAL_TIMEOUT:
7852 /* Nothing we can do. */
7855 /* Discard the two bytes of checksum and stop. */
7856 c = readchar (remote_timeout);
7858 c = readchar (remote_timeout);
7861 case '*': /* Run length encoding. */
7862 /* Discard the repeat count. */
7863 c = readchar (remote_timeout);
7868 /* A regular character. */
7874 /* Come here after finding the start of the frame. Collect the rest
7875 into *BUF, verifying the checksum, length, and handling run-length
7876 compression. NUL terminate the buffer. If there is not enough room,
7877 expand *BUF using xrealloc.
7879 Returns -1 on error, number of characters in buffer (ignoring the
7880 trailing NULL) on success. (could be extended to return one of the
7881 SERIAL status indications). */
7884 read_frame (char **buf_p,
7891 struct remote_state *rs = get_remote_state ();
7898 c = readchar (remote_timeout);
7901 case SERIAL_TIMEOUT:
7903 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
7907 fputs_filtered ("Saw new packet start in middle of old one\n",
7909 return -1; /* Start a new packet, count retries. */
7912 unsigned char pktcsum;
7918 check_0 = readchar (remote_timeout);
7920 check_1 = readchar (remote_timeout);
7922 if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
7925 fputs_filtered ("Timeout in checksum, retrying\n",
7929 else if (check_0 < 0 || check_1 < 0)
7932 fputs_filtered ("Communication error in checksum\n",
7937 /* Don't recompute the checksum; with no ack packets we
7938 don't have any way to indicate a packet retransmission
7943 pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
7944 if (csum == pktcsum)
7949 struct cleanup *old_chain;
7952 str = escape_buffer (buf, bc);
7953 old_chain = make_cleanup (xfree, str);
7954 fprintf_unfiltered (gdb_stdlog,
7955 "Bad checksum, sentsum=0x%x, "
7956 "csum=0x%x, buf=%s\n",
7957 pktcsum, csum, str);
7958 do_cleanups (old_chain);
7960 /* Number of characters in buffer ignoring trailing
7964 case '*': /* Run length encoding. */
7969 c = readchar (remote_timeout);
7971 repeat = c - ' ' + 3; /* Compute repeat count. */
7973 /* The character before ``*'' is repeated. */
7975 if (repeat > 0 && repeat <= 255 && bc > 0)
7977 if (bc + repeat - 1 >= *sizeof_buf - 1)
7979 /* Make some more room in the buffer. */
7980 *sizeof_buf += repeat;
7981 *buf_p = xrealloc (*buf_p, *sizeof_buf);
7985 memset (&buf[bc], buf[bc - 1], repeat);
7991 printf_filtered (_("Invalid run length encoding: %s\n"), buf);
7995 if (bc >= *sizeof_buf - 1)
7997 /* Make some more room in the buffer. */
7999 *buf_p = xrealloc (*buf_p, *sizeof_buf);
8010 /* Read a packet from the remote machine, with error checking, and
8011 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
8012 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
8013 rather than timing out; this is used (in synchronous mode) to wait
8014 for a target that is is executing user code to stop. */
8015 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
8016 don't have to change all the calls to getpkt to deal with the
8017 return value, because at the moment I don't know what the right
8018 thing to do it for those. */
8026 timed_out = getpkt_sane (buf, sizeof_buf, forever);
8030 /* Read a packet from the remote machine, with error checking, and
8031 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
8032 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
8033 rather than timing out; this is used (in synchronous mode) to wait
8034 for a target that is is executing user code to stop. If FOREVER ==
8035 0, this function is allowed to time out gracefully and return an
8036 indication of this to the caller. Otherwise return the number of
8037 bytes read. If EXPECTING_NOTIF, consider receiving a notification
8038 enough reason to return to the caller. *IS_NOTIF is an output
8039 boolean that indicates whether *BUF holds a notification or not
8040 (a regular packet). */
8043 getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, int forever,
8044 int expecting_notif, int *is_notif)
8046 struct remote_state *rs = get_remote_state ();
8052 /* We're reading a new response. Make sure we don't look at a
8053 previously cached response. */
8054 rs->cached_wait_status = 0;
8056 strcpy (*buf, "timeout");
8059 timeout = watchdog > 0 ? watchdog : -1;
8060 else if (expecting_notif)
8061 timeout = 0; /* There should already be a char in the buffer. If
8064 timeout = remote_timeout;
8068 /* Process any number of notifications, and then return when
8072 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
8074 for (tries = 1; tries <= MAX_TRIES; tries++)
8076 /* This can loop forever if the remote side sends us
8077 characters continuously, but if it pauses, we'll get
8078 SERIAL_TIMEOUT from readchar because of timeout. Then
8079 we'll count that as a retry.
8081 Note that even when forever is set, we will only wait
8082 forever prior to the start of a packet. After that, we
8083 expect characters to arrive at a brisk pace. They should
8084 show up within remote_timeout intervals. */
8086 c = readchar (timeout);
8087 while (c != SERIAL_TIMEOUT && c != '$' && c != '%');
8089 if (c == SERIAL_TIMEOUT)
8091 if (expecting_notif)
8092 return -1; /* Don't complain, it's normal to not get
8093 anything in this case. */
8095 if (forever) /* Watchdog went off? Kill the target. */
8098 remote_unpush_target ();
8099 throw_error (TARGET_CLOSE_ERROR,
8100 _("Watchdog timeout has expired. "
8101 "Target detached."));
8104 fputs_filtered ("Timed out.\n", gdb_stdlog);
8108 /* We've found the start of a packet or notification.
8109 Now collect the data. */
8110 val = read_frame (buf, sizeof_buf);
8115 remote_serial_write ("-", 1);
8118 if (tries > MAX_TRIES)
8120 /* We have tried hard enough, and just can't receive the
8121 packet/notification. Give up. */
8122 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
8124 /* Skip the ack char if we're in no-ack mode. */
8125 if (!rs->noack_mode)
8126 remote_serial_write ("+", 1);
8130 /* If we got an ordinary packet, return that to our caller. */
8135 struct cleanup *old_chain;
8138 str = escape_buffer (*buf, val);
8139 old_chain = make_cleanup (xfree, str);
8140 fprintf_unfiltered (gdb_stdlog, "Packet received: %s\n", str);
8141 do_cleanups (old_chain);
8144 /* Skip the ack char if we're in no-ack mode. */
8145 if (!rs->noack_mode)
8146 remote_serial_write ("+", 1);
8147 if (is_notif != NULL)
8152 /* If we got a notification, handle it, and go back to looking
8156 gdb_assert (c == '%');
8160 struct cleanup *old_chain;
8163 str = escape_buffer (*buf, val);
8164 old_chain = make_cleanup (xfree, str);
8165 fprintf_unfiltered (gdb_stdlog,
8166 " Notification received: %s\n",
8168 do_cleanups (old_chain);
8170 if (is_notif != NULL)
8173 handle_notification (rs->notif_state, *buf);
8175 /* Notifications require no acknowledgement. */
8177 if (expecting_notif)
8184 getpkt_sane (char **buf, long *sizeof_buf, int forever)
8186 return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 0, NULL);
8190 getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever,
8193 return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 1,
8197 /* Check whether EVENT is a fork event for the process specified
8198 by the pid passed in DATA, and if it is, kill the fork child. */
8201 kill_child_of_pending_fork (QUEUE (stop_reply_p) *q,
8202 QUEUE_ITER (stop_reply_p) *iter,
8206 struct queue_iter_param *param = data;
8207 int parent_pid = *(int *) param->input;
8209 if (is_pending_fork_parent (&event->ws, parent_pid, event->ptid))
8211 struct remote_state *rs = get_remote_state ();
8212 int child_pid = ptid_get_pid (event->ws.value.related_pid);
8215 res = remote_vkill (child_pid, rs);
8217 error (_("Can't kill fork child process %d"), child_pid);
8223 /* Kill any new fork children of process PID that haven't been
8224 processed by follow_fork. */
8227 kill_new_fork_children (int pid, struct remote_state *rs)
8229 struct thread_info *thread;
8230 struct notif_client *notif = ¬if_client_stop;
8231 struct queue_iter_param param;
8233 /* Kill the fork child threads of any threads in process PID
8234 that are stopped at a fork event. */
8235 ALL_NON_EXITED_THREADS (thread)
8237 struct target_waitstatus *ws = &thread->pending_follow;
8239 if (is_pending_fork_parent (ws, pid, thread->ptid))
8241 struct remote_state *rs = get_remote_state ();
8242 int child_pid = ptid_get_pid (ws->value.related_pid);
8245 res = remote_vkill (child_pid, rs);
8247 error (_("Can't kill fork child process %d"), child_pid);
8251 /* Check for any pending fork events (not reported or processed yet)
8252 in process PID and kill those fork child threads as well. */
8253 remote_notif_get_pending_events (notif);
8255 param.output = NULL;
8256 QUEUE_iterate (stop_reply_p, stop_reply_queue,
8257 kill_child_of_pending_fork, ¶m);
8262 remote_kill (struct target_ops *ops)
8265 /* Catch errors so the user can quit from gdb even when we
8266 aren't on speaking terms with the remote system. */
8271 CATCH (ex, RETURN_MASK_ERROR)
8273 if (ex.error == TARGET_CLOSE_ERROR)
8275 /* If we got an (EOF) error that caused the target
8276 to go away, then we're done, that's what we wanted.
8277 "k" is susceptible to cause a premature EOF, given
8278 that the remote server isn't actually required to
8279 reply to "k", and it can happen that it doesn't
8280 even get to reply ACK to the "k". */
8284 /* Otherwise, something went wrong. We didn't actually kill
8285 the target. Just propagate the exception, and let the
8286 user or higher layers decide what to do. */
8287 throw_exception (ex);
8291 /* We've killed the remote end, we get to mourn it. Since this is
8292 target remote, single-process, mourning the inferior also
8293 unpushes remote_ops. */
8294 target_mourn_inferior ();
8298 remote_vkill (int pid, struct remote_state *rs)
8300 if (packet_support (PACKET_vKill) == PACKET_DISABLE)
8303 /* Tell the remote target to detach. */
8304 xsnprintf (rs->buf, get_remote_packet_size (), "vKill;%x", pid);
8306 getpkt (&rs->buf, &rs->buf_size, 0);
8308 switch (packet_ok (rs->buf,
8309 &remote_protocol_packets[PACKET_vKill]))
8315 case PACKET_UNKNOWN:
8318 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
8323 extended_remote_kill (struct target_ops *ops)
8326 int pid = ptid_get_pid (inferior_ptid);
8327 struct remote_state *rs = get_remote_state ();
8329 /* If we're stopped while forking and we haven't followed yet, kill the
8330 child task. We need to do this before killing the parent task
8331 because if this is a vfork then the parent will be sleeping. */
8332 kill_new_fork_children (pid, rs);
8334 res = remote_vkill (pid, rs);
8335 if (res == -1 && !(rs->extended && remote_multi_process_p (rs)))
8337 /* Don't try 'k' on a multi-process aware stub -- it has no way
8338 to specify the pid. */
8342 getpkt (&rs->buf, &rs->buf_size, 0);
8343 if (rs->buf[0] != 'O' || rs->buf[0] != 'K')
8346 /* Don't wait for it to die. I'm not really sure it matters whether
8347 we do or not. For the existing stubs, kill is a noop. */
8353 error (_("Can't kill process"));
8355 target_mourn_inferior ();
8359 remote_mourn (struct target_ops *target)
8361 unpush_target (target);
8363 /* remote_close takes care of doing most of the clean up. */
8364 generic_mourn_inferior ();
8368 extended_remote_mourn (struct target_ops *target)
8370 struct remote_state *rs = get_remote_state ();
8372 /* In case we got here due to an error, but we're going to stay
8374 rs->waiting_for_stop_reply = 0;
8376 /* If the current general thread belonged to the process we just
8377 detached from or has exited, the remote side current general
8378 thread becomes undefined. Considering a case like this:
8380 - We just got here due to a detach.
8381 - The process that we're detaching from happens to immediately
8382 report a global breakpoint being hit in non-stop mode, in the
8383 same thread we had selected before.
8384 - GDB attaches to this process again.
8385 - This event happens to be the next event we handle.
8387 GDB would consider that the current general thread didn't need to
8388 be set on the stub side (with Hg), since for all it knew,
8389 GENERAL_THREAD hadn't changed.
8391 Notice that although in all-stop mode, the remote server always
8392 sets the current thread to the thread reporting the stop event,
8393 that doesn't happen in non-stop mode; in non-stop, the stub *must
8394 not* change the current thread when reporting a breakpoint hit,
8395 due to the decoupling of event reporting and event handling.
8397 To keep things simple, we always invalidate our notion of the
8399 record_currthread (rs, minus_one_ptid);
8401 /* Unlike "target remote", we do not want to unpush the target; then
8402 the next time the user says "run", we won't be connected. */
8404 /* Call common code to mark the inferior as not running. */
8405 generic_mourn_inferior ();
8407 if (!have_inferiors ())
8409 if (!remote_multi_process_p (rs))
8411 /* Check whether the target is running now - some remote stubs
8412 automatically restart after kill. */
8414 getpkt (&rs->buf, &rs->buf_size, 0);
8416 if (rs->buf[0] == 'S' || rs->buf[0] == 'T')
8418 /* Assume that the target has been restarted. Set
8419 inferior_ptid so that bits of core GDB realizes
8420 there's something here, e.g., so that the user can
8421 say "kill" again. */
8422 inferior_ptid = magic_null_ptid;
8429 extended_remote_supports_disable_randomization (struct target_ops *self)
8431 return packet_support (PACKET_QDisableRandomization) == PACKET_ENABLE;
8435 extended_remote_disable_randomization (int val)
8437 struct remote_state *rs = get_remote_state ();
8440 xsnprintf (rs->buf, get_remote_packet_size (), "QDisableRandomization:%x",
8443 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
8445 error (_("Target does not support QDisableRandomization."));
8446 if (strcmp (reply, "OK") != 0)
8447 error (_("Bogus QDisableRandomization reply from target: %s"), reply);
8451 extended_remote_run (char *args)
8453 struct remote_state *rs = get_remote_state ();
8456 /* If the user has disabled vRun support, or we have detected that
8457 support is not available, do not try it. */
8458 if (packet_support (PACKET_vRun) == PACKET_DISABLE)
8461 strcpy (rs->buf, "vRun;");
8462 len = strlen (rs->buf);
8464 if (strlen (remote_exec_file) * 2 + len >= get_remote_packet_size ())
8465 error (_("Remote file name too long for run packet"));
8466 len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf + len,
8467 strlen (remote_exec_file));
8469 gdb_assert (args != NULL);
8472 struct cleanup *back_to;
8476 argv = gdb_buildargv (args);
8477 back_to = make_cleanup_freeargv (argv);
8478 for (i = 0; argv[i] != NULL; i++)
8480 if (strlen (argv[i]) * 2 + 1 + len >= get_remote_packet_size ())
8481 error (_("Argument list too long for run packet"));
8482 rs->buf[len++] = ';';
8483 len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf + len,
8486 do_cleanups (back_to);
8489 rs->buf[len++] = '\0';
8492 getpkt (&rs->buf, &rs->buf_size, 0);
8494 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun]))
8497 /* We have a wait response. All is well. */
8499 case PACKET_UNKNOWN:
8502 if (remote_exec_file[0] == '\0')
8503 error (_("Running the default executable on the remote target failed; "
8504 "try \"set remote exec-file\"?"));
8506 error (_("Running \"%s\" on the remote target failed"),
8509 gdb_assert_not_reached (_("bad switch"));
8513 /* In the extended protocol we want to be able to do things like
8514 "run" and have them basically work as expected. So we need
8515 a special create_inferior function. We support changing the
8516 executable file and the command line arguments, but not the
8520 extended_remote_create_inferior (struct target_ops *ops,
8521 char *exec_file, char *args,
8522 char **env, int from_tty)
8526 struct remote_state *rs = get_remote_state ();
8528 /* If running asynchronously, register the target file descriptor
8529 with the event loop. */
8530 if (target_can_async_p ())
8533 /* Disable address space randomization if requested (and supported). */
8534 if (extended_remote_supports_disable_randomization (ops))
8535 extended_remote_disable_randomization (disable_randomization);
8537 /* Now restart the remote server. */
8538 run_worked = extended_remote_run (args) != -1;
8541 /* vRun was not supported. Fail if we need it to do what the
8543 if (remote_exec_file[0])
8544 error (_("Remote target does not support \"set remote exec-file\""));
8546 error (_("Remote target does not support \"set args\" or run <ARGS>"));
8548 /* Fall back to "R". */
8549 extended_remote_restart ();
8552 if (!have_inferiors ())
8554 /* Clean up from the last time we ran, before we mark the target
8555 running again. This will mark breakpoints uninserted, and
8556 get_offsets may insert breakpoints. */
8557 init_thread_list ();
8558 init_wait_for_inferior ();
8561 /* vRun's success return is a stop reply. */
8562 stop_reply = run_worked ? rs->buf : NULL;
8563 add_current_inferior_and_thread (stop_reply);
8565 /* Get updated offsets, if the stub uses qOffsets. */
8570 /* Given a location's target info BP_TGT and the packet buffer BUF, output
8571 the list of conditions (in agent expression bytecode format), if any, the
8572 target needs to evaluate. The output is placed into the packet buffer
8573 started from BUF and ended at BUF_END. */
8576 remote_add_target_side_condition (struct gdbarch *gdbarch,
8577 struct bp_target_info *bp_tgt, char *buf,
8580 struct agent_expr *aexpr = NULL;
8583 char *buf_start = buf;
8585 if (VEC_empty (agent_expr_p, bp_tgt->conditions))
8588 buf += strlen (buf);
8589 xsnprintf (buf, buf_end - buf, "%s", ";");
8592 /* Send conditions to the target and free the vector. */
8594 VEC_iterate (agent_expr_p, bp_tgt->conditions, ix, aexpr);
8597 xsnprintf (buf, buf_end - buf, "X%x,", aexpr->len);
8598 buf += strlen (buf);
8599 for (i = 0; i < aexpr->len; ++i)
8600 buf = pack_hex_byte (buf, aexpr->buf[i]);
8607 remote_add_target_side_commands (struct gdbarch *gdbarch,
8608 struct bp_target_info *bp_tgt, char *buf)
8610 struct agent_expr *aexpr = NULL;
8613 if (VEC_empty (agent_expr_p, bp_tgt->tcommands))
8616 buf += strlen (buf);
8618 sprintf (buf, ";cmds:%x,", bp_tgt->persist);
8619 buf += strlen (buf);
8621 /* Concatenate all the agent expressions that are commands into the
8624 VEC_iterate (agent_expr_p, bp_tgt->tcommands, ix, aexpr);
8627 sprintf (buf, "X%x,", aexpr->len);
8628 buf += strlen (buf);
8629 for (i = 0; i < aexpr->len; ++i)
8630 buf = pack_hex_byte (buf, aexpr->buf[i]);
8635 /* Insert a breakpoint. On targets that have software breakpoint
8636 support, we ask the remote target to do the work; on targets
8637 which don't, we insert a traditional memory breakpoint. */
8640 remote_insert_breakpoint (struct target_ops *ops,
8641 struct gdbarch *gdbarch,
8642 struct bp_target_info *bp_tgt)
8644 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
8645 If it succeeds, then set the support to PACKET_ENABLE. If it
8646 fails, and the user has explicitly requested the Z support then
8647 report an error, otherwise, mark it disabled and go on. */
8649 if (packet_support (PACKET_Z0) != PACKET_DISABLE)
8651 CORE_ADDR addr = bp_tgt->reqstd_address;
8652 struct remote_state *rs;
8655 struct condition_list *cond = NULL;
8657 /* Make sure the remote is pointing at the right process, if
8659 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8660 set_general_process ();
8662 gdbarch_remote_breakpoint_from_pc (gdbarch, &addr, &bpsize);
8664 rs = get_remote_state ();
8666 endbuf = rs->buf + get_remote_packet_size ();
8671 addr = (ULONGEST) remote_address_masked (addr);
8672 p += hexnumstr (p, addr);
8673 xsnprintf (p, endbuf - p, ",%d", bpsize);
8675 if (remote_supports_cond_breakpoints (ops))
8676 remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
8678 if (remote_can_run_breakpoint_commands (ops))
8679 remote_add_target_side_commands (gdbarch, bp_tgt, p);
8682 getpkt (&rs->buf, &rs->buf_size, 0);
8684 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0]))
8689 bp_tgt->placed_address = addr;
8690 bp_tgt->placed_size = bpsize;
8692 case PACKET_UNKNOWN:
8697 /* If this breakpoint has target-side commands but this stub doesn't
8698 support Z0 packets, throw error. */
8699 if (!VEC_empty (agent_expr_p, bp_tgt->tcommands))
8700 throw_error (NOT_SUPPORTED_ERROR, _("\
8701 Target doesn't support breakpoints that have target side commands."));
8703 return memory_insert_breakpoint (ops, gdbarch, bp_tgt);
8707 remote_remove_breakpoint (struct target_ops *ops,
8708 struct gdbarch *gdbarch,
8709 struct bp_target_info *bp_tgt)
8711 CORE_ADDR addr = bp_tgt->placed_address;
8712 struct remote_state *rs = get_remote_state ();
8714 if (packet_support (PACKET_Z0) != PACKET_DISABLE)
8717 char *endbuf = rs->buf + get_remote_packet_size ();
8719 /* Make sure the remote is pointing at the right process, if
8721 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8722 set_general_process ();
8728 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
8729 p += hexnumstr (p, addr);
8730 xsnprintf (p, endbuf - p, ",%d", bp_tgt->placed_size);
8733 getpkt (&rs->buf, &rs->buf_size, 0);
8735 return (rs->buf[0] == 'E');
8738 return memory_remove_breakpoint (ops, gdbarch, bp_tgt);
8741 static enum Z_packet_type
8742 watchpoint_to_Z_packet (int type)
8747 return Z_PACKET_WRITE_WP;
8750 return Z_PACKET_READ_WP;
8753 return Z_PACKET_ACCESS_WP;
8756 internal_error (__FILE__, __LINE__,
8757 _("hw_bp_to_z: bad watchpoint type %d"), type);
8762 remote_insert_watchpoint (struct target_ops *self, CORE_ADDR addr, int len,
8763 enum target_hw_bp_type type, struct expression *cond)
8765 struct remote_state *rs = get_remote_state ();
8766 char *endbuf = rs->buf + get_remote_packet_size ();
8768 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
8770 if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE)
8773 /* Make sure the remote is pointing at the right process, if
8775 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8776 set_general_process ();
8778 xsnprintf (rs->buf, endbuf - rs->buf, "Z%x,", packet);
8779 p = strchr (rs->buf, '\0');
8780 addr = remote_address_masked (addr);
8781 p += hexnumstr (p, (ULONGEST) addr);
8782 xsnprintf (p, endbuf - p, ",%x", len);
8785 getpkt (&rs->buf, &rs->buf_size, 0);
8787 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
8791 case PACKET_UNKNOWN:
8796 internal_error (__FILE__, __LINE__,
8797 _("remote_insert_watchpoint: reached end of function"));
8801 remote_watchpoint_addr_within_range (struct target_ops *target, CORE_ADDR addr,
8802 CORE_ADDR start, int length)
8804 CORE_ADDR diff = remote_address_masked (addr - start);
8806 return diff < length;
8811 remote_remove_watchpoint (struct target_ops *self, CORE_ADDR addr, int len,
8812 enum target_hw_bp_type type, struct expression *cond)
8814 struct remote_state *rs = get_remote_state ();
8815 char *endbuf = rs->buf + get_remote_packet_size ();
8817 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
8819 if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE)
8822 /* Make sure the remote is pointing at the right process, if
8824 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8825 set_general_process ();
8827 xsnprintf (rs->buf, endbuf - rs->buf, "z%x,", packet);
8828 p = strchr (rs->buf, '\0');
8829 addr = remote_address_masked (addr);
8830 p += hexnumstr (p, (ULONGEST) addr);
8831 xsnprintf (p, endbuf - p, ",%x", len);
8833 getpkt (&rs->buf, &rs->buf_size, 0);
8835 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
8838 case PACKET_UNKNOWN:
8843 internal_error (__FILE__, __LINE__,
8844 _("remote_remove_watchpoint: reached end of function"));
8848 int remote_hw_watchpoint_limit = -1;
8849 int remote_hw_watchpoint_length_limit = -1;
8850 int remote_hw_breakpoint_limit = -1;
8853 remote_region_ok_for_hw_watchpoint (struct target_ops *self,
8854 CORE_ADDR addr, int len)
8856 if (remote_hw_watchpoint_length_limit == 0)
8858 else if (remote_hw_watchpoint_length_limit < 0)
8860 else if (len <= remote_hw_watchpoint_length_limit)
8867 remote_check_watch_resources (struct target_ops *self,
8868 enum bptype type, int cnt, int ot)
8870 if (type == bp_hardware_breakpoint)
8872 if (remote_hw_breakpoint_limit == 0)
8874 else if (remote_hw_breakpoint_limit < 0)
8876 else if (cnt <= remote_hw_breakpoint_limit)
8881 if (remote_hw_watchpoint_limit == 0)
8883 else if (remote_hw_watchpoint_limit < 0)
8887 else if (cnt <= remote_hw_watchpoint_limit)
8893 /* The to_stopped_by_sw_breakpoint method of target remote. */
8896 remote_stopped_by_sw_breakpoint (struct target_ops *ops)
8898 struct remote_state *rs = get_remote_state ();
8900 return rs->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
8903 /* The to_supports_stopped_by_sw_breakpoint method of target
8907 remote_supports_stopped_by_sw_breakpoint (struct target_ops *ops)
8909 struct remote_state *rs = get_remote_state ();
8911 return (packet_support (PACKET_swbreak_feature) == PACKET_ENABLE);
8914 /* The to_stopped_by_hw_breakpoint method of target remote. */
8917 remote_stopped_by_hw_breakpoint (struct target_ops *ops)
8919 struct remote_state *rs = get_remote_state ();
8921 return rs->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
8924 /* The to_supports_stopped_by_hw_breakpoint method of target
8928 remote_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
8930 struct remote_state *rs = get_remote_state ();
8932 return (packet_support (PACKET_hwbreak_feature) == PACKET_ENABLE);
8936 remote_stopped_by_watchpoint (struct target_ops *ops)
8938 struct remote_state *rs = get_remote_state ();
8940 return rs->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
8944 remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
8946 struct remote_state *rs = get_remote_state ();
8949 if (remote_stopped_by_watchpoint (target))
8951 *addr_p = rs->remote_watch_data_address;
8960 remote_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch,
8961 struct bp_target_info *bp_tgt)
8963 CORE_ADDR addr = bp_tgt->reqstd_address;
8964 struct remote_state *rs;
8969 /* The length field should be set to the size of a breakpoint
8970 instruction, even though we aren't inserting one ourselves. */
8972 gdbarch_remote_breakpoint_from_pc (gdbarch, &addr, &bpsize);
8974 if (packet_support (PACKET_Z1) == PACKET_DISABLE)
8977 /* Make sure the remote is pointing at the right process, if
8979 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
8980 set_general_process ();
8982 rs = get_remote_state ();
8984 endbuf = rs->buf + get_remote_packet_size ();
8990 addr = remote_address_masked (addr);
8991 p += hexnumstr (p, (ULONGEST) addr);
8992 xsnprintf (p, endbuf - p, ",%x", bpsize);
8994 if (remote_supports_cond_breakpoints (self))
8995 remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
8997 if (remote_can_run_breakpoint_commands (self))
8998 remote_add_target_side_commands (gdbarch, bp_tgt, p);
9001 getpkt (&rs->buf, &rs->buf_size, 0);
9003 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
9006 if (rs->buf[1] == '.')
9008 message = strchr (rs->buf + 2, '.');
9010 error (_("Remote failure reply: %s"), message + 1);
9013 case PACKET_UNKNOWN:
9016 bp_tgt->placed_address = addr;
9017 bp_tgt->placed_size = bpsize;
9020 internal_error (__FILE__, __LINE__,
9021 _("remote_insert_hw_breakpoint: reached end of function"));
9026 remote_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch,
9027 struct bp_target_info *bp_tgt)
9030 struct remote_state *rs = get_remote_state ();
9032 char *endbuf = rs->buf + get_remote_packet_size ();
9034 if (packet_support (PACKET_Z1) == PACKET_DISABLE)
9037 /* Make sure the remote is pointing at the right process, if
9039 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9040 set_general_process ();
9046 addr = remote_address_masked (bp_tgt->placed_address);
9047 p += hexnumstr (p, (ULONGEST) addr);
9048 xsnprintf (p, endbuf - p, ",%x", bp_tgt->placed_size);
9051 getpkt (&rs->buf, &rs->buf_size, 0);
9053 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
9056 case PACKET_UNKNOWN:
9061 internal_error (__FILE__, __LINE__,
9062 _("remote_remove_hw_breakpoint: reached end of function"));
9065 /* Verify memory using the "qCRC:" request. */
9068 remote_verify_memory (struct target_ops *ops,
9069 const gdb_byte *data, CORE_ADDR lma, ULONGEST size)
9071 struct remote_state *rs = get_remote_state ();
9072 unsigned long host_crc, target_crc;
9075 /* It doesn't make sense to use qCRC if the remote target is
9076 connected but not running. */
9077 if (target_has_execution && packet_support (PACKET_qCRC) != PACKET_DISABLE)
9079 enum packet_result result;
9081 /* Make sure the remote is pointing at the right process. */
9082 set_general_process ();
9084 /* FIXME: assumes lma can fit into long. */
9085 xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
9086 (long) lma, (long) size);
9089 /* Be clever; compute the host_crc before waiting for target
9091 host_crc = xcrc32 (data, size, 0xffffffff);
9093 getpkt (&rs->buf, &rs->buf_size, 0);
9095 result = packet_ok (rs->buf,
9096 &remote_protocol_packets[PACKET_qCRC]);
9097 if (result == PACKET_ERROR)
9099 else if (result == PACKET_OK)
9101 for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
9102 target_crc = target_crc * 16 + fromhex (*tmp);
9104 return (host_crc == target_crc);
9108 return simple_verify_memory (ops, data, lma, size);
9111 /* compare-sections command
9113 With no arguments, compares each loadable section in the exec bfd
9114 with the same memory range on the target, and reports mismatches.
9115 Useful for verifying the image on the target against the exec file. */
9118 compare_sections_command (char *args, int from_tty)
9121 struct cleanup *old_chain;
9123 const char *sectname;
9132 error (_("command cannot be used without an exec file"));
9134 /* Make sure the remote is pointing at the right process. */
9135 set_general_process ();
9137 if (args != NULL && strcmp (args, "-r") == 0)
9143 for (s = exec_bfd->sections; s; s = s->next)
9145 if (!(s->flags & SEC_LOAD))
9146 continue; /* Skip non-loadable section. */
9148 if (read_only && (s->flags & SEC_READONLY) == 0)
9149 continue; /* Skip writeable sections */
9151 size = bfd_get_section_size (s);
9153 continue; /* Skip zero-length section. */
9155 sectname = bfd_get_section_name (exec_bfd, s);
9156 if (args && strcmp (args, sectname) != 0)
9157 continue; /* Not the section selected by user. */
9159 matched = 1; /* Do this section. */
9162 sectdata = xmalloc (size);
9163 old_chain = make_cleanup (xfree, sectdata);
9164 bfd_get_section_contents (exec_bfd, s, sectdata, 0, size);
9166 res = target_verify_memory (sectdata, lma, size);
9169 error (_("target memory fault, section %s, range %s -- %s"), sectname,
9170 paddress (target_gdbarch (), lma),
9171 paddress (target_gdbarch (), lma + size));
9173 printf_filtered ("Section %s, range %s -- %s: ", sectname,
9174 paddress (target_gdbarch (), lma),
9175 paddress (target_gdbarch (), lma + size));
9177 printf_filtered ("matched.\n");
9180 printf_filtered ("MIS-MATCHED!\n");
9184 do_cleanups (old_chain);
9187 warning (_("One or more sections of the target image does not match\n\
9188 the loaded file\n"));
9189 if (args && !matched)
9190 printf_filtered (_("No loaded section named '%s'.\n"), args);
9193 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
9194 into remote target. The number of bytes written to the remote
9195 target is returned, or -1 for error. */
9197 static enum target_xfer_status
9198 remote_write_qxfer (struct target_ops *ops, const char *object_name,
9199 const char *annex, const gdb_byte *writebuf,
9200 ULONGEST offset, LONGEST len, ULONGEST *xfered_len,
9201 struct packet_config *packet)
9205 struct remote_state *rs = get_remote_state ();
9206 int max_size = get_memory_write_packet_size ();
9208 if (packet->support == PACKET_DISABLE)
9209 return TARGET_XFER_E_IO;
9211 /* Insert header. */
9212 i = snprintf (rs->buf, max_size,
9213 "qXfer:%s:write:%s:%s:",
9214 object_name, annex ? annex : "",
9215 phex_nz (offset, sizeof offset));
9216 max_size -= (i + 1);
9218 /* Escape as much data as fits into rs->buf. */
9219 buf_len = remote_escape_output
9220 (writebuf, len, 1, (gdb_byte *) rs->buf + i, &max_size, max_size);
9222 if (putpkt_binary (rs->buf, i + buf_len) < 0
9223 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
9224 || packet_ok (rs->buf, packet) != PACKET_OK)
9225 return TARGET_XFER_E_IO;
9227 unpack_varlen_hex (rs->buf, &n);
9230 return TARGET_XFER_OK;
9233 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
9234 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
9235 number of bytes read is returned, or 0 for EOF, or -1 for error.
9236 The number of bytes read may be less than LEN without indicating an
9237 EOF. PACKET is checked and updated to indicate whether the remote
9238 target supports this object. */
9240 static enum target_xfer_status
9241 remote_read_qxfer (struct target_ops *ops, const char *object_name,
9243 gdb_byte *readbuf, ULONGEST offset, LONGEST len,
9244 ULONGEST *xfered_len,
9245 struct packet_config *packet)
9247 struct remote_state *rs = get_remote_state ();
9248 LONGEST i, n, packet_len;
9250 if (packet->support == PACKET_DISABLE)
9251 return TARGET_XFER_E_IO;
9253 /* Check whether we've cached an end-of-object packet that matches
9255 if (rs->finished_object)
9257 if (strcmp (object_name, rs->finished_object) == 0
9258 && strcmp (annex ? annex : "", rs->finished_annex) == 0
9259 && offset == rs->finished_offset)
9260 return TARGET_XFER_EOF;
9263 /* Otherwise, we're now reading something different. Discard
9265 xfree (rs->finished_object);
9266 xfree (rs->finished_annex);
9267 rs->finished_object = NULL;
9268 rs->finished_annex = NULL;
9271 /* Request only enough to fit in a single packet. The actual data
9272 may not, since we don't know how much of it will need to be escaped;
9273 the target is free to respond with slightly less data. We subtract
9274 five to account for the response type and the protocol frame. */
9275 n = min (get_remote_packet_size () - 5, len);
9276 snprintf (rs->buf, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
9277 object_name, annex ? annex : "",
9278 phex_nz (offset, sizeof offset),
9279 phex_nz (n, sizeof n));
9280 i = putpkt (rs->buf);
9282 return TARGET_XFER_E_IO;
9285 packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0);
9286 if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)
9287 return TARGET_XFER_E_IO;
9289 if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
9290 error (_("Unknown remote qXfer reply: %s"), rs->buf);
9292 /* 'm' means there is (or at least might be) more data after this
9293 batch. That does not make sense unless there's at least one byte
9294 of data in this reply. */
9295 if (rs->buf[0] == 'm' && packet_len == 1)
9296 error (_("Remote qXfer reply contained no data."));
9298 /* Got some data. */
9299 i = remote_unescape_input ((gdb_byte *) rs->buf + 1,
9300 packet_len - 1, readbuf, n);
9302 /* 'l' is an EOF marker, possibly including a final block of data,
9303 or possibly empty. If we have the final block of a non-empty
9304 object, record this fact to bypass a subsequent partial read. */
9305 if (rs->buf[0] == 'l' && offset + i > 0)
9307 rs->finished_object = xstrdup (object_name);
9308 rs->finished_annex = xstrdup (annex ? annex : "");
9309 rs->finished_offset = offset + i;
9313 return TARGET_XFER_EOF;
9317 return TARGET_XFER_OK;
9321 static enum target_xfer_status
9322 remote_xfer_partial (struct target_ops *ops, enum target_object object,
9323 const char *annex, gdb_byte *readbuf,
9324 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
9325 ULONGEST *xfered_len)
9327 struct remote_state *rs;
9331 int unit_size = gdbarch_addressable_memory_unit_size (target_gdbarch ());
9333 set_remote_traceframe ();
9334 set_general_thread (inferior_ptid);
9336 rs = get_remote_state ();
9338 /* Handle memory using the standard memory routines. */
9339 if (object == TARGET_OBJECT_MEMORY)
9341 /* If the remote target is connected but not running, we should
9342 pass this request down to a lower stratum (e.g. the executable
9344 if (!target_has_execution)
9345 return TARGET_XFER_EOF;
9347 if (writebuf != NULL)
9348 return remote_write_bytes (offset, writebuf, len, unit_size,
9351 return remote_read_bytes (ops, offset, readbuf, len, unit_size,
9355 /* Handle SPU memory using qxfer packets. */
9356 if (object == TARGET_OBJECT_SPU)
9359 return remote_read_qxfer (ops, "spu", annex, readbuf, offset, len,
9360 xfered_len, &remote_protocol_packets
9361 [PACKET_qXfer_spu_read]);
9363 return remote_write_qxfer (ops, "spu", annex, writebuf, offset, len,
9364 xfered_len, &remote_protocol_packets
9365 [PACKET_qXfer_spu_write]);
9368 /* Handle extra signal info using qxfer packets. */
9369 if (object == TARGET_OBJECT_SIGNAL_INFO)
9372 return remote_read_qxfer (ops, "siginfo", annex, readbuf, offset, len,
9373 xfered_len, &remote_protocol_packets
9374 [PACKET_qXfer_siginfo_read]);
9376 return remote_write_qxfer (ops, "siginfo", annex,
9377 writebuf, offset, len, xfered_len,
9378 &remote_protocol_packets
9379 [PACKET_qXfer_siginfo_write]);
9382 if (object == TARGET_OBJECT_STATIC_TRACE_DATA)
9385 return remote_read_qxfer (ops, "statictrace", annex,
9386 readbuf, offset, len, xfered_len,
9387 &remote_protocol_packets
9388 [PACKET_qXfer_statictrace_read]);
9390 return TARGET_XFER_E_IO;
9393 /* Only handle flash writes. */
9394 if (writebuf != NULL)
9400 case TARGET_OBJECT_FLASH:
9401 return remote_flash_write (ops, offset, len, xfered_len,
9405 return TARGET_XFER_E_IO;
9409 /* Map pre-existing objects onto letters. DO NOT do this for new
9410 objects!!! Instead specify new query packets. */
9413 case TARGET_OBJECT_AVR:
9417 case TARGET_OBJECT_AUXV:
9418 gdb_assert (annex == NULL);
9419 return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,
9421 &remote_protocol_packets[PACKET_qXfer_auxv]);
9423 case TARGET_OBJECT_AVAILABLE_FEATURES:
9424 return remote_read_qxfer
9425 (ops, "features", annex, readbuf, offset, len, xfered_len,
9426 &remote_protocol_packets[PACKET_qXfer_features]);
9428 case TARGET_OBJECT_LIBRARIES:
9429 return remote_read_qxfer
9430 (ops, "libraries", annex, readbuf, offset, len, xfered_len,
9431 &remote_protocol_packets[PACKET_qXfer_libraries]);
9433 case TARGET_OBJECT_LIBRARIES_SVR4:
9434 return remote_read_qxfer
9435 (ops, "libraries-svr4", annex, readbuf, offset, len, xfered_len,
9436 &remote_protocol_packets[PACKET_qXfer_libraries_svr4]);
9438 case TARGET_OBJECT_MEMORY_MAP:
9439 gdb_assert (annex == NULL);
9440 return remote_read_qxfer (ops, "memory-map", annex, readbuf, offset, len,
9442 &remote_protocol_packets[PACKET_qXfer_memory_map]);
9444 case TARGET_OBJECT_OSDATA:
9445 /* Should only get here if we're connected. */
9446 gdb_assert (rs->remote_desc);
9447 return remote_read_qxfer
9448 (ops, "osdata", annex, readbuf, offset, len, xfered_len,
9449 &remote_protocol_packets[PACKET_qXfer_osdata]);
9451 case TARGET_OBJECT_THREADS:
9452 gdb_assert (annex == NULL);
9453 return remote_read_qxfer (ops, "threads", annex, readbuf, offset, len,
9455 &remote_protocol_packets[PACKET_qXfer_threads]);
9457 case TARGET_OBJECT_TRACEFRAME_INFO:
9458 gdb_assert (annex == NULL);
9459 return remote_read_qxfer
9460 (ops, "traceframe-info", annex, readbuf, offset, len, xfered_len,
9461 &remote_protocol_packets[PACKET_qXfer_traceframe_info]);
9463 case TARGET_OBJECT_FDPIC:
9464 return remote_read_qxfer (ops, "fdpic", annex, readbuf, offset, len,
9466 &remote_protocol_packets[PACKET_qXfer_fdpic]);
9468 case TARGET_OBJECT_OPENVMS_UIB:
9469 return remote_read_qxfer (ops, "uib", annex, readbuf, offset, len,
9471 &remote_protocol_packets[PACKET_qXfer_uib]);
9473 case TARGET_OBJECT_BTRACE:
9474 return remote_read_qxfer (ops, "btrace", annex, readbuf, offset, len,
9476 &remote_protocol_packets[PACKET_qXfer_btrace]);
9478 case TARGET_OBJECT_BTRACE_CONF:
9479 return remote_read_qxfer (ops, "btrace-conf", annex, readbuf, offset,
9481 &remote_protocol_packets[PACKET_qXfer_btrace_conf]);
9483 case TARGET_OBJECT_EXEC_FILE:
9484 return remote_read_qxfer (ops, "exec-file", annex, readbuf, offset,
9486 &remote_protocol_packets[PACKET_qXfer_exec_file]);
9489 return TARGET_XFER_E_IO;
9492 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
9493 large enough let the caller deal with it. */
9494 if (len < get_remote_packet_size ())
9495 return TARGET_XFER_E_IO;
9496 len = get_remote_packet_size ();
9498 /* Except for querying the minimum buffer size, target must be open. */
9499 if (!rs->remote_desc)
9500 error (_("remote query is only available after target open"));
9502 gdb_assert (annex != NULL);
9503 gdb_assert (readbuf != NULL);
9509 /* We used one buffer char for the remote protocol q command and
9510 another for the query type. As the remote protocol encapsulation
9511 uses 4 chars plus one extra in case we are debugging
9512 (remote_debug), we have PBUFZIZ - 7 left to pack the query
9515 while (annex[i] && (i < (get_remote_packet_size () - 8)))
9517 /* Bad caller may have sent forbidden characters. */
9518 gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#');
9523 gdb_assert (annex[i] == '\0');
9525 i = putpkt (rs->buf);
9527 return TARGET_XFER_E_IO;
9529 getpkt (&rs->buf, &rs->buf_size, 0);
9530 strcpy ((char *) readbuf, rs->buf);
9532 *xfered_len = strlen ((char *) readbuf);
9533 return TARGET_XFER_OK;
9537 remote_search_memory (struct target_ops* ops,
9538 CORE_ADDR start_addr, ULONGEST search_space_len,
9539 const gdb_byte *pattern, ULONGEST pattern_len,
9540 CORE_ADDR *found_addrp)
9542 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
9543 struct remote_state *rs = get_remote_state ();
9544 int max_size = get_memory_write_packet_size ();
9545 struct packet_config *packet =
9546 &remote_protocol_packets[PACKET_qSearch_memory];
9547 /* Number of packet bytes used to encode the pattern;
9548 this could be more than PATTERN_LEN due to escape characters. */
9549 int escaped_pattern_len;
9550 /* Amount of pattern that was encodable in the packet. */
9551 int used_pattern_len;
9554 ULONGEST found_addr;
9556 /* Don't go to the target if we don't have to.
9557 This is done before checking packet->support to avoid the possibility that
9558 a success for this edge case means the facility works in general. */
9559 if (pattern_len > search_space_len)
9561 if (pattern_len == 0)
9563 *found_addrp = start_addr;
9567 /* If we already know the packet isn't supported, fall back to the simple
9568 way of searching memory. */
9570 if (packet_config_support (packet) == PACKET_DISABLE)
9572 /* Target doesn't provided special support, fall back and use the
9573 standard support (copy memory and do the search here). */
9574 return simple_search_memory (ops, start_addr, search_space_len,
9575 pattern, pattern_len, found_addrp);
9578 /* Make sure the remote is pointing at the right process. */
9579 set_general_process ();
9581 /* Insert header. */
9582 i = snprintf (rs->buf, max_size,
9583 "qSearch:memory:%s;%s;",
9584 phex_nz (start_addr, addr_size),
9585 phex_nz (search_space_len, sizeof (search_space_len)));
9586 max_size -= (i + 1);
9588 /* Escape as much data as fits into rs->buf. */
9589 escaped_pattern_len =
9590 remote_escape_output (pattern, pattern_len, 1, (gdb_byte *) rs->buf + i,
9591 &used_pattern_len, max_size);
9593 /* Bail if the pattern is too large. */
9594 if (used_pattern_len != pattern_len)
9595 error (_("Pattern is too large to transmit to remote target."));
9597 if (putpkt_binary (rs->buf, i + escaped_pattern_len) < 0
9598 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
9599 || packet_ok (rs->buf, packet) != PACKET_OK)
9601 /* The request may not have worked because the command is not
9602 supported. If so, fall back to the simple way. */
9603 if (packet->support == PACKET_DISABLE)
9605 return simple_search_memory (ops, start_addr, search_space_len,
9606 pattern, pattern_len, found_addrp);
9611 if (rs->buf[0] == '0')
9613 else if (rs->buf[0] == '1')
9616 if (rs->buf[1] != ',')
9617 error (_("Unknown qSearch:memory reply: %s"), rs->buf);
9618 unpack_varlen_hex (rs->buf + 2, &found_addr);
9619 *found_addrp = found_addr;
9622 error (_("Unknown qSearch:memory reply: %s"), rs->buf);
9628 remote_rcmd (struct target_ops *self, const char *command,
9629 struct ui_file *outbuf)
9631 struct remote_state *rs = get_remote_state ();
9634 if (!rs->remote_desc)
9635 error (_("remote rcmd is only available after target open"));
9637 /* Send a NULL command across as an empty command. */
9638 if (command == NULL)
9641 /* The query prefix. */
9642 strcpy (rs->buf, "qRcmd,");
9643 p = strchr (rs->buf, '\0');
9645 if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/)
9646 > get_remote_packet_size ())
9647 error (_("\"monitor\" command ``%s'' is too long."), command);
9649 /* Encode the actual command. */
9650 bin2hex ((const gdb_byte *) command, p, strlen (command));
9652 if (putpkt (rs->buf) < 0)
9653 error (_("Communication problem with target."));
9655 /* get/display the response */
9660 /* XXX - see also remote_get_noisy_reply(). */
9661 QUIT; /* Allow user to bail out with ^C. */
9663 if (getpkt_sane (&rs->buf, &rs->buf_size, 0) == -1)
9665 /* Timeout. Continue to (try to) read responses.
9666 This is better than stopping with an error, assuming the stub
9667 is still executing the (long) monitor command.
9668 If needed, the user can interrupt gdb using C-c, obtaining
9669 an effect similar to stop on timeout. */
9674 error (_("Target does not support this command."));
9675 if (buf[0] == 'O' && buf[1] != 'K')
9677 remote_console_output (buf + 1); /* 'O' message from stub. */
9680 if (strcmp (buf, "OK") == 0)
9682 if (strlen (buf) == 3 && buf[0] == 'E'
9683 && isdigit (buf[1]) && isdigit (buf[2]))
9685 error (_("Protocol error with Rcmd"));
9687 for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
9689 char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
9691 fputc_unfiltered (c, outbuf);
9697 static VEC(mem_region_s) *
9698 remote_memory_map (struct target_ops *ops)
9700 VEC(mem_region_s) *result = NULL;
9701 char *text = target_read_stralloc (¤t_target,
9702 TARGET_OBJECT_MEMORY_MAP, NULL);
9706 struct cleanup *back_to = make_cleanup (xfree, text);
9708 result = parse_memory_map (text);
9709 do_cleanups (back_to);
9716 packet_command (char *args, int from_tty)
9718 struct remote_state *rs = get_remote_state ();
9720 if (!rs->remote_desc)
9721 error (_("command can only be used with remote target"));
9724 error (_("remote-packet command requires packet text as argument"));
9726 puts_filtered ("sending: ");
9727 print_packet (args);
9728 puts_filtered ("\n");
9731 getpkt (&rs->buf, &rs->buf_size, 0);
9732 puts_filtered ("received: ");
9733 print_packet (rs->buf);
9734 puts_filtered ("\n");
9738 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
9740 static void display_thread_info (struct gdb_ext_thread_info *info);
9742 static void threadset_test_cmd (char *cmd, int tty);
9744 static void threadalive_test (char *cmd, int tty);
9746 static void threadlist_test_cmd (char *cmd, int tty);
9748 int get_and_display_threadinfo (threadref *ref);
9750 static void threadinfo_test_cmd (char *cmd, int tty);
9752 static int thread_display_step (threadref *ref, void *context);
9754 static void threadlist_update_test_cmd (char *cmd, int tty);
9756 static void init_remote_threadtests (void);
9758 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
9761 threadset_test_cmd (char *cmd, int tty)
9763 int sample_thread = SAMPLE_THREAD;
9765 printf_filtered (_("Remote threadset test\n"));
9766 set_general_thread (sample_thread);
9771 threadalive_test (char *cmd, int tty)
9773 int sample_thread = SAMPLE_THREAD;
9774 int pid = ptid_get_pid (inferior_ptid);
9775 ptid_t ptid = ptid_build (pid, sample_thread, 0);
9777 if (remote_thread_alive (ptid))
9778 printf_filtered ("PASS: Thread alive test\n");
9780 printf_filtered ("FAIL: Thread alive test\n");
9783 void output_threadid (char *title, threadref *ref);
9786 output_threadid (char *title, threadref *ref)
9790 pack_threadid (&hexid[0], ref); /* Convert threead id into hex. */
9792 printf_filtered ("%s %s\n", title, (&hexid[0]));
9796 threadlist_test_cmd (char *cmd, int tty)
9799 threadref nextthread;
9800 int done, result_count;
9801 threadref threadlist[3];
9803 printf_filtered ("Remote Threadlist test\n");
9804 if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
9805 &result_count, &threadlist[0]))
9806 printf_filtered ("FAIL: threadlist test\n");
9809 threadref *scan = threadlist;
9810 threadref *limit = scan + result_count;
9812 while (scan < limit)
9813 output_threadid (" thread ", scan++);
9818 display_thread_info (struct gdb_ext_thread_info *info)
9820 output_threadid ("Threadid: ", &info->threadid);
9821 printf_filtered ("Name: %s\n ", info->shortname);
9822 printf_filtered ("State: %s\n", info->display);
9823 printf_filtered ("other: %s\n\n", info->more_display);
9827 get_and_display_threadinfo (threadref *ref)
9831 struct gdb_ext_thread_info threadinfo;
9833 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
9834 | TAG_MOREDISPLAY | TAG_DISPLAY;
9835 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
9836 display_thread_info (&threadinfo);
9841 threadinfo_test_cmd (char *cmd, int tty)
9843 int athread = SAMPLE_THREAD;
9847 int_to_threadref (&thread, athread);
9848 printf_filtered ("Remote Threadinfo test\n");
9849 if (!get_and_display_threadinfo (&thread))
9850 printf_filtered ("FAIL cannot get thread info\n");
9854 thread_display_step (threadref *ref, void *context)
9856 /* output_threadid(" threadstep ",ref); *//* simple test */
9857 return get_and_display_threadinfo (ref);
9861 threadlist_update_test_cmd (char *cmd, int tty)
9863 printf_filtered ("Remote Threadlist update test\n");
9864 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
9868 init_remote_threadtests (void)
9870 add_com ("tlist", class_obscure, threadlist_test_cmd,
9871 _("Fetch and print the remote list of "
9872 "thread identifiers, one pkt only"));
9873 add_com ("tinfo", class_obscure, threadinfo_test_cmd,
9874 _("Fetch and display info about one thread"));
9875 add_com ("tset", class_obscure, threadset_test_cmd,
9876 _("Test setting to a different thread"));
9877 add_com ("tupd", class_obscure, threadlist_update_test_cmd,
9878 _("Iterate through updating all remote thread info"));
9879 add_com ("talive", class_obscure, threadalive_test,
9880 _(" Remote thread alive test "));
9885 /* Convert a thread ID to a string. Returns the string in a static
9889 remote_pid_to_str (struct target_ops *ops, ptid_t ptid)
9891 static char buf[64];
9892 struct remote_state *rs = get_remote_state ();
9894 if (ptid_equal (ptid, null_ptid))
9895 return normal_pid_to_str (ptid);
9896 else if (ptid_is_pid (ptid))
9898 /* Printing an inferior target id. */
9900 /* When multi-process extensions are off, there's no way in the
9901 remote protocol to know the remote process id, if there's any
9902 at all. There's one exception --- when we're connected with
9903 target extended-remote, and we manually attached to a process
9904 with "attach PID". We don't record anywhere a flag that
9905 allows us to distinguish that case from the case of
9906 connecting with extended-remote and the stub already being
9907 attached to a process, and reporting yes to qAttached, hence
9908 no smart special casing here. */
9909 if (!remote_multi_process_p (rs))
9911 xsnprintf (buf, sizeof buf, "Remote target");
9915 return normal_pid_to_str (ptid);
9919 if (ptid_equal (magic_null_ptid, ptid))
9920 xsnprintf (buf, sizeof buf, "Thread <main>");
9921 else if (rs->extended && remote_multi_process_p (rs))
9922 if (ptid_get_lwp (ptid) == 0)
9923 return normal_pid_to_str (ptid);
9925 xsnprintf (buf, sizeof buf, "Thread %d.%ld",
9926 ptid_get_pid (ptid), ptid_get_lwp (ptid));
9928 xsnprintf (buf, sizeof buf, "Thread %ld",
9929 ptid_get_lwp (ptid));
9934 /* Get the address of the thread local variable in OBJFILE which is
9935 stored at OFFSET within the thread local storage for thread PTID. */
9938 remote_get_thread_local_address (struct target_ops *ops,
9939 ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset)
9941 if (packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE)
9943 struct remote_state *rs = get_remote_state ();
9945 char *endp = rs->buf + get_remote_packet_size ();
9946 enum packet_result result;
9948 strcpy (p, "qGetTLSAddr:");
9950 p = write_ptid (p, endp, ptid);
9952 p += hexnumstr (p, offset);
9954 p += hexnumstr (p, lm);
9958 getpkt (&rs->buf, &rs->buf_size, 0);
9959 result = packet_ok (rs->buf,
9960 &remote_protocol_packets[PACKET_qGetTLSAddr]);
9961 if (result == PACKET_OK)
9965 unpack_varlen_hex (rs->buf, &result);
9968 else if (result == PACKET_UNKNOWN)
9969 throw_error (TLS_GENERIC_ERROR,
9970 _("Remote target doesn't support qGetTLSAddr packet"));
9972 throw_error (TLS_GENERIC_ERROR,
9973 _("Remote target failed to process qGetTLSAddr request"));
9976 throw_error (TLS_GENERIC_ERROR,
9977 _("TLS not supported or disabled on this target"));
9982 /* Provide thread local base, i.e. Thread Information Block address.
9983 Returns 1 if ptid is found and thread_local_base is non zero. */
9986 remote_get_tib_address (struct target_ops *self, ptid_t ptid, CORE_ADDR *addr)
9988 if (packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE)
9990 struct remote_state *rs = get_remote_state ();
9992 char *endp = rs->buf + get_remote_packet_size ();
9993 enum packet_result result;
9995 strcpy (p, "qGetTIBAddr:");
9997 p = write_ptid (p, endp, ptid);
10001 getpkt (&rs->buf, &rs->buf_size, 0);
10002 result = packet_ok (rs->buf,
10003 &remote_protocol_packets[PACKET_qGetTIBAddr]);
10004 if (result == PACKET_OK)
10008 unpack_varlen_hex (rs->buf, &result);
10010 *addr = (CORE_ADDR) result;
10013 else if (result == PACKET_UNKNOWN)
10014 error (_("Remote target doesn't support qGetTIBAddr packet"));
10016 error (_("Remote target failed to process qGetTIBAddr request"));
10019 error (_("qGetTIBAddr not supported or disabled on this target"));
10024 /* Support for inferring a target description based on the current
10025 architecture and the size of a 'g' packet. While the 'g' packet
10026 can have any size (since optional registers can be left off the
10027 end), some sizes are easily recognizable given knowledge of the
10028 approximate architecture. */
10030 struct remote_g_packet_guess
10033 const struct target_desc *tdesc;
10035 typedef struct remote_g_packet_guess remote_g_packet_guess_s;
10036 DEF_VEC_O(remote_g_packet_guess_s);
10038 struct remote_g_packet_data
10040 VEC(remote_g_packet_guess_s) *guesses;
10043 static struct gdbarch_data *remote_g_packet_data_handle;
10046 remote_g_packet_data_init (struct obstack *obstack)
10048 return OBSTACK_ZALLOC (obstack, struct remote_g_packet_data);
10052 register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes,
10053 const struct target_desc *tdesc)
10055 struct remote_g_packet_data *data
10056 = gdbarch_data (gdbarch, remote_g_packet_data_handle);
10057 struct remote_g_packet_guess new_guess, *guess;
10060 gdb_assert (tdesc != NULL);
10063 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
10065 if (guess->bytes == bytes)
10066 internal_error (__FILE__, __LINE__,
10067 _("Duplicate g packet description added for size %d"),
10070 new_guess.bytes = bytes;
10071 new_guess.tdesc = tdesc;
10072 VEC_safe_push (remote_g_packet_guess_s, data->guesses, &new_guess);
10075 /* Return 1 if remote_read_description would do anything on this target
10076 and architecture, 0 otherwise. */
10079 remote_read_description_p (struct target_ops *target)
10081 struct remote_g_packet_data *data
10082 = gdbarch_data (target_gdbarch (), remote_g_packet_data_handle);
10084 if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
10090 static const struct target_desc *
10091 remote_read_description (struct target_ops *target)
10093 struct remote_g_packet_data *data
10094 = gdbarch_data (target_gdbarch (), remote_g_packet_data_handle);
10096 /* Do not try this during initial connection, when we do not know
10097 whether there is a running but stopped thread. */
10098 if (!target_has_execution || ptid_equal (inferior_ptid, null_ptid))
10099 return target->beneath->to_read_description (target->beneath);
10101 if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
10103 struct remote_g_packet_guess *guess;
10105 int bytes = send_g_packet ();
10108 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
10110 if (guess->bytes == bytes)
10111 return guess->tdesc;
10113 /* We discard the g packet. A minor optimization would be to
10114 hold on to it, and fill the register cache once we have selected
10115 an architecture, but it's too tricky to do safely. */
10118 return target->beneath->to_read_description (target->beneath);
10121 /* Remote file transfer support. This is host-initiated I/O, not
10122 target-initiated; for target-initiated, see remote-fileio.c. */
10124 /* If *LEFT is at least the length of STRING, copy STRING to
10125 *BUFFER, update *BUFFER to point to the new end of the buffer, and
10126 decrease *LEFT. Otherwise raise an error. */
10129 remote_buffer_add_string (char **buffer, int *left, char *string)
10131 int len = strlen (string);
10134 error (_("Packet too long for target."));
10136 memcpy (*buffer, string, len);
10140 /* NUL-terminate the buffer as a convenience, if there is
10146 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
10147 *BUFFER, update *BUFFER to point to the new end of the buffer, and
10148 decrease *LEFT. Otherwise raise an error. */
10151 remote_buffer_add_bytes (char **buffer, int *left, const gdb_byte *bytes,
10154 if (2 * len > *left)
10155 error (_("Packet too long for target."));
10157 bin2hex (bytes, *buffer, len);
10158 *buffer += 2 * len;
10161 /* NUL-terminate the buffer as a convenience, if there is
10167 /* If *LEFT is large enough, convert VALUE to hex and add it to
10168 *BUFFER, update *BUFFER to point to the new end of the buffer, and
10169 decrease *LEFT. Otherwise raise an error. */
10172 remote_buffer_add_int (char **buffer, int *left, ULONGEST value)
10174 int len = hexnumlen (value);
10177 error (_("Packet too long for target."));
10179 hexnumstr (*buffer, value);
10183 /* NUL-terminate the buffer as a convenience, if there is
10189 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
10190 value, *REMOTE_ERRNO to the remote error number or zero if none
10191 was included, and *ATTACHMENT to point to the start of the annex
10192 if any. The length of the packet isn't needed here; there may
10193 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
10195 Return 0 if the packet could be parsed, -1 if it could not. If
10196 -1 is returned, the other variables may not be initialized. */
10199 remote_hostio_parse_result (char *buffer, int *retcode,
10200 int *remote_errno, char **attachment)
10205 *attachment = NULL;
10207 if (buffer[0] != 'F')
10211 *retcode = strtol (&buffer[1], &p, 16);
10212 if (errno != 0 || p == &buffer[1])
10215 /* Check for ",errno". */
10219 *remote_errno = strtol (p + 1, &p2, 16);
10220 if (errno != 0 || p + 1 == p2)
10225 /* Check for ";attachment". If there is no attachment, the
10226 packet should end here. */
10229 *attachment = p + 1;
10232 else if (*p == '\0')
10238 /* Send a prepared I/O packet to the target and read its response.
10239 The prepared packet is in the global RS->BUF before this function
10240 is called, and the answer is there when we return.
10242 COMMAND_BYTES is the length of the request to send, which may include
10243 binary data. WHICH_PACKET is the packet configuration to check
10244 before attempting a packet. If an error occurs, *REMOTE_ERRNO
10245 is set to the error number and -1 is returned. Otherwise the value
10246 returned by the function is returned.
10248 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
10249 attachment is expected; an error will be reported if there's a
10250 mismatch. If one is found, *ATTACHMENT will be set to point into
10251 the packet buffer and *ATTACHMENT_LEN will be set to the
10252 attachment's length. */
10255 remote_hostio_send_command (int command_bytes, int which_packet,
10256 int *remote_errno, char **attachment,
10257 int *attachment_len)
10259 struct remote_state *rs = get_remote_state ();
10260 int ret, bytes_read;
10261 char *attachment_tmp;
10263 if (!rs->remote_desc
10264 || packet_support (which_packet) == PACKET_DISABLE)
10266 *remote_errno = FILEIO_ENOSYS;
10270 putpkt_binary (rs->buf, command_bytes);
10271 bytes_read = getpkt_sane (&rs->buf, &rs->buf_size, 0);
10273 /* If it timed out, something is wrong. Don't try to parse the
10275 if (bytes_read < 0)
10277 *remote_errno = FILEIO_EINVAL;
10281 switch (packet_ok (rs->buf, &remote_protocol_packets[which_packet]))
10284 *remote_errno = FILEIO_EINVAL;
10286 case PACKET_UNKNOWN:
10287 *remote_errno = FILEIO_ENOSYS;
10293 if (remote_hostio_parse_result (rs->buf, &ret, remote_errno,
10296 *remote_errno = FILEIO_EINVAL;
10300 /* Make sure we saw an attachment if and only if we expected one. */
10301 if ((attachment_tmp == NULL && attachment != NULL)
10302 || (attachment_tmp != NULL && attachment == NULL))
10304 *remote_errno = FILEIO_EINVAL;
10308 /* If an attachment was found, it must point into the packet buffer;
10309 work out how many bytes there were. */
10310 if (attachment_tmp != NULL)
10312 *attachment = attachment_tmp;
10313 *attachment_len = bytes_read - (*attachment - rs->buf);
10319 /* Set the filesystem remote_hostio functions that take FILENAME
10320 arguments will use. Return 0 on success, or -1 if an error
10321 occurs (and set *REMOTE_ERRNO). */
10324 remote_hostio_set_filesystem (struct inferior *inf, int *remote_errno)
10326 struct remote_state *rs = get_remote_state ();
10327 int required_pid = (inf == NULL || inf->fake_pid_p) ? 0 : inf->pid;
10329 int left = get_remote_packet_size () - 1;
10333 if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
10336 if (rs->fs_pid != -1 && required_pid == rs->fs_pid)
10339 remote_buffer_add_string (&p, &left, "vFile:setfs:");
10341 xsnprintf (arg, sizeof (arg), "%x", required_pid);
10342 remote_buffer_add_string (&p, &left, arg);
10344 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_setfs,
10345 remote_errno, NULL, NULL);
10347 if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
10351 rs->fs_pid = required_pid;
10356 /* Implementation of to_fileio_open. */
10359 remote_hostio_open (struct target_ops *self,
10360 struct inferior *inf, const char *filename,
10361 int flags, int mode, int *remote_errno)
10363 struct remote_state *rs = get_remote_state ();
10365 int left = get_remote_packet_size () - 1;
10367 if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
10370 remote_buffer_add_string (&p, &left, "vFile:open:");
10372 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
10373 strlen (filename));
10374 remote_buffer_add_string (&p, &left, ",");
10376 remote_buffer_add_int (&p, &left, flags);
10377 remote_buffer_add_string (&p, &left, ",");
10379 remote_buffer_add_int (&p, &left, mode);
10381 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_open,
10382 remote_errno, NULL, NULL);
10385 /* Implementation of to_fileio_pwrite. */
10388 remote_hostio_pwrite (struct target_ops *self,
10389 int fd, const gdb_byte *write_buf, int len,
10390 ULONGEST offset, int *remote_errno)
10392 struct remote_state *rs = get_remote_state ();
10394 int left = get_remote_packet_size ();
10397 remote_buffer_add_string (&p, &left, "vFile:pwrite:");
10399 remote_buffer_add_int (&p, &left, fd);
10400 remote_buffer_add_string (&p, &left, ",");
10402 remote_buffer_add_int (&p, &left, offset);
10403 remote_buffer_add_string (&p, &left, ",");
10405 p += remote_escape_output (write_buf, len, 1, (gdb_byte *) p, &out_len,
10406 get_remote_packet_size () - (p - rs->buf));
10408 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_pwrite,
10409 remote_errno, NULL, NULL);
10412 /* Implementation of to_fileio_pread. */
10415 remote_hostio_pread (struct target_ops *self,
10416 int fd, gdb_byte *read_buf, int len,
10417 ULONGEST offset, int *remote_errno)
10419 struct remote_state *rs = get_remote_state ();
10422 int left = get_remote_packet_size ();
10423 int ret, attachment_len;
10426 remote_buffer_add_string (&p, &left, "vFile:pread:");
10428 remote_buffer_add_int (&p, &left, fd);
10429 remote_buffer_add_string (&p, &left, ",");
10431 remote_buffer_add_int (&p, &left, len);
10432 remote_buffer_add_string (&p, &left, ",");
10434 remote_buffer_add_int (&p, &left, offset);
10436 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_pread,
10437 remote_errno, &attachment,
10443 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
10445 if (read_len != ret)
10446 error (_("Read returned %d, but %d bytes."), ret, (int) read_len);
10451 /* Implementation of to_fileio_close. */
10454 remote_hostio_close (struct target_ops *self, int fd, int *remote_errno)
10456 struct remote_state *rs = get_remote_state ();
10458 int left = get_remote_packet_size () - 1;
10460 remote_buffer_add_string (&p, &left, "vFile:close:");
10462 remote_buffer_add_int (&p, &left, fd);
10464 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_close,
10465 remote_errno, NULL, NULL);
10468 /* Implementation of to_fileio_unlink. */
10471 remote_hostio_unlink (struct target_ops *self,
10472 struct inferior *inf, const char *filename,
10475 struct remote_state *rs = get_remote_state ();
10477 int left = get_remote_packet_size () - 1;
10479 if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
10482 remote_buffer_add_string (&p, &left, "vFile:unlink:");
10484 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
10485 strlen (filename));
10487 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_unlink,
10488 remote_errno, NULL, NULL);
10491 /* Implementation of to_fileio_readlink. */
10494 remote_hostio_readlink (struct target_ops *self,
10495 struct inferior *inf, const char *filename,
10498 struct remote_state *rs = get_remote_state ();
10501 int left = get_remote_packet_size ();
10502 int len, attachment_len;
10506 if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
10509 remote_buffer_add_string (&p, &left, "vFile:readlink:");
10511 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
10512 strlen (filename));
10514 len = remote_hostio_send_command (p - rs->buf, PACKET_vFile_readlink,
10515 remote_errno, &attachment,
10521 ret = xmalloc (len + 1);
10523 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
10524 (gdb_byte *) ret, len);
10525 if (read_len != len)
10526 error (_("Readlink returned %d, but %d bytes."), len, read_len);
10532 /* Implementation of to_fileio_fstat. */
10535 remote_hostio_fstat (struct target_ops *self,
10536 int fd, struct stat *st,
10539 struct remote_state *rs = get_remote_state ();
10541 int left = get_remote_packet_size ();
10542 int attachment_len, ret;
10544 struct fio_stat fst;
10547 remote_buffer_add_string (&p, &left, "vFile:fstat:");
10549 remote_buffer_add_int (&p, &left, fd);
10551 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_fstat,
10552 remote_errno, &attachment,
10556 if (*remote_errno != FILEIO_ENOSYS)
10559 /* Strictly we should return -1, ENOSYS here, but when
10560 "set sysroot remote:" was implemented in August 2008
10561 BFD's need for a stat function was sidestepped with
10562 this hack. This was not remedied until March 2015
10563 so we retain the previous behavior to avoid breaking
10566 Note that the memset is a March 2015 addition; older
10567 GDBs set st_size *and nothing else* so the structure
10568 would have garbage in all other fields. This might
10569 break something but retaining the previous behavior
10570 here would be just too wrong. */
10572 memset (st, 0, sizeof (struct stat));
10573 st->st_size = INT_MAX;
10577 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
10578 (gdb_byte *) &fst, sizeof (fst));
10580 if (read_len != ret)
10581 error (_("vFile:fstat returned %d, but %d bytes."), ret, read_len);
10583 if (read_len != sizeof (fst))
10584 error (_("vFile:fstat returned %d bytes, but expecting %d."),
10585 read_len, (int) sizeof (fst));
10587 remote_fileio_to_host_stat (&fst, st);
10592 /* Implementation of to_filesystem_is_local. */
10595 remote_filesystem_is_local (struct target_ops *self)
10597 /* Valgrind GDB presents itself as a remote target but works
10598 on the local filesystem: it does not implement remote get
10599 and users are not expected to set a sysroot. To handle
10600 this case we treat the remote filesystem as local if the
10601 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
10602 does not support vFile:open. */
10603 if (strcmp (gdb_sysroot, TARGET_SYSROOT_PREFIX) == 0)
10605 enum packet_support ps = packet_support (PACKET_vFile_open);
10607 if (ps == PACKET_SUPPORT_UNKNOWN)
10609 int fd, remote_errno;
10611 /* Try opening a file to probe support. The supplied
10612 filename is irrelevant, we only care about whether
10613 the stub recognizes the packet or not. */
10614 fd = remote_hostio_open (self, NULL, "just probing",
10615 FILEIO_O_RDONLY, 0700,
10619 remote_hostio_close (self, fd, &remote_errno);
10621 ps = packet_support (PACKET_vFile_open);
10624 if (ps == PACKET_DISABLE)
10626 static int warning_issued = 0;
10628 if (!warning_issued)
10630 warning (_("remote target does not support file"
10631 " transfer, attempting to access files"
10632 " from local filesystem."));
10633 warning_issued = 1;
10644 remote_fileio_errno_to_host (int errnum)
10650 case FILEIO_ENOENT:
10658 case FILEIO_EACCES:
10660 case FILEIO_EFAULT:
10664 case FILEIO_EEXIST:
10666 case FILEIO_ENODEV:
10668 case FILEIO_ENOTDIR:
10670 case FILEIO_EISDIR:
10672 case FILEIO_EINVAL:
10674 case FILEIO_ENFILE:
10676 case FILEIO_EMFILE:
10680 case FILEIO_ENOSPC:
10682 case FILEIO_ESPIPE:
10686 case FILEIO_ENOSYS:
10688 case FILEIO_ENAMETOOLONG:
10689 return ENAMETOOLONG;
10695 remote_hostio_error (int errnum)
10697 int host_error = remote_fileio_errno_to_host (errnum);
10699 if (host_error == -1)
10700 error (_("Unknown remote I/O error %d"), errnum);
10702 error (_("Remote I/O error: %s"), safe_strerror (host_error));
10706 remote_hostio_close_cleanup (void *opaque)
10708 int fd = *(int *) opaque;
10711 remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno);
10715 remote_file_put (const char *local_file, const char *remote_file, int from_tty)
10717 struct cleanup *back_to, *close_cleanup;
10718 int retcode, fd, remote_errno, bytes, io_size;
10721 int bytes_in_buffer;
10724 struct remote_state *rs = get_remote_state ();
10726 if (!rs->remote_desc)
10727 error (_("command can only be used with remote target"));
10729 file = gdb_fopen_cloexec (local_file, "rb");
10731 perror_with_name (local_file);
10732 back_to = make_cleanup_fclose (file);
10734 fd = remote_hostio_open (find_target_at (process_stratum), NULL,
10735 remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT
10737 0700, &remote_errno);
10739 remote_hostio_error (remote_errno);
10741 /* Send up to this many bytes at once. They won't all fit in the
10742 remote packet limit, so we'll transfer slightly fewer. */
10743 io_size = get_remote_packet_size ();
10744 buffer = xmalloc (io_size);
10745 make_cleanup (xfree, buffer);
10747 close_cleanup = make_cleanup (remote_hostio_close_cleanup, &fd);
10749 bytes_in_buffer = 0;
10752 while (bytes_in_buffer || !saw_eof)
10756 bytes = fread (buffer + bytes_in_buffer, 1,
10757 io_size - bytes_in_buffer,
10762 error (_("Error reading %s."), local_file);
10765 /* EOF. Unless there is something still in the
10766 buffer from the last iteration, we are done. */
10768 if (bytes_in_buffer == 0)
10776 bytes += bytes_in_buffer;
10777 bytes_in_buffer = 0;
10779 retcode = remote_hostio_pwrite (find_target_at (process_stratum),
10781 offset, &remote_errno);
10784 remote_hostio_error (remote_errno);
10785 else if (retcode == 0)
10786 error (_("Remote write of %d bytes returned 0!"), bytes);
10787 else if (retcode < bytes)
10789 /* Short write. Save the rest of the read data for the next
10791 bytes_in_buffer = bytes - retcode;
10792 memmove (buffer, buffer + retcode, bytes_in_buffer);
10798 discard_cleanups (close_cleanup);
10799 if (remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno))
10800 remote_hostio_error (remote_errno);
10803 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file);
10804 do_cleanups (back_to);
10808 remote_file_get (const char *remote_file, const char *local_file, int from_tty)
10810 struct cleanup *back_to, *close_cleanup;
10811 int fd, remote_errno, bytes, io_size;
10815 struct remote_state *rs = get_remote_state ();
10817 if (!rs->remote_desc)
10818 error (_("command can only be used with remote target"));
10820 fd = remote_hostio_open (find_target_at (process_stratum), NULL,
10821 remote_file, FILEIO_O_RDONLY, 0, &remote_errno);
10823 remote_hostio_error (remote_errno);
10825 file = gdb_fopen_cloexec (local_file, "wb");
10827 perror_with_name (local_file);
10828 back_to = make_cleanup_fclose (file);
10830 /* Send up to this many bytes at once. They won't all fit in the
10831 remote packet limit, so we'll transfer slightly fewer. */
10832 io_size = get_remote_packet_size ();
10833 buffer = xmalloc (io_size);
10834 make_cleanup (xfree, buffer);
10836 close_cleanup = make_cleanup (remote_hostio_close_cleanup, &fd);
10841 bytes = remote_hostio_pread (find_target_at (process_stratum),
10842 fd, buffer, io_size, offset, &remote_errno);
10844 /* Success, but no bytes, means end-of-file. */
10847 remote_hostio_error (remote_errno);
10851 bytes = fwrite (buffer, 1, bytes, file);
10853 perror_with_name (local_file);
10856 discard_cleanups (close_cleanup);
10857 if (remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno))
10858 remote_hostio_error (remote_errno);
10861 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file);
10862 do_cleanups (back_to);
10866 remote_file_delete (const char *remote_file, int from_tty)
10868 int retcode, remote_errno;
10869 struct remote_state *rs = get_remote_state ();
10871 if (!rs->remote_desc)
10872 error (_("command can only be used with remote target"));
10874 retcode = remote_hostio_unlink (find_target_at (process_stratum),
10875 NULL, remote_file, &remote_errno);
10877 remote_hostio_error (remote_errno);
10880 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file);
10884 remote_put_command (char *args, int from_tty)
10886 struct cleanup *back_to;
10890 error_no_arg (_("file to put"));
10892 argv = gdb_buildargv (args);
10893 back_to = make_cleanup_freeargv (argv);
10894 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL)
10895 error (_("Invalid parameters to remote put"));
10897 remote_file_put (argv[0], argv[1], from_tty);
10899 do_cleanups (back_to);
10903 remote_get_command (char *args, int from_tty)
10905 struct cleanup *back_to;
10909 error_no_arg (_("file to get"));
10911 argv = gdb_buildargv (args);
10912 back_to = make_cleanup_freeargv (argv);
10913 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL)
10914 error (_("Invalid parameters to remote get"));
10916 remote_file_get (argv[0], argv[1], from_tty);
10918 do_cleanups (back_to);
10922 remote_delete_command (char *args, int from_tty)
10924 struct cleanup *back_to;
10928 error_no_arg (_("file to delete"));
10930 argv = gdb_buildargv (args);
10931 back_to = make_cleanup_freeargv (argv);
10932 if (argv[0] == NULL || argv[1] != NULL)
10933 error (_("Invalid parameters to remote delete"));
10935 remote_file_delete (argv[0], from_tty);
10937 do_cleanups (back_to);
10941 remote_command (char *args, int from_tty)
10943 help_list (remote_cmdlist, "remote ", all_commands, gdb_stdout);
10947 remote_can_execute_reverse (struct target_ops *self)
10949 if (packet_support (PACKET_bs) == PACKET_ENABLE
10950 || packet_support (PACKET_bc) == PACKET_ENABLE)
10957 remote_supports_non_stop (struct target_ops *self)
10963 remote_supports_disable_randomization (struct target_ops *self)
10965 /* Only supported in extended mode. */
10970 remote_supports_multi_process (struct target_ops *self)
10972 struct remote_state *rs = get_remote_state ();
10974 /* Only extended-remote handles being attached to multiple
10975 processes, even though plain remote can use the multi-process
10976 thread id extensions, so that GDB knows the target process's
10978 return rs->extended && remote_multi_process_p (rs);
10982 remote_supports_cond_tracepoints (void)
10984 return packet_support (PACKET_ConditionalTracepoints) == PACKET_ENABLE;
10988 remote_supports_cond_breakpoints (struct target_ops *self)
10990 return packet_support (PACKET_ConditionalBreakpoints) == PACKET_ENABLE;
10994 remote_supports_fast_tracepoints (void)
10996 return packet_support (PACKET_FastTracepoints) == PACKET_ENABLE;
11000 remote_supports_static_tracepoints (void)
11002 return packet_support (PACKET_StaticTracepoints) == PACKET_ENABLE;
11006 remote_supports_install_in_trace (void)
11008 return packet_support (PACKET_InstallInTrace) == PACKET_ENABLE;
11012 remote_supports_enable_disable_tracepoint (struct target_ops *self)
11014 return (packet_support (PACKET_EnableDisableTracepoints_feature)
11019 remote_supports_string_tracing (struct target_ops *self)
11021 return packet_support (PACKET_tracenz_feature) == PACKET_ENABLE;
11025 remote_can_run_breakpoint_commands (struct target_ops *self)
11027 return packet_support (PACKET_BreakpointCommands) == PACKET_ENABLE;
11031 remote_trace_init (struct target_ops *self)
11034 remote_get_noisy_reply (&target_buf, &target_buf_size);
11035 if (strcmp (target_buf, "OK") != 0)
11036 error (_("Target does not support this command."));
11039 static void free_actions_list (char **actions_list);
11040 static void free_actions_list_cleanup_wrapper (void *);
11042 free_actions_list_cleanup_wrapper (void *al)
11044 free_actions_list (al);
11048 free_actions_list (char **actions_list)
11052 if (actions_list == 0)
11055 for (ndx = 0; actions_list[ndx]; ndx++)
11056 xfree (actions_list[ndx]);
11058 xfree (actions_list);
11061 /* Recursive routine to walk through command list including loops, and
11062 download packets for each command. */
11065 remote_download_command_source (int num, ULONGEST addr,
11066 struct command_line *cmds)
11068 struct remote_state *rs = get_remote_state ();
11069 struct command_line *cmd;
11071 for (cmd = cmds; cmd; cmd = cmd->next)
11073 QUIT; /* Allow user to bail out with ^C. */
11074 strcpy (rs->buf, "QTDPsrc:");
11075 encode_source_string (num, addr, "cmd", cmd->line,
11076 rs->buf + strlen (rs->buf),
11077 rs->buf_size - strlen (rs->buf));
11079 remote_get_noisy_reply (&target_buf, &target_buf_size);
11080 if (strcmp (target_buf, "OK"))
11081 warning (_("Target does not support source download."));
11083 if (cmd->control_type == while_control
11084 || cmd->control_type == while_stepping_control)
11086 remote_download_command_source (num, addr, *cmd->body_list);
11088 QUIT; /* Allow user to bail out with ^C. */
11089 strcpy (rs->buf, "QTDPsrc:");
11090 encode_source_string (num, addr, "cmd", "end",
11091 rs->buf + strlen (rs->buf),
11092 rs->buf_size - strlen (rs->buf));
11094 remote_get_noisy_reply (&target_buf, &target_buf_size);
11095 if (strcmp (target_buf, "OK"))
11096 warning (_("Target does not support source download."));
11102 remote_download_tracepoint (struct target_ops *self, struct bp_location *loc)
11104 #define BUF_SIZE 2048
11108 char buf[BUF_SIZE];
11109 char **tdp_actions;
11110 char **stepping_actions;
11112 struct cleanup *old_chain = NULL;
11113 struct agent_expr *aexpr;
11114 struct cleanup *aexpr_chain = NULL;
11116 struct breakpoint *b = loc->owner;
11117 struct tracepoint *t = (struct tracepoint *) b;
11119 encode_actions_rsp (loc, &tdp_actions, &stepping_actions);
11120 old_chain = make_cleanup (free_actions_list_cleanup_wrapper,
11122 (void) make_cleanup (free_actions_list_cleanup_wrapper,
11125 tpaddr = loc->address;
11126 sprintf_vma (addrbuf, tpaddr);
11127 xsnprintf (buf, BUF_SIZE, "QTDP:%x:%s:%c:%lx:%x", b->number,
11128 addrbuf, /* address */
11129 (b->enable_state == bp_enabled ? 'E' : 'D'),
11130 t->step_count, t->pass_count);
11131 /* Fast tracepoints are mostly handled by the target, but we can
11132 tell the target how big of an instruction block should be moved
11134 if (b->type == bp_fast_tracepoint)
11136 /* Only test for support at download time; we may not know
11137 target capabilities at definition time. */
11138 if (remote_supports_fast_tracepoints ())
11140 if (gdbarch_fast_tracepoint_valid_at (loc->gdbarch, tpaddr,
11142 xsnprintf (buf + strlen (buf), BUF_SIZE - strlen (buf), ":F%x",
11143 gdb_insn_length (loc->gdbarch, tpaddr));
11145 /* If it passed validation at definition but fails now,
11146 something is very wrong. */
11147 internal_error (__FILE__, __LINE__,
11148 _("Fast tracepoint not "
11149 "valid during download"));
11152 /* Fast tracepoints are functionally identical to regular
11153 tracepoints, so don't take lack of support as a reason to
11154 give up on the trace run. */
11155 warning (_("Target does not support fast tracepoints, "
11156 "downloading %d as regular tracepoint"), b->number);
11158 else if (b->type == bp_static_tracepoint)
11160 /* Only test for support at download time; we may not know
11161 target capabilities at definition time. */
11162 if (remote_supports_static_tracepoints ())
11164 struct static_tracepoint_marker marker;
11166 if (target_static_tracepoint_marker_at (tpaddr, &marker))
11167 strcat (buf, ":S");
11169 error (_("Static tracepoint not valid during download"));
11172 /* Fast tracepoints are functionally identical to regular
11173 tracepoints, so don't take lack of support as a reason
11174 to give up on the trace run. */
11175 error (_("Target does not support static tracepoints"));
11177 /* If the tracepoint has a conditional, make it into an agent
11178 expression and append to the definition. */
11181 /* Only test support at download time, we may not know target
11182 capabilities at definition time. */
11183 if (remote_supports_cond_tracepoints ())
11185 aexpr = gen_eval_for_expr (tpaddr, loc->cond);
11186 aexpr_chain = make_cleanup_free_agent_expr (aexpr);
11187 xsnprintf (buf + strlen (buf), BUF_SIZE - strlen (buf), ":X%x,",
11189 pkt = buf + strlen (buf);
11190 for (ndx = 0; ndx < aexpr->len; ++ndx)
11191 pkt = pack_hex_byte (pkt, aexpr->buf[ndx]);
11193 do_cleanups (aexpr_chain);
11196 warning (_("Target does not support conditional tracepoints, "
11197 "ignoring tp %d cond"), b->number);
11200 if (b->commands || *default_collect)
11203 remote_get_noisy_reply (&target_buf, &target_buf_size);
11204 if (strcmp (target_buf, "OK"))
11205 error (_("Target does not support tracepoints."));
11207 /* do_single_steps (t); */
11210 for (ndx = 0; tdp_actions[ndx]; ndx++)
11212 QUIT; /* Allow user to bail out with ^C. */
11213 xsnprintf (buf, BUF_SIZE, "QTDP:-%x:%s:%s%c",
11214 b->number, addrbuf, /* address */
11216 ((tdp_actions[ndx + 1] || stepping_actions)
11219 remote_get_noisy_reply (&target_buf,
11221 if (strcmp (target_buf, "OK"))
11222 error (_("Error on target while setting tracepoints."));
11225 if (stepping_actions)
11227 for (ndx = 0; stepping_actions[ndx]; ndx++)
11229 QUIT; /* Allow user to bail out with ^C. */
11230 xsnprintf (buf, BUF_SIZE, "QTDP:-%x:%s:%s%s%s",
11231 b->number, addrbuf, /* address */
11232 ((ndx == 0) ? "S" : ""),
11233 stepping_actions[ndx],
11234 (stepping_actions[ndx + 1] ? "-" : ""));
11236 remote_get_noisy_reply (&target_buf,
11238 if (strcmp (target_buf, "OK"))
11239 error (_("Error on target while setting tracepoints."));
11243 if (packet_support (PACKET_TracepointSource) == PACKET_ENABLE)
11245 if (b->addr_string)
11247 strcpy (buf, "QTDPsrc:");
11248 encode_source_string (b->number, loc->address,
11249 "at", b->addr_string, buf + strlen (buf),
11250 2048 - strlen (buf));
11253 remote_get_noisy_reply (&target_buf, &target_buf_size);
11254 if (strcmp (target_buf, "OK"))
11255 warning (_("Target does not support source download."));
11257 if (b->cond_string)
11259 strcpy (buf, "QTDPsrc:");
11260 encode_source_string (b->number, loc->address,
11261 "cond", b->cond_string, buf + strlen (buf),
11262 2048 - strlen (buf));
11264 remote_get_noisy_reply (&target_buf, &target_buf_size);
11265 if (strcmp (target_buf, "OK"))
11266 warning (_("Target does not support source download."));
11268 remote_download_command_source (b->number, loc->address,
11269 breakpoint_commands (b));
11272 do_cleanups (old_chain);
11276 remote_can_download_tracepoint (struct target_ops *self)
11278 struct remote_state *rs = get_remote_state ();
11279 struct trace_status *ts;
11282 /* Don't try to install tracepoints until we've relocated our
11283 symbols, and fetched and merged the target's tracepoint list with
11285 if (rs->starting_up)
11288 ts = current_trace_status ();
11289 status = remote_get_trace_status (self, ts);
11291 if (status == -1 || !ts->running_known || !ts->running)
11294 /* If we are in a tracing experiment, but remote stub doesn't support
11295 installing tracepoint in trace, we have to return. */
11296 if (!remote_supports_install_in_trace ())
11304 remote_download_trace_state_variable (struct target_ops *self,
11305 struct trace_state_variable *tsv)
11307 struct remote_state *rs = get_remote_state ();
11310 xsnprintf (rs->buf, get_remote_packet_size (), "QTDV:%x:%s:%x:",
11311 tsv->number, phex ((ULONGEST) tsv->initial_value, 8),
11313 p = rs->buf + strlen (rs->buf);
11314 if ((p - rs->buf) + strlen (tsv->name) * 2 >= get_remote_packet_size ())
11315 error (_("Trace state variable name too long for tsv definition packet"));
11316 p += 2 * bin2hex ((gdb_byte *) (tsv->name), p, strlen (tsv->name));
11319 remote_get_noisy_reply (&target_buf, &target_buf_size);
11320 if (*target_buf == '\0')
11321 error (_("Target does not support this command."));
11322 if (strcmp (target_buf, "OK") != 0)
11323 error (_("Error on target while downloading trace state variable."));
11327 remote_enable_tracepoint (struct target_ops *self,
11328 struct bp_location *location)
11330 struct remote_state *rs = get_remote_state ();
11333 sprintf_vma (addr_buf, location->address);
11334 xsnprintf (rs->buf, get_remote_packet_size (), "QTEnable:%x:%s",
11335 location->owner->number, addr_buf);
11337 remote_get_noisy_reply (&rs->buf, &rs->buf_size);
11338 if (*rs->buf == '\0')
11339 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
11340 if (strcmp (rs->buf, "OK") != 0)
11341 error (_("Error on target while enabling tracepoint."));
11345 remote_disable_tracepoint (struct target_ops *self,
11346 struct bp_location *location)
11348 struct remote_state *rs = get_remote_state ();
11351 sprintf_vma (addr_buf, location->address);
11352 xsnprintf (rs->buf, get_remote_packet_size (), "QTDisable:%x:%s",
11353 location->owner->number, addr_buf);
11355 remote_get_noisy_reply (&rs->buf, &rs->buf_size);
11356 if (*rs->buf == '\0')
11357 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
11358 if (strcmp (rs->buf, "OK") != 0)
11359 error (_("Error on target while disabling tracepoint."));
11363 remote_trace_set_readonly_regions (struct target_ops *self)
11367 bfd_size_type size;
11373 return; /* No information to give. */
11375 strcpy (target_buf, "QTro");
11376 offset = strlen (target_buf);
11377 for (s = exec_bfd->sections; s; s = s->next)
11379 char tmp1[40], tmp2[40];
11382 if ((s->flags & SEC_LOAD) == 0 ||
11383 /* (s->flags & SEC_CODE) == 0 || */
11384 (s->flags & SEC_READONLY) == 0)
11388 vma = bfd_get_section_vma (abfd, s);
11389 size = bfd_get_section_size (s);
11390 sprintf_vma (tmp1, vma);
11391 sprintf_vma (tmp2, vma + size);
11392 sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2);
11393 if (offset + sec_length + 1 > target_buf_size)
11395 if (packet_support (PACKET_qXfer_traceframe_info) != PACKET_ENABLE)
11397 Too many sections for read-only sections definition packet."));
11400 xsnprintf (target_buf + offset, target_buf_size - offset, ":%s,%s",
11402 offset += sec_length;
11406 putpkt (target_buf);
11407 getpkt (&target_buf, &target_buf_size, 0);
11412 remote_trace_start (struct target_ops *self)
11414 putpkt ("QTStart");
11415 remote_get_noisy_reply (&target_buf, &target_buf_size);
11416 if (*target_buf == '\0')
11417 error (_("Target does not support this command."));
11418 if (strcmp (target_buf, "OK") != 0)
11419 error (_("Bogus reply from target: %s"), target_buf);
11423 remote_get_trace_status (struct target_ops *self, struct trace_status *ts)
11425 /* Initialize it just to avoid a GCC false warning. */
11427 /* FIXME we need to get register block size some other way. */
11428 extern int trace_regblock_size;
11429 enum packet_result result;
11431 if (packet_support (PACKET_qTStatus) == PACKET_DISABLE)
11434 trace_regblock_size = get_remote_arch_state ()->sizeof_g_packet;
11436 putpkt ("qTStatus");
11440 p = remote_get_noisy_reply (&target_buf, &target_buf_size);
11442 CATCH (ex, RETURN_MASK_ERROR)
11444 if (ex.error != TARGET_CLOSE_ERROR)
11446 exception_fprintf (gdb_stderr, ex, "qTStatus: ");
11449 throw_exception (ex);
11453 result = packet_ok (p, &remote_protocol_packets[PACKET_qTStatus]);
11455 /* If the remote target doesn't do tracing, flag it. */
11456 if (result == PACKET_UNKNOWN)
11459 /* We're working with a live target. */
11460 ts->filename = NULL;
11463 error (_("Bogus trace status reply from target: %s"), target_buf);
11465 /* Function 'parse_trace_status' sets default value of each field of
11466 'ts' at first, so we don't have to do it here. */
11467 parse_trace_status (p, ts);
11469 return ts->running;
11473 remote_get_tracepoint_status (struct target_ops *self, struct breakpoint *bp,
11474 struct uploaded_tp *utp)
11476 struct remote_state *rs = get_remote_state ();
11478 struct bp_location *loc;
11479 struct tracepoint *tp = (struct tracepoint *) bp;
11480 size_t size = get_remote_packet_size ();
11484 tp->base.hit_count = 0;
11485 tp->traceframe_usage = 0;
11486 for (loc = tp->base.loc; loc; loc = loc->next)
11488 /* If the tracepoint was never downloaded, don't go asking for
11490 if (tp->number_on_target == 0)
11492 xsnprintf (rs->buf, size, "qTP:%x:%s", tp->number_on_target,
11493 phex_nz (loc->address, 0));
11495 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
11496 if (reply && *reply)
11499 parse_tracepoint_status (reply + 1, bp, utp);
11505 utp->hit_count = 0;
11506 utp->traceframe_usage = 0;
11507 xsnprintf (rs->buf, size, "qTP:%x:%s", utp->number,
11508 phex_nz (utp->addr, 0));
11510 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
11511 if (reply && *reply)
11514 parse_tracepoint_status (reply + 1, bp, utp);
11520 remote_trace_stop (struct target_ops *self)
11523 remote_get_noisy_reply (&target_buf, &target_buf_size);
11524 if (*target_buf == '\0')
11525 error (_("Target does not support this command."));
11526 if (strcmp (target_buf, "OK") != 0)
11527 error (_("Bogus reply from target: %s"), target_buf);
11531 remote_trace_find (struct target_ops *self,
11532 enum trace_find_type type, int num,
11533 CORE_ADDR addr1, CORE_ADDR addr2,
11536 struct remote_state *rs = get_remote_state ();
11537 char *endbuf = rs->buf + get_remote_packet_size ();
11539 int target_frameno = -1, target_tracept = -1;
11541 /* Lookups other than by absolute frame number depend on the current
11542 trace selected, so make sure it is correct on the remote end
11544 if (type != tfind_number)
11545 set_remote_traceframe ();
11548 strcpy (p, "QTFrame:");
11549 p = strchr (p, '\0');
11553 xsnprintf (p, endbuf - p, "%x", num);
11556 xsnprintf (p, endbuf - p, "pc:%s", phex_nz (addr1, 0));
11559 xsnprintf (p, endbuf - p, "tdp:%x", num);
11562 xsnprintf (p, endbuf - p, "range:%s:%s", phex_nz (addr1, 0),
11563 phex_nz (addr2, 0));
11565 case tfind_outside:
11566 xsnprintf (p, endbuf - p, "outside:%s:%s", phex_nz (addr1, 0),
11567 phex_nz (addr2, 0));
11570 error (_("Unknown trace find type %d"), type);
11574 reply = remote_get_noisy_reply (&(rs->buf), &rs->buf_size);
11575 if (*reply == '\0')
11576 error (_("Target does not support this command."));
11578 while (reply && *reply)
11583 target_frameno = (int) strtol (p, &reply, 16);
11585 error (_("Unable to parse trace frame number"));
11586 /* Don't update our remote traceframe number cache on failure
11587 to select a remote traceframe. */
11588 if (target_frameno == -1)
11593 target_tracept = (int) strtol (p, &reply, 16);
11595 error (_("Unable to parse tracepoint number"));
11597 case 'O': /* "OK"? */
11598 if (reply[1] == 'K' && reply[2] == '\0')
11601 error (_("Bogus reply from target: %s"), reply);
11604 error (_("Bogus reply from target: %s"), reply);
11607 *tpp = target_tracept;
11609 rs->remote_traceframe_number = target_frameno;
11610 return target_frameno;
11614 remote_get_trace_state_variable_value (struct target_ops *self,
11615 int tsvnum, LONGEST *val)
11617 struct remote_state *rs = get_remote_state ();
11621 set_remote_traceframe ();
11623 xsnprintf (rs->buf, get_remote_packet_size (), "qTV:%x", tsvnum);
11625 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
11626 if (reply && *reply)
11630 unpack_varlen_hex (reply + 1, &uval);
11631 *val = (LONGEST) uval;
11639 remote_save_trace_data (struct target_ops *self, const char *filename)
11641 struct remote_state *rs = get_remote_state ();
11645 strcpy (p, "QTSave:");
11647 if ((p - rs->buf) + strlen (filename) * 2 >= get_remote_packet_size ())
11648 error (_("Remote file name too long for trace save packet"));
11649 p += 2 * bin2hex ((gdb_byte *) filename, p, strlen (filename));
11652 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
11653 if (*reply == '\0')
11654 error (_("Target does not support this command."));
11655 if (strcmp (reply, "OK") != 0)
11656 error (_("Bogus reply from target: %s"), reply);
11660 /* This is basically a memory transfer, but needs to be its own packet
11661 because we don't know how the target actually organizes its trace
11662 memory, plus we want to be able to ask for as much as possible, but
11663 not be unhappy if we don't get as much as we ask for. */
11666 remote_get_raw_trace_data (struct target_ops *self,
11667 gdb_byte *buf, ULONGEST offset, LONGEST len)
11669 struct remote_state *rs = get_remote_state ();
11675 strcpy (p, "qTBuffer:");
11677 p += hexnumstr (p, offset);
11679 p += hexnumstr (p, len);
11683 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
11684 if (reply && *reply)
11686 /* 'l' by itself means we're at the end of the buffer and
11687 there is nothing more to get. */
11691 /* Convert the reply into binary. Limit the number of bytes to
11692 convert according to our passed-in buffer size, rather than
11693 what was returned in the packet; if the target is
11694 unexpectedly generous and gives us a bigger reply than we
11695 asked for, we don't want to crash. */
11696 rslt = hex2bin (target_buf, buf, len);
11700 /* Something went wrong, flag as an error. */
11705 remote_set_disconnected_tracing (struct target_ops *self, int val)
11707 struct remote_state *rs = get_remote_state ();
11709 if (packet_support (PACKET_DisconnectedTracing_feature) == PACKET_ENABLE)
11713 xsnprintf (rs->buf, get_remote_packet_size (), "QTDisconnected:%x", val);
11715 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
11716 if (*reply == '\0')
11717 error (_("Target does not support this command."));
11718 if (strcmp (reply, "OK") != 0)
11719 error (_("Bogus reply from target: %s"), reply);
11722 warning (_("Target does not support disconnected tracing."));
11726 remote_core_of_thread (struct target_ops *ops, ptid_t ptid)
11728 struct thread_info *info = find_thread_ptid (ptid);
11730 if (info && info->priv)
11731 return info->priv->core;
11736 remote_set_circular_trace_buffer (struct target_ops *self, int val)
11738 struct remote_state *rs = get_remote_state ();
11741 xsnprintf (rs->buf, get_remote_packet_size (), "QTBuffer:circular:%x", val);
11743 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
11744 if (*reply == '\0')
11745 error (_("Target does not support this command."));
11746 if (strcmp (reply, "OK") != 0)
11747 error (_("Bogus reply from target: %s"), reply);
11750 static struct traceframe_info *
11751 remote_traceframe_info (struct target_ops *self)
11755 text = target_read_stralloc (¤t_target,
11756 TARGET_OBJECT_TRACEFRAME_INFO, NULL);
11759 struct traceframe_info *info;
11760 struct cleanup *back_to = make_cleanup (xfree, text);
11762 info = parse_traceframe_info (text);
11763 do_cleanups (back_to);
11770 /* Handle the qTMinFTPILen packet. Returns the minimum length of
11771 instruction on which a fast tracepoint may be placed. Returns -1
11772 if the packet is not supported, and 0 if the minimum instruction
11773 length is unknown. */
11776 remote_get_min_fast_tracepoint_insn_len (struct target_ops *self)
11778 struct remote_state *rs = get_remote_state ();
11781 /* If we're not debugging a process yet, the IPA can't be
11783 if (!target_has_execution)
11786 /* Make sure the remote is pointing at the right process. */
11787 set_general_process ();
11789 xsnprintf (rs->buf, get_remote_packet_size (), "qTMinFTPILen");
11791 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
11792 if (*reply == '\0')
11796 ULONGEST min_insn_len;
11798 unpack_varlen_hex (reply, &min_insn_len);
11800 return (int) min_insn_len;
11805 remote_set_trace_buffer_size (struct target_ops *self, LONGEST val)
11807 if (packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE)
11809 struct remote_state *rs = get_remote_state ();
11810 char *buf = rs->buf;
11811 char *endbuf = rs->buf + get_remote_packet_size ();
11812 enum packet_result result;
11814 gdb_assert (val >= 0 || val == -1);
11815 buf += xsnprintf (buf, endbuf - buf, "QTBuffer:size:");
11816 /* Send -1 as literal "-1" to avoid host size dependency. */
11820 buf += hexnumstr (buf, (ULONGEST) -val);
11823 buf += hexnumstr (buf, (ULONGEST) val);
11826 remote_get_noisy_reply (&rs->buf, &rs->buf_size);
11827 result = packet_ok (rs->buf,
11828 &remote_protocol_packets[PACKET_QTBuffer_size]);
11830 if (result != PACKET_OK)
11831 warning (_("Bogus reply from target: %s"), rs->buf);
11836 remote_set_trace_notes (struct target_ops *self,
11837 const char *user, const char *notes,
11838 const char *stop_notes)
11840 struct remote_state *rs = get_remote_state ();
11842 char *buf = rs->buf;
11843 char *endbuf = rs->buf + get_remote_packet_size ();
11846 buf += xsnprintf (buf, endbuf - buf, "QTNotes:");
11849 buf += xsnprintf (buf, endbuf - buf, "user:");
11850 nbytes = bin2hex ((gdb_byte *) user, buf, strlen (user));
11856 buf += xsnprintf (buf, endbuf - buf, "notes:");
11857 nbytes = bin2hex ((gdb_byte *) notes, buf, strlen (notes));
11863 buf += xsnprintf (buf, endbuf - buf, "tstop:");
11864 nbytes = bin2hex ((gdb_byte *) stop_notes, buf, strlen (stop_notes));
11868 /* Ensure the buffer is terminated. */
11872 reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
11873 if (*reply == '\0')
11876 if (strcmp (reply, "OK") != 0)
11877 error (_("Bogus reply from target: %s"), reply);
11883 remote_use_agent (struct target_ops *self, int use)
11885 if (packet_support (PACKET_QAgent) != PACKET_DISABLE)
11887 struct remote_state *rs = get_remote_state ();
11889 /* If the stub supports QAgent. */
11890 xsnprintf (rs->buf, get_remote_packet_size (), "QAgent:%d", use);
11892 getpkt (&rs->buf, &rs->buf_size, 0);
11894 if (strcmp (rs->buf, "OK") == 0)
11905 remote_can_use_agent (struct target_ops *self)
11907 return (packet_support (PACKET_QAgent) != PACKET_DISABLE);
11910 struct btrace_target_info
11912 /* The ptid of the traced thread. */
11915 /* The obtained branch trace configuration. */
11916 struct btrace_config conf;
11919 /* Reset our idea of our target's btrace configuration. */
11922 remote_btrace_reset (void)
11924 struct remote_state *rs = get_remote_state ();
11926 memset (&rs->btrace_config, 0, sizeof (rs->btrace_config));
11929 /* Check whether the target supports branch tracing. */
11932 remote_supports_btrace (struct target_ops *self, enum btrace_format format)
11934 if (packet_support (PACKET_Qbtrace_off) != PACKET_ENABLE)
11936 if (packet_support (PACKET_qXfer_btrace) != PACKET_ENABLE)
11941 case BTRACE_FORMAT_NONE:
11944 case BTRACE_FORMAT_BTS:
11945 return (packet_support (PACKET_Qbtrace_bts) == PACKET_ENABLE);
11947 case BTRACE_FORMAT_PT:
11948 /* The trace is decoded on the host. Even if our target supports it,
11949 we still need to have libipt to decode the trace. */
11950 #if defined (HAVE_LIBIPT)
11951 return (packet_support (PACKET_Qbtrace_pt) == PACKET_ENABLE);
11952 #else /* !defined (HAVE_LIBIPT) */
11954 #endif /* !defined (HAVE_LIBIPT) */
11957 internal_error (__FILE__, __LINE__, _("Unknown branch trace format"));
11960 /* Synchronize the configuration with the target. */
11963 btrace_sync_conf (const struct btrace_config *conf)
11965 struct packet_config *packet;
11966 struct remote_state *rs;
11967 char *buf, *pos, *endbuf;
11969 rs = get_remote_state ();
11971 endbuf = buf + get_remote_packet_size ();
11973 packet = &remote_protocol_packets[PACKET_Qbtrace_conf_bts_size];
11974 if (packet_config_support (packet) == PACKET_ENABLE
11975 && conf->bts.size != rs->btrace_config.bts.size)
11978 pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
11982 getpkt (&buf, &rs->buf_size, 0);
11984 if (packet_ok (buf, packet) == PACKET_ERROR)
11986 if (buf[0] == 'E' && buf[1] == '.')
11987 error (_("Failed to configure the BTS buffer size: %s"), buf + 2);
11989 error (_("Failed to configure the BTS buffer size."));
11992 rs->btrace_config.bts.size = conf->bts.size;
11995 packet = &remote_protocol_packets[PACKET_Qbtrace_conf_pt_size];
11996 if (packet_config_support (packet) == PACKET_ENABLE
11997 && conf->pt.size != rs->btrace_config.pt.size)
12000 pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
12004 getpkt (&buf, &rs->buf_size, 0);
12006 if (packet_ok (buf, packet) == PACKET_ERROR)
12008 if (buf[0] == 'E' && buf[1] == '.')
12009 error (_("Failed to configure the trace buffer size: %s"), buf + 2);
12011 error (_("Failed to configure the trace buffer size."));
12014 rs->btrace_config.pt.size = conf->pt.size;
12018 /* Read the current thread's btrace configuration from the target and
12019 store it into CONF. */
12022 btrace_read_config (struct btrace_config *conf)
12026 xml = target_read_stralloc (¤t_target,
12027 TARGET_OBJECT_BTRACE_CONF, "");
12030 struct cleanup *cleanup;
12032 cleanup = make_cleanup (xfree, xml);
12033 parse_xml_btrace_conf (conf, xml);
12034 do_cleanups (cleanup);
12038 /* Enable branch tracing. */
12040 static struct btrace_target_info *
12041 remote_enable_btrace (struct target_ops *self, ptid_t ptid,
12042 const struct btrace_config *conf)
12044 struct btrace_target_info *tinfo = NULL;
12045 struct packet_config *packet = NULL;
12046 struct remote_state *rs = get_remote_state ();
12047 char *buf = rs->buf;
12048 char *endbuf = rs->buf + get_remote_packet_size ();
12050 switch (conf->format)
12052 case BTRACE_FORMAT_BTS:
12053 packet = &remote_protocol_packets[PACKET_Qbtrace_bts];
12056 case BTRACE_FORMAT_PT:
12057 packet = &remote_protocol_packets[PACKET_Qbtrace_pt];
12061 if (packet == NULL || packet_config_support (packet) != PACKET_ENABLE)
12062 error (_("Target does not support branch tracing."));
12064 btrace_sync_conf (conf);
12066 set_general_thread (ptid);
12068 buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
12070 getpkt (&rs->buf, &rs->buf_size, 0);
12072 if (packet_ok (rs->buf, packet) == PACKET_ERROR)
12074 if (rs->buf[0] == 'E' && rs->buf[1] == '.')
12075 error (_("Could not enable branch tracing for %s: %s"),
12076 target_pid_to_str (ptid), rs->buf + 2);
12078 error (_("Could not enable branch tracing for %s."),
12079 target_pid_to_str (ptid));
12082 tinfo = xzalloc (sizeof (*tinfo));
12083 tinfo->ptid = ptid;
12085 /* If we fail to read the configuration, we lose some information, but the
12086 tracing itself is not impacted. */
12089 btrace_read_config (&tinfo->conf);
12091 CATCH (err, RETURN_MASK_ERROR)
12093 if (err.message != NULL)
12094 warning ("%s", err.message);
12101 /* Disable branch tracing. */
12104 remote_disable_btrace (struct target_ops *self,
12105 struct btrace_target_info *tinfo)
12107 struct packet_config *packet = &remote_protocol_packets[PACKET_Qbtrace_off];
12108 struct remote_state *rs = get_remote_state ();
12109 char *buf = rs->buf;
12110 char *endbuf = rs->buf + get_remote_packet_size ();
12112 if (packet_config_support (packet) != PACKET_ENABLE)
12113 error (_("Target does not support branch tracing."));
12115 set_general_thread (tinfo->ptid);
12117 buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
12119 getpkt (&rs->buf, &rs->buf_size, 0);
12121 if (packet_ok (rs->buf, packet) == PACKET_ERROR)
12123 if (rs->buf[0] == 'E' && rs->buf[1] == '.')
12124 error (_("Could not disable branch tracing for %s: %s"),
12125 target_pid_to_str (tinfo->ptid), rs->buf + 2);
12127 error (_("Could not disable branch tracing for %s."),
12128 target_pid_to_str (tinfo->ptid));
12134 /* Teardown branch tracing. */
12137 remote_teardown_btrace (struct target_ops *self,
12138 struct btrace_target_info *tinfo)
12140 /* We must not talk to the target during teardown. */
12144 /* Read the branch trace. */
12146 static enum btrace_error
12147 remote_read_btrace (struct target_ops *self,
12148 struct btrace_data *btrace,
12149 struct btrace_target_info *tinfo,
12150 enum btrace_read_type type)
12152 struct packet_config *packet = &remote_protocol_packets[PACKET_qXfer_btrace];
12153 struct remote_state *rs = get_remote_state ();
12154 struct cleanup *cleanup;
12158 if (packet_config_support (packet) != PACKET_ENABLE)
12159 error (_("Target does not support branch tracing."));
12161 #if !defined(HAVE_LIBEXPAT)
12162 error (_("Cannot process branch tracing result. XML parsing not supported."));
12167 case BTRACE_READ_ALL:
12170 case BTRACE_READ_NEW:
12173 case BTRACE_READ_DELTA:
12177 internal_error (__FILE__, __LINE__,
12178 _("Bad branch tracing read type: %u."),
12179 (unsigned int) type);
12182 xml = target_read_stralloc (¤t_target,
12183 TARGET_OBJECT_BTRACE, annex);
12185 return BTRACE_ERR_UNKNOWN;
12187 cleanup = make_cleanup (xfree, xml);
12188 parse_xml_btrace (btrace, xml);
12189 do_cleanups (cleanup);
12191 return BTRACE_ERR_NONE;
12194 static const struct btrace_config *
12195 remote_btrace_conf (struct target_ops *self,
12196 const struct btrace_target_info *tinfo)
12198 return &tinfo->conf;
12202 remote_augmented_libraries_svr4_read (struct target_ops *self)
12204 return (packet_support (PACKET_augmented_libraries_svr4_read_feature)
12208 /* Implementation of to_load. */
12211 remote_load (struct target_ops *self, const char *name, int from_tty)
12213 generic_load (name, from_tty);
12216 /* Accepts an integer PID; returns a string representing a file that
12217 can be opened on the remote side to get the symbols for the child
12218 process. Returns NULL if the operation is not supported. */
12221 remote_pid_to_exec_file (struct target_ops *self, int pid)
12223 static char *filename = NULL;
12224 struct inferior *inf;
12225 char *annex = NULL;
12227 if (packet_support (PACKET_qXfer_exec_file) != PACKET_ENABLE)
12230 if (filename != NULL)
12233 inf = find_inferior_pid (pid);
12235 internal_error (__FILE__, __LINE__,
12236 _("not currently attached to process %d"), pid);
12238 if (!inf->fake_pid_p)
12240 const int annex_size = 9;
12242 annex = alloca (annex_size);
12243 xsnprintf (annex, annex_size, "%x", pid);
12246 filename = target_read_stralloc (¤t_target,
12247 TARGET_OBJECT_EXEC_FILE, annex);
12253 init_remote_ops (void)
12255 remote_ops.to_shortname = "remote";
12256 remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
12257 remote_ops.to_doc =
12258 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
12259 Specify the serial device it is connected to\n\
12260 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
12261 remote_ops.to_open = remote_open;
12262 remote_ops.to_close = remote_close;
12263 remote_ops.to_detach = remote_detach;
12264 remote_ops.to_disconnect = remote_disconnect;
12265 remote_ops.to_resume = remote_resume;
12266 remote_ops.to_wait = remote_wait;
12267 remote_ops.to_fetch_registers = remote_fetch_registers;
12268 remote_ops.to_store_registers = remote_store_registers;
12269 remote_ops.to_prepare_to_store = remote_prepare_to_store;
12270 remote_ops.to_files_info = remote_files_info;
12271 remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
12272 remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
12273 remote_ops.to_stopped_by_sw_breakpoint = remote_stopped_by_sw_breakpoint;
12274 remote_ops.to_supports_stopped_by_sw_breakpoint = remote_supports_stopped_by_sw_breakpoint;
12275 remote_ops.to_stopped_by_hw_breakpoint = remote_stopped_by_hw_breakpoint;
12276 remote_ops.to_supports_stopped_by_hw_breakpoint = remote_supports_stopped_by_hw_breakpoint;
12277 remote_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
12278 remote_ops.to_stopped_data_address = remote_stopped_data_address;
12279 remote_ops.to_watchpoint_addr_within_range =
12280 remote_watchpoint_addr_within_range;
12281 remote_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
12282 remote_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
12283 remote_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
12284 remote_ops.to_region_ok_for_hw_watchpoint
12285 = remote_region_ok_for_hw_watchpoint;
12286 remote_ops.to_insert_watchpoint = remote_insert_watchpoint;
12287 remote_ops.to_remove_watchpoint = remote_remove_watchpoint;
12288 remote_ops.to_kill = remote_kill;
12289 remote_ops.to_load = remote_load;
12290 remote_ops.to_mourn_inferior = remote_mourn;
12291 remote_ops.to_pass_signals = remote_pass_signals;
12292 remote_ops.to_program_signals = remote_program_signals;
12293 remote_ops.to_thread_alive = remote_thread_alive;
12294 remote_ops.to_update_thread_list = remote_update_thread_list;
12295 remote_ops.to_pid_to_str = remote_pid_to_str;
12296 remote_ops.to_extra_thread_info = remote_threads_extra_info;
12297 remote_ops.to_get_ada_task_ptid = remote_get_ada_task_ptid;
12298 remote_ops.to_stop = remote_stop;
12299 remote_ops.to_interrupt = remote_interrupt;
12300 remote_ops.to_xfer_partial = remote_xfer_partial;
12301 remote_ops.to_rcmd = remote_rcmd;
12302 remote_ops.to_pid_to_exec_file = remote_pid_to_exec_file;
12303 remote_ops.to_log_command = serial_log_command;
12304 remote_ops.to_get_thread_local_address = remote_get_thread_local_address;
12305 remote_ops.to_stratum = process_stratum;
12306 remote_ops.to_has_all_memory = default_child_has_all_memory;
12307 remote_ops.to_has_memory = default_child_has_memory;
12308 remote_ops.to_has_stack = default_child_has_stack;
12309 remote_ops.to_has_registers = default_child_has_registers;
12310 remote_ops.to_has_execution = default_child_has_execution;
12311 remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
12312 remote_ops.to_can_execute_reverse = remote_can_execute_reverse;
12313 remote_ops.to_magic = OPS_MAGIC;
12314 remote_ops.to_memory_map = remote_memory_map;
12315 remote_ops.to_flash_erase = remote_flash_erase;
12316 remote_ops.to_flash_done = remote_flash_done;
12317 remote_ops.to_read_description = remote_read_description;
12318 remote_ops.to_search_memory = remote_search_memory;
12319 remote_ops.to_can_async_p = remote_can_async_p;
12320 remote_ops.to_is_async_p = remote_is_async_p;
12321 remote_ops.to_async = remote_async;
12322 remote_ops.to_terminal_inferior = remote_terminal_inferior;
12323 remote_ops.to_terminal_ours = remote_terminal_ours;
12324 remote_ops.to_supports_non_stop = remote_supports_non_stop;
12325 remote_ops.to_supports_multi_process = remote_supports_multi_process;
12326 remote_ops.to_supports_disable_randomization
12327 = remote_supports_disable_randomization;
12328 remote_ops.to_filesystem_is_local = remote_filesystem_is_local;
12329 remote_ops.to_fileio_open = remote_hostio_open;
12330 remote_ops.to_fileio_pwrite = remote_hostio_pwrite;
12331 remote_ops.to_fileio_pread = remote_hostio_pread;
12332 remote_ops.to_fileio_fstat = remote_hostio_fstat;
12333 remote_ops.to_fileio_close = remote_hostio_close;
12334 remote_ops.to_fileio_unlink = remote_hostio_unlink;
12335 remote_ops.to_fileio_readlink = remote_hostio_readlink;
12336 remote_ops.to_supports_enable_disable_tracepoint = remote_supports_enable_disable_tracepoint;
12337 remote_ops.to_supports_string_tracing = remote_supports_string_tracing;
12338 remote_ops.to_supports_evaluation_of_breakpoint_conditions = remote_supports_cond_breakpoints;
12339 remote_ops.to_can_run_breakpoint_commands = remote_can_run_breakpoint_commands;
12340 remote_ops.to_trace_init = remote_trace_init;
12341 remote_ops.to_download_tracepoint = remote_download_tracepoint;
12342 remote_ops.to_can_download_tracepoint = remote_can_download_tracepoint;
12343 remote_ops.to_download_trace_state_variable
12344 = remote_download_trace_state_variable;
12345 remote_ops.to_enable_tracepoint = remote_enable_tracepoint;
12346 remote_ops.to_disable_tracepoint = remote_disable_tracepoint;
12347 remote_ops.to_trace_set_readonly_regions = remote_trace_set_readonly_regions;
12348 remote_ops.to_trace_start = remote_trace_start;
12349 remote_ops.to_get_trace_status = remote_get_trace_status;
12350 remote_ops.to_get_tracepoint_status = remote_get_tracepoint_status;
12351 remote_ops.to_trace_stop = remote_trace_stop;
12352 remote_ops.to_trace_find = remote_trace_find;
12353 remote_ops.to_get_trace_state_variable_value
12354 = remote_get_trace_state_variable_value;
12355 remote_ops.to_save_trace_data = remote_save_trace_data;
12356 remote_ops.to_upload_tracepoints = remote_upload_tracepoints;
12357 remote_ops.to_upload_trace_state_variables
12358 = remote_upload_trace_state_variables;
12359 remote_ops.to_get_raw_trace_data = remote_get_raw_trace_data;
12360 remote_ops.to_get_min_fast_tracepoint_insn_len = remote_get_min_fast_tracepoint_insn_len;
12361 remote_ops.to_set_disconnected_tracing = remote_set_disconnected_tracing;
12362 remote_ops.to_set_circular_trace_buffer = remote_set_circular_trace_buffer;
12363 remote_ops.to_set_trace_buffer_size = remote_set_trace_buffer_size;
12364 remote_ops.to_set_trace_notes = remote_set_trace_notes;
12365 remote_ops.to_core_of_thread = remote_core_of_thread;
12366 remote_ops.to_verify_memory = remote_verify_memory;
12367 remote_ops.to_get_tib_address = remote_get_tib_address;
12368 remote_ops.to_set_permissions = remote_set_permissions;
12369 remote_ops.to_static_tracepoint_marker_at
12370 = remote_static_tracepoint_marker_at;
12371 remote_ops.to_static_tracepoint_markers_by_strid
12372 = remote_static_tracepoint_markers_by_strid;
12373 remote_ops.to_traceframe_info = remote_traceframe_info;
12374 remote_ops.to_use_agent = remote_use_agent;
12375 remote_ops.to_can_use_agent = remote_can_use_agent;
12376 remote_ops.to_supports_btrace = remote_supports_btrace;
12377 remote_ops.to_enable_btrace = remote_enable_btrace;
12378 remote_ops.to_disable_btrace = remote_disable_btrace;
12379 remote_ops.to_teardown_btrace = remote_teardown_btrace;
12380 remote_ops.to_read_btrace = remote_read_btrace;
12381 remote_ops.to_btrace_conf = remote_btrace_conf;
12382 remote_ops.to_augmented_libraries_svr4_read =
12383 remote_augmented_libraries_svr4_read;
12386 /* Set up the extended remote vector by making a copy of the standard
12387 remote vector and adding to it. */
12390 init_extended_remote_ops (void)
12392 extended_remote_ops = remote_ops;
12394 extended_remote_ops.to_shortname = "extended-remote";
12395 extended_remote_ops.to_longname =
12396 "Extended remote serial target in gdb-specific protocol";
12397 extended_remote_ops.to_doc =
12398 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
12399 Specify the serial device it is connected to (e.g. /dev/ttya).";
12400 extended_remote_ops.to_open = extended_remote_open;
12401 extended_remote_ops.to_create_inferior = extended_remote_create_inferior;
12402 extended_remote_ops.to_mourn_inferior = extended_remote_mourn;
12403 extended_remote_ops.to_detach = extended_remote_detach;
12404 extended_remote_ops.to_attach = extended_remote_attach;
12405 extended_remote_ops.to_post_attach = extended_remote_post_attach;
12406 extended_remote_ops.to_kill = extended_remote_kill;
12407 extended_remote_ops.to_supports_disable_randomization
12408 = extended_remote_supports_disable_randomization;
12409 extended_remote_ops.to_follow_fork = remote_follow_fork;
12410 extended_remote_ops.to_insert_fork_catchpoint
12411 = remote_insert_fork_catchpoint;
12412 extended_remote_ops.to_remove_fork_catchpoint
12413 = remote_remove_fork_catchpoint;
12414 extended_remote_ops.to_insert_vfork_catchpoint
12415 = remote_insert_vfork_catchpoint;
12416 extended_remote_ops.to_remove_vfork_catchpoint
12417 = remote_remove_vfork_catchpoint;
12421 remote_can_async_p (struct target_ops *ops)
12423 struct remote_state *rs = get_remote_state ();
12425 if (!target_async_permitted)
12426 /* We only enable async when the user specifically asks for it. */
12429 /* We're async whenever the serial device is. */
12430 return serial_can_async_p (rs->remote_desc);
12434 remote_is_async_p (struct target_ops *ops)
12436 struct remote_state *rs = get_remote_state ();
12438 if (!target_async_permitted)
12439 /* We only enable async when the user specifically asks for it. */
12442 /* We're async whenever the serial device is. */
12443 return serial_is_async_p (rs->remote_desc);
12446 /* Pass the SERIAL event on and up to the client. One day this code
12447 will be able to delay notifying the client of an event until the
12448 point where an entire packet has been received. */
12450 static serial_event_ftype remote_async_serial_handler;
12453 remote_async_serial_handler (struct serial *scb, void *context)
12455 struct remote_state *rs = context;
12457 /* Don't propogate error information up to the client. Instead let
12458 the client find out about the error by querying the target. */
12459 inferior_event_handler (INF_REG_EVENT, NULL);
12463 remote_async_inferior_event_handler (gdb_client_data data)
12465 inferior_event_handler (INF_REG_EVENT, NULL);
12469 remote_async (struct target_ops *ops, int enable)
12471 struct remote_state *rs = get_remote_state ();
12475 serial_async (rs->remote_desc, remote_async_serial_handler, rs);
12477 /* If there are pending events in the stop reply queue tell the
12478 event loop to process them. */
12479 if (!QUEUE_is_empty (stop_reply_p, stop_reply_queue))
12480 mark_async_event_handler (remote_async_inferior_event_token);
12484 serial_async (rs->remote_desc, NULL, NULL);
12485 clear_async_event_handler (remote_async_inferior_event_token);
12490 set_remote_cmd (char *args, int from_tty)
12492 help_list (remote_set_cmdlist, "set remote ", all_commands, gdb_stdout);
12496 show_remote_cmd (char *args, int from_tty)
12498 /* We can't just use cmd_show_list here, because we want to skip
12499 the redundant "show remote Z-packet" and the legacy aliases. */
12500 struct cleanup *showlist_chain;
12501 struct cmd_list_element *list = remote_show_cmdlist;
12502 struct ui_out *uiout = current_uiout;
12504 showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist");
12505 for (; list != NULL; list = list->next)
12506 if (strcmp (list->name, "Z-packet") == 0)
12508 else if (list->type == not_set_cmd)
12509 /* Alias commands are exactly like the original, except they
12510 don't have the normal type. */
12514 struct cleanup *option_chain
12515 = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
12517 ui_out_field_string (uiout, "name", list->name);
12518 ui_out_text (uiout, ": ");
12519 if (list->type == show_cmd)
12520 do_show_command ((char *) NULL, from_tty, list);
12522 cmd_func (list, NULL, from_tty);
12523 /* Close the tuple. */
12524 do_cleanups (option_chain);
12527 /* Close the tuple. */
12528 do_cleanups (showlist_chain);
12532 /* Function to be called whenever a new objfile (shlib) is detected. */
12534 remote_new_objfile (struct objfile *objfile)
12536 struct remote_state *rs = get_remote_state ();
12538 if (rs->remote_desc != 0) /* Have a remote connection. */
12539 remote_check_symbols ();
12542 /* Pull all the tracepoints defined on the target and create local
12543 data structures representing them. We don't want to create real
12544 tracepoints yet, we don't want to mess up the user's existing
12548 remote_upload_tracepoints (struct target_ops *self, struct uploaded_tp **utpp)
12550 struct remote_state *rs = get_remote_state ();
12553 /* Ask for a first packet of tracepoint definition. */
12555 getpkt (&rs->buf, &rs->buf_size, 0);
12557 while (*p && *p != 'l')
12559 parse_tracepoint_definition (p, utpp);
12560 /* Ask for another packet of tracepoint definition. */
12562 getpkt (&rs->buf, &rs->buf_size, 0);
12569 remote_upload_trace_state_variables (struct target_ops *self,
12570 struct uploaded_tsv **utsvp)
12572 struct remote_state *rs = get_remote_state ();
12575 /* Ask for a first packet of variable definition. */
12577 getpkt (&rs->buf, &rs->buf_size, 0);
12579 while (*p && *p != 'l')
12581 parse_tsv_definition (p, utsvp);
12582 /* Ask for another packet of variable definition. */
12584 getpkt (&rs->buf, &rs->buf_size, 0);
12590 /* The "set/show range-stepping" show hook. */
12593 show_range_stepping (struct ui_file *file, int from_tty,
12594 struct cmd_list_element *c,
12597 fprintf_filtered (file,
12598 _("Debugger's willingness to use range stepping "
12599 "is %s.\n"), value);
12602 /* The "set/show range-stepping" set hook. */
12605 set_range_stepping (char *ignore_args, int from_tty,
12606 struct cmd_list_element *c)
12608 struct remote_state *rs = get_remote_state ();
12610 /* Whene enabling, check whether range stepping is actually
12611 supported by the target, and warn if not. */
12612 if (use_range_stepping)
12614 if (rs->remote_desc != NULL)
12616 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
12617 remote_vcont_probe (rs);
12619 if (packet_support (PACKET_vCont) == PACKET_ENABLE
12620 && rs->supports_vCont.r)
12624 warning (_("Range stepping is not supported by the current target"));
12629 _initialize_remote (void)
12631 struct remote_state *rs;
12632 struct cmd_list_element *cmd;
12633 const char *cmd_name;
12635 /* architecture specific data */
12636 remote_gdbarch_data_handle =
12637 gdbarch_data_register_post_init (init_remote_state);
12638 remote_g_packet_data_handle =
12639 gdbarch_data_register_pre_init (remote_g_packet_data_init);
12641 /* Initialize the per-target state. At the moment there is only one
12642 of these, not one per target. Only one target is active at a
12644 remote_state = new_remote_state ();
12646 init_remote_ops ();
12647 add_target (&remote_ops);
12649 init_extended_remote_ops ();
12650 add_target (&extended_remote_ops);
12652 /* Hook into new objfile notification. */
12653 observer_attach_new_objfile (remote_new_objfile);
12654 /* We're no longer interested in notification events of an inferior
12656 observer_attach_inferior_exit (discard_pending_stop_replies);
12658 /* Set up signal handlers. */
12659 async_sigint_remote_token =
12660 create_async_signal_handler (async_remote_interrupt, NULL);
12661 async_sigint_remote_twice_token =
12662 create_async_signal_handler (async_remote_interrupt_twice, NULL);
12665 init_remote_threadtests ();
12668 stop_reply_queue = QUEUE_alloc (stop_reply_p, stop_reply_xfree);
12669 /* set/show remote ... */
12671 add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
12672 Remote protocol specific variables\n\
12673 Configure various remote-protocol specific variables such as\n\
12674 the packets being used"),
12675 &remote_set_cmdlist, "set remote ",
12676 0 /* allow-unknown */, &setlist);
12677 add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\
12678 Remote protocol specific variables\n\
12679 Configure various remote-protocol specific variables such as\n\
12680 the packets being used"),
12681 &remote_show_cmdlist, "show remote ",
12682 0 /* allow-unknown */, &showlist);
12684 add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\
12685 Compare section data on target to the exec file.\n\
12686 Argument is a single section name (default: all loaded sections).\n\
12687 To compare only read-only loaded sections, specify the -r option."),
12690 add_cmd ("packet", class_maintenance, packet_command, _("\
12691 Send an arbitrary packet to a remote target.\n\
12692 maintenance packet TEXT\n\
12693 If GDB is talking to an inferior via the GDB serial protocol, then\n\
12694 this command sends the string TEXT to the inferior, and displays the\n\
12695 response packet. GDB supplies the initial `$' character, and the\n\
12696 terminating `#' character and checksum."),
12699 add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
12700 Set whether to send break if interrupted."), _("\
12701 Show whether to send break if interrupted."), _("\
12702 If set, a break, instead of a cntrl-c, is sent to the remote target."),
12703 set_remotebreak, show_remotebreak,
12704 &setlist, &showlist);
12705 cmd_name = "remotebreak";
12706 cmd = lookup_cmd (&cmd_name, setlist, "", -1, 1);
12707 deprecate_cmd (cmd, "set remote interrupt-sequence");
12708 cmd_name = "remotebreak"; /* needed because lookup_cmd updates the pointer */
12709 cmd = lookup_cmd (&cmd_name, showlist, "", -1, 1);
12710 deprecate_cmd (cmd, "show remote interrupt-sequence");
12712 add_setshow_enum_cmd ("interrupt-sequence", class_support,
12713 interrupt_sequence_modes, &interrupt_sequence_mode,
12715 Set interrupt sequence to remote target."), _("\
12716 Show interrupt sequence to remote target."), _("\
12717 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
12718 NULL, show_interrupt_sequence,
12719 &remote_set_cmdlist,
12720 &remote_show_cmdlist);
12722 add_setshow_boolean_cmd ("interrupt-on-connect", class_support,
12723 &interrupt_on_connect, _("\
12724 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
12725 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
12726 If set, interrupt sequence is sent to remote target."),
12728 &remote_set_cmdlist, &remote_show_cmdlist);
12730 /* Install commands for configuring memory read/write packets. */
12732 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\
12733 Set the maximum number of bytes per memory write packet (deprecated)."),
12735 add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\
12736 Show the maximum number of bytes per memory write packet (deprecated)."),
12738 add_cmd ("memory-write-packet-size", no_class,
12739 set_memory_write_packet_size, _("\
12740 Set the maximum number of bytes per memory-write packet.\n\
12741 Specify the number of bytes in a packet or 0 (zero) for the\n\
12742 default packet size. The actual limit is further reduced\n\
12743 dependent on the target. Specify ``fixed'' to disable the\n\
12744 further restriction and ``limit'' to enable that restriction."),
12745 &remote_set_cmdlist);
12746 add_cmd ("memory-read-packet-size", no_class,
12747 set_memory_read_packet_size, _("\
12748 Set the maximum number of bytes per memory-read packet.\n\
12749 Specify the number of bytes in a packet or 0 (zero) for the\n\
12750 default packet size. The actual limit is further reduced\n\
12751 dependent on the target. Specify ``fixed'' to disable the\n\
12752 further restriction and ``limit'' to enable that restriction."),
12753 &remote_set_cmdlist);
12754 add_cmd ("memory-write-packet-size", no_class,
12755 show_memory_write_packet_size,
12756 _("Show the maximum number of bytes per memory-write packet."),
12757 &remote_show_cmdlist);
12758 add_cmd ("memory-read-packet-size", no_class,
12759 show_memory_read_packet_size,
12760 _("Show the maximum number of bytes per memory-read packet."),
12761 &remote_show_cmdlist);
12763 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class,
12764 &remote_hw_watchpoint_limit, _("\
12765 Set the maximum number of target hardware watchpoints."), _("\
12766 Show the maximum number of target hardware watchpoints."), _("\
12767 Specify a negative limit for unlimited."),
12768 NULL, NULL, /* FIXME: i18n: The maximum
12769 number of target hardware
12770 watchpoints is %s. */
12771 &remote_set_cmdlist, &remote_show_cmdlist);
12772 add_setshow_zinteger_cmd ("hardware-watchpoint-length-limit", no_class,
12773 &remote_hw_watchpoint_length_limit, _("\
12774 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
12775 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
12776 Specify a negative limit for unlimited."),
12777 NULL, NULL, /* FIXME: i18n: The maximum
12778 length (in bytes) of a target
12779 hardware watchpoint is %s. */
12780 &remote_set_cmdlist, &remote_show_cmdlist);
12781 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class,
12782 &remote_hw_breakpoint_limit, _("\
12783 Set the maximum number of target hardware breakpoints."), _("\
12784 Show the maximum number of target hardware breakpoints."), _("\
12785 Specify a negative limit for unlimited."),
12786 NULL, NULL, /* FIXME: i18n: The maximum
12787 number of target hardware
12788 breakpoints is %s. */
12789 &remote_set_cmdlist, &remote_show_cmdlist);
12791 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure,
12792 &remote_address_size, _("\
12793 Set the maximum size of the address (in bits) in a memory packet."), _("\
12794 Show the maximum size of the address (in bits) in a memory packet."), NULL,
12796 NULL, /* FIXME: i18n: */
12797 &setlist, &showlist);
12799 init_all_packet_configs ();
12801 add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
12802 "X", "binary-download", 1);
12804 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont],
12805 "vCont", "verbose-resume", 0);
12807 add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals],
12808 "QPassSignals", "pass-signals", 0);
12810 add_packet_config_cmd (&remote_protocol_packets[PACKET_QProgramSignals],
12811 "QProgramSignals", "program-signals", 0);
12813 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
12814 "qSymbol", "symbol-lookup", 0);
12816 add_packet_config_cmd (&remote_protocol_packets[PACKET_P],
12817 "P", "set-register", 1);
12819 add_packet_config_cmd (&remote_protocol_packets[PACKET_p],
12820 "p", "fetch-register", 1);
12822 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0],
12823 "Z0", "software-breakpoint", 0);
12825 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1],
12826 "Z1", "hardware-breakpoint", 0);
12828 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2],
12829 "Z2", "write-watchpoint", 0);
12831 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3],
12832 "Z3", "read-watchpoint", 0);
12834 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4],
12835 "Z4", "access-watchpoint", 0);
12837 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv],
12838 "qXfer:auxv:read", "read-aux-vector", 0);
12840 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_exec_file],
12841 "qXfer:exec-file:read", "pid-to-exec-file", 0);
12843 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features],
12844 "qXfer:features:read", "target-features", 0);
12846 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries],
12847 "qXfer:libraries:read", "library-info", 0);
12849 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries_svr4],
12850 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
12852 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
12853 "qXfer:memory-map:read", "memory-map", 0);
12855 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_read],
12856 "qXfer:spu:read", "read-spu-object", 0);
12858 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write],
12859 "qXfer:spu:write", "write-spu-object", 0);
12861 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata],
12862 "qXfer:osdata:read", "osdata", 0);
12864 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_threads],
12865 "qXfer:threads:read", "threads", 0);
12867 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_read],
12868 "qXfer:siginfo:read", "read-siginfo-object", 0);
12870 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_write],
12871 "qXfer:siginfo:write", "write-siginfo-object", 0);
12873 add_packet_config_cmd
12874 (&remote_protocol_packets[PACKET_qXfer_traceframe_info],
12875 "qXfer:traceframe-info:read", "traceframe-info", 0);
12877 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_uib],
12878 "qXfer:uib:read", "unwind-info-block", 0);
12880 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
12881 "qGetTLSAddr", "get-thread-local-storage-address",
12884 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTIBAddr],
12885 "qGetTIBAddr", "get-thread-information-block-address",
12888 add_packet_config_cmd (&remote_protocol_packets[PACKET_bc],
12889 "bc", "reverse-continue", 0);
12891 add_packet_config_cmd (&remote_protocol_packets[PACKET_bs],
12892 "bs", "reverse-step", 0);
12894 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported],
12895 "qSupported", "supported-packets", 0);
12897 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSearch_memory],
12898 "qSearch:memory", "search-memory", 0);
12900 add_packet_config_cmd (&remote_protocol_packets[PACKET_qTStatus],
12901 "qTStatus", "trace-status", 0);
12903 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_setfs],
12904 "vFile:setfs", "hostio-setfs", 0);
12906 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_open],
12907 "vFile:open", "hostio-open", 0);
12909 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pread],
12910 "vFile:pread", "hostio-pread", 0);
12912 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pwrite],
12913 "vFile:pwrite", "hostio-pwrite", 0);
12915 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_close],
12916 "vFile:close", "hostio-close", 0);
12918 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_unlink],
12919 "vFile:unlink", "hostio-unlink", 0);
12921 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_readlink],
12922 "vFile:readlink", "hostio-readlink", 0);
12924 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_fstat],
12925 "vFile:fstat", "hostio-fstat", 0);
12927 add_packet_config_cmd (&remote_protocol_packets[PACKET_vAttach],
12928 "vAttach", "attach", 0);
12930 add_packet_config_cmd (&remote_protocol_packets[PACKET_vRun],
12933 add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartNoAckMode],
12934 "QStartNoAckMode", "noack", 0);
12936 add_packet_config_cmd (&remote_protocol_packets[PACKET_vKill],
12937 "vKill", "kill", 0);
12939 add_packet_config_cmd (&remote_protocol_packets[PACKET_qAttached],
12940 "qAttached", "query-attached", 0);
12942 add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints],
12943 "ConditionalTracepoints",
12944 "conditional-tracepoints", 0);
12946 add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalBreakpoints],
12947 "ConditionalBreakpoints",
12948 "conditional-breakpoints", 0);
12950 add_packet_config_cmd (&remote_protocol_packets[PACKET_BreakpointCommands],
12951 "BreakpointCommands",
12952 "breakpoint-commands", 0);
12954 add_packet_config_cmd (&remote_protocol_packets[PACKET_FastTracepoints],
12955 "FastTracepoints", "fast-tracepoints", 0);
12957 add_packet_config_cmd (&remote_protocol_packets[PACKET_TracepointSource],
12958 "TracepointSource", "TracepointSource", 0);
12960 add_packet_config_cmd (&remote_protocol_packets[PACKET_QAllow],
12961 "QAllow", "allow", 0);
12963 add_packet_config_cmd (&remote_protocol_packets[PACKET_StaticTracepoints],
12964 "StaticTracepoints", "static-tracepoints", 0);
12966 add_packet_config_cmd (&remote_protocol_packets[PACKET_InstallInTrace],
12967 "InstallInTrace", "install-in-trace", 0);
12969 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read],
12970 "qXfer:statictrace:read", "read-sdata-object", 0);
12972 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_fdpic],
12973 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
12975 add_packet_config_cmd (&remote_protocol_packets[PACKET_QDisableRandomization],
12976 "QDisableRandomization", "disable-randomization", 0);
12978 add_packet_config_cmd (&remote_protocol_packets[PACKET_QAgent],
12979 "QAgent", "agent", 0);
12981 add_packet_config_cmd (&remote_protocol_packets[PACKET_QTBuffer_size],
12982 "QTBuffer:size", "trace-buffer-size", 0);
12984 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_off],
12985 "Qbtrace:off", "disable-btrace", 0);
12987 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_bts],
12988 "Qbtrace:bts", "enable-btrace-bts", 0);
12990 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_pt],
12991 "Qbtrace:pt", "enable-btrace-pt", 0);
12993 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace],
12994 "qXfer:btrace", "read-btrace", 0);
12996 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace_conf],
12997 "qXfer:btrace-conf", "read-btrace-conf", 0);
12999 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_bts_size],
13000 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
13002 add_packet_config_cmd (&remote_protocol_packets[PACKET_swbreak_feature],
13003 "swbreak-feature", "swbreak-feature", 0);
13005 add_packet_config_cmd (&remote_protocol_packets[PACKET_hwbreak_feature],
13006 "hwbreak-feature", "hwbreak-feature", 0);
13008 add_packet_config_cmd (&remote_protocol_packets[PACKET_fork_event_feature],
13009 "fork-event-feature", "fork-event-feature", 0);
13011 add_packet_config_cmd (&remote_protocol_packets[PACKET_vfork_event_feature],
13012 "vfork-event-feature", "vfork-event-feature", 0);
13014 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_pt_size],
13015 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
13017 /* Assert that we've registered "set remote foo-packet" commands
13018 for all packet configs. */
13022 for (i = 0; i < PACKET_MAX; i++)
13024 /* Ideally all configs would have a command associated. Some
13025 still don't though. */
13030 case PACKET_QNonStop:
13031 case PACKET_multiprocess_feature:
13032 case PACKET_EnableDisableTracepoints_feature:
13033 case PACKET_tracenz_feature:
13034 case PACKET_DisconnectedTracing_feature:
13035 case PACKET_augmented_libraries_svr4_read_feature:
13037 /* Additions to this list need to be well justified:
13038 pre-existing packets are OK; new packets are not. */
13046 /* This catches both forgetting to add a config command, and
13047 forgetting to remove a packet from the exception list. */
13048 gdb_assert (excepted == (remote_protocol_packets[i].name == NULL));
13052 /* Keep the old ``set remote Z-packet ...'' working. Each individual
13053 Z sub-packet has its own set and show commands, but users may
13054 have sets to this variable in their .gdbinit files (or in their
13056 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
13057 &remote_Z_packet_detect, _("\
13058 Set use of remote protocol `Z' packets"), _("\
13059 Show use of remote protocol `Z' packets "), _("\
13060 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
13062 set_remote_protocol_Z_packet_cmd,
13063 show_remote_protocol_Z_packet_cmd,
13064 /* FIXME: i18n: Use of remote protocol
13065 `Z' packets is %s. */
13066 &remote_set_cmdlist, &remote_show_cmdlist);
13068 add_prefix_cmd ("remote", class_files, remote_command, _("\
13069 Manipulate files on the remote system\n\
13070 Transfer files to and from the remote target system."),
13071 &remote_cmdlist, "remote ",
13072 0 /* allow-unknown */, &cmdlist);
13074 add_cmd ("put", class_files, remote_put_command,
13075 _("Copy a local file to the remote system."),
13078 add_cmd ("get", class_files, remote_get_command,
13079 _("Copy a remote file to the local system."),
13082 add_cmd ("delete", class_files, remote_delete_command,
13083 _("Delete a remote file."),
13086 remote_exec_file = xstrdup ("");
13087 add_setshow_string_noescape_cmd ("exec-file", class_files,
13088 &remote_exec_file, _("\
13089 Set the remote pathname for \"run\""), _("\
13090 Show the remote pathname for \"run\""), NULL, NULL, NULL,
13091 &remote_set_cmdlist, &remote_show_cmdlist);
13093 add_setshow_boolean_cmd ("range-stepping", class_run,
13094 &use_range_stepping, _("\
13095 Enable or disable range stepping."), _("\
13096 Show whether target-assisted range stepping is enabled."), _("\
13097 If on, and the target supports it, when stepping a source line, GDB\n\
13098 tells the target to step the corresponding range of addresses itself instead\n\
13099 of issuing multiple single-steps. This speeds up source level\n\
13100 stepping. If off, GDB always issues single-steps, even if range\n\
13101 stepping is supported by the target. The default is on."),
13102 set_range_stepping,
13103 show_range_stepping,
13107 /* Eventually initialize fileio. See fileio.c */
13108 initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);
13110 /* Take advantage of the fact that the TID field is not used, to tag
13111 special ptids with it set to != 0. */
13112 magic_null_ptid = ptid_build (42000, -1, 1);
13113 not_sent_ptid = ptid_build (42000, -2, 1);
13114 any_thread_ptid = ptid_build (42000, 0, 1);
13116 target_buf_size = 2048;
13117 target_buf = xmalloc (target_buf_size);