1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2018 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"
39 #include "observable.h"
41 #include "cli/cli-decode.h"
42 #include "cli/cli-setshow.h"
43 #include "target-descriptions.h"
45 #include "filestuff.h"
50 #include "gdb_sys_time.h"
52 #include "event-loop.h"
53 #include "event-top.h"
59 #include "gdbcore.h" /* for exec_bfd */
61 #include "remote-fileio.h"
62 #include "gdb/fileio.h"
64 #include "xml-support.h"
66 #include "memory-map.h"
68 #include "tracepoint.h"
73 #include "record-btrace.h"
75 #include "common/scoped_restore.h"
77 #include "common/byte-vector.h"
78 #include <unordered_map>
80 /* The remote target. */
82 static const char remote_doc[] = N_("\
83 Use a remote computer via a serial line, using a gdb-specific protocol.\n\
84 Specify the serial device it is connected to\n\
85 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
87 #define OPAQUETHREADBYTES 8
89 /* a 64 bit opaque identifier */
90 typedef unsigned char threadref[OPAQUETHREADBYTES];
92 struct gdb_ext_thread_info;
93 struct threads_listing_context;
94 typedef int (*rmt_thread_action) (threadref *ref, void *context);
95 struct protocol_feature;
99 static void stop_reply_xfree (struct stop_reply *);
101 struct stop_reply_deleter
103 void operator() (stop_reply *r) const
105 stop_reply_xfree (r);
109 typedef std::unique_ptr<stop_reply, stop_reply_deleter> stop_reply_up;
111 /* Generic configuration support for packets the stub optionally
112 supports. Allows the user to specify the use of the packet as well
113 as allowing GDB to auto-detect support in the remote stub. */
117 PACKET_SUPPORT_UNKNOWN = 0,
122 /* Analyze a packet's return value and update the packet config
132 struct threads_listing_context;
134 /* Stub vCont actions support.
136 Each field is a boolean flag indicating whether the stub reports
137 support for the corresponding action. */
139 struct vCont_action_support
154 /* About this many threadisds fit in a packet. */
156 #define MAXTHREADLISTRESULTS 32
158 /* Data for the vFile:pread readahead cache. */
160 struct readahead_cache
162 /* Invalidate the readahead cache. */
165 /* Invalidate the readahead cache if it is holding data for FD. */
166 void invalidate_fd (int fd);
168 /* Serve pread from the readahead cache. Returns number of bytes
169 read, or 0 if the request can't be served from the cache. */
170 int pread (int fd, gdb_byte *read_buf, size_t len, ULONGEST offset);
172 /* The file descriptor for the file that is being cached. -1 if the
176 /* The offset into the file that the cache buffer corresponds
180 /* The buffer holding the cache contents. */
181 gdb_byte *buf = nullptr;
182 /* The buffer's size. We try to read as much as fits into a packet
186 /* Cache hit and miss counters. */
187 ULONGEST hit_count = 0;
188 ULONGEST miss_count = 0;
191 /* Description of the remote protocol for a given architecture. */
195 long offset; /* Offset into G packet. */
196 long regnum; /* GDB's internal register number. */
197 LONGEST pnum; /* Remote protocol register number. */
198 int in_g_packet; /* Always part of G packet. */
199 /* long size in bytes; == register_size (target_gdbarch (), regnum);
201 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
205 struct remote_arch_state
207 explicit remote_arch_state (struct gdbarch *gdbarch);
209 /* Description of the remote protocol registers. */
210 long sizeof_g_packet;
212 /* Description of the remote protocol registers indexed by REGNUM
213 (making an array gdbarch_num_regs in size). */
214 std::unique_ptr<packet_reg[]> regs;
216 /* This is the size (in chars) of the first response to the ``g''
217 packet. It is used as a heuristic when determining the maximum
218 size of memory-read and memory-write packets. A target will
219 typically only reserve a buffer large enough to hold the ``g''
220 packet. The size does not include packet overhead (headers and
222 long actual_register_packet_size;
224 /* This is the maximum size (in chars) of a non read/write packet.
225 It is also used as a cap on the size of read/write packets. */
226 long remote_packet_size;
229 /* Description of the remote protocol state for the currently
230 connected target. This is per-target state, and independent of the
231 selected architecture. */
240 /* Get the remote arch state for GDBARCH. */
241 struct remote_arch_state *get_remote_arch_state (struct gdbarch *gdbarch);
245 /* A buffer to use for incoming packets, and its current size. The
246 buffer is grown dynamically for larger incoming packets.
247 Outgoing packets may also be constructed in this buffer.
248 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
249 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
254 /* True if we're going through initial connection setup (finding out
255 about the remote side's threads, relocating symbols, etc.). */
256 bool starting_up = false;
258 /* If we negotiated packet size explicitly (and thus can bypass
259 heuristics for the largest packet size that will not overflow
260 a buffer in the stub), this will be set to that packet size.
261 Otherwise zero, meaning to use the guessed size. */
262 long explicit_packet_size = 0;
264 /* remote_wait is normally called when the target is running and
265 waits for a stop reply packet. But sometimes we need to call it
266 when the target is already stopped. We can send a "?" packet
267 and have remote_wait read the response. Or, if we already have
268 the response, we can stash it in BUF and tell remote_wait to
269 skip calling getpkt. This flag is set when BUF contains a
270 stop reply packet and the target is not waiting. */
271 int cached_wait_status = 0;
273 /* True, if in no ack mode. That is, neither GDB nor the stub will
274 expect acks from each other. The connection is assumed to be
276 bool noack_mode = false;
278 /* True if we're connected in extended remote mode. */
279 bool extended = false;
281 /* True if we resumed the target and we're waiting for the target to
282 stop. In the mean time, we can't start another command/query.
283 The remote server wouldn't be ready to process it, so we'd
284 timeout waiting for a reply that would never come and eventually
285 we'd close the connection. This can happen in asynchronous mode
286 because we allow GDB commands while the target is running. */
287 bool waiting_for_stop_reply = false;
289 /* The status of the stub support for the various vCont actions. */
290 vCont_action_support supports_vCont;
292 /* True if the user has pressed Ctrl-C, but the target hasn't
293 responded to that. */
294 bool ctrlc_pending_p = false;
296 /* True if we saw a Ctrl-C while reading or writing from/to the
297 remote descriptor. At that point it is not safe to send a remote
298 interrupt packet, so we instead remember we saw the Ctrl-C and
299 process it once we're done with sending/receiving the current
300 packet, which should be shortly. If however that takes too long,
301 and the user presses Ctrl-C again, we offer to disconnect. */
302 bool got_ctrlc_during_io = false;
304 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
305 remote_open knows that we don't have a file open when the program
307 struct serial *remote_desc = nullptr;
309 /* These are the threads which we last sent to the remote system. The
310 TID member will be -1 for all or -2 for not sent yet. */
311 ptid_t general_thread = null_ptid;
312 ptid_t continue_thread = null_ptid;
314 /* This is the traceframe which we last selected on the remote system.
315 It will be -1 if no traceframe is selected. */
316 int remote_traceframe_number = -1;
318 char *last_pass_packet = nullptr;
320 /* The last QProgramSignals packet sent to the target. We bypass
321 sending a new program signals list down to the target if the new
322 packet is exactly the same as the last we sent. IOW, we only let
323 the target know about program signals list changes. */
324 char *last_program_signals_packet = nullptr;
326 gdb_signal last_sent_signal = GDB_SIGNAL_0;
328 bool last_sent_step = false;
330 /* The execution direction of the last resume we got. */
331 exec_direction_kind last_resume_exec_dir = EXEC_FORWARD;
333 char *finished_object = nullptr;
334 char *finished_annex = nullptr;
335 ULONGEST finished_offset = 0;
337 /* Should we try the 'ThreadInfo' query packet?
339 This variable (NOT available to the user: auto-detect only!)
340 determines whether GDB will use the new, simpler "ThreadInfo"
341 query or the older, more complex syntax for thread queries.
342 This is an auto-detect variable (set to true at each connect,
343 and set to false when the target fails to recognize it). */
344 bool use_threadinfo_query = false;
345 bool use_threadextra_query = false;
347 threadref echo_nextthread {};
348 threadref nextthread {};
349 threadref resultthreadlist[MAXTHREADLISTRESULTS] {};
351 /* The state of remote notification. */
352 struct remote_notif_state *notif_state = nullptr;
354 /* The branch trace configuration. */
355 struct btrace_config btrace_config {};
357 /* The argument to the last "vFile:setfs:" packet we sent, used
358 to avoid sending repeated unnecessary "vFile:setfs:" packets.
359 Initialized to -1 to indicate that no "vFile:setfs:" packet
360 has yet been sent. */
363 /* A readahead cache for vFile:pread. Often, reading a binary
364 involves a sequence of small reads. E.g., when parsing an ELF
365 file. A readahead cache helps mostly the case of remote
366 debugging on a connection with higher latency, due to the
367 request/reply nature of the RSP. We only cache data for a single
368 file descriptor at a time. */
369 struct readahead_cache readahead_cache;
371 /* The list of already fetched and acknowledged stop events. This
372 queue is used for notification Stop, and other notifications
373 don't need queue for their events, because the notification
374 events of Stop can't be consumed immediately, so that events
375 should be queued first, and be consumed by remote_wait_{ns,as}
376 one per time. Other notifications can consume their events
377 immediately, so queue is not needed for them. */
378 std::vector<stop_reply_up> stop_reply_queue;
380 /* Asynchronous signal handle registered as event loop source for
381 when we have pending events ready to be passed to the core. */
382 struct async_event_handler *remote_async_inferior_event_token = nullptr;
384 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
385 ``forever'' still use the normal timeout mechanism. This is
386 currently used by the ASYNC code to guarentee that target reads
387 during the initial connect always time-out. Once getpkt has been
388 modified to return a timeout indication and, in turn
389 remote_wait()/wait_for_inferior() have gained a timeout parameter
391 int wait_forever_enabled_p = 1;
394 /* Mapping of remote protocol data for each gdbarch. Usually there
395 is only one entry here, though we may see more with stubs that
396 support multi-process. */
397 std::unordered_map<struct gdbarch *, remote_arch_state>
401 static const target_info remote_target_info = {
403 N_("Remote serial target in gdb-specific protocol"),
407 class remote_target : public target_ops
412 to_stratum = process_stratum;
414 ~remote_target () override;
416 const target_info &info () const override
417 { return remote_target_info; }
419 thread_control_capabilities get_thread_control_capabilities () override
420 { return tc_schedlock; }
422 /* Open a remote connection. */
423 static void open (const char *, int);
425 void close () override;
427 void detach (inferior *, int) override;
428 void disconnect (const char *, int) override;
430 void commit_resume () override;
431 void resume (ptid_t, int, enum gdb_signal) override;
432 ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
434 void fetch_registers (struct regcache *, int) override;
435 void store_registers (struct regcache *, int) override;
436 void prepare_to_store (struct regcache *) override;
438 void files_info () override;
440 int insert_breakpoint (struct gdbarch *, struct bp_target_info *) override;
442 int remove_breakpoint (struct gdbarch *, struct bp_target_info *,
443 enum remove_bp_reason) override;
446 bool stopped_by_sw_breakpoint () override;
447 bool supports_stopped_by_sw_breakpoint () override;
449 bool stopped_by_hw_breakpoint () override;
451 bool supports_stopped_by_hw_breakpoint () override;
453 bool stopped_by_watchpoint () override;
455 bool stopped_data_address (CORE_ADDR *) override;
457 bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override;
459 int can_use_hw_breakpoint (enum bptype, int, int) override;
461 int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
463 int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
465 int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;
467 int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
468 struct expression *) override;
470 int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
471 struct expression *) override;
473 void kill () override;
475 void load (const char *, int) override;
477 void mourn_inferior () override;
479 void pass_signals (int, unsigned char *) override;
481 int set_syscall_catchpoint (int, bool, int,
482 gdb::array_view<const int>) override;
484 void program_signals (int, unsigned char *) override;
486 bool thread_alive (ptid_t ptid) override;
488 const char *thread_name (struct thread_info *) override;
490 void update_thread_list () override;
492 const char *pid_to_str (ptid_t) override;
494 const char *extra_thread_info (struct thread_info *) override;
496 ptid_t get_ada_task_ptid (long lwp, long thread) override;
498 thread_info *thread_handle_to_thread_info (const gdb_byte *thread_handle,
500 inferior *inf) override;
502 void stop (ptid_t) override;
504 void interrupt () override;
506 void pass_ctrlc () override;
508 enum target_xfer_status xfer_partial (enum target_object object,
511 const gdb_byte *writebuf,
512 ULONGEST offset, ULONGEST len,
513 ULONGEST *xfered_len) override;
515 ULONGEST get_memory_xfer_limit () override;
517 void rcmd (const char *command, struct ui_file *output) override;
519 char *pid_to_exec_file (int pid) override;
521 void log_command (const char *cmd) override
523 serial_log_command (this, cmd);
526 CORE_ADDR get_thread_local_address (ptid_t ptid,
527 CORE_ADDR load_module_addr,
528 CORE_ADDR offset) override;
530 bool has_all_memory () override { return default_child_has_all_memory (); }
531 bool has_memory () override { return default_child_has_memory (); }
532 bool has_stack () override { return default_child_has_stack (); }
533 bool has_registers () override { return default_child_has_registers (); }
534 bool has_execution (ptid_t ptid) override { return default_child_has_execution (ptid); }
536 bool can_execute_reverse () override;
538 std::vector<mem_region> memory_map () override;
540 void flash_erase (ULONGEST address, LONGEST length) override;
542 void flash_done () override;
544 const struct target_desc *read_description () override;
546 int search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
547 const gdb_byte *pattern, ULONGEST pattern_len,
548 CORE_ADDR *found_addrp) override;
550 bool can_async_p () override;
552 bool is_async_p () override;
554 void async (int) override;
556 void thread_events (int) override;
558 int can_do_single_step () override;
560 void terminal_inferior () override;
562 void terminal_ours () override;
564 bool supports_non_stop () override;
566 bool supports_multi_process () override;
568 bool supports_disable_randomization () override;
570 bool filesystem_is_local () override;
573 int fileio_open (struct inferior *inf, const char *filename,
574 int flags, int mode, int warn_if_slow,
575 int *target_errno) override;
577 int fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
578 ULONGEST offset, int *target_errno) override;
580 int fileio_pread (int fd, gdb_byte *read_buf, int len,
581 ULONGEST offset, int *target_errno) override;
583 int fileio_fstat (int fd, struct stat *sb, int *target_errno) override;
585 int fileio_close (int fd, int *target_errno) override;
587 int fileio_unlink (struct inferior *inf,
588 const char *filename,
589 int *target_errno) override;
591 gdb::optional<std::string>
592 fileio_readlink (struct inferior *inf,
593 const char *filename,
594 int *target_errno) override;
596 bool supports_enable_disable_tracepoint () override;
598 bool supports_string_tracing () override;
600 bool supports_evaluation_of_breakpoint_conditions () override;
602 bool can_run_breakpoint_commands () override;
604 void trace_init () override;
606 void download_tracepoint (struct bp_location *location) override;
608 bool can_download_tracepoint () override;
610 void download_trace_state_variable (const trace_state_variable &tsv) override;
612 void enable_tracepoint (struct bp_location *location) override;
614 void disable_tracepoint (struct bp_location *location) override;
616 void trace_set_readonly_regions () override;
618 void trace_start () override;
620 int get_trace_status (struct trace_status *ts) override;
622 void get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
625 void trace_stop () override;
627 int trace_find (enum trace_find_type type, int num,
628 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) override;
630 bool get_trace_state_variable_value (int tsv, LONGEST *val) override;
632 int save_trace_data (const char *filename) override;
634 int upload_tracepoints (struct uploaded_tp **utpp) override;
636 int upload_trace_state_variables (struct uploaded_tsv **utsvp) override;
638 LONGEST get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len) override;
640 int get_min_fast_tracepoint_insn_len () override;
642 void set_disconnected_tracing (int val) override;
644 void set_circular_trace_buffer (int val) override;
646 void set_trace_buffer_size (LONGEST val) override;
648 bool set_trace_notes (const char *user, const char *notes,
649 const char *stopnotes) override;
651 int core_of_thread (ptid_t ptid) override;
653 int verify_memory (const gdb_byte *data,
654 CORE_ADDR memaddr, ULONGEST size) override;
657 bool get_tib_address (ptid_t ptid, CORE_ADDR *addr) override;
659 void set_permissions () override;
661 bool static_tracepoint_marker_at (CORE_ADDR,
662 struct static_tracepoint_marker *marker)
665 std::vector<static_tracepoint_marker>
666 static_tracepoint_markers_by_strid (const char *id) override;
668 traceframe_info_up traceframe_info () override;
670 bool use_agent (bool use) override;
671 bool can_use_agent () override;
673 struct btrace_target_info *enable_btrace (ptid_t ptid,
674 const struct btrace_config *conf) override;
676 void disable_btrace (struct btrace_target_info *tinfo) override;
678 void teardown_btrace (struct btrace_target_info *tinfo) override;
680 enum btrace_error read_btrace (struct btrace_data *data,
681 struct btrace_target_info *btinfo,
682 enum btrace_read_type type) override;
684 const struct btrace_config *btrace_conf (const struct btrace_target_info *) override;
685 bool augmented_libraries_svr4_read () override;
686 int follow_fork (int, int) override;
687 void follow_exec (struct inferior *, char *) override;
688 int insert_fork_catchpoint (int) override;
689 int remove_fork_catchpoint (int) override;
690 int insert_vfork_catchpoint (int) override;
691 int remove_vfork_catchpoint (int) override;
692 int insert_exec_catchpoint (int) override;
693 int remove_exec_catchpoint (int) override;
694 enum exec_direction_kind execution_direction () override;
696 public: /* Remote specific methods. */
698 void remote_download_command_source (int num, ULONGEST addr,
699 struct command_line *cmds);
701 void remote_file_put (const char *local_file, const char *remote_file,
703 void remote_file_get (const char *remote_file, const char *local_file,
705 void remote_file_delete (const char *remote_file, int from_tty);
707 int remote_hostio_pread (int fd, gdb_byte *read_buf, int len,
708 ULONGEST offset, int *remote_errno);
709 int remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
710 ULONGEST offset, int *remote_errno);
711 int remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len,
712 ULONGEST offset, int *remote_errno);
714 int remote_hostio_send_command (int command_bytes, int which_packet,
715 int *remote_errno, char **attachment,
716 int *attachment_len);
717 int remote_hostio_set_filesystem (struct inferior *inf,
719 /* We should get rid of this and use fileio_open directly. */
720 int remote_hostio_open (struct inferior *inf, const char *filename,
721 int flags, int mode, int warn_if_slow,
723 int remote_hostio_close (int fd, int *remote_errno);
725 int remote_hostio_unlink (inferior *inf, const char *filename,
728 struct remote_state *get_remote_state ();
730 long get_remote_packet_size (void);
731 long get_memory_packet_size (struct memory_packet_config *config);
733 long get_memory_write_packet_size ();
734 long get_memory_read_packet_size ();
736 char *append_pending_thread_resumptions (char *p, char *endp,
738 static void open_1 (const char *name, int from_tty, int extended_p);
739 void start_remote (int from_tty, int extended_p);
740 void remote_detach_1 (struct inferior *inf, int from_tty);
742 char *append_resumption (char *p, char *endp,
743 ptid_t ptid, int step, gdb_signal siggnal);
744 int remote_resume_with_vcont (ptid_t ptid, int step,
747 void add_current_inferior_and_thread (char *wait_status);
749 ptid_t wait_ns (ptid_t ptid, struct target_waitstatus *status,
751 ptid_t wait_as (ptid_t ptid, target_waitstatus *status,
754 ptid_t process_stop_reply (struct stop_reply *stop_reply,
755 target_waitstatus *status);
757 void remote_notice_new_inferior (ptid_t currthread, int executing);
759 void process_initial_stop_replies (int from_tty);
761 thread_info *remote_add_thread (ptid_t ptid, bool running, bool executing);
763 void btrace_sync_conf (const btrace_config *conf);
765 void remote_btrace_maybe_reopen ();
767 void remove_new_fork_children (threads_listing_context *context);
768 void kill_new_fork_children (int pid);
769 void discard_pending_stop_replies (struct inferior *inf);
770 int stop_reply_queue_length ();
772 void check_pending_events_prevent_wildcard_vcont
773 (int *may_global_wildcard_vcont);
775 void discard_pending_stop_replies_in_queue ();
776 struct stop_reply *remote_notif_remove_queued_reply (ptid_t ptid);
777 struct stop_reply *queued_stop_reply (ptid_t ptid);
778 int peek_stop_reply (ptid_t ptid);
779 void remote_parse_stop_reply (char *buf, stop_reply *event);
781 void remote_stop_ns (ptid_t ptid);
782 void remote_interrupt_as ();
783 void remote_interrupt_ns ();
785 char *remote_get_noisy_reply ();
786 int remote_query_attached (int pid);
787 inferior *remote_add_inferior (int fake_pid_p, int pid, int attached,
790 ptid_t remote_current_thread (ptid_t oldpid);
791 ptid_t get_current_thread (char *wait_status);
793 void set_thread (ptid_t ptid, int gen);
794 void set_general_thread (ptid_t ptid);
795 void set_continue_thread (ptid_t ptid);
796 void set_general_process ();
798 char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);
800 int remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
801 gdb_ext_thread_info *info);
802 int remote_get_threadinfo (threadref *threadid, int fieldset,
803 gdb_ext_thread_info *info);
805 int parse_threadlist_response (char *pkt, int result_limit,
806 threadref *original_echo,
807 threadref *resultlist,
809 int remote_get_threadlist (int startflag, threadref *nextthread,
810 int result_limit, int *done, int *result_count,
811 threadref *threadlist);
813 int remote_threadlist_iterator (rmt_thread_action stepfunction,
814 void *context, int looplimit);
816 int remote_get_threads_with_ql (threads_listing_context *context);
817 int remote_get_threads_with_qxfer (threads_listing_context *context);
818 int remote_get_threads_with_qthreadinfo (threads_listing_context *context);
820 void extended_remote_restart ();
824 void remote_check_symbols ();
826 void remote_supported_packet (const struct protocol_feature *feature,
827 enum packet_support support,
828 const char *argument);
830 void remote_query_supported ();
832 void remote_packet_size (const protocol_feature *feature,
833 packet_support support, const char *value);
835 void remote_serial_quit_handler ();
837 void remote_detach_pid (int pid);
839 void remote_vcont_probe ();
841 void remote_resume_with_hc (ptid_t ptid, int step,
844 void send_interrupt_sequence ();
845 void interrupt_query ();
847 void remote_notif_get_pending_events (notif_client *nc);
849 int fetch_register_using_p (struct regcache *regcache,
851 int send_g_packet ();
852 void process_g_packet (struct regcache *regcache);
853 void fetch_registers_using_g (struct regcache *regcache);
854 int store_register_using_P (const struct regcache *regcache,
856 void store_registers_using_G (const struct regcache *regcache);
858 void set_remote_traceframe ();
860 void check_binary_download (CORE_ADDR addr);
862 target_xfer_status remote_write_bytes_aux (const char *header,
864 const gdb_byte *myaddr,
867 ULONGEST *xfered_len_units,
871 target_xfer_status remote_write_bytes (CORE_ADDR memaddr,
872 const gdb_byte *myaddr, ULONGEST len,
873 int unit_size, ULONGEST *xfered_len);
875 target_xfer_status remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr,
877 int unit_size, ULONGEST *xfered_len_units);
879 target_xfer_status remote_xfer_live_readonly_partial (gdb_byte *readbuf,
883 ULONGEST *xfered_len);
885 target_xfer_status remote_read_bytes (CORE_ADDR memaddr,
886 gdb_byte *myaddr, ULONGEST len,
888 ULONGEST *xfered_len);
890 packet_result remote_send_printf (const char *format, ...)
891 ATTRIBUTE_PRINTF (2, 3);
893 target_xfer_status remote_flash_write (ULONGEST address,
894 ULONGEST length, ULONGEST *xfered_len,
895 const gdb_byte *data);
897 int readchar (int timeout);
899 void remote_serial_write (const char *str, int len);
901 int putpkt (const char *buf);
902 int putpkt_binary (const char *buf, int cnt);
905 long read_frame (char **buf_p, long *sizeof_buf);
906 void getpkt (char **buf, long *sizeof_buf, int forever);
907 int getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, int forever,
908 int expecting_notif, int *is_notif);
909 int getpkt_sane (char **buf, long *sizeof_buf, int forever);
910 int getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever,
912 int remote_vkill (int pid);
913 void remote_kill_k ();
915 void extended_remote_disable_randomization (int val);
916 int extended_remote_run (const std::string &args);
918 void send_environment_packet (const char *action,
922 void extended_remote_environment_support ();
923 void extended_remote_set_inferior_cwd ();
925 target_xfer_status remote_write_qxfer (const char *object_name,
927 const gdb_byte *writebuf,
928 ULONGEST offset, LONGEST len,
929 ULONGEST *xfered_len,
930 struct packet_config *packet);
932 target_xfer_status remote_read_qxfer (const char *object_name,
934 gdb_byte *readbuf, ULONGEST offset,
936 ULONGEST *xfered_len,
937 struct packet_config *packet);
939 void push_stop_reply (struct stop_reply *new_event);
941 bool vcont_r_supported ();
943 void packet_command (const char *args, int from_tty);
945 private: /* data fields */
947 /* The remote state. Don't reference this directly. Use the
948 get_remote_state method instead. */
949 remote_state m_remote_state;
952 static const target_info extended_remote_target_info = {
954 N_("Extended remote serial target in gdb-specific protocol"),
958 /* Set up the extended remote target by extending the standard remote
959 target and adding to it. */
961 class extended_remote_target final : public remote_target
964 const target_info &info () const override
965 { return extended_remote_target_info; }
967 /* Open an extended-remote connection. */
968 static void open (const char *, int);
970 bool can_create_inferior () override { return true; }
971 void create_inferior (const char *, const std::string &,
972 char **, int) override;
974 void detach (inferior *, int) override;
976 bool can_attach () override { return true; }
977 void attach (const char *, int) override;
979 void post_attach (int) override;
980 bool supports_disable_randomization () override;
983 /* Per-program-space data key. */
984 static const struct program_space_data *remote_pspace_data;
986 /* The variable registered as the control variable used by the
987 remote exec-file commands. While the remote exec-file setting is
988 per-program-space, the set/show machinery uses this as the
989 location of the remote exec-file value. */
990 static char *remote_exec_file_var;
992 /* The size to align memory write packets, when practical. The protocol
993 does not guarantee any alignment, and gdb will generate short
994 writes and unaligned writes, but even as a best-effort attempt this
995 can improve bulk transfers. For instance, if a write is misaligned
996 relative to the target's data bus, the stub may need to make an extra
997 round trip fetching data from the target. This doesn't make a
998 huge difference, but it's easy to do, so we try to be helpful.
1000 The alignment chosen is arbitrary; usually data bus width is
1001 important here, not the possibly larger cache line size. */
1002 enum { REMOTE_ALIGN_WRITES = 16 };
1004 /* Prototypes for local functions. */
1006 static int hexnumlen (ULONGEST num);
1008 static int stubhex (int ch);
1010 static int hexnumstr (char *, ULONGEST);
1012 static int hexnumnstr (char *, ULONGEST, int);
1014 static CORE_ADDR remote_address_masked (CORE_ADDR);
1016 static void print_packet (const char *);
1018 static int stub_unpack_int (char *buff, int fieldlength);
1020 struct packet_config;
1022 static void show_packet_config_cmd (struct packet_config *config);
1024 static void show_remote_protocol_packet_cmd (struct ui_file *file,
1026 struct cmd_list_element *c,
1029 static ptid_t read_ptid (const char *buf, const char **obuf);
1031 static void remote_async_inferior_event_handler (gdb_client_data);
1033 static int remote_read_description_p (struct target_ops *target);
1035 static void remote_console_output (char *msg);
1037 static void remote_btrace_reset (remote_state *rs);
1039 static void remote_unpush_and_throw (void);
1043 static struct cmd_list_element *remote_cmdlist;
1045 /* For "set remote" and "show remote". */
1047 static struct cmd_list_element *remote_set_cmdlist;
1048 static struct cmd_list_element *remote_show_cmdlist;
1050 /* Controls whether GDB is willing to use range stepping. */
1052 static int use_range_stepping = 1;
1054 /* The max number of chars in debug output. The rest of chars are
1057 #define REMOTE_DEBUG_MAX_CHAR 512
1059 /* Private data that we'll store in (struct thread_info)->priv. */
1060 struct remote_thread_info : public private_thread_info
1066 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1067 sequence of bytes. */
1068 gdb::byte_vector thread_handle;
1070 /* Whether the target stopped for a breakpoint/watchpoint. */
1071 enum target_stop_reason stop_reason = TARGET_STOPPED_BY_NO_REASON;
1073 /* This is set to the data address of the access causing the target
1074 to stop for a watchpoint. */
1075 CORE_ADDR watch_data_address = 0;
1077 /* Fields used by the vCont action coalescing implemented in
1078 remote_resume / remote_commit_resume. remote_resume stores each
1079 thread's last resume request in these fields, so that a later
1080 remote_commit_resume knows which is the proper action for this
1081 thread to include in the vCont packet. */
1083 /* True if the last target_resume call for this thread was a step
1084 request, false if a continue request. */
1085 int last_resume_step = 0;
1087 /* The signal specified in the last target_resume call for this
1089 gdb_signal last_resume_sig = GDB_SIGNAL_0;
1091 /* Whether this thread was already vCont-resumed on the remote
1093 int vcont_resumed = 0;
1096 remote_state::remote_state ()
1098 /* The default buffer size is unimportant; it will be expanded
1099 whenever a larger buffer is needed. */
1100 this->buf_size = 400;
1101 this->buf = (char *) xmalloc (this->buf_size);
1104 remote_state::~remote_state ()
1106 xfree (this->last_pass_packet);
1107 xfree (this->last_program_signals_packet);
1109 xfree (this->finished_object);
1110 xfree (this->finished_annex);
1113 /* Utility: generate error from an incoming stub packet. */
1115 trace_error (char *buf)
1118 return; /* not an error msg */
1121 case '1': /* malformed packet error */
1122 if (*++buf == '0') /* general case: */
1123 error (_("remote.c: error in outgoing packet."));
1125 error (_("remote.c: error in outgoing packet at field #%ld."),
1126 strtol (buf, NULL, 16));
1128 error (_("Target returns error code '%s'."), buf);
1132 /* Utility: wait for reply from stub, while accepting "O" packets. */
1135 remote_target::remote_get_noisy_reply ()
1137 struct remote_state *rs = get_remote_state ();
1139 do /* Loop on reply from remote stub. */
1143 QUIT; /* Allow user to bail out with ^C. */
1144 getpkt (&rs->buf, &rs->buf_size, 0);
1148 else if (startswith (buf, "qRelocInsn:"))
1151 CORE_ADDR from, to, org_to;
1153 int adjusted_size = 0;
1156 p = buf + strlen ("qRelocInsn:");
1157 pp = unpack_varlen_hex (p, &ul);
1159 error (_("invalid qRelocInsn packet: %s"), buf);
1163 unpack_varlen_hex (p, &ul);
1170 gdbarch_relocate_instruction (target_gdbarch (), &to, from);
1173 CATCH (ex, RETURN_MASK_ALL)
1175 if (ex.error == MEMORY_ERROR)
1177 /* Propagate memory errors silently back to the
1178 target. The stub may have limited the range of
1179 addresses we can write to, for example. */
1183 /* Something unexpectedly bad happened. Be verbose
1184 so we can tell what, and propagate the error back
1185 to the stub, so it doesn't get stuck waiting for
1187 exception_fprintf (gdb_stderr, ex,
1188 _("warning: relocating instruction: "));
1196 adjusted_size = to - org_to;
1198 xsnprintf (buf, rs->buf_size, "qRelocInsn:%x", adjusted_size);
1202 else if (buf[0] == 'O' && buf[1] != 'K')
1203 remote_console_output (buf + 1); /* 'O' message from stub */
1205 return buf; /* Here's the actual reply. */
1210 struct remote_arch_state *
1211 remote_state::get_remote_arch_state (struct gdbarch *gdbarch)
1213 remote_arch_state *rsa;
1215 auto it = this->m_arch_states.find (gdbarch);
1216 if (it == this->m_arch_states.end ())
1218 auto p = this->m_arch_states.emplace (std::piecewise_construct,
1219 std::forward_as_tuple (gdbarch),
1220 std::forward_as_tuple (gdbarch));
1221 rsa = &p.first->second;
1223 /* Make sure that the packet buffer is plenty big enough for
1224 this architecture. */
1225 if (this->buf_size < rsa->remote_packet_size)
1227 this->buf_size = 2 * rsa->remote_packet_size;
1228 this->buf = (char *) xrealloc (this->buf, this->buf_size);
1237 /* Fetch the global remote target state. */
1240 remote_target::get_remote_state ()
1242 /* Make sure that the remote architecture state has been
1243 initialized, because doing so might reallocate rs->buf. Any
1244 function which calls getpkt also needs to be mindful of changes
1245 to rs->buf, but this call limits the number of places which run
1247 m_remote_state.get_remote_arch_state (target_gdbarch ());
1249 return &m_remote_state;
1252 /* Cleanup routine for the remote module's pspace data. */
1255 remote_pspace_data_cleanup (struct program_space *pspace, void *arg)
1257 char *remote_exec_file = (char *) arg;
1259 xfree (remote_exec_file);
1262 /* Fetch the remote exec-file from the current program space. */
1265 get_remote_exec_file (void)
1267 char *remote_exec_file;
1270 = (char *) program_space_data (current_program_space,
1271 remote_pspace_data);
1272 if (remote_exec_file == NULL)
1275 return remote_exec_file;
1278 /* Set the remote exec file for PSPACE. */
1281 set_pspace_remote_exec_file (struct program_space *pspace,
1282 char *remote_exec_file)
1284 char *old_file = (char *) program_space_data (pspace, remote_pspace_data);
1287 set_program_space_data (pspace, remote_pspace_data,
1288 xstrdup (remote_exec_file));
1291 /* The "set/show remote exec-file" set command hook. */
1294 set_remote_exec_file (const char *ignored, int from_tty,
1295 struct cmd_list_element *c)
1297 gdb_assert (remote_exec_file_var != NULL);
1298 set_pspace_remote_exec_file (current_program_space, remote_exec_file_var);
1301 /* The "set/show remote exec-file" show command hook. */
1304 show_remote_exec_file (struct ui_file *file, int from_tty,
1305 struct cmd_list_element *cmd, const char *value)
1307 fprintf_filtered (file, "%s\n", remote_exec_file_var);
1311 compare_pnums (const void *lhs_, const void *rhs_)
1313 const struct packet_reg * const *lhs
1314 = (const struct packet_reg * const *) lhs_;
1315 const struct packet_reg * const *rhs
1316 = (const struct packet_reg * const *) rhs_;
1318 if ((*lhs)->pnum < (*rhs)->pnum)
1320 else if ((*lhs)->pnum == (*rhs)->pnum)
1327 map_regcache_remote_table (struct gdbarch *gdbarch, struct packet_reg *regs)
1329 int regnum, num_remote_regs, offset;
1330 struct packet_reg **remote_regs;
1332 for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
1334 struct packet_reg *r = ®s[regnum];
1336 if (register_size (gdbarch, regnum) == 0)
1337 /* Do not try to fetch zero-sized (placeholder) registers. */
1340 r->pnum = gdbarch_remote_register_number (gdbarch, regnum);
1345 /* Define the g/G packet format as the contents of each register
1346 with a remote protocol number, in order of ascending protocol
1349 remote_regs = XALLOCAVEC (struct packet_reg *, gdbarch_num_regs (gdbarch));
1350 for (num_remote_regs = 0, regnum = 0;
1351 regnum < gdbarch_num_regs (gdbarch);
1353 if (regs[regnum].pnum != -1)
1354 remote_regs[num_remote_regs++] = ®s[regnum];
1356 qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
1359 for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++)
1361 remote_regs[regnum]->in_g_packet = 1;
1362 remote_regs[regnum]->offset = offset;
1363 offset += register_size (gdbarch, remote_regs[regnum]->regnum);
1369 /* Given the architecture described by GDBARCH, return the remote
1370 protocol register's number and the register's offset in the g/G
1371 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1372 If the target does not have a mapping for REGNUM, return false,
1373 otherwise, return true. */
1376 remote_register_number_and_offset (struct gdbarch *gdbarch, int regnum,
1377 int *pnum, int *poffset)
1379 gdb_assert (regnum < gdbarch_num_regs (gdbarch));
1381 std::vector<packet_reg> regs (gdbarch_num_regs (gdbarch));
1383 map_regcache_remote_table (gdbarch, regs.data ());
1385 *pnum = regs[regnum].pnum;
1386 *poffset = regs[regnum].offset;
1391 remote_arch_state::remote_arch_state (struct gdbarch *gdbarch)
1393 /* Use the architecture to build a regnum<->pnum table, which will be
1394 1:1 unless a feature set specifies otherwise. */
1395 this->regs.reset (new packet_reg [gdbarch_num_regs (gdbarch)] ());
1397 /* Record the maximum possible size of the g packet - it may turn out
1399 this->sizeof_g_packet
1400 = map_regcache_remote_table (gdbarch, this->regs.get ());
1402 /* Default maximum number of characters in a packet body. Many
1403 remote stubs have a hardwired buffer size of 400 bytes
1404 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1405 as the maximum packet-size to ensure that the packet and an extra
1406 NUL character can always fit in the buffer. This stops GDB
1407 trashing stubs that try to squeeze an extra NUL into what is
1408 already a full buffer (As of 1999-12-04 that was most stubs). */
1409 this->remote_packet_size = 400 - 1;
1411 /* This one is filled in when a ``g'' packet is received. */
1412 this->actual_register_packet_size = 0;
1414 /* Should rsa->sizeof_g_packet needs more space than the
1415 default, adjust the size accordingly. Remember that each byte is
1416 encoded as two characters. 32 is the overhead for the packet
1417 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1418 (``$NN:G...#NN'') is a better guess, the below has been padded a
1420 if (this->sizeof_g_packet > ((this->remote_packet_size - 32) / 2))
1421 this->remote_packet_size = (this->sizeof_g_packet * 2 + 32);
1424 /* Get a pointer to the current remote target. If not connected to a
1425 remote target, return NULL. */
1427 static remote_target *
1428 get_current_remote_target ()
1430 target_ops *proc_target = find_target_at (process_stratum);
1431 return dynamic_cast<remote_target *> (proc_target);
1434 /* Return the current allowed size of a remote packet. This is
1435 inferred from the current architecture, and should be used to
1436 limit the length of outgoing packets. */
1438 remote_target::get_remote_packet_size ()
1440 struct remote_state *rs = get_remote_state ();
1441 remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ());
1443 if (rs->explicit_packet_size)
1444 return rs->explicit_packet_size;
1446 return rsa->remote_packet_size;
1449 static struct packet_reg *
1450 packet_reg_from_regnum (struct gdbarch *gdbarch, struct remote_arch_state *rsa,
1453 if (regnum < 0 && regnum >= gdbarch_num_regs (gdbarch))
1457 struct packet_reg *r = &rsa->regs[regnum];
1459 gdb_assert (r->regnum == regnum);
1464 static struct packet_reg *
1465 packet_reg_from_pnum (struct gdbarch *gdbarch, struct remote_arch_state *rsa,
1470 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
1472 struct packet_reg *r = &rsa->regs[i];
1474 if (r->pnum == pnum)
1480 /* Allow the user to specify what sequence to send to the remote
1481 when he requests a program interruption: Although ^C is usually
1482 what remote systems expect (this is the default, here), it is
1483 sometimes preferable to send a break. On other systems such
1484 as the Linux kernel, a break followed by g, which is Magic SysRq g
1485 is required in order to interrupt the execution. */
1486 const char interrupt_sequence_control_c[] = "Ctrl-C";
1487 const char interrupt_sequence_break[] = "BREAK";
1488 const char interrupt_sequence_break_g[] = "BREAK-g";
1489 static const char *const interrupt_sequence_modes[] =
1491 interrupt_sequence_control_c,
1492 interrupt_sequence_break,
1493 interrupt_sequence_break_g,
1496 static const char *interrupt_sequence_mode = interrupt_sequence_control_c;
1499 show_interrupt_sequence (struct ui_file *file, int from_tty,
1500 struct cmd_list_element *c,
1503 if (interrupt_sequence_mode == interrupt_sequence_control_c)
1504 fprintf_filtered (file,
1505 _("Send the ASCII ETX character (Ctrl-c) "
1506 "to the remote target to interrupt the "
1507 "execution of the program.\n"));
1508 else if (interrupt_sequence_mode == interrupt_sequence_break)
1509 fprintf_filtered (file,
1510 _("send a break signal to the remote target "
1511 "to interrupt the execution of the program.\n"));
1512 else if (interrupt_sequence_mode == interrupt_sequence_break_g)
1513 fprintf_filtered (file,
1514 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1515 "the remote target to interrupt the execution "
1516 "of Linux kernel.\n"));
1518 internal_error (__FILE__, __LINE__,
1519 _("Invalid value for interrupt_sequence_mode: %s."),
1520 interrupt_sequence_mode);
1523 /* This boolean variable specifies whether interrupt_sequence is sent
1524 to the remote target when gdb connects to it.
1525 This is mostly needed when you debug the Linux kernel: The Linux kernel
1526 expects BREAK g which is Magic SysRq g for connecting gdb. */
1527 static int interrupt_on_connect = 0;
1529 /* This variable is used to implement the "set/show remotebreak" commands.
1530 Since these commands are now deprecated in favor of "set/show remote
1531 interrupt-sequence", it no longer has any effect on the code. */
1532 static int remote_break;
1535 set_remotebreak (const char *args, int from_tty, struct cmd_list_element *c)
1538 interrupt_sequence_mode = interrupt_sequence_break;
1540 interrupt_sequence_mode = interrupt_sequence_control_c;
1544 show_remotebreak (struct ui_file *file, int from_tty,
1545 struct cmd_list_element *c,
1550 /* This variable sets the number of bits in an address that are to be
1551 sent in a memory ("M" or "m") packet. Normally, after stripping
1552 leading zeros, the entire address would be sent. This variable
1553 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1554 initial implementation of remote.c restricted the address sent in
1555 memory packets to ``host::sizeof long'' bytes - (typically 32
1556 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1557 address was never sent. Since fixing this bug may cause a break in
1558 some remote targets this variable is principly provided to
1559 facilitate backward compatibility. */
1561 static unsigned int remote_address_size;
1564 /* User configurable variables for the number of characters in a
1565 memory read/write packet. MIN (rsa->remote_packet_size,
1566 rsa->sizeof_g_packet) is the default. Some targets need smaller
1567 values (fifo overruns, et.al.) and some users need larger values
1568 (speed up transfers). The variables ``preferred_*'' (the user
1569 request), ``current_*'' (what was actually set) and ``forced_*''
1570 (Positive - a soft limit, negative - a hard limit). */
1572 struct memory_packet_config
1579 /* The default max memory-write-packet-size, when the setting is
1580 "fixed". The 16k is historical. (It came from older GDB's using
1581 alloca for buffers and the knowledge (folklore?) that some hosts
1582 don't cope very well with large alloca calls.) */
1583 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1585 /* The minimum remote packet size for memory transfers. Ensures we
1586 can write at least one byte. */
1587 #define MIN_MEMORY_PACKET_SIZE 20
1589 /* Get the memory packet size, assuming it is fixed. */
1592 get_fixed_memory_packet_size (struct memory_packet_config *config)
1594 gdb_assert (config->fixed_p);
1596 if (config->size <= 0)
1597 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED;
1599 return config->size;
1602 /* Compute the current size of a read/write packet. Since this makes
1603 use of ``actual_register_packet_size'' the computation is dynamic. */
1606 remote_target::get_memory_packet_size (struct memory_packet_config *config)
1608 struct remote_state *rs = get_remote_state ();
1609 remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ());
1612 if (config->fixed_p)
1613 what_they_get = get_fixed_memory_packet_size (config);
1616 what_they_get = get_remote_packet_size ();
1617 /* Limit the packet to the size specified by the user. */
1618 if (config->size > 0
1619 && what_they_get > config->size)
1620 what_they_get = config->size;
1622 /* Limit it to the size of the targets ``g'' response unless we have
1623 permission from the stub to use a larger packet size. */
1624 if (rs->explicit_packet_size == 0
1625 && rsa->actual_register_packet_size > 0
1626 && what_they_get > rsa->actual_register_packet_size)
1627 what_they_get = rsa->actual_register_packet_size;
1629 if (what_they_get < MIN_MEMORY_PACKET_SIZE)
1630 what_they_get = MIN_MEMORY_PACKET_SIZE;
1632 /* Make sure there is room in the global buffer for this packet
1633 (including its trailing NUL byte). */
1634 if (rs->buf_size < what_they_get + 1)
1636 rs->buf_size = 2 * what_they_get;
1637 rs->buf = (char *) xrealloc (rs->buf, 2 * what_they_get);
1640 return what_they_get;
1643 /* Update the size of a read/write packet. If they user wants
1644 something really big then do a sanity check. */
1647 set_memory_packet_size (const char *args, struct memory_packet_config *config)
1649 int fixed_p = config->fixed_p;
1650 long size = config->size;
1653 error (_("Argument required (integer, `fixed' or `limited')."));
1654 else if (strcmp (args, "hard") == 0
1655 || strcmp (args, "fixed") == 0)
1657 else if (strcmp (args, "soft") == 0
1658 || strcmp (args, "limit") == 0)
1664 size = strtoul (args, &end, 0);
1666 error (_("Invalid %s (bad syntax)."), config->name);
1668 /* Instead of explicitly capping the size of a packet to or
1669 disallowing it, the user is allowed to set the size to
1670 something arbitrarily large. */
1674 if (fixed_p && !config->fixed_p)
1676 /* So that the query shows the correct value. */
1677 long query_size = (size <= 0
1678 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1681 if (! query (_("The target may not be able to correctly handle a %s\n"
1682 "of %ld bytes. Change the packet size? "),
1683 config->name, query_size))
1684 error (_("Packet size not changed."));
1686 /* Update the config. */
1687 config->fixed_p = fixed_p;
1688 config->size = size;
1692 show_memory_packet_size (struct memory_packet_config *config)
1694 if (config->size == 0)
1695 printf_filtered (_("The %s is 0 (default). "), config->name);
1697 printf_filtered (_("The %s is %ld. "), config->name, config->size);
1698 if (config->fixed_p)
1699 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1700 get_fixed_memory_packet_size (config));
1703 remote_target *remote = get_current_remote_target ();
1706 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1707 remote->get_memory_packet_size (config));
1709 puts_filtered ("The actual limit will be further reduced "
1710 "dependent on the target.\n");
1714 static struct memory_packet_config memory_write_packet_config =
1716 "memory-write-packet-size",
1720 set_memory_write_packet_size (const char *args, int from_tty)
1722 set_memory_packet_size (args, &memory_write_packet_config);
1726 show_memory_write_packet_size (const char *args, int from_tty)
1728 show_memory_packet_size (&memory_write_packet_config);
1731 /* Show the number of hardware watchpoints that can be used. */
1734 show_hardware_watchpoint_limit (struct ui_file *file, int from_tty,
1735 struct cmd_list_element *c,
1738 fprintf_filtered (file, _("The maximum number of target hardware "
1739 "watchpoints is %s.\n"), value);
1742 /* Show the length limit (in bytes) for hardware watchpoints. */
1745 show_hardware_watchpoint_length_limit (struct ui_file *file, int from_tty,
1746 struct cmd_list_element *c,
1749 fprintf_filtered (file, _("The maximum length (in bytes) of a target "
1750 "hardware watchpoint is %s.\n"), value);
1753 /* Show the number of hardware breakpoints that can be used. */
1756 show_hardware_breakpoint_limit (struct ui_file *file, int from_tty,
1757 struct cmd_list_element *c,
1760 fprintf_filtered (file, _("The maximum number of target hardware "
1761 "breakpoints is %s.\n"), value);
1765 remote_target::get_memory_write_packet_size ()
1767 return get_memory_packet_size (&memory_write_packet_config);
1770 static struct memory_packet_config memory_read_packet_config =
1772 "memory-read-packet-size",
1776 set_memory_read_packet_size (const char *args, int from_tty)
1778 set_memory_packet_size (args, &memory_read_packet_config);
1782 show_memory_read_packet_size (const char *args, int from_tty)
1784 show_memory_packet_size (&memory_read_packet_config);
1788 remote_target::get_memory_read_packet_size ()
1790 long size = get_memory_packet_size (&memory_read_packet_config);
1792 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1793 extra buffer size argument before the memory read size can be
1794 increased beyond this. */
1795 if (size > get_remote_packet_size ())
1796 size = get_remote_packet_size ();
1802 struct packet_config
1807 /* If auto, GDB auto-detects support for this packet or feature,
1808 either through qSupported, or by trying the packet and looking
1809 at the response. If true, GDB assumes the target supports this
1810 packet. If false, the packet is disabled. Configs that don't
1811 have an associated command always have this set to auto. */
1812 enum auto_boolean detect;
1814 /* Does the target support this packet? */
1815 enum packet_support support;
1818 static enum packet_support packet_config_support (struct packet_config *config);
1819 static enum packet_support packet_support (int packet);
1822 show_packet_config_cmd (struct packet_config *config)
1824 const char *support = "internal-error";
1826 switch (packet_config_support (config))
1829 support = "enabled";
1831 case PACKET_DISABLE:
1832 support = "disabled";
1834 case PACKET_SUPPORT_UNKNOWN:
1835 support = "unknown";
1838 switch (config->detect)
1840 case AUTO_BOOLEAN_AUTO:
1841 printf_filtered (_("Support for the `%s' packet "
1842 "is auto-detected, currently %s.\n"),
1843 config->name, support);
1845 case AUTO_BOOLEAN_TRUE:
1846 case AUTO_BOOLEAN_FALSE:
1847 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1848 config->name, support);
1854 add_packet_config_cmd (struct packet_config *config, const char *name,
1855 const char *title, int legacy)
1861 config->name = name;
1862 config->title = title;
1863 set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
1865 show_doc = xstrprintf ("Show current use of remote "
1866 "protocol `%s' (%s) packet",
1868 /* set/show TITLE-packet {auto,on,off} */
1869 cmd_name = xstrprintf ("%s-packet", title);
1870 add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
1871 &config->detect, set_doc,
1872 show_doc, NULL, /* help_doc */
1874 show_remote_protocol_packet_cmd,
1875 &remote_set_cmdlist, &remote_show_cmdlist);
1876 /* The command code copies the documentation strings. */
1879 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1884 legacy_name = xstrprintf ("%s-packet", name);
1885 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1886 &remote_set_cmdlist);
1887 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1888 &remote_show_cmdlist);
1892 static enum packet_result
1893 packet_check_result (const char *buf)
1897 /* The stub recognized the packet request. Check that the
1898 operation succeeded. */
1900 && isxdigit (buf[1]) && isxdigit (buf[2])
1902 /* "Enn" - definitly an error. */
1903 return PACKET_ERROR;
1905 /* Always treat "E." as an error. This will be used for
1906 more verbose error messages, such as E.memtypes. */
1907 if (buf[0] == 'E' && buf[1] == '.')
1908 return PACKET_ERROR;
1910 /* The packet may or may not be OK. Just assume it is. */
1914 /* The stub does not support the packet. */
1915 return PACKET_UNKNOWN;
1918 static enum packet_result
1919 packet_ok (const char *buf, struct packet_config *config)
1921 enum packet_result result;
1923 if (config->detect != AUTO_BOOLEAN_TRUE
1924 && config->support == PACKET_DISABLE)
1925 internal_error (__FILE__, __LINE__,
1926 _("packet_ok: attempt to use a disabled packet"));
1928 result = packet_check_result (buf);
1933 /* The stub recognized the packet request. */
1934 if (config->support == PACKET_SUPPORT_UNKNOWN)
1937 fprintf_unfiltered (gdb_stdlog,
1938 "Packet %s (%s) is supported\n",
1939 config->name, config->title);
1940 config->support = PACKET_ENABLE;
1943 case PACKET_UNKNOWN:
1944 /* The stub does not support the packet. */
1945 if (config->detect == AUTO_BOOLEAN_AUTO
1946 && config->support == PACKET_ENABLE)
1948 /* If the stub previously indicated that the packet was
1949 supported then there is a protocol error. */
1950 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1951 config->name, config->title);
1953 else if (config->detect == AUTO_BOOLEAN_TRUE)
1955 /* The user set it wrong. */
1956 error (_("Enabled packet %s (%s) not recognized by stub"),
1957 config->name, config->title);
1961 fprintf_unfiltered (gdb_stdlog,
1962 "Packet %s (%s) is NOT supported\n",
1963 config->name, config->title);
1964 config->support = PACKET_DISABLE;
1985 PACKET_vFile_pwrite,
1987 PACKET_vFile_unlink,
1988 PACKET_vFile_readlink,
1991 PACKET_qXfer_features,
1992 PACKET_qXfer_exec_file,
1993 PACKET_qXfer_libraries,
1994 PACKET_qXfer_libraries_svr4,
1995 PACKET_qXfer_memory_map,
1996 PACKET_qXfer_spu_read,
1997 PACKET_qXfer_spu_write,
1998 PACKET_qXfer_osdata,
1999 PACKET_qXfer_threads,
2000 PACKET_qXfer_statictrace_read,
2001 PACKET_qXfer_traceframe_info,
2007 PACKET_QPassSignals,
2008 PACKET_QCatchSyscalls,
2009 PACKET_QProgramSignals,
2010 PACKET_QSetWorkingDir,
2011 PACKET_QStartupWithShell,
2012 PACKET_QEnvironmentHexEncoded,
2013 PACKET_QEnvironmentReset,
2014 PACKET_QEnvironmentUnset,
2016 PACKET_qSearch_memory,
2019 PACKET_QStartNoAckMode,
2021 PACKET_qXfer_siginfo_read,
2022 PACKET_qXfer_siginfo_write,
2025 /* Support for conditional tracepoints. */
2026 PACKET_ConditionalTracepoints,
2028 /* Support for target-side breakpoint conditions. */
2029 PACKET_ConditionalBreakpoints,
2031 /* Support for target-side breakpoint commands. */
2032 PACKET_BreakpointCommands,
2034 /* Support for fast tracepoints. */
2035 PACKET_FastTracepoints,
2037 /* Support for static tracepoints. */
2038 PACKET_StaticTracepoints,
2040 /* Support for installing tracepoints while a trace experiment is
2042 PACKET_InstallInTrace,
2046 PACKET_TracepointSource,
2049 PACKET_QDisableRandomization,
2051 PACKET_QTBuffer_size,
2055 PACKET_qXfer_btrace,
2057 /* Support for the QNonStop packet. */
2060 /* Support for the QThreadEvents packet. */
2061 PACKET_QThreadEvents,
2063 /* Support for multi-process extensions. */
2064 PACKET_multiprocess_feature,
2066 /* Support for enabling and disabling tracepoints while a trace
2067 experiment is running. */
2068 PACKET_EnableDisableTracepoints_feature,
2070 /* Support for collecting strings using the tracenz bytecode. */
2071 PACKET_tracenz_feature,
2073 /* Support for continuing to run a trace experiment while GDB is
2075 PACKET_DisconnectedTracing_feature,
2077 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2078 PACKET_augmented_libraries_svr4_read_feature,
2080 /* Support for the qXfer:btrace-conf:read packet. */
2081 PACKET_qXfer_btrace_conf,
2083 /* Support for the Qbtrace-conf:bts:size packet. */
2084 PACKET_Qbtrace_conf_bts_size,
2086 /* Support for swbreak+ feature. */
2087 PACKET_swbreak_feature,
2089 /* Support for hwbreak+ feature. */
2090 PACKET_hwbreak_feature,
2092 /* Support for fork events. */
2093 PACKET_fork_event_feature,
2095 /* Support for vfork events. */
2096 PACKET_vfork_event_feature,
2098 /* Support for the Qbtrace-conf:pt:size packet. */
2099 PACKET_Qbtrace_conf_pt_size,
2101 /* Support for exec events. */
2102 PACKET_exec_event_feature,
2104 /* Support for query supported vCont actions. */
2105 PACKET_vContSupported,
2107 /* Support remote CTRL-C. */
2110 /* Support TARGET_WAITKIND_NO_RESUMED. */
2116 static struct packet_config remote_protocol_packets[PACKET_MAX];
2118 /* Returns the packet's corresponding "set remote foo-packet" command
2119 state. See struct packet_config for more details. */
2121 static enum auto_boolean
2122 packet_set_cmd_state (int packet)
2124 return remote_protocol_packets[packet].detect;
2127 /* Returns whether a given packet or feature is supported. This takes
2128 into account the state of the corresponding "set remote foo-packet"
2129 command, which may be used to bypass auto-detection. */
2131 static enum packet_support
2132 packet_config_support (struct packet_config *config)
2134 switch (config->detect)
2136 case AUTO_BOOLEAN_TRUE:
2137 return PACKET_ENABLE;
2138 case AUTO_BOOLEAN_FALSE:
2139 return PACKET_DISABLE;
2140 case AUTO_BOOLEAN_AUTO:
2141 return config->support;
2143 gdb_assert_not_reached (_("bad switch"));
2147 /* Same as packet_config_support, but takes the packet's enum value as
2150 static enum packet_support
2151 packet_support (int packet)
2153 struct packet_config *config = &remote_protocol_packets[packet];
2155 return packet_config_support (config);
2159 show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty,
2160 struct cmd_list_element *c,
2163 struct packet_config *packet;
2165 for (packet = remote_protocol_packets;
2166 packet < &remote_protocol_packets[PACKET_MAX];
2169 if (&packet->detect == c->var)
2171 show_packet_config_cmd (packet);
2175 internal_error (__FILE__, __LINE__, _("Could not find config for %s"),
2179 /* Should we try one of the 'Z' requests? */
2183 Z_PACKET_SOFTWARE_BP,
2184 Z_PACKET_HARDWARE_BP,
2191 /* For compatibility with older distributions. Provide a ``set remote
2192 Z-packet ...'' command that updates all the Z packet types. */
2194 static enum auto_boolean remote_Z_packet_detect;
2197 set_remote_protocol_Z_packet_cmd (const char *args, int from_tty,
2198 struct cmd_list_element *c)
2202 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
2203 remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
2207 show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty,
2208 struct cmd_list_element *c,
2213 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
2215 show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]);
2219 /* Returns true if the multi-process extensions are in effect. */
2222 remote_multi_process_p (struct remote_state *rs)
2224 return packet_support (PACKET_multiprocess_feature) == PACKET_ENABLE;
2227 /* Returns true if fork events are supported. */
2230 remote_fork_event_p (struct remote_state *rs)
2232 return packet_support (PACKET_fork_event_feature) == PACKET_ENABLE;
2235 /* Returns true if vfork events are supported. */
2238 remote_vfork_event_p (struct remote_state *rs)
2240 return packet_support (PACKET_vfork_event_feature) == PACKET_ENABLE;
2243 /* Returns true if exec events are supported. */
2246 remote_exec_event_p (struct remote_state *rs)
2248 return packet_support (PACKET_exec_event_feature) == PACKET_ENABLE;
2251 /* Insert fork catchpoint target routine. If fork events are enabled
2252 then return success, nothing more to do. */
2255 remote_target::insert_fork_catchpoint (int pid)
2257 struct remote_state *rs = get_remote_state ();
2259 return !remote_fork_event_p (rs);
2262 /* Remove fork catchpoint target routine. Nothing to do, just
2266 remote_target::remove_fork_catchpoint (int pid)
2271 /* Insert vfork catchpoint target routine. If vfork events are enabled
2272 then return success, nothing more to do. */
2275 remote_target::insert_vfork_catchpoint (int pid)
2277 struct remote_state *rs = get_remote_state ();
2279 return !remote_vfork_event_p (rs);
2282 /* Remove vfork catchpoint target routine. Nothing to do, just
2286 remote_target::remove_vfork_catchpoint (int pid)
2291 /* Insert exec catchpoint target routine. If exec events are
2292 enabled, just return success. */
2295 remote_target::insert_exec_catchpoint (int pid)
2297 struct remote_state *rs = get_remote_state ();
2299 return !remote_exec_event_p (rs);
2302 /* Remove exec catchpoint target routine. Nothing to do, just
2306 remote_target::remove_exec_catchpoint (int pid)
2313 static ptid_t magic_null_ptid;
2314 static ptid_t not_sent_ptid;
2315 static ptid_t any_thread_ptid;
2317 /* Find out if the stub attached to PID (and hence GDB should offer to
2318 detach instead of killing it when bailing out). */
2321 remote_target::remote_query_attached (int pid)
2323 struct remote_state *rs = get_remote_state ();
2324 size_t size = get_remote_packet_size ();
2326 if (packet_support (PACKET_qAttached) == PACKET_DISABLE)
2329 if (remote_multi_process_p (rs))
2330 xsnprintf (rs->buf, size, "qAttached:%x", pid);
2332 xsnprintf (rs->buf, size, "qAttached");
2335 getpkt (&rs->buf, &rs->buf_size, 0);
2337 switch (packet_ok (rs->buf,
2338 &remote_protocol_packets[PACKET_qAttached]))
2341 if (strcmp (rs->buf, "1") == 0)
2345 warning (_("Remote failure reply: %s"), rs->buf);
2347 case PACKET_UNKNOWN:
2354 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2355 has been invented by GDB, instead of reported by the target. Since
2356 we can be connected to a remote system before before knowing about
2357 any inferior, mark the target with execution when we find the first
2358 inferior. If ATTACHED is 1, then we had just attached to this
2359 inferior. If it is 0, then we just created this inferior. If it
2360 is -1, then try querying the remote stub to find out if it had
2361 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2362 attempt to open this inferior's executable as the main executable
2363 if no main executable is open already. */
2366 remote_target::remote_add_inferior (int fake_pid_p, int pid, int attached,
2369 struct inferior *inf;
2371 /* Check whether this process we're learning about is to be
2372 considered attached, or if is to be considered to have been
2373 spawned by the stub. */
2375 attached = remote_query_attached (pid);
2377 if (gdbarch_has_global_solist (target_gdbarch ()))
2379 /* If the target shares code across all inferiors, then every
2380 attach adds a new inferior. */
2381 inf = add_inferior (pid);
2383 /* ... and every inferior is bound to the same program space.
2384 However, each inferior may still have its own address
2386 inf->aspace = maybe_new_address_space ();
2387 inf->pspace = current_program_space;
2391 /* In the traditional debugging scenario, there's a 1-1 match
2392 between program/address spaces. We simply bind the inferior
2393 to the program space's address space. */
2394 inf = current_inferior ();
2395 inferior_appeared (inf, pid);
2398 inf->attach_flag = attached;
2399 inf->fake_pid_p = fake_pid_p;
2401 /* If no main executable is currently open then attempt to
2402 open the file that was executed to create this inferior. */
2403 if (try_open_exec && get_exec_file (0) == NULL)
2404 exec_file_locate_attach (pid, 0, 1);
2409 static remote_thread_info *get_remote_thread_info (thread_info *thread);
2410 static remote_thread_info *get_remote_thread_info (ptid_t ptid);
2412 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2413 according to RUNNING. */
2416 remote_target::remote_add_thread (ptid_t ptid, bool running, bool executing)
2418 struct remote_state *rs = get_remote_state ();
2419 struct thread_info *thread;
2421 /* GDB historically didn't pull threads in the initial connection
2422 setup. If the remote target doesn't even have a concept of
2423 threads (e.g., a bare-metal target), even if internally we
2424 consider that a single-threaded target, mentioning a new thread
2425 might be confusing to the user. Be silent then, preserving the
2426 age old behavior. */
2427 if (rs->starting_up)
2428 thread = add_thread_silent (ptid);
2430 thread = add_thread (ptid);
2432 get_remote_thread_info (thread)->vcont_resumed = executing;
2433 set_executing (ptid, executing);
2434 set_running (ptid, running);
2439 /* Come here when we learn about a thread id from the remote target.
2440 It may be the first time we hear about such thread, so take the
2441 opportunity to add it to GDB's thread list. In case this is the
2442 first time we're noticing its corresponding inferior, add it to
2443 GDB's inferior list as well. EXECUTING indicates whether the
2444 thread is (internally) executing or stopped. */
2447 remote_target::remote_notice_new_inferior (ptid_t currthread, int executing)
2449 /* In non-stop mode, we assume new found threads are (externally)
2450 running until proven otherwise with a stop reply. In all-stop,
2451 we can only get here if all threads are stopped. */
2452 int running = target_is_non_stop_p () ? 1 : 0;
2454 /* If this is a new thread, add it to GDB's thread list.
2455 If we leave it up to WFI to do this, bad things will happen. */
2457 thread_info *tp = find_thread_ptid (currthread);
2458 if (tp != NULL && tp->state == THREAD_EXITED)
2460 /* We're seeing an event on a thread id we knew had exited.
2461 This has to be a new thread reusing the old id. Add it. */
2462 remote_add_thread (currthread, running, executing);
2466 if (!in_thread_list (currthread))
2468 struct inferior *inf = NULL;
2469 int pid = currthread.pid ();
2471 if (inferior_ptid.is_pid ()
2472 && pid == inferior_ptid.pid ())
2474 /* inferior_ptid has no thread member yet. This can happen
2475 with the vAttach -> remote_wait,"TAAthread:" path if the
2476 stub doesn't support qC. This is the first stop reported
2477 after an attach, so this is the main thread. Update the
2478 ptid in the thread list. */
2479 if (in_thread_list (ptid_t (pid)))
2480 thread_change_ptid (inferior_ptid, currthread);
2483 remote_add_thread (currthread, running, executing);
2484 inferior_ptid = currthread;
2489 if (magic_null_ptid == inferior_ptid)
2491 /* inferior_ptid is not set yet. This can happen with the
2492 vRun -> remote_wait,"TAAthread:" path if the stub
2493 doesn't support qC. This is the first stop reported
2494 after an attach, so this is the main thread. Update the
2495 ptid in the thread list. */
2496 thread_change_ptid (inferior_ptid, currthread);
2500 /* When connecting to a target remote, or to a target
2501 extended-remote which already was debugging an inferior, we
2502 may not know about it yet. Add it before adding its child
2503 thread, so notifications are emitted in a sensible order. */
2504 if (find_inferior_pid (currthread.pid ()) == NULL)
2506 struct remote_state *rs = get_remote_state ();
2507 int fake_pid_p = !remote_multi_process_p (rs);
2509 inf = remote_add_inferior (fake_pid_p,
2510 currthread.pid (), -1, 1);
2513 /* This is really a new thread. Add it. */
2514 thread_info *new_thr
2515 = remote_add_thread (currthread, running, executing);
2517 /* If we found a new inferior, let the common code do whatever
2518 it needs to with it (e.g., read shared libraries, insert
2519 breakpoints), unless we're just setting up an all-stop
2523 struct remote_state *rs = get_remote_state ();
2525 if (!rs->starting_up)
2526 notice_new_inferior (new_thr, executing, 0);
2531 /* Return THREAD's private thread data, creating it if necessary. */
2533 static remote_thread_info *
2534 get_remote_thread_info (thread_info *thread)
2536 gdb_assert (thread != NULL);
2538 if (thread->priv == NULL)
2539 thread->priv.reset (new remote_thread_info);
2541 return static_cast<remote_thread_info *> (thread->priv.get ());
2544 static remote_thread_info *
2545 get_remote_thread_info (ptid_t ptid)
2547 thread_info *thr = find_thread_ptid (ptid);
2548 return get_remote_thread_info (thr);
2551 /* Call this function as a result of
2552 1) A halt indication (T packet) containing a thread id
2553 2) A direct query of currthread
2554 3) Successful execution of set thread */
2557 record_currthread (struct remote_state *rs, ptid_t currthread)
2559 rs->general_thread = currthread;
2562 /* If 'QPassSignals' is supported, tell the remote stub what signals
2563 it can simply pass through to the inferior without reporting. */
2566 remote_target::pass_signals (int numsigs, unsigned char *pass_signals)
2568 if (packet_support (PACKET_QPassSignals) != PACKET_DISABLE)
2570 char *pass_packet, *p;
2572 struct remote_state *rs = get_remote_state ();
2574 gdb_assert (numsigs < 256);
2575 for (i = 0; i < numsigs; i++)
2577 if (pass_signals[i])
2580 pass_packet = (char *) xmalloc (count * 3 + strlen ("QPassSignals:") + 1);
2581 strcpy (pass_packet, "QPassSignals:");
2582 p = pass_packet + strlen (pass_packet);
2583 for (i = 0; i < numsigs; i++)
2585 if (pass_signals[i])
2588 *p++ = tohex (i >> 4);
2589 *p++ = tohex (i & 15);
2598 if (!rs->last_pass_packet || strcmp (rs->last_pass_packet, pass_packet))
2600 putpkt (pass_packet);
2601 getpkt (&rs->buf, &rs->buf_size, 0);
2602 packet_ok (rs->buf, &remote_protocol_packets[PACKET_QPassSignals]);
2603 if (rs->last_pass_packet)
2604 xfree (rs->last_pass_packet);
2605 rs->last_pass_packet = pass_packet;
2608 xfree (pass_packet);
2612 /* If 'QCatchSyscalls' is supported, tell the remote stub
2613 to report syscalls to GDB. */
2616 remote_target::set_syscall_catchpoint (int pid, bool needed, int any_count,
2617 gdb::array_view<const int> syscall_counts)
2619 const char *catch_packet;
2620 enum packet_result result;
2623 if (packet_support (PACKET_QCatchSyscalls) == PACKET_DISABLE)
2625 /* Not supported. */
2629 if (needed && any_count == 0)
2631 /* Count how many syscalls are to be caught. */
2632 for (size_t i = 0; i < syscall_counts.size (); i++)
2634 if (syscall_counts[i] != 0)
2641 fprintf_unfiltered (gdb_stdlog,
2642 "remote_set_syscall_catchpoint "
2643 "pid %d needed %d any_count %d n_sysno %d\n",
2644 pid, needed, any_count, n_sysno);
2647 std::string built_packet;
2650 /* Prepare a packet with the sysno list, assuming max 8+1
2651 characters for a sysno. If the resulting packet size is too
2652 big, fallback on the non-selective packet. */
2653 const int maxpktsz = strlen ("QCatchSyscalls:1") + n_sysno * 9 + 1;
2654 built_packet.reserve (maxpktsz);
2655 built_packet = "QCatchSyscalls:1";
2658 /* Add in each syscall to be caught. */
2659 for (size_t i = 0; i < syscall_counts.size (); i++)
2661 if (syscall_counts[i] != 0)
2662 string_appendf (built_packet, ";%zx", i);
2665 if (built_packet.size () > get_remote_packet_size ())
2667 /* catch_packet too big. Fallback to less efficient
2668 non selective mode, with GDB doing the filtering. */
2669 catch_packet = "QCatchSyscalls:1";
2672 catch_packet = built_packet.c_str ();
2675 catch_packet = "QCatchSyscalls:0";
2677 struct remote_state *rs = get_remote_state ();
2679 putpkt (catch_packet);
2680 getpkt (&rs->buf, &rs->buf_size, 0);
2681 result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_QCatchSyscalls]);
2682 if (result == PACKET_OK)
2688 /* If 'QProgramSignals' is supported, tell the remote stub what
2689 signals it should pass through to the inferior when detaching. */
2692 remote_target::program_signals (int numsigs, unsigned char *signals)
2694 if (packet_support (PACKET_QProgramSignals) != PACKET_DISABLE)
2698 struct remote_state *rs = get_remote_state ();
2700 gdb_assert (numsigs < 256);
2701 for (i = 0; i < numsigs; i++)
2706 packet = (char *) xmalloc (count * 3 + strlen ("QProgramSignals:") + 1);
2707 strcpy (packet, "QProgramSignals:");
2708 p = packet + strlen (packet);
2709 for (i = 0; i < numsigs; i++)
2711 if (signal_pass_state (i))
2714 *p++ = tohex (i >> 4);
2715 *p++ = tohex (i & 15);
2724 if (!rs->last_program_signals_packet
2725 || strcmp (rs->last_program_signals_packet, packet) != 0)
2728 getpkt (&rs->buf, &rs->buf_size, 0);
2729 packet_ok (rs->buf, &remote_protocol_packets[PACKET_QProgramSignals]);
2730 xfree (rs->last_program_signals_packet);
2731 rs->last_program_signals_packet = packet;
2738 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2739 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2740 thread. If GEN is set, set the general thread, if not, then set
2741 the step/continue thread. */
2743 remote_target::set_thread (ptid_t ptid, int gen)
2745 struct remote_state *rs = get_remote_state ();
2746 ptid_t state = gen ? rs->general_thread : rs->continue_thread;
2747 char *buf = rs->buf;
2748 char *endbuf = rs->buf + get_remote_packet_size ();
2754 *buf++ = gen ? 'g' : 'c';
2755 if (ptid == magic_null_ptid)
2756 xsnprintf (buf, endbuf - buf, "0");
2757 else if (ptid == any_thread_ptid)
2758 xsnprintf (buf, endbuf - buf, "0");
2759 else if (ptid == minus_one_ptid)
2760 xsnprintf (buf, endbuf - buf, "-1");
2762 write_ptid (buf, endbuf, ptid);
2764 getpkt (&rs->buf, &rs->buf_size, 0);
2766 rs->general_thread = ptid;
2768 rs->continue_thread = ptid;
2772 remote_target::set_general_thread (ptid_t ptid)
2774 set_thread (ptid, 1);
2778 remote_target::set_continue_thread (ptid_t ptid)
2780 set_thread (ptid, 0);
2783 /* Change the remote current process. Which thread within the process
2784 ends up selected isn't important, as long as it is the same process
2785 as what INFERIOR_PTID points to.
2787 This comes from that fact that there is no explicit notion of
2788 "selected process" in the protocol. The selected process for
2789 general operations is the process the selected general thread
2793 remote_target::set_general_process ()
2795 struct remote_state *rs = get_remote_state ();
2797 /* If the remote can't handle multiple processes, don't bother. */
2798 if (!remote_multi_process_p (rs))
2801 /* We only need to change the remote current thread if it's pointing
2802 at some other process. */
2803 if (rs->general_thread.pid () != inferior_ptid.pid ())
2804 set_general_thread (inferior_ptid);
2808 /* Return nonzero if this is the main thread that we made up ourselves
2809 to model non-threaded targets as single-threaded. */
2812 remote_thread_always_alive (ptid_t ptid)
2814 if (ptid == magic_null_ptid)
2815 /* The main thread is always alive. */
2818 if (ptid.pid () != 0 && ptid.lwp () == 0)
2819 /* The main thread is always alive. This can happen after a
2820 vAttach, if the remote side doesn't support
2827 /* Return nonzero if the thread PTID is still alive on the remote
2831 remote_target::thread_alive (ptid_t ptid)
2833 struct remote_state *rs = get_remote_state ();
2836 /* Check if this is a thread that we made up ourselves to model
2837 non-threaded targets as single-threaded. */
2838 if (remote_thread_always_alive (ptid))
2842 endp = rs->buf + get_remote_packet_size ();
2845 write_ptid (p, endp, ptid);
2848 getpkt (&rs->buf, &rs->buf_size, 0);
2849 return (rs->buf[0] == 'O' && rs->buf[1] == 'K');
2852 /* Return a pointer to a thread name if we know it and NULL otherwise.
2853 The thread_info object owns the memory for the name. */
2856 remote_target::thread_name (struct thread_info *info)
2858 if (info->priv != NULL)
2860 const std::string &name = get_remote_thread_info (info)->name;
2861 return !name.empty () ? name.c_str () : NULL;
2867 /* About these extended threadlist and threadinfo packets. They are
2868 variable length packets but, the fields within them are often fixed
2869 length. They are redundent enough to send over UDP as is the
2870 remote protocol in general. There is a matching unit test module
2873 /* WARNING: This threadref data structure comes from the remote O.S.,
2874 libstub protocol encoding, and remote.c. It is not particularly
2877 /* Right now, the internal structure is int. We want it to be bigger.
2878 Plan to fix this. */
2880 typedef int gdb_threadref; /* Internal GDB thread reference. */
2882 /* gdb_ext_thread_info is an internal GDB data structure which is
2883 equivalent to the reply of the remote threadinfo packet. */
2885 struct gdb_ext_thread_info
2887 threadref threadid; /* External form of thread reference. */
2888 int active; /* Has state interesting to GDB?
2890 char display[256]; /* Brief state display, name,
2891 blocked/suspended. */
2892 char shortname[32]; /* To be used to name threads. */
2893 char more_display[256]; /* Long info, statistics, queue depth,
2897 /* The volume of remote transfers can be limited by submitting
2898 a mask containing bits specifying the desired information.
2899 Use a union of these values as the 'selection' parameter to
2900 get_thread_info. FIXME: Make these TAG names more thread specific. */
2902 #define TAG_THREADID 1
2903 #define TAG_EXISTS 2
2904 #define TAG_DISPLAY 4
2905 #define TAG_THREADNAME 8
2906 #define TAG_MOREDISPLAY 16
2908 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2910 static char *unpack_nibble (char *buf, int *val);
2912 static char *unpack_byte (char *buf, int *value);
2914 static char *pack_int (char *buf, int value);
2916 static char *unpack_int (char *buf, int *value);
2918 static char *unpack_string (char *src, char *dest, int length);
2920 static char *pack_threadid (char *pkt, threadref *id);
2922 static char *unpack_threadid (char *inbuf, threadref *id);
2924 void int_to_threadref (threadref *id, int value);
2926 static int threadref_to_int (threadref *ref);
2928 static void copy_threadref (threadref *dest, threadref *src);
2930 static int threadmatch (threadref *dest, threadref *src);
2932 static char *pack_threadinfo_request (char *pkt, int mode,
2935 static char *pack_threadlist_request (char *pkt, int startflag,
2937 threadref *nextthread);
2939 static int remote_newthread_step (threadref *ref, void *context);
2942 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2943 buffer we're allowed to write to. Returns
2944 BUF+CHARACTERS_WRITTEN. */
2947 remote_target::write_ptid (char *buf, const char *endbuf, ptid_t ptid)
2950 struct remote_state *rs = get_remote_state ();
2952 if (remote_multi_process_p (rs))
2956 buf += xsnprintf (buf, endbuf - buf, "p-%x.", -pid);
2958 buf += xsnprintf (buf, endbuf - buf, "p%x.", pid);
2962 buf += xsnprintf (buf, endbuf - buf, "-%x", -tid);
2964 buf += xsnprintf (buf, endbuf - buf, "%x", tid);
2969 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2970 last parsed char. Returns null_ptid if no thread id is found, and
2971 throws an error if the thread id has an invalid format. */
2974 read_ptid (const char *buf, const char **obuf)
2976 const char *p = buf;
2978 ULONGEST pid = 0, tid = 0;
2982 /* Multi-process ptid. */
2983 pp = unpack_varlen_hex (p + 1, &pid);
2985 error (_("invalid remote ptid: %s"), p);
2988 pp = unpack_varlen_hex (p + 1, &tid);
2991 return ptid_t (pid, tid, 0);
2994 /* No multi-process. Just a tid. */
2995 pp = unpack_varlen_hex (p, &tid);
2997 /* Return null_ptid when no thread id is found. */
3005 /* Since the stub is not sending a process id, then default to
3006 what's in inferior_ptid, unless it's null at this point. If so,
3007 then since there's no way to know the pid of the reported
3008 threads, use the magic number. */
3009 if (inferior_ptid == null_ptid)
3010 pid = magic_null_ptid.pid ();
3012 pid = inferior_ptid.pid ();
3016 return ptid_t (pid, tid, 0);
3022 if (ch >= 'a' && ch <= 'f')
3023 return ch - 'a' + 10;
3024 if (ch >= '0' && ch <= '9')
3026 if (ch >= 'A' && ch <= 'F')
3027 return ch - 'A' + 10;
3032 stub_unpack_int (char *buff, int fieldlength)
3039 nibble = stubhex (*buff++);
3043 retval = retval << 4;
3049 unpack_nibble (char *buf, int *val)
3051 *val = fromhex (*buf++);
3056 unpack_byte (char *buf, int *value)
3058 *value = stub_unpack_int (buf, 2);
3063 pack_int (char *buf, int value)
3065 buf = pack_hex_byte (buf, (value >> 24) & 0xff);
3066 buf = pack_hex_byte (buf, (value >> 16) & 0xff);
3067 buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
3068 buf = pack_hex_byte (buf, (value & 0xff));
3073 unpack_int (char *buf, int *value)
3075 *value = stub_unpack_int (buf, 8);
3079 #if 0 /* Currently unused, uncomment when needed. */
3080 static char *pack_string (char *pkt, char *string);
3083 pack_string (char *pkt, char *string)
3088 len = strlen (string);
3090 len = 200; /* Bigger than most GDB packets, junk??? */
3091 pkt = pack_hex_byte (pkt, len);
3095 if ((ch == '\0') || (ch == '#'))
3096 ch = '*'; /* Protect encapsulation. */
3101 #endif /* 0 (unused) */
3104 unpack_string (char *src, char *dest, int length)
3113 pack_threadid (char *pkt, threadref *id)
3116 unsigned char *altid;
3118 altid = (unsigned char *) id;
3119 limit = pkt + BUF_THREAD_ID_SIZE;
3121 pkt = pack_hex_byte (pkt, *altid++);
3127 unpack_threadid (char *inbuf, threadref *id)
3130 char *limit = inbuf + BUF_THREAD_ID_SIZE;
3133 altref = (char *) id;
3135 while (inbuf < limit)
3137 x = stubhex (*inbuf++);
3138 y = stubhex (*inbuf++);
3139 *altref++ = (x << 4) | y;
3144 /* Externally, threadrefs are 64 bits but internally, they are still
3145 ints. This is due to a mismatch of specifications. We would like
3146 to use 64bit thread references internally. This is an adapter
3150 int_to_threadref (threadref *id, int value)
3152 unsigned char *scan;
3154 scan = (unsigned char *) id;
3160 *scan++ = (value >> 24) & 0xff;
3161 *scan++ = (value >> 16) & 0xff;
3162 *scan++ = (value >> 8) & 0xff;
3163 *scan++ = (value & 0xff);
3167 threadref_to_int (threadref *ref)
3170 unsigned char *scan;
3176 value = (value << 8) | ((*scan++) & 0xff);
3181 copy_threadref (threadref *dest, threadref *src)
3184 unsigned char *csrc, *cdest;
3186 csrc = (unsigned char *) src;
3187 cdest = (unsigned char *) dest;
3194 threadmatch (threadref *dest, threadref *src)
3196 /* Things are broken right now, so just assume we got a match. */
3198 unsigned char *srcp, *destp;
3200 srcp = (char *) src;
3201 destp = (char *) dest;
3205 result &= (*srcp++ == *destp++) ? 1 : 0;
3212 threadid:1, # always request threadid
3219 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3222 pack_threadinfo_request (char *pkt, int mode, threadref *id)
3224 *pkt++ = 'q'; /* Info Query */
3225 *pkt++ = 'P'; /* process or thread info */
3226 pkt = pack_int (pkt, mode); /* mode */
3227 pkt = pack_threadid (pkt, id); /* threadid */
3228 *pkt = '\0'; /* terminate */
3232 /* These values tag the fields in a thread info response packet. */
3233 /* Tagging the fields allows us to request specific fields and to
3234 add more fields as time goes by. */
3236 #define TAG_THREADID 1 /* Echo the thread identifier. */
3237 #define TAG_EXISTS 2 /* Is this process defined enough to
3238 fetch registers and its stack? */
3239 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3240 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3241 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3245 remote_target::remote_unpack_thread_info_response (char *pkt,
3246 threadref *expectedref,
3247 gdb_ext_thread_info *info)
3249 struct remote_state *rs = get_remote_state ();
3253 char *limit = pkt + rs->buf_size; /* Plausible parsing limit. */
3256 /* info->threadid = 0; FIXME: implement zero_threadref. */
3258 info->display[0] = '\0';
3259 info->shortname[0] = '\0';
3260 info->more_display[0] = '\0';
3262 /* Assume the characters indicating the packet type have been
3264 pkt = unpack_int (pkt, &mask); /* arg mask */
3265 pkt = unpack_threadid (pkt, &ref);
3268 warning (_("Incomplete response to threadinfo request."));
3269 if (!threadmatch (&ref, expectedref))
3270 { /* This is an answer to a different request. */
3271 warning (_("ERROR RMT Thread info mismatch."));
3274 copy_threadref (&info->threadid, &ref);
3276 /* Loop on tagged fields , try to bail if somthing goes wrong. */
3278 /* Packets are terminated with nulls. */
3279 while ((pkt < limit) && mask && *pkt)
3281 pkt = unpack_int (pkt, &tag); /* tag */
3282 pkt = unpack_byte (pkt, &length); /* length */
3283 if (!(tag & mask)) /* Tags out of synch with mask. */
3285 warning (_("ERROR RMT: threadinfo tag mismatch."));
3289 if (tag == TAG_THREADID)
3293 warning (_("ERROR RMT: length of threadid is not 16."));
3297 pkt = unpack_threadid (pkt, &ref);
3298 mask = mask & ~TAG_THREADID;
3301 if (tag == TAG_EXISTS)
3303 info->active = stub_unpack_int (pkt, length);
3305 mask = mask & ~(TAG_EXISTS);
3308 warning (_("ERROR RMT: 'exists' length too long."));
3314 if (tag == TAG_THREADNAME)
3316 pkt = unpack_string (pkt, &info->shortname[0], length);
3317 mask = mask & ~TAG_THREADNAME;
3320 if (tag == TAG_DISPLAY)
3322 pkt = unpack_string (pkt, &info->display[0], length);
3323 mask = mask & ~TAG_DISPLAY;
3326 if (tag == TAG_MOREDISPLAY)
3328 pkt = unpack_string (pkt, &info->more_display[0], length);
3329 mask = mask & ~TAG_MOREDISPLAY;
3332 warning (_("ERROR RMT: unknown thread info tag."));
3333 break; /* Not a tag we know about. */
3339 remote_target::remote_get_threadinfo (threadref *threadid,
3341 gdb_ext_thread_info *info)
3343 struct remote_state *rs = get_remote_state ();
3346 pack_threadinfo_request (rs->buf, fieldset, threadid);
3348 getpkt (&rs->buf, &rs->buf_size, 0);
3350 if (rs->buf[0] == '\0')
3353 result = remote_unpack_thread_info_response (rs->buf + 2,
3358 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3361 pack_threadlist_request (char *pkt, int startflag, int threadcount,
3362 threadref *nextthread)
3364 *pkt++ = 'q'; /* info query packet */
3365 *pkt++ = 'L'; /* Process LIST or threadLIST request */
3366 pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */
3367 pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */
3368 pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */
3373 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3376 remote_target::parse_threadlist_response (char *pkt, int result_limit,
3377 threadref *original_echo,
3378 threadref *resultlist,
3381 struct remote_state *rs = get_remote_state ();
3383 int count, resultcount, done;
3386 /* Assume the 'q' and 'M chars have been stripped. */
3387 limit = pkt + (rs->buf_size - BUF_THREAD_ID_SIZE);
3388 /* done parse past here */
3389 pkt = unpack_byte (pkt, &count); /* count field */
3390 pkt = unpack_nibble (pkt, &done);
3391 /* The first threadid is the argument threadid. */
3392 pkt = unpack_threadid (pkt, original_echo); /* should match query packet */
3393 while ((count-- > 0) && (pkt < limit))
3395 pkt = unpack_threadid (pkt, resultlist++);
3396 if (resultcount++ >= result_limit)
3404 /* Fetch the next batch of threads from the remote. Returns -1 if the
3405 qL packet is not supported, 0 on error and 1 on success. */
3408 remote_target::remote_get_threadlist (int startflag, threadref *nextthread,
3409 int result_limit, int *done, int *result_count,
3410 threadref *threadlist)
3412 struct remote_state *rs = get_remote_state ();
3415 /* Trancate result limit to be smaller than the packet size. */
3416 if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10)
3417 >= get_remote_packet_size ())
3418 result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
3420 pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
3422 getpkt (&rs->buf, &rs->buf_size, 0);
3423 if (*rs->buf == '\0')
3425 /* Packet not supported. */
3430 parse_threadlist_response (rs->buf + 2, result_limit,
3431 &rs->echo_nextthread, threadlist, done);
3433 if (!threadmatch (&rs->echo_nextthread, nextthread))
3435 /* FIXME: This is a good reason to drop the packet. */
3436 /* Possably, there is a duplicate response. */
3438 retransmit immediatly - race conditions
3439 retransmit after timeout - yes
3441 wait for packet, then exit
3443 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3444 return 0; /* I choose simply exiting. */
3446 if (*result_count <= 0)
3450 warning (_("RMT ERROR : failed to get remote thread list."));
3453 return result; /* break; */
3455 if (*result_count > result_limit)
3458 warning (_("RMT ERROR: threadlist response longer than requested."));
3464 /* Fetch the list of remote threads, with the qL packet, and call
3465 STEPFUNCTION for each thread found. Stops iterating and returns 1
3466 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3467 STEPFUNCTION returns false. If the packet is not supported,
3471 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction,
3472 void *context, int looplimit)
3474 struct remote_state *rs = get_remote_state ();
3475 int done, i, result_count;
3483 if (loopcount++ > looplimit)
3486 warning (_("Remote fetch threadlist -infinite loop-."));
3489 result = remote_get_threadlist (startflag, &rs->nextthread,
3490 MAXTHREADLISTRESULTS,
3491 &done, &result_count,
3492 rs->resultthreadlist);
3495 /* Clear for later iterations. */
3497 /* Setup to resume next batch of thread references, set nextthread. */
3498 if (result_count >= 1)
3499 copy_threadref (&rs->nextthread,
3500 &rs->resultthreadlist[result_count - 1]);
3502 while (result_count--)
3504 if (!(*stepfunction) (&rs->resultthreadlist[i++], context))
3514 /* A thread found on the remote target. */
3518 explicit thread_item (ptid_t ptid_)
3522 thread_item (thread_item &&other) = default;
3523 thread_item &operator= (thread_item &&other) = default;
3525 DISABLE_COPY_AND_ASSIGN (thread_item);
3527 /* The thread's PTID. */
3530 /* The thread's extra info. */
3533 /* The thread's name. */
3536 /* The core the thread was running on. -1 if not known. */
3539 /* The thread handle associated with the thread. */
3540 gdb::byte_vector thread_handle;
3543 /* Context passed around to the various methods listing remote
3544 threads. As new threads are found, they're added to the ITEMS
3547 struct threads_listing_context
3549 /* Return true if this object contains an entry for a thread with ptid
3552 bool contains_thread (ptid_t ptid) const
3554 auto match_ptid = [&] (const thread_item &item)
3556 return item.ptid == ptid;
3559 auto it = std::find_if (this->items.begin (),
3563 return it != this->items.end ();
3566 /* Remove the thread with ptid PTID. */
3568 void remove_thread (ptid_t ptid)
3570 auto match_ptid = [&] (const thread_item &item)
3572 return item.ptid == ptid;
3575 auto it = std::remove_if (this->items.begin (),
3579 if (it != this->items.end ())
3580 this->items.erase (it);
3583 /* The threads found on the remote target. */
3584 std::vector<thread_item> items;
3588 remote_newthread_step (threadref *ref, void *data)
3590 struct threads_listing_context *context
3591 = (struct threads_listing_context *) data;
3592 int pid = inferior_ptid.pid ();
3593 int lwp = threadref_to_int (ref);
3594 ptid_t ptid (pid, lwp);
3596 context->items.emplace_back (ptid);
3598 return 1; /* continue iterator */
3601 #define CRAZY_MAX_THREADS 1000
3604 remote_target::remote_current_thread (ptid_t oldpid)
3606 struct remote_state *rs = get_remote_state ();
3609 getpkt (&rs->buf, &rs->buf_size, 0);
3610 if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
3615 result = read_ptid (&rs->buf[2], &obuf);
3616 if (*obuf != '\0' && remote_debug)
3617 fprintf_unfiltered (gdb_stdlog,
3618 "warning: garbage in qC reply\n");
3626 /* List remote threads using the deprecated qL packet. */
3629 remote_target::remote_get_threads_with_ql (threads_listing_context *context)
3631 if (remote_threadlist_iterator (remote_newthread_step, context,
3632 CRAZY_MAX_THREADS) >= 0)
3638 #if defined(HAVE_LIBEXPAT)
3641 start_thread (struct gdb_xml_parser *parser,
3642 const struct gdb_xml_element *element,
3644 std::vector<gdb_xml_value> &attributes)
3646 struct threads_listing_context *data
3647 = (struct threads_listing_context *) user_data;
3648 struct gdb_xml_value *attr;
3650 char *id = (char *) xml_find_attribute (attributes, "id")->value.get ();
3651 ptid_t ptid = read_ptid (id, NULL);
3653 data->items.emplace_back (ptid);
3654 thread_item &item = data->items.back ();
3656 attr = xml_find_attribute (attributes, "core");
3658 item.core = *(ULONGEST *) attr->value.get ();
3660 attr = xml_find_attribute (attributes, "name");
3662 item.name = (const char *) attr->value.get ();
3664 attr = xml_find_attribute (attributes, "handle");
3666 item.thread_handle = hex2bin ((const char *) attr->value.get ());
3670 end_thread (struct gdb_xml_parser *parser,
3671 const struct gdb_xml_element *element,
3672 void *user_data, const char *body_text)
3674 struct threads_listing_context *data
3675 = (struct threads_listing_context *) user_data;
3677 if (body_text != NULL && *body_text != '\0')
3678 data->items.back ().extra = body_text;
3681 const struct gdb_xml_attribute thread_attributes[] = {
3682 { "id", GDB_XML_AF_NONE, NULL, NULL },
3683 { "core", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
3684 { "name", GDB_XML_AF_OPTIONAL, NULL, NULL },
3685 { "handle", GDB_XML_AF_OPTIONAL, NULL, NULL },
3686 { NULL, GDB_XML_AF_NONE, NULL, NULL }
3689 const struct gdb_xml_element thread_children[] = {
3690 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3693 const struct gdb_xml_element threads_children[] = {
3694 { "thread", thread_attributes, thread_children,
3695 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
3696 start_thread, end_thread },
3697 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3700 const struct gdb_xml_element threads_elements[] = {
3701 { "threads", NULL, threads_children,
3702 GDB_XML_EF_NONE, NULL, NULL },
3703 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3708 /* List remote threads using qXfer:threads:read. */
3711 remote_target::remote_get_threads_with_qxfer (threads_listing_context *context)
3713 #if defined(HAVE_LIBEXPAT)
3714 if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
3716 gdb::optional<gdb::char_vector> xml
3717 = target_read_stralloc (this, TARGET_OBJECT_THREADS, NULL);
3719 if (xml && (*xml)[0] != '\0')
3721 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3722 threads_elements, xml->data (), context);
3732 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3735 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context *context)
3737 struct remote_state *rs = get_remote_state ();
3739 if (rs->use_threadinfo_query)
3743 putpkt ("qfThreadInfo");
3744 getpkt (&rs->buf, &rs->buf_size, 0);
3746 if (bufp[0] != '\0') /* q packet recognized */
3748 while (*bufp++ == 'm') /* reply contains one or more TID */
3752 ptid_t ptid = read_ptid (bufp, &bufp);
3753 context->items.emplace_back (ptid);
3755 while (*bufp++ == ','); /* comma-separated list */
3756 putpkt ("qsThreadInfo");
3757 getpkt (&rs->buf, &rs->buf_size, 0);
3764 /* Packet not recognized. */
3765 rs->use_threadinfo_query = 0;
3772 /* Implement the to_update_thread_list function for the remote
3776 remote_target::update_thread_list ()
3778 struct threads_listing_context context;
3781 /* We have a few different mechanisms to fetch the thread list. Try
3782 them all, starting with the most preferred one first, falling
3783 back to older methods. */
3784 if (remote_get_threads_with_qxfer (&context)
3785 || remote_get_threads_with_qthreadinfo (&context)
3786 || remote_get_threads_with_ql (&context))
3788 struct thread_info *tp, *tmp;
3792 if (context.items.empty ()
3793 && remote_thread_always_alive (inferior_ptid))
3795 /* Some targets don't really support threads, but still
3796 reply an (empty) thread list in response to the thread
3797 listing packets, instead of replying "packet not
3798 supported". Exit early so we don't delete the main
3803 /* CONTEXT now holds the current thread list on the remote
3804 target end. Delete GDB-side threads no longer found on the
3806 ALL_THREADS_SAFE (tp, tmp)
3808 if (!context.contains_thread (tp->ptid))
3815 /* Remove any unreported fork child threads from CONTEXT so
3816 that we don't interfere with follow fork, which is where
3817 creation of such threads is handled. */
3818 remove_new_fork_children (&context);
3820 /* And now add threads we don't know about yet to our list. */
3821 for (thread_item &item : context.items)
3823 if (item.ptid != null_ptid)
3825 /* In non-stop mode, we assume new found threads are
3826 executing until proven otherwise with a stop reply.
3827 In all-stop, we can only get here if all threads are
3829 int executing = target_is_non_stop_p () ? 1 : 0;
3831 remote_notice_new_inferior (item.ptid, executing);
3833 thread_info *tp = find_thread_ptid (item.ptid);
3834 remote_thread_info *info = get_remote_thread_info (tp);
3835 info->core = item.core;
3836 info->extra = std::move (item.extra);
3837 info->name = std::move (item.name);
3838 info->thread_handle = std::move (item.thread_handle);
3845 /* If no thread listing method is supported, then query whether
3846 each known thread is alive, one by one, with the T packet.
3847 If the target doesn't support threads at all, then this is a
3848 no-op. See remote_thread_alive. */
3854 * Collect a descriptive string about the given thread.
3855 * The target may say anything it wants to about the thread
3856 * (typically info about its blocked / runnable state, name, etc.).
3857 * This string will appear in the info threads display.
3859 * Optional: targets are not required to implement this function.
3863 remote_target::extra_thread_info (thread_info *tp)
3865 struct remote_state *rs = get_remote_state ();
3868 struct gdb_ext_thread_info threadinfo;
3870 if (rs->remote_desc == 0) /* paranoia */
3871 internal_error (__FILE__, __LINE__,
3872 _("remote_threads_extra_info"));
3874 if (tp->ptid == magic_null_ptid
3875 || (tp->ptid.pid () != 0 && tp->ptid.lwp () == 0))
3876 /* This is the main thread which was added by GDB. The remote
3877 server doesn't know about it. */
3880 std::string &extra = get_remote_thread_info (tp)->extra;
3882 /* If already have cached info, use it. */
3883 if (!extra.empty ())
3884 return extra.c_str ();
3886 if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
3888 /* If we're using qXfer:threads:read, then the extra info is
3889 included in the XML. So if we didn't have anything cached,
3890 it's because there's really no extra info. */
3894 if (rs->use_threadextra_query)
3897 char *endb = rs->buf + get_remote_packet_size ();
3899 xsnprintf (b, endb - b, "qThreadExtraInfo,");
3901 write_ptid (b, endb, tp->ptid);
3904 getpkt (&rs->buf, &rs->buf_size, 0);
3905 if (rs->buf[0] != 0)
3907 extra.resize (strlen (rs->buf) / 2);
3908 hex2bin (rs->buf, (gdb_byte *) &extra[0], extra.size ());
3909 return extra.c_str ();
3913 /* If the above query fails, fall back to the old method. */
3914 rs->use_threadextra_query = 0;
3915 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
3916 | TAG_MOREDISPLAY | TAG_DISPLAY;
3917 int_to_threadref (&id, tp->ptid.lwp ());
3918 if (remote_get_threadinfo (&id, set, &threadinfo))
3919 if (threadinfo.active)
3921 if (*threadinfo.shortname)
3922 string_appendf (extra, " Name: %s", threadinfo.shortname);
3923 if (*threadinfo.display)
3925 if (!extra.empty ())
3927 string_appendf (extra, " State: %s", threadinfo.display);
3929 if (*threadinfo.more_display)
3931 if (!extra.empty ())
3933 string_appendf (extra, " Priority: %s", threadinfo.more_display);
3935 return extra.c_str ();
3942 remote_target::static_tracepoint_marker_at (CORE_ADDR addr,
3943 struct static_tracepoint_marker *marker)
3945 struct remote_state *rs = get_remote_state ();
3948 xsnprintf (p, get_remote_packet_size (), "qTSTMat:");
3950 p += hexnumstr (p, addr);
3952 getpkt (&rs->buf, &rs->buf_size, 0);
3956 error (_("Remote failure reply: %s"), p);
3960 parse_static_tracepoint_marker_definition (p, NULL, marker);
3967 std::vector<static_tracepoint_marker>
3968 remote_target::static_tracepoint_markers_by_strid (const char *strid)
3970 struct remote_state *rs = get_remote_state ();
3971 std::vector<static_tracepoint_marker> markers;
3973 static_tracepoint_marker marker;
3975 /* Ask for a first packet of static tracepoint marker
3978 getpkt (&rs->buf, &rs->buf_size, 0);
3981 error (_("Remote failure reply: %s"), p);
3987 parse_static_tracepoint_marker_definition (p, &p, &marker);
3989 if (strid == NULL || marker.str_id == strid)
3990 markers.push_back (std::move (marker));
3992 while (*p++ == ','); /* comma-separated list */
3993 /* Ask for another packet of static tracepoint definition. */
3995 getpkt (&rs->buf, &rs->buf_size, 0);
4003 /* Implement the to_get_ada_task_ptid function for the remote targets. */
4006 remote_target::get_ada_task_ptid (long lwp, long thread)
4008 return ptid_t (inferior_ptid.pid (), lwp, 0);
4012 /* Restart the remote side; this is an extended protocol operation. */
4015 remote_target::extended_remote_restart ()
4017 struct remote_state *rs = get_remote_state ();
4019 /* Send the restart command; for reasons I don't understand the
4020 remote side really expects a number after the "R". */
4021 xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0);
4024 remote_fileio_reset ();
4027 /* Clean up connection to a remote debugger. */
4030 remote_target::close ()
4032 /* Make sure we leave stdin registered in the event loop. */
4035 /* We don't have a connection to the remote stub anymore. Get rid
4036 of all the inferiors and their threads we were controlling.
4037 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
4038 will be unable to find the thread corresponding to (pid, 0, 0). */
4039 inferior_ptid = null_ptid;
4040 discard_all_inferiors ();
4042 trace_reset_local_state ();
4047 remote_target::~remote_target ()
4049 struct remote_state *rs = get_remote_state ();
4051 /* Check for NULL because we may get here with a partially
4052 constructed target/connection. */
4053 if (rs->remote_desc == nullptr)
4056 serial_close (rs->remote_desc);
4058 /* We are destroying the remote target, so we should discard
4059 everything of this target. */
4060 discard_pending_stop_replies_in_queue ();
4062 if (rs->remote_async_inferior_event_token)
4063 delete_async_event_handler (&rs->remote_async_inferior_event_token);
4065 remote_notif_state_xfree (rs->notif_state);
4068 /* Query the remote side for the text, data and bss offsets. */
4071 remote_target::get_offsets ()
4073 struct remote_state *rs = get_remote_state ();
4076 int lose, num_segments = 0, do_sections, do_segments;
4077 CORE_ADDR text_addr, data_addr, bss_addr, segments[2];
4078 struct section_offsets *offs;
4079 struct symfile_segment_data *data;
4081 if (symfile_objfile == NULL)
4084 putpkt ("qOffsets");
4085 getpkt (&rs->buf, &rs->buf_size, 0);
4088 if (buf[0] == '\000')
4089 return; /* Return silently. Stub doesn't support
4093 warning (_("Remote failure reply: %s"), buf);
4097 /* Pick up each field in turn. This used to be done with scanf, but
4098 scanf will make trouble if CORE_ADDR size doesn't match
4099 conversion directives correctly. The following code will work
4100 with any size of CORE_ADDR. */
4101 text_addr = data_addr = bss_addr = 0;
4105 if (startswith (ptr, "Text="))
4108 /* Don't use strtol, could lose on big values. */
4109 while (*ptr && *ptr != ';')
4110 text_addr = (text_addr << 4) + fromhex (*ptr++);
4112 if (startswith (ptr, ";Data="))
4115 while (*ptr && *ptr != ';')
4116 data_addr = (data_addr << 4) + fromhex (*ptr++);
4121 if (!lose && startswith (ptr, ";Bss="))
4124 while (*ptr && *ptr != ';')
4125 bss_addr = (bss_addr << 4) + fromhex (*ptr++);
4127 if (bss_addr != data_addr)
4128 warning (_("Target reported unsupported offsets: %s"), buf);
4133 else if (startswith (ptr, "TextSeg="))
4136 /* Don't use strtol, could lose on big values. */
4137 while (*ptr && *ptr != ';')
4138 text_addr = (text_addr << 4) + fromhex (*ptr++);
4141 if (startswith (ptr, ";DataSeg="))
4144 while (*ptr && *ptr != ';')
4145 data_addr = (data_addr << 4) + fromhex (*ptr++);
4153 error (_("Malformed response to offset query, %s"), buf);
4154 else if (*ptr != '\0')
4155 warning (_("Target reported unsupported offsets: %s"), buf);
4157 offs = ((struct section_offsets *)
4158 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)));
4159 memcpy (offs, symfile_objfile->section_offsets,
4160 SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections));
4162 data = get_symfile_segment_data (symfile_objfile->obfd);
4163 do_segments = (data != NULL);
4164 do_sections = num_segments == 0;
4166 if (num_segments > 0)
4168 segments[0] = text_addr;
4169 segments[1] = data_addr;
4171 /* If we have two segments, we can still try to relocate everything
4172 by assuming that the .text and .data offsets apply to the whole
4173 text and data segments. Convert the offsets given in the packet
4174 to base addresses for symfile_map_offsets_to_segments. */
4175 else if (data && data->num_segments == 2)
4177 segments[0] = data->segment_bases[0] + text_addr;
4178 segments[1] = data->segment_bases[1] + data_addr;
4181 /* If the object file has only one segment, assume that it is text
4182 rather than data; main programs with no writable data are rare,
4183 but programs with no code are useless. Of course the code might
4184 have ended up in the data segment... to detect that we would need
4185 the permissions here. */
4186 else if (data && data->num_segments == 1)
4188 segments[0] = data->segment_bases[0] + text_addr;
4191 /* There's no way to relocate by segment. */
4197 int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, data,
4198 offs, num_segments, segments);
4200 if (ret == 0 && !do_sections)
4201 error (_("Can not handle qOffsets TextSeg "
4202 "response with this symbol file"));
4209 free_symfile_segment_data (data);
4213 offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
4215 /* This is a temporary kludge to force data and bss to use the
4216 same offsets because that's what nlmconv does now. The real
4217 solution requires changes to the stub and remote.c that I
4218 don't have time to do right now. */
4220 offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
4221 offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
4224 objfile_relocate (symfile_objfile, offs);
4227 /* Send interrupt_sequence to remote target. */
4230 remote_target::send_interrupt_sequence ()
4232 struct remote_state *rs = get_remote_state ();
4234 if (interrupt_sequence_mode == interrupt_sequence_control_c)
4235 remote_serial_write ("\x03", 1);
4236 else if (interrupt_sequence_mode == interrupt_sequence_break)
4237 serial_send_break (rs->remote_desc);
4238 else if (interrupt_sequence_mode == interrupt_sequence_break_g)
4240 serial_send_break (rs->remote_desc);
4241 remote_serial_write ("g", 1);
4244 internal_error (__FILE__, __LINE__,
4245 _("Invalid value for interrupt_sequence_mode: %s."),
4246 interrupt_sequence_mode);
4250 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4251 and extract the PTID. Returns NULL_PTID if not found. */
4254 stop_reply_extract_thread (char *stop_reply)
4256 if (stop_reply[0] == 'T' && strlen (stop_reply) > 3)
4260 /* Txx r:val ; r:val (...) */
4263 /* Look for "register" named "thread". */
4268 p1 = strchr (p, ':');
4272 if (strncmp (p, "thread", p1 - p) == 0)
4273 return read_ptid (++p1, &p);
4275 p1 = strchr (p, ';');
4287 /* Determine the remote side's current thread. If we have a stop
4288 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4289 "thread" register we can extract the current thread from. If not,
4290 ask the remote which is the current thread with qC. The former
4291 method avoids a roundtrip. */
4294 remote_target::get_current_thread (char *wait_status)
4296 ptid_t ptid = null_ptid;
4298 /* Note we don't use remote_parse_stop_reply as that makes use of
4299 the target architecture, which we haven't yet fully determined at
4301 if (wait_status != NULL)
4302 ptid = stop_reply_extract_thread (wait_status);
4303 if (ptid == null_ptid)
4304 ptid = remote_current_thread (inferior_ptid);
4309 /* Query the remote target for which is the current thread/process,
4310 add it to our tables, and update INFERIOR_PTID. The caller is
4311 responsible for setting the state such that the remote end is ready
4312 to return the current thread.
4314 This function is called after handling the '?' or 'vRun' packets,
4315 whose response is a stop reply from which we can also try
4316 extracting the thread. If the target doesn't support the explicit
4317 qC query, we infer the current thread from that stop reply, passed
4318 in in WAIT_STATUS, which may be NULL. */
4321 remote_target::add_current_inferior_and_thread (char *wait_status)
4323 struct remote_state *rs = get_remote_state ();
4326 inferior_ptid = null_ptid;
4328 /* Now, if we have thread information, update inferior_ptid. */
4329 ptid_t curr_ptid = get_current_thread (wait_status);
4331 if (curr_ptid != null_ptid)
4333 if (!remote_multi_process_p (rs))
4338 /* Without this, some commands which require an active target
4339 (such as kill) won't work. This variable serves (at least)
4340 double duty as both the pid of the target process (if it has
4341 such), and as a flag indicating that a target is active. */
4342 curr_ptid = magic_null_ptid;
4346 remote_add_inferior (fake_pid_p, curr_ptid.pid (), -1, 1);
4348 /* Add the main thread and switch to it. Don't try reading
4349 registers yet, since we haven't fetched the target description
4351 thread_info *tp = add_thread_silent (curr_ptid);
4352 switch_to_thread_no_regs (tp);
4355 /* Print info about a thread that was found already stopped on
4359 print_one_stopped_thread (struct thread_info *thread)
4361 struct target_waitstatus *ws = &thread->suspend.waitstatus;
4363 switch_to_thread (thread);
4364 thread->suspend.stop_pc = get_frame_pc (get_current_frame ());
4365 set_current_sal_from_frame (get_current_frame ());
4367 thread->suspend.waitstatus_pending_p = 0;
4369 if (ws->kind == TARGET_WAITKIND_STOPPED)
4371 enum gdb_signal sig = ws->value.sig;
4373 if (signal_print_state (sig))
4374 gdb::observers::signal_received.notify (sig);
4376 gdb::observers::normal_stop.notify (NULL, 1);
4379 /* Process all initial stop replies the remote side sent in response
4380 to the ? packet. These indicate threads that were already stopped
4381 on initial connection. We mark these threads as stopped and print
4382 their current frame before giving the user the prompt. */
4385 remote_target::process_initial_stop_replies (int from_tty)
4387 int pending_stop_replies = stop_reply_queue_length ();
4388 struct inferior *inf;
4389 struct thread_info *thread;
4390 struct thread_info *selected = NULL;
4391 struct thread_info *lowest_stopped = NULL;
4392 struct thread_info *first = NULL;
4394 /* Consume the initial pending events. */
4395 while (pending_stop_replies-- > 0)
4397 ptid_t waiton_ptid = minus_one_ptid;
4399 struct target_waitstatus ws;
4400 int ignore_event = 0;
4401 struct thread_info *thread;
4403 memset (&ws, 0, sizeof (ws));
4404 event_ptid = target_wait (waiton_ptid, &ws, TARGET_WNOHANG);
4406 print_target_wait_results (waiton_ptid, event_ptid, &ws);
4410 case TARGET_WAITKIND_IGNORE:
4411 case TARGET_WAITKIND_NO_RESUMED:
4412 case TARGET_WAITKIND_SIGNALLED:
4413 case TARGET_WAITKIND_EXITED:
4414 /* We shouldn't see these, but if we do, just ignore. */
4416 fprintf_unfiltered (gdb_stdlog, "remote: event ignored\n");
4420 case TARGET_WAITKIND_EXECD:
4421 xfree (ws.value.execd_pathname);
4430 thread = find_thread_ptid (event_ptid);
4432 if (ws.kind == TARGET_WAITKIND_STOPPED)
4434 enum gdb_signal sig = ws.value.sig;
4436 /* Stubs traditionally report SIGTRAP as initial signal,
4437 instead of signal 0. Suppress it. */
4438 if (sig == GDB_SIGNAL_TRAP)
4440 thread->suspend.stop_signal = sig;
4444 thread->suspend.waitstatus = ws;
4446 if (ws.kind != TARGET_WAITKIND_STOPPED
4447 || ws.value.sig != GDB_SIGNAL_0)
4448 thread->suspend.waitstatus_pending_p = 1;
4450 set_executing (event_ptid, 0);
4451 set_running (event_ptid, 0);
4452 get_remote_thread_info (thread)->vcont_resumed = 0;
4455 /* "Notice" the new inferiors before anything related to
4456 registers/memory. */
4462 inf->needs_setup = 1;
4466 thread = any_live_thread_of_inferior (inf);
4467 notice_new_inferior (thread, thread->state == THREAD_RUNNING,
4472 /* If all-stop on top of non-stop, pause all threads. Note this
4473 records the threads' stop pc, so must be done after "noticing"
4477 stop_all_threads ();
4479 /* If all threads of an inferior were already stopped, we
4480 haven't setup the inferior yet. */
4486 if (inf->needs_setup)
4488 thread = any_live_thread_of_inferior (inf);
4489 switch_to_thread_no_regs (thread);
4495 /* Now go over all threads that are stopped, and print their current
4496 frame. If all-stop, then if there's a signalled thread, pick
4498 ALL_NON_EXITED_THREADS (thread)
4504 thread->set_running (false);
4505 else if (thread->state != THREAD_STOPPED)
4508 if (selected == NULL
4509 && thread->suspend.waitstatus_pending_p)
4512 if (lowest_stopped == NULL
4513 || thread->inf->num < lowest_stopped->inf->num
4514 || thread->per_inf_num < lowest_stopped->per_inf_num)
4515 lowest_stopped = thread;
4518 print_one_stopped_thread (thread);
4521 /* In all-stop, we only print the status of one thread, and leave
4522 others with their status pending. */
4527 thread = lowest_stopped;
4531 print_one_stopped_thread (thread);
4534 /* For "info program". */
4535 thread = inferior_thread ();
4536 if (thread->state == THREAD_STOPPED)
4537 set_last_target_status (inferior_ptid, thread->suspend.waitstatus);
4540 /* Start the remote connection and sync state. */
4543 remote_target::start_remote (int from_tty, int extended_p)
4545 struct remote_state *rs = get_remote_state ();
4546 struct packet_config *noack_config;
4547 char *wait_status = NULL;
4549 /* Signal other parts that we're going through the initial setup,
4550 and so things may not be stable yet. E.g., we don't try to
4551 install tracepoints until we've relocated symbols. Also, a
4552 Ctrl-C before we're connected and synced up can't interrupt the
4553 target. Instead, it offers to drop the (potentially wedged)
4555 rs->starting_up = 1;
4559 if (interrupt_on_connect)
4560 send_interrupt_sequence ();
4562 /* Ack any packet which the remote side has already sent. */
4563 remote_serial_write ("+", 1);
4565 /* The first packet we send to the target is the optional "supported
4566 packets" request. If the target can answer this, it will tell us
4567 which later probes to skip. */
4568 remote_query_supported ();
4570 /* If the stub wants to get a QAllow, compose one and send it. */
4571 if (packet_support (PACKET_QAllow) != PACKET_DISABLE)
4574 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4575 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4576 as a reply to known packet. For packet "vFile:setfs:" it is an
4577 invalid reply and GDB would return error in
4578 remote_hostio_set_filesystem, making remote files access impossible.
4579 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4580 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4582 const char v_mustreplyempty[] = "vMustReplyEmpty";
4584 putpkt (v_mustreplyempty);
4585 getpkt (&rs->buf, &rs->buf_size, 0);
4586 if (strcmp (rs->buf, "OK") == 0)
4587 remote_protocol_packets[PACKET_vFile_setfs].support = PACKET_DISABLE;
4588 else if (strcmp (rs->buf, "") != 0)
4589 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty,
4593 /* Next, we possibly activate noack mode.
4595 If the QStartNoAckMode packet configuration is set to AUTO,
4596 enable noack mode if the stub reported a wish for it with
4599 If set to TRUE, then enable noack mode even if the stub didn't
4600 report it in qSupported. If the stub doesn't reply OK, the
4601 session ends with an error.
4603 If FALSE, then don't activate noack mode, regardless of what the
4604 stub claimed should be the default with qSupported. */
4606 noack_config = &remote_protocol_packets[PACKET_QStartNoAckMode];
4607 if (packet_config_support (noack_config) != PACKET_DISABLE)
4609 putpkt ("QStartNoAckMode");
4610 getpkt (&rs->buf, &rs->buf_size, 0);
4611 if (packet_ok (rs->buf, noack_config) == PACKET_OK)
4617 /* Tell the remote that we are using the extended protocol. */
4619 getpkt (&rs->buf, &rs->buf_size, 0);
4622 /* Let the target know which signals it is allowed to pass down to
4624 update_signals_program_target ();
4626 /* Next, if the target can specify a description, read it. We do
4627 this before anything involving memory or registers. */
4628 target_find_description ();
4630 /* Next, now that we know something about the target, update the
4631 address spaces in the program spaces. */
4632 update_address_spaces ();
4634 /* On OSs where the list of libraries is global to all
4635 processes, we fetch them early. */
4636 if (gdbarch_has_global_solist (target_gdbarch ()))
4637 solib_add (NULL, from_tty, auto_solib_add);
4639 if (target_is_non_stop_p ())
4641 if (packet_support (PACKET_QNonStop) != PACKET_ENABLE)
4642 error (_("Non-stop mode requested, but remote "
4643 "does not support non-stop"));
4645 putpkt ("QNonStop:1");
4646 getpkt (&rs->buf, &rs->buf_size, 0);
4648 if (strcmp (rs->buf, "OK") != 0)
4649 error (_("Remote refused setting non-stop mode with: %s"), rs->buf);
4651 /* Find about threads and processes the stub is already
4652 controlling. We default to adding them in the running state.
4653 The '?' query below will then tell us about which threads are
4655 this->update_thread_list ();
4657 else if (packet_support (PACKET_QNonStop) == PACKET_ENABLE)
4659 /* Don't assume that the stub can operate in all-stop mode.
4660 Request it explicitly. */
4661 putpkt ("QNonStop:0");
4662 getpkt (&rs->buf, &rs->buf_size, 0);
4664 if (strcmp (rs->buf, "OK") != 0)
4665 error (_("Remote refused setting all-stop mode with: %s"), rs->buf);
4668 /* Upload TSVs regardless of whether the target is running or not. The
4669 remote stub, such as GDBserver, may have some predefined or builtin
4670 TSVs, even if the target is not running. */
4671 if (get_trace_status (current_trace_status ()) != -1)
4673 struct uploaded_tsv *uploaded_tsvs = NULL;
4675 upload_trace_state_variables (&uploaded_tsvs);
4676 merge_uploaded_trace_state_variables (&uploaded_tsvs);
4679 /* Check whether the target is running now. */
4681 getpkt (&rs->buf, &rs->buf_size, 0);
4683 if (!target_is_non_stop_p ())
4685 if (rs->buf[0] == 'W' || rs->buf[0] == 'X')
4688 error (_("The target is not running (try extended-remote?)"));
4690 /* We're connected, but not running. Drop out before we
4691 call start_remote. */
4692 rs->starting_up = 0;
4697 /* Save the reply for later. */
4698 wait_status = (char *) alloca (strlen (rs->buf) + 1);
4699 strcpy (wait_status, rs->buf);
4702 /* Fetch thread list. */
4703 target_update_thread_list ();
4705 /* Let the stub know that we want it to return the thread. */
4706 set_continue_thread (minus_one_ptid);
4708 if (thread_count () == 0)
4710 /* Target has no concept of threads at all. GDB treats
4711 non-threaded target as single-threaded; add a main
4713 add_current_inferior_and_thread (wait_status);
4717 /* We have thread information; select the thread the target
4718 says should be current. If we're reconnecting to a
4719 multi-threaded program, this will ideally be the thread
4720 that last reported an event before GDB disconnected. */
4721 inferior_ptid = get_current_thread (wait_status);
4722 if (inferior_ptid == null_ptid)
4724 /* Odd... The target was able to list threads, but not
4725 tell us which thread was current (no "thread"
4726 register in T stop reply?). Just pick the first
4727 thread in the thread list then. */
4730 fprintf_unfiltered (gdb_stdlog,
4731 "warning: couldn't determine remote "
4732 "current thread; picking first in list.\n");
4734 inferior_ptid = thread_list->ptid;
4738 /* init_wait_for_inferior should be called before get_offsets in order
4739 to manage `inserted' flag in bp loc in a correct state.
4740 breakpoint_init_inferior, called from init_wait_for_inferior, set
4741 `inserted' flag to 0, while before breakpoint_re_set, called from
4742 start_remote, set `inserted' flag to 1. In the initialization of
4743 inferior, breakpoint_init_inferior should be called first, and then
4744 breakpoint_re_set can be called. If this order is broken, state of
4745 `inserted' flag is wrong, and cause some problems on breakpoint
4747 init_wait_for_inferior ();
4749 get_offsets (); /* Get text, data & bss offsets. */
4751 /* If we could not find a description using qXfer, and we know
4752 how to do it some other way, try again. This is not
4753 supported for non-stop; it could be, but it is tricky if
4754 there are no stopped threads when we connect. */
4755 if (remote_read_description_p (this)
4756 && gdbarch_target_desc (target_gdbarch ()) == NULL)
4758 target_clear_description ();
4759 target_find_description ();
4762 /* Use the previously fetched status. */
4763 gdb_assert (wait_status != NULL);
4764 strcpy (rs->buf, wait_status);
4765 rs->cached_wait_status = 1;
4767 ::start_remote (from_tty); /* Initialize gdb process mechanisms. */
4771 /* Clear WFI global state. Do this before finding about new
4772 threads and inferiors, and setting the current inferior.
4773 Otherwise we would clear the proceed status of the current
4774 inferior when we want its stop_soon state to be preserved
4775 (see notice_new_inferior). */
4776 init_wait_for_inferior ();
4778 /* In non-stop, we will either get an "OK", meaning that there
4779 are no stopped threads at this time; or, a regular stop
4780 reply. In the latter case, there may be more than one thread
4781 stopped --- we pull them all out using the vStopped
4783 if (strcmp (rs->buf, "OK") != 0)
4785 struct notif_client *notif = ¬if_client_stop;
4787 /* remote_notif_get_pending_replies acks this one, and gets
4789 rs->notif_state->pending_event[notif_client_stop.id]
4790 = remote_notif_parse (this, notif, rs->buf);
4791 remote_notif_get_pending_events (notif);
4794 if (thread_count () == 0)
4797 error (_("The target is not running (try extended-remote?)"));
4799 /* We're connected, but not running. Drop out before we
4800 call start_remote. */
4801 rs->starting_up = 0;
4805 /* In non-stop mode, any cached wait status will be stored in
4806 the stop reply queue. */
4807 gdb_assert (wait_status == NULL);
4809 /* Report all signals during attach/startup. */
4810 pass_signals (0, NULL);
4812 /* If there are already stopped threads, mark them stopped and
4813 report their stops before giving the prompt to the user. */
4814 process_initial_stop_replies (from_tty);
4816 if (target_can_async_p ())
4820 /* If we connected to a live target, do some additional setup. */
4821 if (target_has_execution)
4823 if (symfile_objfile) /* No use without a symbol-file. */
4824 remote_check_symbols ();
4827 /* Possibly the target has been engaged in a trace run started
4828 previously; find out where things are at. */
4829 if (get_trace_status (current_trace_status ()) != -1)
4831 struct uploaded_tp *uploaded_tps = NULL;
4833 if (current_trace_status ()->running)
4834 printf_filtered (_("Trace is already running on the target.\n"));
4836 upload_tracepoints (&uploaded_tps);
4838 merge_uploaded_tracepoints (&uploaded_tps);
4841 /* Possibly the target has been engaged in a btrace record started
4842 previously; find out where things are at. */
4843 remote_btrace_maybe_reopen ();
4845 /* The thread and inferior lists are now synchronized with the
4846 target, our symbols have been relocated, and we're merged the
4847 target's tracepoints with ours. We're done with basic start
4849 rs->starting_up = 0;
4851 /* Maybe breakpoints are global and need to be inserted now. */
4852 if (breakpoints_should_be_inserted_now ())
4853 insert_breakpoints ();
4856 /* Open a connection to a remote debugger.
4857 NAME is the filename used for communication. */
4860 remote_target::open (const char *name, int from_tty)
4862 open_1 (name, from_tty, 0);
4865 /* Open a connection to a remote debugger using the extended
4866 remote gdb protocol. NAME is the filename used for communication. */
4869 extended_remote_target::open (const char *name, int from_tty)
4871 open_1 (name, from_tty, 1 /*extended_p */);
4874 /* Reset all packets back to "unknown support". Called when opening a
4875 new connection to a remote target. */
4878 reset_all_packet_configs_support (void)
4882 for (i = 0; i < PACKET_MAX; i++)
4883 remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN;
4886 /* Initialize all packet configs. */
4889 init_all_packet_configs (void)
4893 for (i = 0; i < PACKET_MAX; i++)
4895 remote_protocol_packets[i].detect = AUTO_BOOLEAN_AUTO;
4896 remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN;
4900 /* Symbol look-up. */
4903 remote_target::remote_check_symbols ()
4905 char *msg, *reply, *tmp;
4908 struct cleanup *old_chain;
4910 /* The remote side has no concept of inferiors that aren't running
4911 yet, it only knows about running processes. If we're connected
4912 but our current inferior is not running, we should not invite the
4913 remote target to request symbol lookups related to its
4914 (unrelated) current process. */
4915 if (!target_has_execution)
4918 if (packet_support (PACKET_qSymbol) == PACKET_DISABLE)
4921 /* Make sure the remote is pointing at the right process. Note
4922 there's no way to select "no process". */
4923 set_general_process ();
4925 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4926 because we need both at the same time. */
4927 msg = (char *) xmalloc (get_remote_packet_size ());
4928 old_chain = make_cleanup (xfree, msg);
4929 reply = (char *) xmalloc (get_remote_packet_size ());
4930 make_cleanup (free_current_contents, &reply);
4931 reply_size = get_remote_packet_size ();
4933 /* Invite target to request symbol lookups. */
4935 putpkt ("qSymbol::");
4936 getpkt (&reply, &reply_size, 0);
4937 packet_ok (reply, &remote_protocol_packets[PACKET_qSymbol]);
4939 while (startswith (reply, "qSymbol:"))
4941 struct bound_minimal_symbol sym;
4944 end = hex2bin (tmp, (gdb_byte *) msg, strlen (tmp) / 2);
4946 sym = lookup_minimal_symbol (msg, NULL, NULL);
4947 if (sym.minsym == NULL)
4948 xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
4951 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
4952 CORE_ADDR sym_addr = BMSYMBOL_VALUE_ADDRESS (sym);
4954 /* If this is a function address, return the start of code
4955 instead of any data function descriptor. */
4956 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4958 current_top_target ());
4960 xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
4961 phex_nz (sym_addr, addr_size), &reply[8]);
4965 getpkt (&reply, &reply_size, 0);
4968 do_cleanups (old_chain);
4971 static struct serial *
4972 remote_serial_open (const char *name)
4974 static int udp_warning = 0;
4976 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4977 of in ser-tcp.c, because it is the remote protocol assuming that the
4978 serial connection is reliable and not the serial connection promising
4980 if (!udp_warning && startswith (name, "udp:"))
4982 warning (_("The remote protocol may be unreliable over UDP.\n"
4983 "Some events may be lost, rendering further debugging "
4988 return serial_open (name);
4991 /* Inform the target of our permission settings. The permission flags
4992 work without this, but if the target knows the settings, it can do
4993 a couple things. First, it can add its own check, to catch cases
4994 that somehow manage to get by the permissions checks in target
4995 methods. Second, if the target is wired to disallow particular
4996 settings (for instance, a system in the field that is not set up to
4997 be able to stop at a breakpoint), it can object to any unavailable
5001 remote_target::set_permissions ()
5003 struct remote_state *rs = get_remote_state ();
5005 xsnprintf (rs->buf, get_remote_packet_size (), "QAllow:"
5006 "WriteReg:%x;WriteMem:%x;"
5007 "InsertBreak:%x;InsertTrace:%x;"
5008 "InsertFastTrace:%x;Stop:%x",
5009 may_write_registers, may_write_memory,
5010 may_insert_breakpoints, may_insert_tracepoints,
5011 may_insert_fast_tracepoints, may_stop);
5013 getpkt (&rs->buf, &rs->buf_size, 0);
5015 /* If the target didn't like the packet, warn the user. Do not try
5016 to undo the user's settings, that would just be maddening. */
5017 if (strcmp (rs->buf, "OK") != 0)
5018 warning (_("Remote refused setting permissions with: %s"), rs->buf);
5021 /* This type describes each known response to the qSupported
5023 struct protocol_feature
5025 /* The name of this protocol feature. */
5028 /* The default for this protocol feature. */
5029 enum packet_support default_support;
5031 /* The function to call when this feature is reported, or after
5032 qSupported processing if the feature is not supported.
5033 The first argument points to this structure. The second
5034 argument indicates whether the packet requested support be
5035 enabled, disabled, or probed (or the default, if this function
5036 is being called at the end of processing and this feature was
5037 not reported). The third argument may be NULL; if not NULL, it
5038 is a NUL-terminated string taken from the packet following
5039 this feature's name and an equals sign. */
5040 void (*func) (remote_target *remote, const struct protocol_feature *,
5041 enum packet_support, const char *);
5043 /* The corresponding packet for this feature. Only used if
5044 FUNC is remote_supported_packet. */
5049 remote_supported_packet (remote_target *remote,
5050 const struct protocol_feature *feature,
5051 enum packet_support support,
5052 const char *argument)
5056 warning (_("Remote qSupported response supplied an unexpected value for"
5057 " \"%s\"."), feature->name);
5061 remote_protocol_packets[feature->packet].support = support;
5065 remote_target::remote_packet_size (const protocol_feature *feature,
5066 enum packet_support support, const char *value)
5068 struct remote_state *rs = get_remote_state ();
5073 if (support != PACKET_ENABLE)
5076 if (value == NULL || *value == '\0')
5078 warning (_("Remote target reported \"%s\" without a size."),
5084 packet_size = strtol (value, &value_end, 16);
5085 if (errno != 0 || *value_end != '\0' || packet_size < 0)
5087 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5088 feature->name, value);
5092 /* Record the new maximum packet size. */
5093 rs->explicit_packet_size = packet_size;
5097 remote_packet_size (remote_target *remote, const protocol_feature *feature,
5098 enum packet_support support, const char *value)
5100 remote->remote_packet_size (feature, support, value);
5103 static const struct protocol_feature remote_protocol_features[] = {
5104 { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
5105 { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
5106 PACKET_qXfer_auxv },
5107 { "qXfer:exec-file:read", PACKET_DISABLE, remote_supported_packet,
5108 PACKET_qXfer_exec_file },
5109 { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet,
5110 PACKET_qXfer_features },
5111 { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet,
5112 PACKET_qXfer_libraries },
5113 { "qXfer:libraries-svr4:read", PACKET_DISABLE, remote_supported_packet,
5114 PACKET_qXfer_libraries_svr4 },
5115 { "augmented-libraries-svr4-read", PACKET_DISABLE,
5116 remote_supported_packet, PACKET_augmented_libraries_svr4_read_feature },
5117 { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
5118 PACKET_qXfer_memory_map },
5119 { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
5120 PACKET_qXfer_spu_read },
5121 { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet,
5122 PACKET_qXfer_spu_write },
5123 { "qXfer:osdata:read", PACKET_DISABLE, remote_supported_packet,
5124 PACKET_qXfer_osdata },
5125 { "qXfer:threads:read", PACKET_DISABLE, remote_supported_packet,
5126 PACKET_qXfer_threads },
5127 { "qXfer:traceframe-info:read", PACKET_DISABLE, remote_supported_packet,
5128 PACKET_qXfer_traceframe_info },
5129 { "QPassSignals", PACKET_DISABLE, remote_supported_packet,
5130 PACKET_QPassSignals },
5131 { "QCatchSyscalls", PACKET_DISABLE, remote_supported_packet,
5132 PACKET_QCatchSyscalls },
5133 { "QProgramSignals", PACKET_DISABLE, remote_supported_packet,
5134 PACKET_QProgramSignals },
5135 { "QSetWorkingDir", PACKET_DISABLE, remote_supported_packet,
5136 PACKET_QSetWorkingDir },
5137 { "QStartupWithShell", PACKET_DISABLE, remote_supported_packet,
5138 PACKET_QStartupWithShell },
5139 { "QEnvironmentHexEncoded", PACKET_DISABLE, remote_supported_packet,
5140 PACKET_QEnvironmentHexEncoded },
5141 { "QEnvironmentReset", PACKET_DISABLE, remote_supported_packet,
5142 PACKET_QEnvironmentReset },
5143 { "QEnvironmentUnset", PACKET_DISABLE, remote_supported_packet,
5144 PACKET_QEnvironmentUnset },
5145 { "QStartNoAckMode", PACKET_DISABLE, remote_supported_packet,
5146 PACKET_QStartNoAckMode },
5147 { "multiprocess", PACKET_DISABLE, remote_supported_packet,
5148 PACKET_multiprocess_feature },
5149 { "QNonStop", PACKET_DISABLE, remote_supported_packet, PACKET_QNonStop },
5150 { "qXfer:siginfo:read", PACKET_DISABLE, remote_supported_packet,
5151 PACKET_qXfer_siginfo_read },
5152 { "qXfer:siginfo:write", PACKET_DISABLE, remote_supported_packet,
5153 PACKET_qXfer_siginfo_write },
5154 { "ConditionalTracepoints", PACKET_DISABLE, remote_supported_packet,
5155 PACKET_ConditionalTracepoints },
5156 { "ConditionalBreakpoints", PACKET_DISABLE, remote_supported_packet,
5157 PACKET_ConditionalBreakpoints },
5158 { "BreakpointCommands", PACKET_DISABLE, remote_supported_packet,
5159 PACKET_BreakpointCommands },
5160 { "FastTracepoints", PACKET_DISABLE, remote_supported_packet,
5161 PACKET_FastTracepoints },
5162 { "StaticTracepoints", PACKET_DISABLE, remote_supported_packet,
5163 PACKET_StaticTracepoints },
5164 {"InstallInTrace", PACKET_DISABLE, remote_supported_packet,
5165 PACKET_InstallInTrace},
5166 { "DisconnectedTracing", PACKET_DISABLE, remote_supported_packet,
5167 PACKET_DisconnectedTracing_feature },
5168 { "ReverseContinue", PACKET_DISABLE, remote_supported_packet,
5170 { "ReverseStep", PACKET_DISABLE, remote_supported_packet,
5172 { "TracepointSource", PACKET_DISABLE, remote_supported_packet,
5173 PACKET_TracepointSource },
5174 { "QAllow", PACKET_DISABLE, remote_supported_packet,
5176 { "EnableDisableTracepoints", PACKET_DISABLE, remote_supported_packet,
5177 PACKET_EnableDisableTracepoints_feature },
5178 { "qXfer:fdpic:read", PACKET_DISABLE, remote_supported_packet,
5179 PACKET_qXfer_fdpic },
5180 { "qXfer:uib:read", PACKET_DISABLE, remote_supported_packet,
5182 { "QDisableRandomization", PACKET_DISABLE, remote_supported_packet,
5183 PACKET_QDisableRandomization },
5184 { "QAgent", PACKET_DISABLE, remote_supported_packet, PACKET_QAgent},
5185 { "QTBuffer:size", PACKET_DISABLE,
5186 remote_supported_packet, PACKET_QTBuffer_size},
5187 { "tracenz", PACKET_DISABLE, remote_supported_packet, PACKET_tracenz_feature },
5188 { "Qbtrace:off", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_off },
5189 { "Qbtrace:bts", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_bts },
5190 { "Qbtrace:pt", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_pt },
5191 { "qXfer:btrace:read", PACKET_DISABLE, remote_supported_packet,
5192 PACKET_qXfer_btrace },
5193 { "qXfer:btrace-conf:read", PACKET_DISABLE, remote_supported_packet,
5194 PACKET_qXfer_btrace_conf },
5195 { "Qbtrace-conf:bts:size", PACKET_DISABLE, remote_supported_packet,
5196 PACKET_Qbtrace_conf_bts_size },
5197 { "swbreak", PACKET_DISABLE, remote_supported_packet, PACKET_swbreak_feature },
5198 { "hwbreak", PACKET_DISABLE, remote_supported_packet, PACKET_hwbreak_feature },
5199 { "fork-events", PACKET_DISABLE, remote_supported_packet,
5200 PACKET_fork_event_feature },
5201 { "vfork-events", PACKET_DISABLE, remote_supported_packet,
5202 PACKET_vfork_event_feature },
5203 { "exec-events", PACKET_DISABLE, remote_supported_packet,
5204 PACKET_exec_event_feature },
5205 { "Qbtrace-conf:pt:size", PACKET_DISABLE, remote_supported_packet,
5206 PACKET_Qbtrace_conf_pt_size },
5207 { "vContSupported", PACKET_DISABLE, remote_supported_packet, PACKET_vContSupported },
5208 { "QThreadEvents", PACKET_DISABLE, remote_supported_packet, PACKET_QThreadEvents },
5209 { "no-resumed", PACKET_DISABLE, remote_supported_packet, PACKET_no_resumed },
5212 static char *remote_support_xml;
5214 /* Register string appended to "xmlRegisters=" in qSupported query. */
5217 register_remote_support_xml (const char *xml)
5219 #if defined(HAVE_LIBEXPAT)
5220 if (remote_support_xml == NULL)
5221 remote_support_xml = concat ("xmlRegisters=", xml, (char *) NULL);
5224 char *copy = xstrdup (remote_support_xml + 13);
5225 char *p = strtok (copy, ",");
5229 if (strcmp (p, xml) == 0)
5236 while ((p = strtok (NULL, ",")) != NULL);
5239 remote_support_xml = reconcat (remote_support_xml,
5240 remote_support_xml, ",", xml,
5247 remote_query_supported_append (std::string *msg, const char *append)
5251 msg->append (append);
5255 remote_target::remote_query_supported ()
5257 struct remote_state *rs = get_remote_state ();
5260 unsigned char seen [ARRAY_SIZE (remote_protocol_features)];
5262 /* The packet support flags are handled differently for this packet
5263 than for most others. We treat an error, a disabled packet, and
5264 an empty response identically: any features which must be reported
5265 to be used will be automatically disabled. An empty buffer
5266 accomplishes this, since that is also the representation for a list
5267 containing no features. */
5270 if (packet_support (PACKET_qSupported) != PACKET_DISABLE)
5274 if (packet_set_cmd_state (PACKET_multiprocess_feature) != AUTO_BOOLEAN_FALSE)
5275 remote_query_supported_append (&q, "multiprocess+");
5277 if (packet_set_cmd_state (PACKET_swbreak_feature) != AUTO_BOOLEAN_FALSE)
5278 remote_query_supported_append (&q, "swbreak+");
5279 if (packet_set_cmd_state (PACKET_hwbreak_feature) != AUTO_BOOLEAN_FALSE)
5280 remote_query_supported_append (&q, "hwbreak+");
5282 remote_query_supported_append (&q, "qRelocInsn+");
5284 if (packet_set_cmd_state (PACKET_fork_event_feature)
5285 != AUTO_BOOLEAN_FALSE)
5286 remote_query_supported_append (&q, "fork-events+");
5287 if (packet_set_cmd_state (PACKET_vfork_event_feature)
5288 != AUTO_BOOLEAN_FALSE)
5289 remote_query_supported_append (&q, "vfork-events+");
5290 if (packet_set_cmd_state (PACKET_exec_event_feature)
5291 != AUTO_BOOLEAN_FALSE)
5292 remote_query_supported_append (&q, "exec-events+");
5294 if (packet_set_cmd_state (PACKET_vContSupported) != AUTO_BOOLEAN_FALSE)
5295 remote_query_supported_append (&q, "vContSupported+");
5297 if (packet_set_cmd_state (PACKET_QThreadEvents) != AUTO_BOOLEAN_FALSE)
5298 remote_query_supported_append (&q, "QThreadEvents+");
5300 if (packet_set_cmd_state (PACKET_no_resumed) != AUTO_BOOLEAN_FALSE)
5301 remote_query_supported_append (&q, "no-resumed+");
5303 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5304 the qSupported:xmlRegisters=i386 handling. */
5305 if (remote_support_xml != NULL
5306 && packet_support (PACKET_qXfer_features) != PACKET_DISABLE)
5307 remote_query_supported_append (&q, remote_support_xml);
5309 q = "qSupported:" + q;
5310 putpkt (q.c_str ());
5312 getpkt (&rs->buf, &rs->buf_size, 0);
5314 /* If an error occured, warn, but do not return - just reset the
5315 buffer to empty and go on to disable features. */
5316 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported])
5319 warning (_("Remote failure reply: %s"), rs->buf);
5324 memset (seen, 0, sizeof (seen));
5329 enum packet_support is_supported;
5330 char *p, *end, *name_end, *value;
5332 /* First separate out this item from the rest of the packet. If
5333 there's another item after this, we overwrite the separator
5334 (terminated strings are much easier to work with). */
5336 end = strchr (p, ';');
5339 end = p + strlen (p);
5349 warning (_("empty item in \"qSupported\" response"));
5354 name_end = strchr (p, '=');
5357 /* This is a name=value entry. */
5358 is_supported = PACKET_ENABLE;
5359 value = name_end + 1;
5368 is_supported = PACKET_ENABLE;
5372 is_supported = PACKET_DISABLE;
5376 is_supported = PACKET_SUPPORT_UNKNOWN;
5380 warning (_("unrecognized item \"%s\" "
5381 "in \"qSupported\" response"), p);
5387 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
5388 if (strcmp (remote_protocol_features[i].name, p) == 0)
5390 const struct protocol_feature *feature;
5393 feature = &remote_protocol_features[i];
5394 feature->func (this, feature, is_supported, value);
5399 /* If we increased the packet size, make sure to increase the global
5400 buffer size also. We delay this until after parsing the entire
5401 qSupported packet, because this is the same buffer we were
5403 if (rs->buf_size < rs->explicit_packet_size)
5405 rs->buf_size = rs->explicit_packet_size;
5406 rs->buf = (char *) xrealloc (rs->buf, rs->buf_size);
5409 /* Handle the defaults for unmentioned features. */
5410 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
5413 const struct protocol_feature *feature;
5415 feature = &remote_protocol_features[i];
5416 feature->func (this, feature, feature->default_support, NULL);
5420 /* Serial QUIT handler for the remote serial descriptor.
5422 Defers handling a Ctrl-C until we're done with the current
5423 command/response packet sequence, unless:
5425 - We're setting up the connection. Don't send a remote interrupt
5426 request, as we're not fully synced yet. Quit immediately
5429 - The target has been resumed in the foreground
5430 (target_terminal::is_ours is false) with a synchronous resume
5431 packet, and we're blocked waiting for the stop reply, thus a
5432 Ctrl-C should be immediately sent to the target.
5434 - We get a second Ctrl-C while still within the same serial read or
5435 write. In that case the serial is seemingly wedged --- offer to
5438 - We see a second Ctrl-C without target response, after having
5439 previously interrupted the target. In that case the target/stub
5440 is probably wedged --- offer to quit/disconnect.
5444 remote_target::remote_serial_quit_handler ()
5446 struct remote_state *rs = get_remote_state ();
5448 if (check_quit_flag ())
5450 /* If we're starting up, we're not fully synced yet. Quit
5452 if (rs->starting_up)
5454 else if (rs->got_ctrlc_during_io)
5456 if (query (_("The target is not responding to GDB commands.\n"
5457 "Stop debugging it? ")))
5458 remote_unpush_and_throw ();
5460 /* If ^C has already been sent once, offer to disconnect. */
5461 else if (!target_terminal::is_ours () && rs->ctrlc_pending_p)
5463 /* All-stop protocol, and blocked waiting for stop reply. Send
5464 an interrupt request. */
5465 else if (!target_terminal::is_ours () && rs->waiting_for_stop_reply)
5466 target_interrupt ();
5468 rs->got_ctrlc_during_io = 1;
5472 /* The remote_target that is current while the quit handler is
5473 overridden with remote_serial_quit_handler. */
5474 static remote_target *curr_quit_handler_target;
5477 remote_serial_quit_handler ()
5479 curr_quit_handler_target->remote_serial_quit_handler ();
5482 /* Remove any of the remote.c targets from target stack. Upper targets depend
5483 on it so remove them first. */
5486 remote_unpush_target (void)
5488 pop_all_targets_at_and_above (process_stratum);
5492 remote_unpush_and_throw (void)
5494 remote_unpush_target ();
5495 throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target."));
5499 remote_target::open_1 (const char *name, int from_tty, int extended_p)
5501 remote_target *curr_remote = get_current_remote_target ();
5504 error (_("To open a remote debug connection, you need to specify what\n"
5505 "serial device is attached to the remote system\n"
5506 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5508 /* If we're connected to a running target, target_preopen will kill it.
5509 Ask this question first, before target_preopen has a chance to kill
5511 if (curr_remote != NULL && !have_inferiors ())
5514 && !query (_("Already connected to a remote target. Disconnect? ")))
5515 error (_("Still connected."));
5518 /* Here the possibly existing remote target gets unpushed. */
5519 target_preopen (from_tty);
5521 remote_fileio_reset ();
5522 reopen_exec_file ();
5525 remote_target *remote
5526 = (extended_p ? new extended_remote_target () : new remote_target ());
5527 target_ops_up target_holder (remote);
5529 remote_state *rs = remote->get_remote_state ();
5531 /* See FIXME above. */
5532 if (!target_async_permitted)
5533 rs->wait_forever_enabled_p = 1;
5535 rs->remote_desc = remote_serial_open (name);
5536 if (!rs->remote_desc)
5537 perror_with_name (name);
5539 if (baud_rate != -1)
5541 if (serial_setbaudrate (rs->remote_desc, baud_rate))
5543 /* The requested speed could not be set. Error out to
5544 top level after closing remote_desc. Take care to
5545 set remote_desc to NULL to avoid closing remote_desc
5547 serial_close (rs->remote_desc);
5548 rs->remote_desc = NULL;
5549 perror_with_name (name);
5553 serial_setparity (rs->remote_desc, serial_parity);
5554 serial_raw (rs->remote_desc);
5556 /* If there is something sitting in the buffer we might take it as a
5557 response to a command, which would be bad. */
5558 serial_flush_input (rs->remote_desc);
5562 puts_filtered ("Remote debugging using ");
5563 puts_filtered (name);
5564 puts_filtered ("\n");
5567 /* Switch to using the remote target now. */
5568 push_target (remote);
5569 /* The target stack owns the target now. */
5570 target_holder.release ();
5572 /* Register extra event sources in the event loop. */
5573 rs->remote_async_inferior_event_token
5574 = create_async_event_handler (remote_async_inferior_event_handler,
5576 rs->notif_state = remote_notif_state_allocate (remote);
5578 /* Reset the target state; these things will be queried either by
5579 remote_query_supported or as they are needed. */
5580 reset_all_packet_configs_support ();
5581 rs->cached_wait_status = 0;
5582 rs->explicit_packet_size = 0;
5584 rs->extended = extended_p;
5585 rs->waiting_for_stop_reply = 0;
5586 rs->ctrlc_pending_p = 0;
5587 rs->got_ctrlc_during_io = 0;
5589 rs->general_thread = not_sent_ptid;
5590 rs->continue_thread = not_sent_ptid;
5591 rs->remote_traceframe_number = -1;
5593 rs->last_resume_exec_dir = EXEC_FORWARD;
5595 /* Probe for ability to use "ThreadInfo" query, as required. */
5596 rs->use_threadinfo_query = 1;
5597 rs->use_threadextra_query = 1;
5599 rs->readahead_cache.invalidate ();
5601 if (target_async_permitted)
5603 /* FIXME: cagney/1999-09-23: During the initial connection it is
5604 assumed that the target is already ready and able to respond to
5605 requests. Unfortunately remote_start_remote() eventually calls
5606 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5607 around this. Eventually a mechanism that allows
5608 wait_for_inferior() to expect/get timeouts will be
5610 rs->wait_forever_enabled_p = 0;
5613 /* First delete any symbols previously loaded from shared libraries. */
5614 no_shared_libraries (NULL, 0);
5617 init_thread_list ();
5619 /* Start the remote connection. If error() or QUIT, discard this
5620 target (we'd otherwise be in an inconsistent state) and then
5621 propogate the error on up the exception chain. This ensures that
5622 the caller doesn't stumble along blindly assuming that the
5623 function succeeded. The CLI doesn't have this problem but other
5624 UI's, such as MI do.
5626 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5627 this function should return an error indication letting the
5628 caller restore the previous state. Unfortunately the command
5629 ``target remote'' is directly wired to this function making that
5630 impossible. On a positive note, the CLI side of this problem has
5631 been fixed - the function set_cmd_context() makes it possible for
5632 all the ``target ....'' commands to share a common callback
5633 function. See cli-dump.c. */
5638 remote->start_remote (from_tty, extended_p);
5640 CATCH (ex, RETURN_MASK_ALL)
5642 /* Pop the partially set up target - unless something else did
5643 already before throwing the exception. */
5644 if (ex.error != TARGET_CLOSE_ERROR)
5645 remote_unpush_target ();
5646 throw_exception (ex);
5651 remote_btrace_reset (rs);
5653 if (target_async_permitted)
5654 rs->wait_forever_enabled_p = 1;
5657 /* Detach the specified process. */
5660 remote_target::remote_detach_pid (int pid)
5662 struct remote_state *rs = get_remote_state ();
5664 if (remote_multi_process_p (rs))
5665 xsnprintf (rs->buf, get_remote_packet_size (), "D;%x", pid);
5667 strcpy (rs->buf, "D");
5670 getpkt (&rs->buf, &rs->buf_size, 0);
5672 if (rs->buf[0] == 'O' && rs->buf[1] == 'K')
5674 else if (rs->buf[0] == '\0')
5675 error (_("Remote doesn't know how to detach"));
5677 error (_("Can't detach process."));
5680 /* This detaches a program to which we previously attached, using
5681 inferior_ptid to identify the process. After this is done, GDB
5682 can be used to debug some other program. We better not have left
5683 any breakpoints in the target program or it'll die when it hits
5687 remote_target::remote_detach_1 (inferior *inf, int from_tty)
5689 int pid = inferior_ptid.pid ();
5690 struct remote_state *rs = get_remote_state ();
5693 if (!target_has_execution)
5694 error (_("No process to detach from."));
5696 target_announce_detach (from_tty);
5698 /* Tell the remote target to detach. */
5699 remote_detach_pid (pid);
5701 /* Exit only if this is the only active inferior. */
5702 if (from_tty && !rs->extended && number_of_live_inferiors () == 1)
5703 puts_filtered (_("Ending remote debugging.\n"));
5705 struct thread_info *tp = find_thread_ptid (inferior_ptid);
5707 /* Check to see if we are detaching a fork parent. Note that if we
5708 are detaching a fork child, tp == NULL. */
5709 is_fork_parent = (tp != NULL
5710 && tp->pending_follow.kind == TARGET_WAITKIND_FORKED);
5712 /* If doing detach-on-fork, we don't mourn, because that will delete
5713 breakpoints that should be available for the followed inferior. */
5714 if (!is_fork_parent)
5716 /* Save the pid as a string before mourning, since that will
5717 unpush the remote target, and we need the string after. */
5718 std::string infpid = target_pid_to_str (ptid_t (pid));
5720 target_mourn_inferior (inferior_ptid);
5721 if (print_inferior_events)
5722 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5723 inf->num, infpid.c_str ());
5727 inferior_ptid = null_ptid;
5728 detach_inferior (current_inferior ());
5733 remote_target::detach (inferior *inf, int from_tty)
5735 remote_detach_1 (inf, from_tty);
5739 extended_remote_target::detach (inferior *inf, int from_tty)
5741 remote_detach_1 (inf, from_tty);
5744 /* Target follow-fork function for remote targets. On entry, and
5745 at return, the current inferior is the fork parent.
5747 Note that although this is currently only used for extended-remote,
5748 it is named remote_follow_fork in anticipation of using it for the
5749 remote target as well. */
5752 remote_target::follow_fork (int follow_child, int detach_fork)
5754 struct remote_state *rs = get_remote_state ();
5755 enum target_waitkind kind = inferior_thread ()->pending_follow.kind;
5757 if ((kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs))
5758 || (kind == TARGET_WAITKIND_VFORKED && remote_vfork_event_p (rs)))
5760 /* When following the parent and detaching the child, we detach
5761 the child here. For the case of following the child and
5762 detaching the parent, the detach is done in the target-
5763 independent follow fork code in infrun.c. We can't use
5764 target_detach when detaching an unfollowed child because
5765 the client side doesn't know anything about the child. */
5766 if (detach_fork && !follow_child)
5768 /* Detach the fork child. */
5772 child_ptid = inferior_thread ()->pending_follow.value.related_pid;
5773 child_pid = child_ptid.pid ();
5775 remote_detach_pid (child_pid);
5781 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5782 in the program space of the new inferior. On entry and at return the
5783 current inferior is the exec'ing inferior. INF is the new exec'd
5784 inferior, which may be the same as the exec'ing inferior unless
5785 follow-exec-mode is "new". */
5788 remote_target::follow_exec (struct inferior *inf, char *execd_pathname)
5790 /* We know that this is a target file name, so if it has the "target:"
5791 prefix we strip it off before saving it in the program space. */
5792 if (is_target_filename (execd_pathname))
5793 execd_pathname += strlen (TARGET_SYSROOT_PREFIX);
5795 set_pspace_remote_exec_file (inf->pspace, execd_pathname);
5798 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5801 remote_target::disconnect (const char *args, int from_tty)
5804 error (_("Argument given to \"disconnect\" when remotely debugging."));
5806 /* Make sure we unpush even the extended remote targets. Calling
5807 target_mourn_inferior won't unpush, and remote_mourn won't
5808 unpush if there is more than one inferior left. */
5809 unpush_target (this);
5810 generic_mourn_inferior ();
5813 puts_filtered ("Ending remote debugging.\n");
5816 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5817 be chatty about it. */
5820 extended_remote_target::attach (const char *args, int from_tty)
5822 struct remote_state *rs = get_remote_state ();
5824 char *wait_status = NULL;
5826 pid = parse_pid_to_attach (args);
5828 /* Remote PID can be freely equal to getpid, do not check it here the same
5829 way as in other targets. */
5831 if (packet_support (PACKET_vAttach) == PACKET_DISABLE)
5832 error (_("This target does not support attaching to a process"));
5836 char *exec_file = get_exec_file (0);
5839 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
5840 target_pid_to_str (ptid_t (pid)));
5842 printf_unfiltered (_("Attaching to %s\n"),
5843 target_pid_to_str (ptid_t (pid)));
5845 gdb_flush (gdb_stdout);
5848 xsnprintf (rs->buf, get_remote_packet_size (), "vAttach;%x", pid);
5850 getpkt (&rs->buf, &rs->buf_size, 0);
5852 switch (packet_ok (rs->buf,
5853 &remote_protocol_packets[PACKET_vAttach]))
5856 if (!target_is_non_stop_p ())
5858 /* Save the reply for later. */
5859 wait_status = (char *) alloca (strlen (rs->buf) + 1);
5860 strcpy (wait_status, rs->buf);
5862 else if (strcmp (rs->buf, "OK") != 0)
5863 error (_("Attaching to %s failed with: %s"),
5864 target_pid_to_str (ptid_t (pid)),
5867 case PACKET_UNKNOWN:
5868 error (_("This target does not support attaching to a process"));
5870 error (_("Attaching to %s failed"),
5871 target_pid_to_str (ptid_t (pid)));
5874 set_current_inferior (remote_add_inferior (0, pid, 1, 0));
5876 inferior_ptid = ptid_t (pid);
5878 if (target_is_non_stop_p ())
5880 struct thread_info *thread;
5882 /* Get list of threads. */
5883 update_thread_list ();
5885 thread = first_thread_of_inferior (current_inferior ());
5887 inferior_ptid = thread->ptid;
5889 inferior_ptid = ptid_t (pid);
5891 /* Invalidate our notion of the remote current thread. */
5892 record_currthread (rs, minus_one_ptid);
5896 /* Now, if we have thread information, update inferior_ptid. */
5897 inferior_ptid = remote_current_thread (inferior_ptid);
5899 /* Add the main thread to the thread list. */
5900 thread_info *thr = add_thread_silent (inferior_ptid);
5901 /* Don't consider the thread stopped until we've processed the
5902 saved stop reply. */
5903 set_executing (thr->ptid, true);
5906 /* Next, if the target can specify a description, read it. We do
5907 this before anything involving memory or registers. */
5908 target_find_description ();
5910 if (!target_is_non_stop_p ())
5912 /* Use the previously fetched status. */
5913 gdb_assert (wait_status != NULL);
5915 if (target_can_async_p ())
5917 struct notif_event *reply
5918 = remote_notif_parse (this, ¬if_client_stop, wait_status);
5920 push_stop_reply ((struct stop_reply *) reply);
5926 gdb_assert (wait_status != NULL);
5927 strcpy (rs->buf, wait_status);
5928 rs->cached_wait_status = 1;
5932 gdb_assert (wait_status == NULL);
5935 /* Implementation of the to_post_attach method. */
5938 extended_remote_target::post_attach (int pid)
5940 /* Get text, data & bss offsets. */
5943 /* In certain cases GDB might not have had the chance to start
5944 symbol lookup up until now. This could happen if the debugged
5945 binary is not using shared libraries, the vsyscall page is not
5946 present (on Linux) and the binary itself hadn't changed since the
5947 debugging process was started. */
5948 if (symfile_objfile != NULL)
5949 remote_check_symbols();
5953 /* Check for the availability of vCont. This function should also check
5957 remote_target::remote_vcont_probe ()
5959 remote_state *rs = get_remote_state ();
5962 strcpy (rs->buf, "vCont?");
5964 getpkt (&rs->buf, &rs->buf_size, 0);
5967 /* Make sure that the features we assume are supported. */
5968 if (startswith (buf, "vCont"))
5971 int support_c, support_C;
5973 rs->supports_vCont.s = 0;
5974 rs->supports_vCont.S = 0;
5977 rs->supports_vCont.t = 0;
5978 rs->supports_vCont.r = 0;
5979 while (p && *p == ';')
5982 if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0))
5983 rs->supports_vCont.s = 1;
5984 else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0))
5985 rs->supports_vCont.S = 1;
5986 else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0))
5988 else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0))
5990 else if (*p == 't' && (*(p + 1) == ';' || *(p + 1) == 0))
5991 rs->supports_vCont.t = 1;
5992 else if (*p == 'r' && (*(p + 1) == ';' || *(p + 1) == 0))
5993 rs->supports_vCont.r = 1;
5995 p = strchr (p, ';');
5998 /* If c, and C are not all supported, we can't use vCont. Clearing
5999 BUF will make packet_ok disable the packet. */
6000 if (!support_c || !support_C)
6004 packet_ok (buf, &remote_protocol_packets[PACKET_vCont]);
6007 /* Helper function for building "vCont" resumptions. Write a
6008 resumption to P. ENDP points to one-passed-the-end of the buffer
6009 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
6010 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
6011 resumed thread should be single-stepped and/or signalled. If PTID
6012 equals minus_one_ptid, then all threads are resumed; if PTID
6013 represents a process, then all threads of the process are resumed;
6014 the thread to be stepped and/or signalled is given in the global
6018 remote_target::append_resumption (char *p, char *endp,
6019 ptid_t ptid, int step, gdb_signal siggnal)
6021 struct remote_state *rs = get_remote_state ();
6023 if (step && siggnal != GDB_SIGNAL_0)
6024 p += xsnprintf (p, endp - p, ";S%02x", siggnal);
6026 /* GDB is willing to range step. */
6027 && use_range_stepping
6028 /* Target supports range stepping. */
6029 && rs->supports_vCont.r
6030 /* We don't currently support range stepping multiple
6031 threads with a wildcard (though the protocol allows it,
6032 so stubs shouldn't make an active effort to forbid
6034 && !(remote_multi_process_p (rs) && ptid.is_pid ()))
6036 struct thread_info *tp;
6038 if (ptid == minus_one_ptid)
6040 /* If we don't know about the target thread's tid, then
6041 we're resuming magic_null_ptid (see caller). */
6042 tp = find_thread_ptid (magic_null_ptid);
6045 tp = find_thread_ptid (ptid);
6046 gdb_assert (tp != NULL);
6048 if (tp->control.may_range_step)
6050 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
6052 p += xsnprintf (p, endp - p, ";r%s,%s",
6053 phex_nz (tp->control.step_range_start,
6055 phex_nz (tp->control.step_range_end,
6059 p += xsnprintf (p, endp - p, ";s");
6062 p += xsnprintf (p, endp - p, ";s");
6063 else if (siggnal != GDB_SIGNAL_0)
6064 p += xsnprintf (p, endp - p, ";C%02x", siggnal);
6066 p += xsnprintf (p, endp - p, ";c");
6068 if (remote_multi_process_p (rs) && ptid.is_pid ())
6072 /* All (-1) threads of process. */
6073 nptid = ptid_t (ptid.pid (), -1, 0);
6075 p += xsnprintf (p, endp - p, ":");
6076 p = write_ptid (p, endp, nptid);
6078 else if (ptid != minus_one_ptid)
6080 p += xsnprintf (p, endp - p, ":");
6081 p = write_ptid (p, endp, ptid);
6087 /* Clear the thread's private info on resume. */
6090 resume_clear_thread_private_info (struct thread_info *thread)
6092 if (thread->priv != NULL)
6094 remote_thread_info *priv = get_remote_thread_info (thread);
6096 priv->stop_reason = TARGET_STOPPED_BY_NO_REASON;
6097 priv->watch_data_address = 0;
6101 /* Append a vCont continue-with-signal action for threads that have a
6102 non-zero stop signal. */
6105 remote_target::append_pending_thread_resumptions (char *p, char *endp,
6108 struct thread_info *thread;
6110 ALL_NON_EXITED_THREADS (thread)
6111 if (thread->ptid.matches (ptid)
6112 && inferior_ptid != thread->ptid
6113 && thread->suspend.stop_signal != GDB_SIGNAL_0)
6115 p = append_resumption (p, endp, thread->ptid,
6116 0, thread->suspend.stop_signal);
6117 thread->suspend.stop_signal = GDB_SIGNAL_0;
6118 resume_clear_thread_private_info (thread);
6124 /* Set the target running, using the packets that use Hc
6128 remote_target::remote_resume_with_hc (ptid_t ptid, int step,
6131 struct remote_state *rs = get_remote_state ();
6132 struct thread_info *thread;
6135 rs->last_sent_signal = siggnal;
6136 rs->last_sent_step = step;
6138 /* The c/s/C/S resume packets use Hc, so set the continue
6140 if (ptid == minus_one_ptid)
6141 set_continue_thread (any_thread_ptid);
6143 set_continue_thread (ptid);
6145 ALL_NON_EXITED_THREADS (thread)
6146 resume_clear_thread_private_info (thread);
6149 if (::execution_direction == EXEC_REVERSE)
6151 /* We don't pass signals to the target in reverse exec mode. */
6152 if (info_verbose && siggnal != GDB_SIGNAL_0)
6153 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6156 if (step && packet_support (PACKET_bs) == PACKET_DISABLE)
6157 error (_("Remote reverse-step not supported."));
6158 if (!step && packet_support (PACKET_bc) == PACKET_DISABLE)
6159 error (_("Remote reverse-continue not supported."));
6161 strcpy (buf, step ? "bs" : "bc");
6163 else if (siggnal != GDB_SIGNAL_0)
6165 buf[0] = step ? 'S' : 'C';
6166 buf[1] = tohex (((int) siggnal >> 4) & 0xf);
6167 buf[2] = tohex (((int) siggnal) & 0xf);
6171 strcpy (buf, step ? "s" : "c");
6176 /* Resume the remote inferior by using a "vCont" packet. The thread
6177 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6178 resumed thread should be single-stepped and/or signalled. If PTID
6179 equals minus_one_ptid, then all threads are resumed; the thread to
6180 be stepped and/or signalled is given in the global INFERIOR_PTID.
6181 This function returns non-zero iff it resumes the inferior.
6183 This function issues a strict subset of all possible vCont commands
6187 remote_target::remote_resume_with_vcont (ptid_t ptid, int step,
6188 enum gdb_signal siggnal)
6190 struct remote_state *rs = get_remote_state ();
6194 /* No reverse execution actions defined for vCont. */
6195 if (::execution_direction == EXEC_REVERSE)
6198 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
6199 remote_vcont_probe ();
6201 if (packet_support (PACKET_vCont) == PACKET_DISABLE)
6205 endp = rs->buf + get_remote_packet_size ();
6207 /* If we could generate a wider range of packets, we'd have to worry
6208 about overflowing BUF. Should there be a generic
6209 "multi-part-packet" packet? */
6211 p += xsnprintf (p, endp - p, "vCont");
6213 if (ptid == magic_null_ptid)
6215 /* MAGIC_NULL_PTID means that we don't have any active threads,
6216 so we don't have any TID numbers the inferior will
6217 understand. Make sure to only send forms that do not specify
6219 append_resumption (p, endp, minus_one_ptid, step, siggnal);
6221 else if (ptid == minus_one_ptid || ptid.is_pid ())
6223 /* Resume all threads (of all processes, or of a single
6224 process), with preference for INFERIOR_PTID. This assumes
6225 inferior_ptid belongs to the set of all threads we are about
6227 if (step || siggnal != GDB_SIGNAL_0)
6229 /* Step inferior_ptid, with or without signal. */
6230 p = append_resumption (p, endp, inferior_ptid, step, siggnal);
6233 /* Also pass down any pending signaled resumption for other
6234 threads not the current. */
6235 p = append_pending_thread_resumptions (p, endp, ptid);
6237 /* And continue others without a signal. */
6238 append_resumption (p, endp, ptid, /*step=*/ 0, GDB_SIGNAL_0);
6242 /* Scheduler locking; resume only PTID. */
6243 append_resumption (p, endp, ptid, step, siggnal);
6246 gdb_assert (strlen (rs->buf) < get_remote_packet_size ());
6249 if (target_is_non_stop_p ())
6251 /* In non-stop, the stub replies to vCont with "OK". The stop
6252 reply will be reported asynchronously by means of a `%Stop'
6254 getpkt (&rs->buf, &rs->buf_size, 0);
6255 if (strcmp (rs->buf, "OK") != 0)
6256 error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf);
6262 /* Tell the remote machine to resume. */
6265 remote_target::resume (ptid_t ptid, int step, enum gdb_signal siggnal)
6267 struct remote_state *rs = get_remote_state ();
6269 /* When connected in non-stop mode, the core resumes threads
6270 individually. Resuming remote threads directly in target_resume
6271 would thus result in sending one packet per thread. Instead, to
6272 minimize roundtrip latency, here we just store the resume
6273 request; the actual remote resumption will be done in
6274 target_commit_resume / remote_commit_resume, where we'll be able
6275 to do vCont action coalescing. */
6276 if (target_is_non_stop_p () && ::execution_direction != EXEC_REVERSE)
6278 remote_thread_info *remote_thr;
6280 if (minus_one_ptid == ptid || ptid.is_pid ())
6281 remote_thr = get_remote_thread_info (inferior_ptid);
6283 remote_thr = get_remote_thread_info (ptid);
6285 remote_thr->last_resume_step = step;
6286 remote_thr->last_resume_sig = siggnal;
6290 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6291 (explained in remote-notif.c:handle_notification) so
6292 remote_notif_process is not called. We need find a place where
6293 it is safe to start a 'vNotif' sequence. It is good to do it
6294 before resuming inferior, because inferior was stopped and no RSP
6295 traffic at that moment. */
6296 if (!target_is_non_stop_p ())
6297 remote_notif_process (rs->notif_state, ¬if_client_stop);
6299 rs->last_resume_exec_dir = ::execution_direction;
6301 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6302 if (!remote_resume_with_vcont (ptid, step, siggnal))
6303 remote_resume_with_hc (ptid, step, siggnal);
6305 /* We are about to start executing the inferior, let's register it
6306 with the event loop. NOTE: this is the one place where all the
6307 execution commands end up. We could alternatively do this in each
6308 of the execution commands in infcmd.c. */
6309 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6310 into infcmd.c in order to allow inferior function calls to work
6311 NOT asynchronously. */
6312 if (target_can_async_p ())
6315 /* We've just told the target to resume. The remote server will
6316 wait for the inferior to stop, and then send a stop reply. In
6317 the mean time, we can't start another command/query ourselves
6318 because the stub wouldn't be ready to process it. This applies
6319 only to the base all-stop protocol, however. In non-stop (which
6320 only supports vCont), the stub replies with an "OK", and is
6321 immediate able to process further serial input. */
6322 if (!target_is_non_stop_p ())
6323 rs->waiting_for_stop_reply = 1;
6326 static int is_pending_fork_parent_thread (struct thread_info *thread);
6328 /* Private per-inferior info for target remote processes. */
6330 struct remote_inferior : public private_inferior
6332 /* Whether we can send a wildcard vCont for this process. */
6333 bool may_wildcard_vcont = true;
6336 /* Get the remote private inferior data associated to INF. */
6338 static remote_inferior *
6339 get_remote_inferior (inferior *inf)
6341 if (inf->priv == NULL)
6342 inf->priv.reset (new remote_inferior);
6344 return static_cast<remote_inferior *> (inf->priv.get ());
6347 /* Class used to track the construction of a vCont packet in the
6348 outgoing packet buffer. This is used to send multiple vCont
6349 packets if we have more actions than would fit a single packet. */
6354 explicit vcont_builder (remote_target *remote)
6361 void push_action (ptid_t ptid, bool step, gdb_signal siggnal);
6366 /* The remote target. */
6367 remote_target *m_remote;
6369 /* Pointer to the first action. P points here if no action has been
6371 char *m_first_action;
6373 /* Where the next action will be appended. */
6376 /* The end of the buffer. Must never write past this. */
6380 /* Prepare the outgoing buffer for a new vCont packet. */
6383 vcont_builder::restart ()
6385 struct remote_state *rs = m_remote->get_remote_state ();
6388 m_endp = rs->buf + m_remote->get_remote_packet_size ();
6389 m_p += xsnprintf (m_p, m_endp - m_p, "vCont");
6390 m_first_action = m_p;
6393 /* If the vCont packet being built has any action, send it to the
6397 vcont_builder::flush ()
6399 struct remote_state *rs;
6401 if (m_p == m_first_action)
6404 rs = m_remote->get_remote_state ();
6405 m_remote->putpkt (rs->buf);
6406 m_remote->getpkt (&rs->buf, &rs->buf_size, 0);
6407 if (strcmp (rs->buf, "OK") != 0)
6408 error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf);
6411 /* The largest action is range-stepping, with its two addresses. This
6412 is more than sufficient. If a new, bigger action is created, it'll
6413 quickly trigger a failed assertion in append_resumption (and we'll
6415 #define MAX_ACTION_SIZE 200
6417 /* Append a new vCont action in the outgoing packet being built. If
6418 the action doesn't fit the packet along with previous actions, push
6419 what we've got so far to the remote end and start over a new vCont
6420 packet (with the new action). */
6423 vcont_builder::push_action (ptid_t ptid, bool step, gdb_signal siggnal)
6425 char buf[MAX_ACTION_SIZE + 1];
6427 char *endp = m_remote->append_resumption (buf, buf + sizeof (buf),
6428 ptid, step, siggnal);
6430 /* Check whether this new action would fit in the vCont packet along
6431 with previous actions. If not, send what we've got so far and
6432 start a new vCont packet. */
6433 size_t rsize = endp - buf;
6434 if (rsize > m_endp - m_p)
6439 /* Should now fit. */
6440 gdb_assert (rsize <= m_endp - m_p);
6443 memcpy (m_p, buf, rsize);
6448 /* to_commit_resume implementation. */
6451 remote_target::commit_resume ()
6453 struct inferior *inf;
6454 struct thread_info *tp;
6455 int any_process_wildcard;
6456 int may_global_wildcard_vcont;
6458 /* If connected in all-stop mode, we'd send the remote resume
6459 request directly from remote_resume. Likewise if
6460 reverse-debugging, as there are no defined vCont actions for
6461 reverse execution. */
6462 if (!target_is_non_stop_p () || ::execution_direction == EXEC_REVERSE)
6465 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6466 instead of resuming all threads of each process individually.
6467 However, if any thread of a process must remain halted, we can't
6468 send wildcard resumes and must send one action per thread.
6470 Care must be taken to not resume threads/processes the server
6471 side already told us are stopped, but the core doesn't know about
6472 yet, because the events are still in the vStopped notification
6475 #1 => vCont s:p1.1;c
6477 #3 <= %Stopped T05 p1.1
6482 #8 (infrun handles the stop for p1.1 and continues stepping)
6483 #9 => vCont s:p1.1;c
6485 The last vCont above would resume thread p1.2 by mistake, because
6486 the server has no idea that the event for p1.2 had not been
6489 The server side must similarly ignore resume actions for the
6490 thread that has a pending %Stopped notification (and any other
6491 threads with events pending), until GDB acks the notification
6492 with vStopped. Otherwise, e.g., the following case is
6495 #1 => g (or any other packet)
6497 #3 <= %Stopped T05 p1.2
6498 #4 => vCont s:p1.1;c
6501 Above, the server must not resume thread p1.2. GDB can't know
6502 that p1.2 stopped until it acks the %Stopped notification, and
6503 since from GDB's perspective all threads should be running, it
6506 Finally, special care must also be given to handling fork/vfork
6507 events. A (v)fork event actually tells us that two processes
6508 stopped -- the parent and the child. Until we follow the fork,
6509 we must not resume the child. Therefore, if we have a pending
6510 fork follow, we must not send a global wildcard resume action
6511 (vCont;c). We can still send process-wide wildcards though. */
6513 /* Start by assuming a global wildcard (vCont;c) is possible. */
6514 may_global_wildcard_vcont = 1;
6516 /* And assume every process is individually wildcard-able too. */
6517 ALL_NON_EXITED_INFERIORS (inf)
6519 remote_inferior *priv = get_remote_inferior (inf);
6521 priv->may_wildcard_vcont = true;
6524 /* Check for any pending events (not reported or processed yet) and
6525 disable process and global wildcard resumes appropriately. */
6526 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont);
6528 ALL_NON_EXITED_THREADS (tp)
6530 /* If a thread of a process is not meant to be resumed, then we
6531 can't wildcard that process. */
6534 get_remote_inferior (tp->inf)->may_wildcard_vcont = false;
6536 /* And if we can't wildcard a process, we can't wildcard
6537 everything either. */
6538 may_global_wildcard_vcont = 0;
6542 /* If a thread is the parent of an unfollowed fork, then we
6543 can't do a global wildcard, as that would resume the fork
6545 if (is_pending_fork_parent_thread (tp))
6546 may_global_wildcard_vcont = 0;
6549 /* Now let's build the vCont packet(s). Actions must be appended
6550 from narrower to wider scopes (thread -> process -> global). If
6551 we end up with too many actions for a single packet vcont_builder
6552 flushes the current vCont packet to the remote side and starts a
6554 struct vcont_builder vcont_builder (this);
6556 /* Threads first. */
6557 ALL_NON_EXITED_THREADS (tp)
6559 remote_thread_info *remote_thr = get_remote_thread_info (tp);
6561 if (!tp->executing || remote_thr->vcont_resumed)
6564 gdb_assert (!thread_is_in_step_over_chain (tp));
6566 if (!remote_thr->last_resume_step
6567 && remote_thr->last_resume_sig == GDB_SIGNAL_0
6568 && get_remote_inferior (tp->inf)->may_wildcard_vcont)
6570 /* We'll send a wildcard resume instead. */
6571 remote_thr->vcont_resumed = 1;
6575 vcont_builder.push_action (tp->ptid,
6576 remote_thr->last_resume_step,
6577 remote_thr->last_resume_sig);
6578 remote_thr->vcont_resumed = 1;
6581 /* Now check whether we can send any process-wide wildcard. This is
6582 to avoid sending a global wildcard in the case nothing is
6583 supposed to be resumed. */
6584 any_process_wildcard = 0;
6586 ALL_NON_EXITED_INFERIORS (inf)
6588 if (get_remote_inferior (inf)->may_wildcard_vcont)
6590 any_process_wildcard = 1;
6595 if (any_process_wildcard)
6597 /* If all processes are wildcard-able, then send a single "c"
6598 action, otherwise, send an "all (-1) threads of process"
6599 continue action for each running process, if any. */
6600 if (may_global_wildcard_vcont)
6602 vcont_builder.push_action (minus_one_ptid,
6603 false, GDB_SIGNAL_0);
6607 ALL_NON_EXITED_INFERIORS (inf)
6609 if (get_remote_inferior (inf)->may_wildcard_vcont)
6611 vcont_builder.push_action (ptid_t (inf->pid),
6612 false, GDB_SIGNAL_0);
6618 vcont_builder.flush ();
6623 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6624 thread, all threads of a remote process, or all threads of all
6628 remote_target::remote_stop_ns (ptid_t ptid)
6630 struct remote_state *rs = get_remote_state ();
6632 char *endp = rs->buf + get_remote_packet_size ();
6634 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
6635 remote_vcont_probe ();
6637 if (!rs->supports_vCont.t)
6638 error (_("Remote server does not support stopping threads"));
6640 if (ptid == minus_one_ptid
6641 || (!remote_multi_process_p (rs) && ptid.is_pid ()))
6642 p += xsnprintf (p, endp - p, "vCont;t");
6647 p += xsnprintf (p, endp - p, "vCont;t:");
6650 /* All (-1) threads of process. */
6651 nptid = ptid_t (ptid.pid (), -1, 0);
6654 /* Small optimization: if we already have a stop reply for
6655 this thread, no use in telling the stub we want this
6657 if (peek_stop_reply (ptid))
6663 write_ptid (p, endp, nptid);
6666 /* In non-stop, we get an immediate OK reply. The stop reply will
6667 come in asynchronously by notification. */
6669 getpkt (&rs->buf, &rs->buf_size, 0);
6670 if (strcmp (rs->buf, "OK") != 0)
6671 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid), rs->buf);
6674 /* All-stop version of target_interrupt. Sends a break or a ^C to
6675 interrupt the remote target. It is undefined which thread of which
6676 process reports the interrupt. */
6679 remote_target::remote_interrupt_as ()
6681 struct remote_state *rs = get_remote_state ();
6683 rs->ctrlc_pending_p = 1;
6685 /* If the inferior is stopped already, but the core didn't know
6686 about it yet, just ignore the request. The cached wait status
6687 will be collected in remote_wait. */
6688 if (rs->cached_wait_status)
6691 /* Send interrupt_sequence to remote target. */
6692 send_interrupt_sequence ();
6695 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6696 the remote target. It is undefined which thread of which process
6697 reports the interrupt. Throws an error if the packet is not
6698 supported by the server. */
6701 remote_target::remote_interrupt_ns ()
6703 struct remote_state *rs = get_remote_state ();
6705 char *endp = rs->buf + get_remote_packet_size ();
6707 xsnprintf (p, endp - p, "vCtrlC");
6709 /* In non-stop, we get an immediate OK reply. The stop reply will
6710 come in asynchronously by notification. */
6712 getpkt (&rs->buf, &rs->buf_size, 0);
6714 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCtrlC]))
6718 case PACKET_UNKNOWN:
6719 error (_("No support for interrupting the remote target."));
6721 error (_("Interrupting target failed: %s"), rs->buf);
6725 /* Implement the to_stop function for the remote targets. */
6728 remote_target::stop (ptid_t ptid)
6731 fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
6733 if (target_is_non_stop_p ())
6734 remote_stop_ns (ptid);
6737 /* We don't currently have a way to transparently pause the
6738 remote target in all-stop mode. Interrupt it instead. */
6739 remote_interrupt_as ();
6743 /* Implement the to_interrupt function for the remote targets. */
6746 remote_target::interrupt ()
6749 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
6751 if (target_is_non_stop_p ())
6752 remote_interrupt_ns ();
6754 remote_interrupt_as ();
6757 /* Implement the to_pass_ctrlc function for the remote targets. */
6760 remote_target::pass_ctrlc ()
6762 struct remote_state *rs = get_remote_state ();
6765 fprintf_unfiltered (gdb_stdlog, "remote_pass_ctrlc called\n");
6767 /* If we're starting up, we're not fully synced yet. Quit
6769 if (rs->starting_up)
6771 /* If ^C has already been sent once, offer to disconnect. */
6772 else if (rs->ctrlc_pending_p)
6775 target_interrupt ();
6778 /* Ask the user what to do when an interrupt is received. */
6781 remote_target::interrupt_query ()
6783 struct remote_state *rs = get_remote_state ();
6785 if (rs->waiting_for_stop_reply && rs->ctrlc_pending_p)
6787 if (query (_("The target is not responding to interrupt requests.\n"
6788 "Stop debugging it? ")))
6790 remote_unpush_target ();
6791 throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target."));
6796 if (query (_("Interrupted while waiting for the program.\n"
6797 "Give up waiting? ")))
6802 /* Enable/disable target terminal ownership. Most targets can use
6803 terminal groups to control terminal ownership. Remote targets are
6804 different in that explicit transfer of ownership to/from GDB/target
6808 remote_target::terminal_inferior ()
6810 /* NOTE: At this point we could also register our selves as the
6811 recipient of all input. Any characters typed could then be
6812 passed on down to the target. */
6816 remote_target::terminal_ours ()
6821 remote_console_output (char *msg)
6825 for (p = msg; p[0] && p[1]; p += 2)
6828 char c = fromhex (p[0]) * 16 + fromhex (p[1]);
6832 fputs_unfiltered (tb, gdb_stdtarg);
6834 gdb_flush (gdb_stdtarg);
6837 DEF_VEC_O(cached_reg_t);
6839 typedef struct stop_reply
6841 struct notif_event base;
6843 /* The identifier of the thread about this event */
6846 /* The remote state this event is associated with. When the remote
6847 connection, represented by a remote_state object, is closed,
6848 all the associated stop_reply events should be released. */
6849 struct remote_state *rs;
6851 struct target_waitstatus ws;
6853 /* The architecture associated with the expedited registers. */
6856 /* Expedited registers. This makes remote debugging a bit more
6857 efficient for those targets that provide critical registers as
6858 part of their normal status mechanism (as another roundtrip to
6859 fetch them is avoided). */
6860 VEC(cached_reg_t) *regcache;
6862 enum target_stop_reason stop_reason;
6864 CORE_ADDR watch_data_address;
6870 stop_reply_xfree (struct stop_reply *r)
6872 notif_event_xfree ((struct notif_event *) r);
6875 /* Return the length of the stop reply queue. */
6878 remote_target::stop_reply_queue_length ()
6880 remote_state *rs = get_remote_state ();
6881 return rs->stop_reply_queue.size ();
6885 remote_notif_stop_parse (remote_target *remote,
6886 struct notif_client *self, char *buf,
6887 struct notif_event *event)
6889 remote->remote_parse_stop_reply (buf, (struct stop_reply *) event);
6893 remote_notif_stop_ack (remote_target *remote,
6894 struct notif_client *self, char *buf,
6895 struct notif_event *event)
6897 struct stop_reply *stop_reply = (struct stop_reply *) event;
6900 putpkt (remote, self->ack_command);
6902 if (stop_reply->ws.kind == TARGET_WAITKIND_IGNORE)
6904 /* We got an unknown stop reply. */
6905 error (_("Unknown stop reply"));
6908 remote->push_stop_reply (stop_reply);
6912 remote_notif_stop_can_get_pending_events (remote_target *remote,
6913 struct notif_client *self)
6915 /* We can't get pending events in remote_notif_process for
6916 notification stop, and we have to do this in remote_wait_ns
6917 instead. If we fetch all queued events from stub, remote stub
6918 may exit and we have no chance to process them back in
6920 remote_state *rs = remote->get_remote_state ();
6921 mark_async_event_handler (rs->remote_async_inferior_event_token);
6926 stop_reply_dtr (struct notif_event *event)
6928 struct stop_reply *r = (struct stop_reply *) event;
6933 VEC_iterate (cached_reg_t, r->regcache, ix, reg);
6937 VEC_free (cached_reg_t, r->regcache);
6940 static struct notif_event *
6941 remote_notif_stop_alloc_reply (void)
6943 /* We cast to a pointer to the "base class". */
6944 struct notif_event *r = (struct notif_event *) XNEW (struct stop_reply);
6946 r->dtr = stop_reply_dtr;
6951 /* A client of notification Stop. */
6953 struct notif_client notif_client_stop =
6957 remote_notif_stop_parse,
6958 remote_notif_stop_ack,
6959 remote_notif_stop_can_get_pending_events,
6960 remote_notif_stop_alloc_reply,
6964 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6965 the pid of the process that owns the threads we want to check, or
6966 -1 if we want to check all threads. */
6969 is_pending_fork_parent (struct target_waitstatus *ws, int event_pid,
6972 if (ws->kind == TARGET_WAITKIND_FORKED
6973 || ws->kind == TARGET_WAITKIND_VFORKED)
6975 if (event_pid == -1 || event_pid == thread_ptid.pid ())
6982 /* Return the thread's pending status used to determine whether the
6983 thread is a fork parent stopped at a fork event. */
6985 static struct target_waitstatus *
6986 thread_pending_fork_status (struct thread_info *thread)
6988 if (thread->suspend.waitstatus_pending_p)
6989 return &thread->suspend.waitstatus;
6991 return &thread->pending_follow;
6994 /* Determine if THREAD is a pending fork parent thread. */
6997 is_pending_fork_parent_thread (struct thread_info *thread)
6999 struct target_waitstatus *ws = thread_pending_fork_status (thread);
7002 return is_pending_fork_parent (ws, pid, thread->ptid);
7005 /* If CONTEXT contains any fork child threads that have not been
7006 reported yet, remove them from the CONTEXT list. If such a
7007 thread exists it is because we are stopped at a fork catchpoint
7008 and have not yet called follow_fork, which will set up the
7009 host-side data structures for the new process. */
7012 remote_target::remove_new_fork_children (threads_listing_context *context)
7014 struct thread_info * thread;
7016 struct notif_client *notif = ¬if_client_stop;
7018 /* For any threads stopped at a fork event, remove the corresponding
7019 fork child threads from the CONTEXT list. */
7020 ALL_NON_EXITED_THREADS (thread)
7022 struct target_waitstatus *ws = thread_pending_fork_status (thread);
7024 if (is_pending_fork_parent (ws, pid, thread->ptid))
7025 context->remove_thread (ws->value.related_pid);
7028 /* Check for any pending fork events (not reported or processed yet)
7029 in process PID and remove those fork child threads from the
7030 CONTEXT list as well. */
7031 remote_notif_get_pending_events (notif);
7032 for (auto &event : get_remote_state ()->stop_reply_queue)
7033 if (event->ws.kind == TARGET_WAITKIND_FORKED
7034 || event->ws.kind == TARGET_WAITKIND_VFORKED
7035 || event->ws.kind == TARGET_WAITKIND_THREAD_EXITED)
7036 context->remove_thread (event->ws.value.related_pid);
7039 /* Check whether any event pending in the vStopped queue would prevent
7040 a global or process wildcard vCont action. Clear
7041 *may_global_wildcard if we can't do a global wildcard (vCont;c),
7042 and clear the event inferior's may_wildcard_vcont flag if we can't
7043 do a process-wide wildcard resume (vCont;c:pPID.-1). */
7046 remote_target::check_pending_events_prevent_wildcard_vcont
7047 (int *may_global_wildcard)
7049 struct notif_client *notif = ¬if_client_stop;
7051 remote_notif_get_pending_events (notif);
7052 for (auto &event : get_remote_state ()->stop_reply_queue)
7054 if (event->ws.kind == TARGET_WAITKIND_NO_RESUMED
7055 || event->ws.kind == TARGET_WAITKIND_NO_HISTORY)
7058 if (event->ws.kind == TARGET_WAITKIND_FORKED
7059 || event->ws.kind == TARGET_WAITKIND_VFORKED)
7060 *may_global_wildcard = 0;
7062 struct inferior *inf = find_inferior_ptid (event->ptid);
7064 /* This may be the first time we heard about this process.
7065 Regardless, we must not do a global wildcard resume, otherwise
7066 we'd resume this process too. */
7067 *may_global_wildcard = 0;
7069 get_remote_inferior (inf)->may_wildcard_vcont = false;
7073 /* Discard all pending stop replies of inferior INF. */
7076 remote_target::discard_pending_stop_replies (struct inferior *inf)
7078 struct stop_reply *reply;
7079 struct remote_state *rs = get_remote_state ();
7080 struct remote_notif_state *rns = rs->notif_state;
7082 /* This function can be notified when an inferior exists. When the
7083 target is not remote, the notification state is NULL. */
7084 if (rs->remote_desc == NULL)
7087 reply = (struct stop_reply *) rns->pending_event[notif_client_stop.id];
7089 /* Discard the in-flight notification. */
7090 if (reply != NULL && reply->ptid.pid () == inf->pid)
7092 stop_reply_xfree (reply);
7093 rns->pending_event[notif_client_stop.id] = NULL;
7096 /* Discard the stop replies we have already pulled with
7098 auto iter = std::remove_if (rs->stop_reply_queue.begin (),
7099 rs->stop_reply_queue.end (),
7100 [=] (const stop_reply_up &event)
7102 return event->ptid.pid () == inf->pid;
7104 rs->stop_reply_queue.erase (iter, rs->stop_reply_queue.end ());
7107 /* Discard the stop replies for RS in stop_reply_queue. */
7110 remote_target::discard_pending_stop_replies_in_queue ()
7112 remote_state *rs = get_remote_state ();
7114 /* Discard the stop replies we have already pulled with
7116 auto iter = std::remove_if (rs->stop_reply_queue.begin (),
7117 rs->stop_reply_queue.end (),
7118 [=] (const stop_reply_up &event)
7120 return event->rs == rs;
7122 rs->stop_reply_queue.erase (iter, rs->stop_reply_queue.end ());
7125 /* Remove the first reply in 'stop_reply_queue' which matches
7129 remote_target::remote_notif_remove_queued_reply (ptid_t ptid)
7131 remote_state *rs = get_remote_state ();
7133 auto iter = std::find_if (rs->stop_reply_queue.begin (),
7134 rs->stop_reply_queue.end (),
7135 [=] (const stop_reply_up &event)
7137 return event->ptid.matches (ptid);
7139 struct stop_reply *result;
7140 if (iter == rs->stop_reply_queue.end ())
7144 result = iter->release ();
7145 rs->stop_reply_queue.erase (iter);
7149 fprintf_unfiltered (gdb_stdlog,
7150 "notif: discard queued event: 'Stop' in %s\n",
7151 target_pid_to_str (ptid));
7156 /* Look for a queued stop reply belonging to PTID. If one is found,
7157 remove it from the queue, and return it. Returns NULL if none is
7158 found. If there are still queued events left to process, tell the
7159 event loop to get back to target_wait soon. */
7162 remote_target::queued_stop_reply (ptid_t ptid)
7164 remote_state *rs = get_remote_state ();
7165 struct stop_reply *r = remote_notif_remove_queued_reply (ptid);
7167 if (!rs->stop_reply_queue.empty ())
7169 /* There's still at least an event left. */
7170 mark_async_event_handler (rs->remote_async_inferior_event_token);
7176 /* Push a fully parsed stop reply in the stop reply queue. Since we
7177 know that we now have at least one queued event left to pass to the
7178 core side, tell the event loop to get back to target_wait soon. */
7181 remote_target::push_stop_reply (struct stop_reply *new_event)
7183 remote_state *rs = get_remote_state ();
7184 rs->stop_reply_queue.push_back (stop_reply_up (new_event));
7187 fprintf_unfiltered (gdb_stdlog,
7188 "notif: push 'Stop' %s to queue %d\n",
7189 target_pid_to_str (new_event->ptid),
7190 int (rs->stop_reply_queue.size ()));
7192 mark_async_event_handler (rs->remote_async_inferior_event_token);
7195 /* Returns true if we have a stop reply for PTID. */
7198 remote_target::peek_stop_reply (ptid_t ptid)
7200 remote_state *rs = get_remote_state ();
7201 for (auto &event : rs->stop_reply_queue)
7202 if (ptid == event->ptid
7203 && event->ws.kind == TARGET_WAITKIND_STOPPED)
7208 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7209 starting with P and ending with PEND matches PREFIX. */
7212 strprefix (const char *p, const char *pend, const char *prefix)
7214 for ( ; p < pend; p++, prefix++)
7217 return *prefix == '\0';
7220 /* Parse the stop reply in BUF. Either the function succeeds, and the
7221 result is stored in EVENT, or throws an error. */
7224 remote_target::remote_parse_stop_reply (char *buf, stop_reply *event)
7226 remote_arch_state *rsa = NULL;
7231 event->ptid = null_ptid;
7232 event->rs = get_remote_state ();
7233 event->ws.kind = TARGET_WAITKIND_IGNORE;
7234 event->ws.value.integer = 0;
7235 event->stop_reason = TARGET_STOPPED_BY_NO_REASON;
7236 event->regcache = NULL;
7241 case 'T': /* Status with PC, SP, FP, ... */
7242 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7243 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7245 n... = register number
7246 r... = register contents
7249 p = &buf[3]; /* after Txx */
7255 p1 = strchr (p, ':');
7257 error (_("Malformed packet(a) (missing colon): %s\n\
7261 error (_("Malformed packet(a) (missing register number): %s\n\
7265 /* Some "registers" are actually extended stop information.
7266 Note if you're adding a new entry here: GDB 7.9 and
7267 earlier assume that all register "numbers" that start
7268 with an hex digit are real register numbers. Make sure
7269 the server only sends such a packet if it knows the
7270 client understands it. */
7272 if (strprefix (p, p1, "thread"))
7273 event->ptid = read_ptid (++p1, &p);
7274 else if (strprefix (p, p1, "syscall_entry"))
7278 event->ws.kind = TARGET_WAITKIND_SYSCALL_ENTRY;
7279 p = unpack_varlen_hex (++p1, &sysno);
7280 event->ws.value.syscall_number = (int) sysno;
7282 else if (strprefix (p, p1, "syscall_return"))
7286 event->ws.kind = TARGET_WAITKIND_SYSCALL_RETURN;
7287 p = unpack_varlen_hex (++p1, &sysno);
7288 event->ws.value.syscall_number = (int) sysno;
7290 else if (strprefix (p, p1, "watch")
7291 || strprefix (p, p1, "rwatch")
7292 || strprefix (p, p1, "awatch"))
7294 event->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
7295 p = unpack_varlen_hex (++p1, &addr);
7296 event->watch_data_address = (CORE_ADDR) addr;
7298 else if (strprefix (p, p1, "swbreak"))
7300 event->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
7302 /* Make sure the stub doesn't forget to indicate support
7304 if (packet_support (PACKET_swbreak_feature) != PACKET_ENABLE)
7305 error (_("Unexpected swbreak stop reason"));
7307 /* The value part is documented as "must be empty",
7308 though we ignore it, in case we ever decide to make
7309 use of it in a backward compatible way. */
7310 p = strchrnul (p1 + 1, ';');
7312 else if (strprefix (p, p1, "hwbreak"))
7314 event->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
7316 /* Make sure the stub doesn't forget to indicate support
7318 if (packet_support (PACKET_hwbreak_feature) != PACKET_ENABLE)
7319 error (_("Unexpected hwbreak stop reason"));
7322 p = strchrnul (p1 + 1, ';');
7324 else if (strprefix (p, p1, "library"))
7326 event->ws.kind = TARGET_WAITKIND_LOADED;
7327 p = strchrnul (p1 + 1, ';');
7329 else if (strprefix (p, p1, "replaylog"))
7331 event->ws.kind = TARGET_WAITKIND_NO_HISTORY;
7332 /* p1 will indicate "begin" or "end", but it makes
7333 no difference for now, so ignore it. */
7334 p = strchrnul (p1 + 1, ';');
7336 else if (strprefix (p, p1, "core"))
7340 p = unpack_varlen_hex (++p1, &c);
7343 else if (strprefix (p, p1, "fork"))
7345 event->ws.value.related_pid = read_ptid (++p1, &p);
7346 event->ws.kind = TARGET_WAITKIND_FORKED;
7348 else if (strprefix (p, p1, "vfork"))
7350 event->ws.value.related_pid = read_ptid (++p1, &p);
7351 event->ws.kind = TARGET_WAITKIND_VFORKED;
7353 else if (strprefix (p, p1, "vforkdone"))
7355 event->ws.kind = TARGET_WAITKIND_VFORK_DONE;
7356 p = strchrnul (p1 + 1, ';');
7358 else if (strprefix (p, p1, "exec"))
7361 char pathname[PATH_MAX];
7364 /* Determine the length of the execd pathname. */
7365 p = unpack_varlen_hex (++p1, &ignored);
7366 pathlen = (p - p1) / 2;
7368 /* Save the pathname for event reporting and for
7369 the next run command. */
7370 hex2bin (p1, (gdb_byte *) pathname, pathlen);
7371 pathname[pathlen] = '\0';
7373 /* This is freed during event handling. */
7374 event->ws.value.execd_pathname = xstrdup (pathname);
7375 event->ws.kind = TARGET_WAITKIND_EXECD;
7377 /* Skip the registers included in this packet, since
7378 they may be for an architecture different from the
7379 one used by the original program. */
7382 else if (strprefix (p, p1, "create"))
7384 event->ws.kind = TARGET_WAITKIND_THREAD_CREATED;
7385 p = strchrnul (p1 + 1, ';');
7394 p = strchrnul (p1 + 1, ';');
7399 /* Maybe a real ``P'' register number. */
7400 p_temp = unpack_varlen_hex (p, &pnum);
7401 /* If the first invalid character is the colon, we got a
7402 register number. Otherwise, it's an unknown stop
7406 /* If we haven't parsed the event's thread yet, find
7407 it now, in order to find the architecture of the
7408 reported expedited registers. */
7409 if (event->ptid == null_ptid)
7411 const char *thr = strstr (p1 + 1, ";thread:");
7413 event->ptid = read_ptid (thr + strlen (";thread:"),
7417 /* Either the current thread hasn't changed,
7418 or the inferior is not multi-threaded.
7419 The event must be for the thread we last
7420 set as (or learned as being) current. */
7421 event->ptid = event->rs->general_thread;
7427 inferior *inf = (event->ptid == null_ptid
7429 : find_inferior_ptid (event->ptid));
7430 /* If this is the first time we learn anything
7431 about this process, skip the registers
7432 included in this packet, since we don't yet
7433 know which architecture to use to parse them.
7434 We'll determine the architecture later when
7435 we process the stop reply and retrieve the
7436 target description, via
7437 remote_notice_new_inferior ->
7438 post_create_inferior. */
7441 p = strchrnul (p1 + 1, ';');
7446 event->arch = inf->gdbarch;
7447 rsa = event->rs->get_remote_arch_state (event->arch);
7451 = packet_reg_from_pnum (event->arch, rsa, pnum);
7452 cached_reg_t cached_reg;
7455 error (_("Remote sent bad register number %s: %s\n\
7457 hex_string (pnum), p, buf);
7459 cached_reg.num = reg->regnum;
7460 cached_reg.data = (gdb_byte *)
7461 xmalloc (register_size (event->arch, reg->regnum));
7464 fieldsize = hex2bin (p, cached_reg.data,
7465 register_size (event->arch, reg->regnum));
7467 if (fieldsize < register_size (event->arch, reg->regnum))
7468 warning (_("Remote reply is too short: %s"), buf);
7470 VEC_safe_push (cached_reg_t, event->regcache, &cached_reg);
7474 /* Not a number. Silently skip unknown optional
7476 p = strchrnul (p1 + 1, ';');
7481 error (_("Remote register badly formatted: %s\nhere: %s"),
7486 if (event->ws.kind != TARGET_WAITKIND_IGNORE)
7490 case 'S': /* Old style status, just signal only. */
7494 event->ws.kind = TARGET_WAITKIND_STOPPED;
7495 sig = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
7496 if (GDB_SIGNAL_FIRST <= sig && sig < GDB_SIGNAL_LAST)
7497 event->ws.value.sig = (enum gdb_signal) sig;
7499 event->ws.value.sig = GDB_SIGNAL_UNKNOWN;
7502 case 'w': /* Thread exited. */
7507 event->ws.kind = TARGET_WAITKIND_THREAD_EXITED;
7508 p = unpack_varlen_hex (&buf[1], &value);
7509 event->ws.value.integer = value;
7511 error (_("stop reply packet badly formatted: %s"), buf);
7512 event->ptid = read_ptid (++p, NULL);
7515 case 'W': /* Target exited. */
7522 /* GDB used to accept only 2 hex chars here. Stubs should
7523 only send more if they detect GDB supports multi-process
7525 p = unpack_varlen_hex (&buf[1], &value);
7529 /* The remote process exited. */
7530 event->ws.kind = TARGET_WAITKIND_EXITED;
7531 event->ws.value.integer = value;
7535 /* The remote process exited with a signal. */
7536 event->ws.kind = TARGET_WAITKIND_SIGNALLED;
7537 if (GDB_SIGNAL_FIRST <= value && value < GDB_SIGNAL_LAST)
7538 event->ws.value.sig = (enum gdb_signal) value;
7540 event->ws.value.sig = GDB_SIGNAL_UNKNOWN;
7543 /* If no process is specified, assume inferior_ptid. */
7544 pid = inferior_ptid.pid ();
7553 else if (startswith (p, "process:"))
7557 p += sizeof ("process:") - 1;
7558 unpack_varlen_hex (p, &upid);
7562 error (_("unknown stop reply packet: %s"), buf);
7565 error (_("unknown stop reply packet: %s"), buf);
7566 event->ptid = ptid_t (pid);
7570 event->ws.kind = TARGET_WAITKIND_NO_RESUMED;
7571 event->ptid = minus_one_ptid;
7575 if (target_is_non_stop_p () && event->ptid == null_ptid)
7576 error (_("No process or thread specified in stop reply: %s"), buf);
7579 /* When the stub wants to tell GDB about a new notification reply, it
7580 sends a notification (%Stop, for example). Those can come it at
7581 any time, hence, we have to make sure that any pending
7582 putpkt/getpkt sequence we're making is finished, before querying
7583 the stub for more events with the corresponding ack command
7584 (vStopped, for example). E.g., if we started a vStopped sequence
7585 immediately upon receiving the notification, something like this
7593 1.6) <-- (registers reply to step #1.3)
7595 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7598 To solve this, whenever we parse a %Stop notification successfully,
7599 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7600 doing whatever we were doing:
7606 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7607 2.5) <-- (registers reply to step #2.3)
7609 Eventualy after step #2.5, we return to the event loop, which
7610 notices there's an event on the
7611 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7612 associated callback --- the function below. At this point, we're
7613 always safe to start a vStopped sequence. :
7616 2.7) <-- T05 thread:2
7622 remote_target::remote_notif_get_pending_events (notif_client *nc)
7624 struct remote_state *rs = get_remote_state ();
7626 if (rs->notif_state->pending_event[nc->id] != NULL)
7629 fprintf_unfiltered (gdb_stdlog,
7630 "notif: process: '%s' ack pending event\n",
7634 nc->ack (this, nc, rs->buf, rs->notif_state->pending_event[nc->id]);
7635 rs->notif_state->pending_event[nc->id] = NULL;
7639 getpkt (&rs->buf, &rs->buf_size, 0);
7640 if (strcmp (rs->buf, "OK") == 0)
7643 remote_notif_ack (this, nc, rs->buf);
7649 fprintf_unfiltered (gdb_stdlog,
7650 "notif: process: '%s' no pending reply\n",
7655 /* Wrapper around remote_target::remote_notif_get_pending_events to
7656 avoid having to export the whole remote_target class. */
7659 remote_notif_get_pending_events (remote_target *remote, notif_client *nc)
7661 remote->remote_notif_get_pending_events (nc);
7664 /* Called when it is decided that STOP_REPLY holds the info of the
7665 event that is to be returned to the core. This function always
7666 destroys STOP_REPLY. */
7669 remote_target::process_stop_reply (struct stop_reply *stop_reply,
7670 struct target_waitstatus *status)
7674 *status = stop_reply->ws;
7675 ptid = stop_reply->ptid;
7677 /* If no thread/process was reported by the stub, assume the current
7679 if (ptid == null_ptid)
7680 ptid = inferior_ptid;
7682 if (status->kind != TARGET_WAITKIND_EXITED
7683 && status->kind != TARGET_WAITKIND_SIGNALLED
7684 && status->kind != TARGET_WAITKIND_NO_RESUMED)
7686 /* Expedited registers. */
7687 if (stop_reply->regcache)
7689 struct regcache *regcache
7690 = get_thread_arch_regcache (ptid, stop_reply->arch);
7695 VEC_iterate (cached_reg_t, stop_reply->regcache, ix, reg);
7698 regcache->raw_supply (reg->num, reg->data);
7702 VEC_free (cached_reg_t, stop_reply->regcache);
7705 remote_notice_new_inferior (ptid, 0);
7706 remote_thread_info *remote_thr = get_remote_thread_info (ptid);
7707 remote_thr->core = stop_reply->core;
7708 remote_thr->stop_reason = stop_reply->stop_reason;
7709 remote_thr->watch_data_address = stop_reply->watch_data_address;
7710 remote_thr->vcont_resumed = 0;
7713 stop_reply_xfree (stop_reply);
7717 /* The non-stop mode version of target_wait. */
7720 remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status, int options)
7722 struct remote_state *rs = get_remote_state ();
7723 struct stop_reply *stop_reply;
7727 /* If in non-stop mode, get out of getpkt even if a
7728 notification is received. */
7730 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
7731 0 /* forever */, &is_notif);
7734 if (ret != -1 && !is_notif)
7737 case 'E': /* Error of some sort. */
7738 /* We're out of sync with the target now. Did it continue
7739 or not? We can't tell which thread it was in non-stop,
7740 so just ignore this. */
7741 warning (_("Remote failure reply: %s"), rs->buf);
7743 case 'O': /* Console output. */
7744 remote_console_output (rs->buf + 1);
7747 warning (_("Invalid remote reply: %s"), rs->buf);
7751 /* Acknowledge a pending stop reply that may have arrived in the
7753 if (rs->notif_state->pending_event[notif_client_stop.id] != NULL)
7754 remote_notif_get_pending_events (¬if_client_stop);
7756 /* If indeed we noticed a stop reply, we're done. */
7757 stop_reply = queued_stop_reply (ptid);
7758 if (stop_reply != NULL)
7759 return process_stop_reply (stop_reply, status);
7761 /* Still no event. If we're just polling for an event, then
7762 return to the event loop. */
7763 if (options & TARGET_WNOHANG)
7765 status->kind = TARGET_WAITKIND_IGNORE;
7766 return minus_one_ptid;
7769 /* Otherwise do a blocking wait. */
7770 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
7771 1 /* forever */, &is_notif);
7775 /* Wait until the remote machine stops, then return, storing status in
7776 STATUS just as `wait' would. */
7779 remote_target::wait_as (ptid_t ptid, target_waitstatus *status, int options)
7781 struct remote_state *rs = get_remote_state ();
7782 ptid_t event_ptid = null_ptid;
7784 struct stop_reply *stop_reply;
7788 status->kind = TARGET_WAITKIND_IGNORE;
7789 status->value.integer = 0;
7791 stop_reply = queued_stop_reply (ptid);
7792 if (stop_reply != NULL)
7793 return process_stop_reply (stop_reply, status);
7795 if (rs->cached_wait_status)
7796 /* Use the cached wait status, but only once. */
7797 rs->cached_wait_status = 0;
7802 int forever = ((options & TARGET_WNOHANG) == 0
7803 && rs->wait_forever_enabled_p);
7805 if (!rs->waiting_for_stop_reply)
7807 status->kind = TARGET_WAITKIND_NO_RESUMED;
7808 return minus_one_ptid;
7811 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7812 _never_ wait for ever -> test on target_is_async_p().
7813 However, before we do that we need to ensure that the caller
7814 knows how to take the target into/out of async mode. */
7815 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
7816 forever, &is_notif);
7818 /* GDB gets a notification. Return to core as this event is
7820 if (ret != -1 && is_notif)
7821 return minus_one_ptid;
7823 if (ret == -1 && (options & TARGET_WNOHANG) != 0)
7824 return minus_one_ptid;
7829 /* Assume that the target has acknowledged Ctrl-C unless we receive
7830 an 'F' or 'O' packet. */
7831 if (buf[0] != 'F' && buf[0] != 'O')
7832 rs->ctrlc_pending_p = 0;
7836 case 'E': /* Error of some sort. */
7837 /* We're out of sync with the target now. Did it continue or
7838 not? Not is more likely, so report a stop. */
7839 rs->waiting_for_stop_reply = 0;
7841 warning (_("Remote failure reply: %s"), buf);
7842 status->kind = TARGET_WAITKIND_STOPPED;
7843 status->value.sig = GDB_SIGNAL_0;
7845 case 'F': /* File-I/O request. */
7846 /* GDB may access the inferior memory while handling the File-I/O
7847 request, but we don't want GDB accessing memory while waiting
7848 for a stop reply. See the comments in putpkt_binary. Set
7849 waiting_for_stop_reply to 0 temporarily. */
7850 rs->waiting_for_stop_reply = 0;
7851 remote_fileio_request (this, buf, rs->ctrlc_pending_p);
7852 rs->ctrlc_pending_p = 0;
7853 /* GDB handled the File-I/O request, and the target is running
7854 again. Keep waiting for events. */
7855 rs->waiting_for_stop_reply = 1;
7857 case 'N': case 'T': case 'S': case 'X': case 'W':
7859 struct stop_reply *stop_reply;
7861 /* There is a stop reply to handle. */
7862 rs->waiting_for_stop_reply = 0;
7865 = (struct stop_reply *) remote_notif_parse (this,
7869 event_ptid = process_stop_reply (stop_reply, status);
7872 case 'O': /* Console output. */
7873 remote_console_output (buf + 1);
7876 if (rs->last_sent_signal != GDB_SIGNAL_0)
7878 /* Zero length reply means that we tried 'S' or 'C' and the
7879 remote system doesn't support it. */
7880 target_terminal::ours_for_output ();
7882 ("Can't send signals to this remote system. %s not sent.\n",
7883 gdb_signal_to_name (rs->last_sent_signal));
7884 rs->last_sent_signal = GDB_SIGNAL_0;
7885 target_terminal::inferior ();
7887 strcpy (buf, rs->last_sent_step ? "s" : "c");
7893 warning (_("Invalid remote reply: %s"), buf);
7897 if (status->kind == TARGET_WAITKIND_NO_RESUMED)
7898 return minus_one_ptid;
7899 else if (status->kind == TARGET_WAITKIND_IGNORE)
7901 /* Nothing interesting happened. If we're doing a non-blocking
7902 poll, we're done. Otherwise, go back to waiting. */
7903 if (options & TARGET_WNOHANG)
7904 return minus_one_ptid;
7908 else if (status->kind != TARGET_WAITKIND_EXITED
7909 && status->kind != TARGET_WAITKIND_SIGNALLED)
7911 if (event_ptid != null_ptid)
7912 record_currthread (rs, event_ptid);
7914 event_ptid = inferior_ptid;
7917 /* A process exit. Invalidate our notion of current thread. */
7918 record_currthread (rs, minus_one_ptid);
7923 /* Wait until the remote machine stops, then return, storing status in
7924 STATUS just as `wait' would. */
7927 remote_target::wait (ptid_t ptid, struct target_waitstatus *status, int options)
7931 if (target_is_non_stop_p ())
7932 event_ptid = wait_ns (ptid, status, options);
7934 event_ptid = wait_as (ptid, status, options);
7936 if (target_is_async_p ())
7938 remote_state *rs = get_remote_state ();
7940 /* If there are are events left in the queue tell the event loop
7942 if (!rs->stop_reply_queue.empty ())
7943 mark_async_event_handler (rs->remote_async_inferior_event_token);
7949 /* Fetch a single register using a 'p' packet. */
7952 remote_target::fetch_register_using_p (struct regcache *regcache,
7955 struct gdbarch *gdbarch = regcache->arch ();
7956 struct remote_state *rs = get_remote_state ();
7958 gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum));
7961 if (packet_support (PACKET_p) == PACKET_DISABLE)
7964 if (reg->pnum == -1)
7969 p += hexnumstr (p, reg->pnum);
7972 getpkt (&rs->buf, &rs->buf_size, 0);
7976 switch (packet_ok (buf, &remote_protocol_packets[PACKET_p]))
7980 case PACKET_UNKNOWN:
7983 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7984 gdbarch_register_name (regcache->arch (),
7989 /* If this register is unfetchable, tell the regcache. */
7992 regcache->raw_supply (reg->regnum, NULL);
7996 /* Otherwise, parse and supply the value. */
8002 error (_("fetch_register_using_p: early buf termination"));
8004 regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
8007 regcache->raw_supply (reg->regnum, regp);
8011 /* Fetch the registers included in the target's 'g' packet. */
8014 remote_target::send_g_packet ()
8016 struct remote_state *rs = get_remote_state ();
8019 xsnprintf (rs->buf, get_remote_packet_size (), "g");
8021 getpkt (&rs->buf, &rs->buf_size, 0);
8022 if (packet_check_result (rs->buf) == PACKET_ERROR)
8023 error (_("Could not read registers; remote failure reply '%s'"),
8026 /* We can get out of synch in various cases. If the first character
8027 in the buffer is not a hex character, assume that has happened
8028 and try to fetch another packet to read. */
8029 while ((rs->buf[0] < '0' || rs->buf[0] > '9')
8030 && (rs->buf[0] < 'A' || rs->buf[0] > 'F')
8031 && (rs->buf[0] < 'a' || rs->buf[0] > 'f')
8032 && rs->buf[0] != 'x') /* New: unavailable register value. */
8035 fprintf_unfiltered (gdb_stdlog,
8036 "Bad register packet; fetching a new packet\n");
8037 getpkt (&rs->buf, &rs->buf_size, 0);
8040 buf_len = strlen (rs->buf);
8042 /* Sanity check the received packet. */
8043 if (buf_len % 2 != 0)
8044 error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf);
8050 remote_target::process_g_packet (struct regcache *regcache)
8052 struct gdbarch *gdbarch = regcache->arch ();
8053 struct remote_state *rs = get_remote_state ();
8054 remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch);
8059 buf_len = strlen (rs->buf);
8061 /* Further sanity checks, with knowledge of the architecture. */
8062 if (buf_len > 2 * rsa->sizeof_g_packet)
8063 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8064 "bytes): %s"), rsa->sizeof_g_packet, buf_len / 2, rs->buf);
8066 /* Save the size of the packet sent to us by the target. It is used
8067 as a heuristic when determining the max size of packets that the
8068 target can safely receive. */
8069 if (rsa->actual_register_packet_size == 0)
8070 rsa->actual_register_packet_size = buf_len;
8072 /* If this is smaller than we guessed the 'g' packet would be,
8073 update our records. A 'g' reply that doesn't include a register's
8074 value implies either that the register is not available, or that
8075 the 'p' packet must be used. */
8076 if (buf_len < 2 * rsa->sizeof_g_packet)
8078 long sizeof_g_packet = buf_len / 2;
8080 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
8082 long offset = rsa->regs[i].offset;
8083 long reg_size = register_size (gdbarch, i);
8085 if (rsa->regs[i].pnum == -1)
8088 if (offset >= sizeof_g_packet)
8089 rsa->regs[i].in_g_packet = 0;
8090 else if (offset + reg_size > sizeof_g_packet)
8091 error (_("Truncated register %d in remote 'g' packet"), i);
8093 rsa->regs[i].in_g_packet = 1;
8096 /* Looks valid enough, we can assume this is the correct length
8097 for a 'g' packet. It's important not to adjust
8098 rsa->sizeof_g_packet if we have truncated registers otherwise
8099 this "if" won't be run the next time the method is called
8100 with a packet of the same size and one of the internal errors
8101 below will trigger instead. */
8102 rsa->sizeof_g_packet = sizeof_g_packet;
8105 regs = (char *) alloca (rsa->sizeof_g_packet);
8107 /* Unimplemented registers read as all bits zero. */
8108 memset (regs, 0, rsa->sizeof_g_packet);
8110 /* Reply describes registers byte by byte, each byte encoded as two
8111 hex characters. Suck them all up, then supply them to the
8112 register cacheing/storage mechanism. */
8115 for (i = 0; i < rsa->sizeof_g_packet; i++)
8117 if (p[0] == 0 || p[1] == 0)
8118 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8119 internal_error (__FILE__, __LINE__,
8120 _("unexpected end of 'g' packet reply"));
8122 if (p[0] == 'x' && p[1] == 'x')
8123 regs[i] = 0; /* 'x' */
8125 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
8129 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
8131 struct packet_reg *r = &rsa->regs[i];
8132 long reg_size = register_size (gdbarch, i);
8136 if ((r->offset + reg_size) * 2 > strlen (rs->buf))
8137 /* This shouldn't happen - we adjusted in_g_packet above. */
8138 internal_error (__FILE__, __LINE__,
8139 _("unexpected end of 'g' packet reply"));
8140 else if (rs->buf[r->offset * 2] == 'x')
8142 gdb_assert (r->offset * 2 < strlen (rs->buf));
8143 /* The register isn't available, mark it as such (at
8144 the same time setting the value to zero). */
8145 regcache->raw_supply (r->regnum, NULL);
8148 regcache->raw_supply (r->regnum, regs + r->offset);
8154 remote_target::fetch_registers_using_g (struct regcache *regcache)
8157 process_g_packet (regcache);
8160 /* Make the remote selected traceframe match GDB's selected
8164 remote_target::set_remote_traceframe ()
8167 struct remote_state *rs = get_remote_state ();
8169 if (rs->remote_traceframe_number == get_traceframe_number ())
8172 /* Avoid recursion, remote_trace_find calls us again. */
8173 rs->remote_traceframe_number = get_traceframe_number ();
8175 newnum = target_trace_find (tfind_number,
8176 get_traceframe_number (), 0, 0, NULL);
8178 /* Should not happen. If it does, all bets are off. */
8179 if (newnum != get_traceframe_number ())
8180 warning (_("could not set remote traceframe"));
8184 remote_target::fetch_registers (struct regcache *regcache, int regnum)
8186 struct gdbarch *gdbarch = regcache->arch ();
8187 struct remote_state *rs = get_remote_state ();
8188 remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch);
8191 set_remote_traceframe ();
8192 set_general_thread (regcache->ptid ());
8196 packet_reg *reg = packet_reg_from_regnum (gdbarch, rsa, regnum);
8198 gdb_assert (reg != NULL);
8200 /* If this register might be in the 'g' packet, try that first -
8201 we are likely to read more than one register. If this is the
8202 first 'g' packet, we might be overly optimistic about its
8203 contents, so fall back to 'p'. */
8204 if (reg->in_g_packet)
8206 fetch_registers_using_g (regcache);
8207 if (reg->in_g_packet)
8211 if (fetch_register_using_p (regcache, reg))
8214 /* This register is not available. */
8215 regcache->raw_supply (reg->regnum, NULL);
8220 fetch_registers_using_g (regcache);
8222 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
8223 if (!rsa->regs[i].in_g_packet)
8224 if (!fetch_register_using_p (regcache, &rsa->regs[i]))
8226 /* This register is not available. */
8227 regcache->raw_supply (i, NULL);
8231 /* Prepare to store registers. Since we may send them all (using a
8232 'G' request), we have to read out the ones we don't want to change
8236 remote_target::prepare_to_store (struct regcache *regcache)
8238 struct remote_state *rs = get_remote_state ();
8239 remote_arch_state *rsa = rs->get_remote_arch_state (regcache->arch ());
8242 /* Make sure the entire registers array is valid. */
8243 switch (packet_support (PACKET_P))
8245 case PACKET_DISABLE:
8246 case PACKET_SUPPORT_UNKNOWN:
8247 /* Make sure all the necessary registers are cached. */
8248 for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
8249 if (rsa->regs[i].in_g_packet)
8250 regcache->raw_update (rsa->regs[i].regnum);
8257 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8258 packet was not recognized. */
8261 remote_target::store_register_using_P (const struct regcache *regcache,
8264 struct gdbarch *gdbarch = regcache->arch ();
8265 struct remote_state *rs = get_remote_state ();
8266 /* Try storing a single register. */
8267 char *buf = rs->buf;
8268 gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum));
8271 if (packet_support (PACKET_P) == PACKET_DISABLE)
8274 if (reg->pnum == -1)
8277 xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0));
8278 p = buf + strlen (buf);
8279 regcache->raw_collect (reg->regnum, regp);
8280 bin2hex (regp, p, register_size (gdbarch, reg->regnum));
8282 getpkt (&rs->buf, &rs->buf_size, 0);
8284 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P]))
8289 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8290 gdbarch_register_name (gdbarch, reg->regnum), rs->buf);
8291 case PACKET_UNKNOWN:
8294 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
8298 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8299 contents of the register cache buffer. FIXME: ignores errors. */
8302 remote_target::store_registers_using_G (const struct regcache *regcache)
8304 struct remote_state *rs = get_remote_state ();
8305 remote_arch_state *rsa = rs->get_remote_arch_state (regcache->arch ());
8309 /* Extract all the registers in the regcache copying them into a
8314 regs = (gdb_byte *) alloca (rsa->sizeof_g_packet);
8315 memset (regs, 0, rsa->sizeof_g_packet);
8316 for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
8318 struct packet_reg *r = &rsa->regs[i];
8321 regcache->raw_collect (r->regnum, regs + r->offset);
8325 /* Command describes registers byte by byte,
8326 each byte encoded as two hex characters. */
8329 bin2hex (regs, p, rsa->sizeof_g_packet);
8331 getpkt (&rs->buf, &rs->buf_size, 0);
8332 if (packet_check_result (rs->buf) == PACKET_ERROR)
8333 error (_("Could not write registers; remote failure reply '%s'"),
8337 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8338 of the register cache buffer. FIXME: ignores errors. */
8341 remote_target::store_registers (struct regcache *regcache, int regnum)
8343 struct gdbarch *gdbarch = regcache->arch ();
8344 struct remote_state *rs = get_remote_state ();
8345 remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch);
8348 set_remote_traceframe ();
8349 set_general_thread (regcache->ptid ());
8353 packet_reg *reg = packet_reg_from_regnum (gdbarch, rsa, regnum);
8355 gdb_assert (reg != NULL);
8357 /* Always prefer to store registers using the 'P' packet if
8358 possible; we often change only a small number of registers.
8359 Sometimes we change a larger number; we'd need help from a
8360 higher layer to know to use 'G'. */
8361 if (store_register_using_P (regcache, reg))
8364 /* For now, don't complain if we have no way to write the
8365 register. GDB loses track of unavailable registers too
8366 easily. Some day, this may be an error. We don't have
8367 any way to read the register, either... */
8368 if (!reg->in_g_packet)
8371 store_registers_using_G (regcache);
8375 store_registers_using_G (regcache);
8377 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
8378 if (!rsa->regs[i].in_g_packet)
8379 if (!store_register_using_P (regcache, &rsa->regs[i]))
8380 /* See above for why we do not issue an error here. */
8385 /* Return the number of hex digits in num. */
8388 hexnumlen (ULONGEST num)
8392 for (i = 0; num != 0; i++)
8395 return std::max (i, 1);
8398 /* Set BUF to the minimum number of hex digits representing NUM. */
8401 hexnumstr (char *buf, ULONGEST num)
8403 int len = hexnumlen (num);
8405 return hexnumnstr (buf, num, len);
8409 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8412 hexnumnstr (char *buf, ULONGEST num, int width)
8418 for (i = width - 1; i >= 0; i--)
8420 buf[i] = "0123456789abcdef"[(num & 0xf)];
8427 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8430 remote_address_masked (CORE_ADDR addr)
8432 unsigned int address_size = remote_address_size;
8434 /* If "remoteaddresssize" was not set, default to target address size. */
8436 address_size = gdbarch_addr_bit (target_gdbarch ());
8438 if (address_size > 0
8439 && address_size < (sizeof (ULONGEST) * 8))
8441 /* Only create a mask when that mask can safely be constructed
8442 in a ULONGEST variable. */
8445 mask = (mask << address_size) - 1;
8451 /* Determine whether the remote target supports binary downloading.
8452 This is accomplished by sending a no-op memory write of zero length
8453 to the target at the specified address. It does not suffice to send
8454 the whole packet, since many stubs strip the eighth bit and
8455 subsequently compute a wrong checksum, which causes real havoc with
8458 NOTE: This can still lose if the serial line is not eight-bit
8459 clean. In cases like this, the user should clear "remote
8463 remote_target::check_binary_download (CORE_ADDR addr)
8465 struct remote_state *rs = get_remote_state ();
8467 switch (packet_support (PACKET_X))
8469 case PACKET_DISABLE:
8473 case PACKET_SUPPORT_UNKNOWN:
8479 p += hexnumstr (p, (ULONGEST) addr);
8481 p += hexnumstr (p, (ULONGEST) 0);
8485 putpkt_binary (rs->buf, (int) (p - rs->buf));
8486 getpkt (&rs->buf, &rs->buf_size, 0);
8488 if (rs->buf[0] == '\0')
8491 fprintf_unfiltered (gdb_stdlog,
8492 "binary downloading NOT "
8493 "supported by target\n");
8494 remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
8499 fprintf_unfiltered (gdb_stdlog,
8500 "binary downloading supported by target\n");
8501 remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
8508 /* Helper function to resize the payload in order to try to get a good
8509 alignment. We try to write an amount of data such that the next write will
8510 start on an address aligned on REMOTE_ALIGN_WRITES. */
8513 align_for_efficient_write (int todo, CORE_ADDR memaddr)
8515 return ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr;
8518 /* Write memory data directly to the remote machine.
8519 This does not inform the data cache; the data cache uses this.
8520 HEADER is the starting part of the packet.
8521 MEMADDR is the address in the remote memory space.
8522 MYADDR is the address of the buffer in our space.
8523 LEN_UNITS is the number of addressable units to write.
8524 UNIT_SIZE is the length in bytes of an addressable unit.
8525 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8526 should send data as binary ('X'), or hex-encoded ('M').
8528 The function creates packet of the form
8529 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8531 where encoding of <DATA> is terminated by PACKET_FORMAT.
8533 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8536 Return the transferred status, error or OK (an
8537 'enum target_xfer_status' value). Save the number of addressable units
8538 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8540 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8541 exchange between gdb and the stub could look like (?? in place of the
8547 -> $M1000,3:eeeeffffeeee#??
8551 <- eeeeffffeeeedddd */
8554 remote_target::remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
8555 const gdb_byte *myaddr,
8558 ULONGEST *xfered_len_units,
8559 char packet_format, int use_length)
8561 struct remote_state *rs = get_remote_state ();
8567 int payload_capacity_bytes;
8568 int payload_length_bytes;
8570 if (packet_format != 'X' && packet_format != 'M')
8571 internal_error (__FILE__, __LINE__,
8572 _("remote_write_bytes_aux: bad packet format"));
8575 return TARGET_XFER_EOF;
8577 payload_capacity_bytes = get_memory_write_packet_size ();
8579 /* The packet buffer will be large enough for the payload;
8580 get_memory_packet_size ensures this. */
8583 /* Compute the size of the actual payload by subtracting out the
8584 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8586 payload_capacity_bytes -= strlen ("$,:#NN");
8588 /* The comma won't be used. */
8589 payload_capacity_bytes += 1;
8590 payload_capacity_bytes -= strlen (header);
8591 payload_capacity_bytes -= hexnumlen (memaddr);
8593 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8595 strcat (rs->buf, header);
8596 p = rs->buf + strlen (header);
8598 /* Compute a best guess of the number of bytes actually transfered. */
8599 if (packet_format == 'X')
8601 /* Best guess at number of bytes that will fit. */
8602 todo_units = std::min (len_units,
8603 (ULONGEST) payload_capacity_bytes / unit_size);
8605 payload_capacity_bytes -= hexnumlen (todo_units);
8606 todo_units = std::min (todo_units, payload_capacity_bytes / unit_size);
8610 /* Number of bytes that will fit. */
8612 = std::min (len_units,
8613 (ULONGEST) (payload_capacity_bytes / unit_size) / 2);
8615 payload_capacity_bytes -= hexnumlen (todo_units);
8616 todo_units = std::min (todo_units,
8617 (payload_capacity_bytes / unit_size) / 2);
8620 if (todo_units <= 0)
8621 internal_error (__FILE__, __LINE__,
8622 _("minimum packet size too small to write data"));
8624 /* If we already need another packet, then try to align the end
8625 of this packet to a useful boundary. */
8626 if (todo_units > 2 * REMOTE_ALIGN_WRITES && todo_units < len_units)
8627 todo_units = align_for_efficient_write (todo_units, memaddr);
8629 /* Append "<memaddr>". */
8630 memaddr = remote_address_masked (memaddr);
8631 p += hexnumstr (p, (ULONGEST) memaddr);
8638 /* Append the length and retain its location and size. It may need to be
8639 adjusted once the packet body has been created. */
8641 plenlen = hexnumstr (p, (ULONGEST) todo_units);
8649 /* Append the packet body. */
8650 if (packet_format == 'X')
8652 /* Binary mode. Send target system values byte by byte, in
8653 increasing byte addresses. Only escape certain critical
8655 payload_length_bytes =
8656 remote_escape_output (myaddr, todo_units, unit_size, (gdb_byte *) p,
8657 &units_written, payload_capacity_bytes);
8659 /* If not all TODO units fit, then we'll need another packet. Make
8660 a second try to keep the end of the packet aligned. Don't do
8661 this if the packet is tiny. */
8662 if (units_written < todo_units && units_written > 2 * REMOTE_ALIGN_WRITES)
8666 new_todo_units = align_for_efficient_write (units_written, memaddr);
8668 if (new_todo_units != units_written)
8669 payload_length_bytes =
8670 remote_escape_output (myaddr, new_todo_units, unit_size,
8671 (gdb_byte *) p, &units_written,
8672 payload_capacity_bytes);
8675 p += payload_length_bytes;
8676 if (use_length && units_written < todo_units)
8678 /* Escape chars have filled up the buffer prematurely,
8679 and we have actually sent fewer units than planned.
8680 Fix-up the length field of the packet. Use the same
8681 number of characters as before. */
8682 plen += hexnumnstr (plen, (ULONGEST) units_written,
8684 *plen = ':'; /* overwrite \0 from hexnumnstr() */
8689 /* Normal mode: Send target system values byte by byte, in
8690 increasing byte addresses. Each byte is encoded as a two hex
8692 p += 2 * bin2hex (myaddr, p, todo_units * unit_size);
8693 units_written = todo_units;
8696 putpkt_binary (rs->buf, (int) (p - rs->buf));
8697 getpkt (&rs->buf, &rs->buf_size, 0);
8699 if (rs->buf[0] == 'E')
8700 return TARGET_XFER_E_IO;
8702 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8703 send fewer units than we'd planned. */
8704 *xfered_len_units = (ULONGEST) units_written;
8705 return (*xfered_len_units != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
8708 /* Write memory data directly to the remote machine.
8709 This does not inform the data cache; the data cache uses this.
8710 MEMADDR is the address in the remote memory space.
8711 MYADDR is the address of the buffer in our space.
8712 LEN is the number of bytes.
8714 Return the transferred status, error or OK (an
8715 'enum target_xfer_status' value). Save the number of bytes
8716 transferred in *XFERED_LEN. Only transfer a single packet. */
8719 remote_target::remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr,
8720 ULONGEST len, int unit_size,
8721 ULONGEST *xfered_len)
8723 const char *packet_format = NULL;
8725 /* Check whether the target supports binary download. */
8726 check_binary_download (memaddr);
8728 switch (packet_support (PACKET_X))
8731 packet_format = "X";
8733 case PACKET_DISABLE:
8734 packet_format = "M";
8736 case PACKET_SUPPORT_UNKNOWN:
8737 internal_error (__FILE__, __LINE__,
8738 _("remote_write_bytes: bad internal state"));
8740 internal_error (__FILE__, __LINE__, _("bad switch"));
8743 return remote_write_bytes_aux (packet_format,
8744 memaddr, myaddr, len, unit_size, xfered_len,
8745 packet_format[0], 1);
8748 /* Read memory data directly from the remote machine.
8749 This does not use the data cache; the data cache uses this.
8750 MEMADDR is the address in the remote memory space.
8751 MYADDR is the address of the buffer in our space.
8752 LEN_UNITS is the number of addressable memory units to read..
8753 UNIT_SIZE is the length in bytes of an addressable unit.
8755 Return the transferred status, error or OK (an
8756 'enum target_xfer_status' value). Save the number of bytes
8757 transferred in *XFERED_LEN_UNITS.
8759 See the comment of remote_write_bytes_aux for an example of
8760 memory read/write exchange between gdb and the stub. */
8763 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr,
8765 int unit_size, ULONGEST *xfered_len_units)
8767 struct remote_state *rs = get_remote_state ();
8768 int buf_size_bytes; /* Max size of packet output buffer. */
8773 buf_size_bytes = get_memory_read_packet_size ();
8774 /* The packet buffer will be large enough for the payload;
8775 get_memory_packet_size ensures this. */
8777 /* Number of units that will fit. */
8778 todo_units = std::min (len_units,
8779 (ULONGEST) (buf_size_bytes / unit_size) / 2);
8781 /* Construct "m"<memaddr>","<len>". */
8782 memaddr = remote_address_masked (memaddr);
8785 p += hexnumstr (p, (ULONGEST) memaddr);
8787 p += hexnumstr (p, (ULONGEST) todo_units);
8790 getpkt (&rs->buf, &rs->buf_size, 0);
8791 if (rs->buf[0] == 'E'
8792 && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
8793 && rs->buf[3] == '\0')
8794 return TARGET_XFER_E_IO;
8795 /* Reply describes memory byte by byte, each byte encoded as two hex
8798 decoded_bytes = hex2bin (p, myaddr, todo_units * unit_size);
8799 /* Return what we have. Let higher layers handle partial reads. */
8800 *xfered_len_units = (ULONGEST) (decoded_bytes / unit_size);
8801 return (*xfered_len_units != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
8804 /* Using the set of read-only target sections of remote, read live
8807 For interface/parameters/return description see target.h,
8811 remote_target::remote_xfer_live_readonly_partial (gdb_byte *readbuf,
8815 ULONGEST *xfered_len)
8817 struct target_section *secp;
8818 struct target_section_table *table;
8820 secp = target_section_by_addr (this, memaddr);
8822 && (bfd_get_section_flags (secp->the_bfd_section->owner,
8823 secp->the_bfd_section)
8826 struct target_section *p;
8827 ULONGEST memend = memaddr + len;
8829 table = target_get_section_table (this);
8831 for (p = table->sections; p < table->sections_end; p++)
8833 if (memaddr >= p->addr)
8835 if (memend <= p->endaddr)
8837 /* Entire transfer is within this section. */
8838 return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
8841 else if (memaddr >= p->endaddr)
8843 /* This section ends before the transfer starts. */
8848 /* This section overlaps the transfer. Just do half. */
8849 len = p->endaddr - memaddr;
8850 return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
8857 return TARGET_XFER_EOF;
8860 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8861 first if the requested memory is unavailable in traceframe.
8862 Otherwise, fall back to remote_read_bytes_1. */
8865 remote_target::remote_read_bytes (CORE_ADDR memaddr,
8866 gdb_byte *myaddr, ULONGEST len, int unit_size,
8867 ULONGEST *xfered_len)
8870 return TARGET_XFER_EOF;
8872 if (get_traceframe_number () != -1)
8874 std::vector<mem_range> available;
8876 /* If we fail to get the set of available memory, then the
8877 target does not support querying traceframe info, and so we
8878 attempt reading from the traceframe anyway (assuming the
8879 target implements the old QTro packet then). */
8880 if (traceframe_available_memory (&available, memaddr, len))
8882 if (available.empty () || available[0].start != memaddr)
8884 enum target_xfer_status res;
8886 /* Don't read into the traceframe's available
8888 if (!available.empty ())
8890 LONGEST oldlen = len;
8892 len = available[0].start - memaddr;
8893 gdb_assert (len <= oldlen);
8896 /* This goes through the topmost target again. */
8897 res = remote_xfer_live_readonly_partial (myaddr, memaddr,
8898 len, unit_size, xfered_len);
8899 if (res == TARGET_XFER_OK)
8900 return TARGET_XFER_OK;
8903 /* No use trying further, we know some memory starting
8904 at MEMADDR isn't available. */
8906 return (*xfered_len != 0) ?
8907 TARGET_XFER_UNAVAILABLE : TARGET_XFER_EOF;
8911 /* Don't try to read more than how much is available, in
8912 case the target implements the deprecated QTro packet to
8913 cater for older GDBs (the target's knowledge of read-only
8914 sections may be outdated by now). */
8915 len = available[0].length;
8919 return remote_read_bytes_1 (memaddr, myaddr, len, unit_size, xfered_len);
8924 /* Sends a packet with content determined by the printf format string
8925 FORMAT and the remaining arguments, then gets the reply. Returns
8926 whether the packet was a success, a failure, or unknown. */
8929 remote_target::remote_send_printf (const char *format, ...)
8931 struct remote_state *rs = get_remote_state ();
8932 int max_size = get_remote_packet_size ();
8935 va_start (ap, format);
8938 if (vsnprintf (rs->buf, max_size, format, ap) >= max_size)
8939 internal_error (__FILE__, __LINE__, _("Too long remote packet."));
8941 if (putpkt (rs->buf) < 0)
8942 error (_("Communication problem with target."));
8945 getpkt (&rs->buf, &rs->buf_size, 0);
8947 return packet_check_result (rs->buf);
8950 /* Flash writing can take quite some time. We'll set
8951 effectively infinite timeout for flash operations.
8952 In future, we'll need to decide on a better approach. */
8953 static const int remote_flash_timeout = 1000;
8956 remote_target::flash_erase (ULONGEST address, LONGEST length)
8958 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
8959 enum packet_result ret;
8960 scoped_restore restore_timeout
8961 = make_scoped_restore (&remote_timeout, remote_flash_timeout);
8963 ret = remote_send_printf ("vFlashErase:%s,%s",
8964 phex (address, addr_size),
8968 case PACKET_UNKNOWN:
8969 error (_("Remote target does not support flash erase"));
8971 error (_("Error erasing flash with vFlashErase packet"));
8978 remote_target::remote_flash_write (ULONGEST address,
8979 ULONGEST length, ULONGEST *xfered_len,
8980 const gdb_byte *data)
8982 scoped_restore restore_timeout
8983 = make_scoped_restore (&remote_timeout, remote_flash_timeout);
8984 return remote_write_bytes_aux ("vFlashWrite:", address, data, length, 1,
8989 remote_target::flash_done ()
8993 scoped_restore restore_timeout
8994 = make_scoped_restore (&remote_timeout, remote_flash_timeout);
8996 ret = remote_send_printf ("vFlashDone");
9000 case PACKET_UNKNOWN:
9001 error (_("Remote target does not support vFlashDone"));
9003 error (_("Error finishing flash operation"));
9010 remote_target::files_info ()
9012 puts_filtered ("Debugging a target over a serial line.\n");
9015 /* Stuff for dealing with the packets which are part of this protocol.
9016 See comment at top of file for details. */
9018 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
9019 error to higher layers. Called when a serial error is detected.
9020 The exception message is STRING, followed by a colon and a blank,
9021 the system error message for errno at function entry and final dot
9022 for output compatibility with throw_perror_with_name. */
9025 unpush_and_perror (const char *string)
9027 int saved_errno = errno;
9029 remote_unpush_target ();
9030 throw_error (TARGET_CLOSE_ERROR, "%s: %s.", string,
9031 safe_strerror (saved_errno));
9034 /* Read a single character from the remote end. The current quit
9035 handler is overridden to avoid quitting in the middle of packet
9036 sequence, as that would break communication with the remote server.
9037 See remote_serial_quit_handler for more detail. */
9040 remote_target::readchar (int timeout)
9043 struct remote_state *rs = get_remote_state ();
9046 scoped_restore restore_quit_target
9047 = make_scoped_restore (&curr_quit_handler_target, this);
9048 scoped_restore restore_quit
9049 = make_scoped_restore (&quit_handler, ::remote_serial_quit_handler);
9051 rs->got_ctrlc_during_io = 0;
9053 ch = serial_readchar (rs->remote_desc, timeout);
9055 if (rs->got_ctrlc_during_io)
9062 switch ((enum serial_rc) ch)
9065 remote_unpush_target ();
9066 throw_error (TARGET_CLOSE_ERROR, _("Remote connection closed"));
9069 unpush_and_perror (_("Remote communication error. "
9070 "Target disconnected."));
9072 case SERIAL_TIMEOUT:
9078 /* Wrapper for serial_write that closes the target and throws if
9079 writing fails. The current quit handler is overridden to avoid
9080 quitting in the middle of packet sequence, as that would break
9081 communication with the remote server. See
9082 remote_serial_quit_handler for more detail. */
9085 remote_target::remote_serial_write (const char *str, int len)
9087 struct remote_state *rs = get_remote_state ();
9089 scoped_restore restore_quit_target
9090 = make_scoped_restore (&curr_quit_handler_target, this);
9091 scoped_restore restore_quit
9092 = make_scoped_restore (&quit_handler, ::remote_serial_quit_handler);
9094 rs->got_ctrlc_during_io = 0;
9096 if (serial_write (rs->remote_desc, str, len))
9098 unpush_and_perror (_("Remote communication error. "
9099 "Target disconnected."));
9102 if (rs->got_ctrlc_during_io)
9106 /* Return a string representing an escaped version of BUF, of len N.
9107 E.g. \n is converted to \\n, \t to \\t, etc. */
9110 escape_buffer (const char *buf, int n)
9114 stb.putstrn (buf, n, '\\');
9115 return std::move (stb.string ());
9118 /* Display a null-terminated packet on stdout, for debugging, using C
9122 print_packet (const char *buf)
9124 puts_filtered ("\"");
9125 fputstr_filtered (buf, '"', gdb_stdout);
9126 puts_filtered ("\"");
9130 remote_target::putpkt (const char *buf)
9132 return putpkt_binary (buf, strlen (buf));
9135 /* Wrapper around remote_target::putpkt to avoid exporting
9139 putpkt (remote_target *remote, const char *buf)
9141 return remote->putpkt (buf);
9144 /* Send a packet to the remote machine, with error checking. The data
9145 of the packet is in BUF. The string in BUF can be at most
9146 get_remote_packet_size () - 5 to account for the $, # and checksum,
9147 and for a possible /0 if we are debugging (remote_debug) and want
9148 to print the sent packet as a string. */
9151 remote_target::putpkt_binary (const char *buf, int cnt)
9153 struct remote_state *rs = get_remote_state ();
9155 unsigned char csum = 0;
9156 gdb::def_vector<char> data (cnt + 6);
9157 char *buf2 = data.data ();
9163 /* Catch cases like trying to read memory or listing threads while
9164 we're waiting for a stop reply. The remote server wouldn't be
9165 ready to handle this request, so we'd hang and timeout. We don't
9166 have to worry about this in synchronous mode, because in that
9167 case it's not possible to issue a command while the target is
9168 running. This is not a problem in non-stop mode, because in that
9169 case, the stub is always ready to process serial input. */
9170 if (!target_is_non_stop_p ()
9171 && target_is_async_p ()
9172 && rs->waiting_for_stop_reply)
9174 error (_("Cannot execute this command while the target is running.\n"
9175 "Use the \"interrupt\" command to stop the target\n"
9176 "and then try again."));
9179 /* We're sending out a new packet. Make sure we don't look at a
9180 stale cached response. */
9181 rs->cached_wait_status = 0;
9183 /* Copy the packet into buffer BUF2, encapsulating it
9184 and giving it a checksum. */
9189 for (i = 0; i < cnt; i++)
9195 *p++ = tohex ((csum >> 4) & 0xf);
9196 *p++ = tohex (csum & 0xf);
9198 /* Send it over and over until we get a positive ack. */
9202 int started_error_output = 0;
9208 int len = (int) (p - buf2);
9211 = escape_buffer (buf2, std::min (len, REMOTE_DEBUG_MAX_CHAR));
9213 fprintf_unfiltered (gdb_stdlog, "Sending packet: %s", str.c_str ());
9215 if (len > REMOTE_DEBUG_MAX_CHAR)
9216 fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]",
9217 len - REMOTE_DEBUG_MAX_CHAR);
9219 fprintf_unfiltered (gdb_stdlog, "...");
9221 gdb_flush (gdb_stdlog);
9223 remote_serial_write (buf2, p - buf2);
9225 /* If this is a no acks version of the remote protocol, send the
9226 packet and move on. */
9230 /* Read until either a timeout occurs (-2) or '+' is read.
9231 Handle any notification that arrives in the mean time. */
9234 ch = readchar (remote_timeout);
9242 case SERIAL_TIMEOUT:
9245 if (started_error_output)
9247 putchar_unfiltered ('\n');
9248 started_error_output = 0;
9257 fprintf_unfiltered (gdb_stdlog, "Ack\n");
9261 fprintf_unfiltered (gdb_stdlog, "Nak\n");
9263 case SERIAL_TIMEOUT:
9267 break; /* Retransmit buffer. */
9271 fprintf_unfiltered (gdb_stdlog,
9272 "Packet instead of Ack, ignoring it\n");
9273 /* It's probably an old response sent because an ACK
9274 was lost. Gobble up the packet and ack it so it
9275 doesn't get retransmitted when we resend this
9278 remote_serial_write ("+", 1);
9279 continue; /* Now, go look for +. */
9286 /* If we got a notification, handle it, and go back to looking
9288 /* We've found the start of a notification. Now
9289 collect the data. */
9290 val = read_frame (&rs->buf, &rs->buf_size);
9295 std::string str = escape_buffer (rs->buf, val);
9297 fprintf_unfiltered (gdb_stdlog,
9298 " Notification received: %s\n",
9301 handle_notification (rs->notif_state, rs->buf);
9302 /* We're in sync now, rewait for the ack. */
9309 if (!started_error_output)
9311 started_error_output = 1;
9312 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
9314 fputc_unfiltered (ch & 0177, gdb_stdlog);
9315 fprintf_unfiltered (gdb_stdlog, "%s", rs->buf);
9324 if (!started_error_output)
9326 started_error_output = 1;
9327 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
9329 fputc_unfiltered (ch & 0177, gdb_stdlog);
9333 break; /* Here to retransmit. */
9337 /* This is wrong. If doing a long backtrace, the user should be
9338 able to get out next time we call QUIT, without anything as
9339 violent as interrupt_query. If we want to provide a way out of
9340 here without getting to the next QUIT, it should be based on
9341 hitting ^C twice as in remote_wait. */
9353 /* Come here after finding the start of a frame when we expected an
9354 ack. Do our best to discard the rest of this packet. */
9357 remote_target::skip_frame ()
9363 c = readchar (remote_timeout);
9366 case SERIAL_TIMEOUT:
9367 /* Nothing we can do. */
9370 /* Discard the two bytes of checksum and stop. */
9371 c = readchar (remote_timeout);
9373 c = readchar (remote_timeout);
9376 case '*': /* Run length encoding. */
9377 /* Discard the repeat count. */
9378 c = readchar (remote_timeout);
9383 /* A regular character. */
9389 /* Come here after finding the start of the frame. Collect the rest
9390 into *BUF, verifying the checksum, length, and handling run-length
9391 compression. NUL terminate the buffer. If there is not enough room,
9392 expand *BUF using xrealloc.
9394 Returns -1 on error, number of characters in buffer (ignoring the
9395 trailing NULL) on success. (could be extended to return one of the
9396 SERIAL status indications). */
9399 remote_target::read_frame (char **buf_p, long *sizeof_buf)
9405 struct remote_state *rs = get_remote_state ();
9412 c = readchar (remote_timeout);
9415 case SERIAL_TIMEOUT:
9417 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
9421 fputs_filtered ("Saw new packet start in middle of old one\n",
9423 return -1; /* Start a new packet, count retries. */
9426 unsigned char pktcsum;
9432 check_0 = readchar (remote_timeout);
9434 check_1 = readchar (remote_timeout);
9436 if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
9439 fputs_filtered ("Timeout in checksum, retrying\n",
9443 else if (check_0 < 0 || check_1 < 0)
9446 fputs_filtered ("Communication error in checksum\n",
9451 /* Don't recompute the checksum; with no ack packets we
9452 don't have any way to indicate a packet retransmission
9457 pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
9458 if (csum == pktcsum)
9463 std::string str = escape_buffer (buf, bc);
9465 fprintf_unfiltered (gdb_stdlog,
9466 "Bad checksum, sentsum=0x%x, "
9467 "csum=0x%x, buf=%s\n",
9468 pktcsum, csum, str.c_str ());
9470 /* Number of characters in buffer ignoring trailing
9474 case '*': /* Run length encoding. */
9479 c = readchar (remote_timeout);
9481 repeat = c - ' ' + 3; /* Compute repeat count. */
9483 /* The character before ``*'' is repeated. */
9485 if (repeat > 0 && repeat <= 255 && bc > 0)
9487 if (bc + repeat - 1 >= *sizeof_buf - 1)
9489 /* Make some more room in the buffer. */
9490 *sizeof_buf += repeat;
9491 *buf_p = (char *) xrealloc (*buf_p, *sizeof_buf);
9495 memset (&buf[bc], buf[bc - 1], repeat);
9501 printf_filtered (_("Invalid run length encoding: %s\n"), buf);
9505 if (bc >= *sizeof_buf - 1)
9507 /* Make some more room in the buffer. */
9509 *buf_p = (char *) xrealloc (*buf_p, *sizeof_buf);
9520 /* Read a packet from the remote machine, with error checking, and
9521 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9522 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9523 rather than timing out; this is used (in synchronous mode) to wait
9524 for a target that is is executing user code to stop. */
9525 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9526 don't have to change all the calls to getpkt to deal with the
9527 return value, because at the moment I don't know what the right
9528 thing to do it for those. */
9531 remote_target::getpkt (char **buf, long *sizeof_buf, int forever)
9533 getpkt_sane (buf, sizeof_buf, forever);
9537 /* Read a packet from the remote machine, with error checking, and
9538 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9539 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9540 rather than timing out; this is used (in synchronous mode) to wait
9541 for a target that is is executing user code to stop. If FOREVER ==
9542 0, this function is allowed to time out gracefully and return an
9543 indication of this to the caller. Otherwise return the number of
9544 bytes read. If EXPECTING_NOTIF, consider receiving a notification
9545 enough reason to return to the caller. *IS_NOTIF is an output
9546 boolean that indicates whether *BUF holds a notification or not
9547 (a regular packet). */
9550 remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf,
9551 int forever, int expecting_notif,
9554 struct remote_state *rs = get_remote_state ();
9560 /* We're reading a new response. Make sure we don't look at a
9561 previously cached response. */
9562 rs->cached_wait_status = 0;
9564 strcpy (*buf, "timeout");
9567 timeout = watchdog > 0 ? watchdog : -1;
9568 else if (expecting_notif)
9569 timeout = 0; /* There should already be a char in the buffer. If
9572 timeout = remote_timeout;
9576 /* Process any number of notifications, and then return when
9580 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9582 for (tries = 1; tries <= MAX_TRIES; tries++)
9584 /* This can loop forever if the remote side sends us
9585 characters continuously, but if it pauses, we'll get
9586 SERIAL_TIMEOUT from readchar because of timeout. Then
9587 we'll count that as a retry.
9589 Note that even when forever is set, we will only wait
9590 forever prior to the start of a packet. After that, we
9591 expect characters to arrive at a brisk pace. They should
9592 show up within remote_timeout intervals. */
9594 c = readchar (timeout);
9595 while (c != SERIAL_TIMEOUT && c != '$' && c != '%');
9597 if (c == SERIAL_TIMEOUT)
9599 if (expecting_notif)
9600 return -1; /* Don't complain, it's normal to not get
9601 anything in this case. */
9603 if (forever) /* Watchdog went off? Kill the target. */
9605 remote_unpush_target ();
9606 throw_error (TARGET_CLOSE_ERROR,
9607 _("Watchdog timeout has expired. "
9608 "Target detached."));
9611 fputs_filtered ("Timed out.\n", gdb_stdlog);
9615 /* We've found the start of a packet or notification.
9616 Now collect the data. */
9617 val = read_frame (buf, sizeof_buf);
9622 remote_serial_write ("-", 1);
9625 if (tries > MAX_TRIES)
9627 /* We have tried hard enough, and just can't receive the
9628 packet/notification. Give up. */
9629 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9631 /* Skip the ack char if we're in no-ack mode. */
9632 if (!rs->noack_mode)
9633 remote_serial_write ("+", 1);
9637 /* If we got an ordinary packet, return that to our caller. */
9643 = escape_buffer (*buf,
9644 std::min (val, REMOTE_DEBUG_MAX_CHAR));
9646 fprintf_unfiltered (gdb_stdlog, "Packet received: %s",
9649 if (val > REMOTE_DEBUG_MAX_CHAR)
9650 fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]",
9651 val - REMOTE_DEBUG_MAX_CHAR);
9653 fprintf_unfiltered (gdb_stdlog, "\n");
9656 /* Skip the ack char if we're in no-ack mode. */
9657 if (!rs->noack_mode)
9658 remote_serial_write ("+", 1);
9659 if (is_notif != NULL)
9664 /* If we got a notification, handle it, and go back to looking
9668 gdb_assert (c == '%');
9672 std::string str = escape_buffer (*buf, val);
9674 fprintf_unfiltered (gdb_stdlog,
9675 " Notification received: %s\n",
9678 if (is_notif != NULL)
9681 handle_notification (rs->notif_state, *buf);
9683 /* Notifications require no acknowledgement. */
9685 if (expecting_notif)
9692 remote_target::getpkt_sane (char **buf, long *sizeof_buf, int forever)
9694 return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 0, NULL);
9698 remote_target::getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever,
9701 return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 1,
9705 /* Kill any new fork children of process PID that haven't been
9706 processed by follow_fork. */
9709 remote_target::kill_new_fork_children (int pid)
9711 remote_state *rs = get_remote_state ();
9712 struct thread_info *thread;
9713 struct notif_client *notif = ¬if_client_stop;
9715 /* Kill the fork child threads of any threads in process PID
9716 that are stopped at a fork event. */
9717 ALL_NON_EXITED_THREADS (thread)
9719 struct target_waitstatus *ws = &thread->pending_follow;
9721 if (is_pending_fork_parent (ws, pid, thread->ptid))
9723 int child_pid = ws->value.related_pid.pid ();
9726 res = remote_vkill (child_pid);
9728 error (_("Can't kill fork child process %d"), child_pid);
9732 /* Check for any pending fork events (not reported or processed yet)
9733 in process PID and kill those fork child threads as well. */
9734 remote_notif_get_pending_events (notif);
9735 for (auto &event : rs->stop_reply_queue)
9736 if (is_pending_fork_parent (&event->ws, pid, event->ptid))
9738 int child_pid = event->ws.value.related_pid.pid ();
9741 res = remote_vkill (child_pid);
9743 error (_("Can't kill fork child process %d"), child_pid);
9748 /* Target hook to kill the current inferior. */
9751 remote_target::kill ()
9754 int pid = inferior_ptid.pid ();
9755 struct remote_state *rs = get_remote_state ();
9757 if (packet_support (PACKET_vKill) != PACKET_DISABLE)
9759 /* If we're stopped while forking and we haven't followed yet,
9760 kill the child task. We need to do this before killing the
9761 parent task because if this is a vfork then the parent will
9763 kill_new_fork_children (pid);
9765 res = remote_vkill (pid);
9768 target_mourn_inferior (inferior_ptid);
9773 /* If we are in 'target remote' mode and we are killing the only
9774 inferior, then we will tell gdbserver to exit and unpush the
9776 if (res == -1 && !remote_multi_process_p (rs)
9777 && number_of_live_inferiors () == 1)
9781 /* We've killed the remote end, we get to mourn it. If we are
9782 not in extended mode, mourning the inferior also unpushes
9783 remote_ops from the target stack, which closes the remote
9785 target_mourn_inferior (inferior_ptid);
9790 error (_("Can't kill process"));
9793 /* Send a kill request to the target using the 'vKill' packet. */
9796 remote_target::remote_vkill (int pid)
9798 if (packet_support (PACKET_vKill) == PACKET_DISABLE)
9801 remote_state *rs = get_remote_state ();
9803 /* Tell the remote target to detach. */
9804 xsnprintf (rs->buf, get_remote_packet_size (), "vKill;%x", pid);
9806 getpkt (&rs->buf, &rs->buf_size, 0);
9808 switch (packet_ok (rs->buf,
9809 &remote_protocol_packets[PACKET_vKill]))
9815 case PACKET_UNKNOWN:
9818 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
9822 /* Send a kill request to the target using the 'k' packet. */
9825 remote_target::remote_kill_k ()
9827 /* Catch errors so the user can quit from gdb even when we
9828 aren't on speaking terms with the remote system. */
9833 CATCH (ex, RETURN_MASK_ERROR)
9835 if (ex.error == TARGET_CLOSE_ERROR)
9837 /* If we got an (EOF) error that caused the target
9838 to go away, then we're done, that's what we wanted.
9839 "k" is susceptible to cause a premature EOF, given
9840 that the remote server isn't actually required to
9841 reply to "k", and it can happen that it doesn't
9842 even get to reply ACK to the "k". */
9846 /* Otherwise, something went wrong. We didn't actually kill
9847 the target. Just propagate the exception, and let the
9848 user or higher layers decide what to do. */
9849 throw_exception (ex);
9855 remote_target::mourn_inferior ()
9857 struct remote_state *rs = get_remote_state ();
9859 /* We're no longer interested in notification events of an inferior
9860 that exited or was killed/detached. */
9861 discard_pending_stop_replies (current_inferior ());
9863 /* In 'target remote' mode with one inferior, we close the connection. */
9864 if (!rs->extended && number_of_live_inferiors () <= 1)
9866 unpush_target (this);
9868 /* remote_close takes care of doing most of the clean up. */
9869 generic_mourn_inferior ();
9873 /* In case we got here due to an error, but we're going to stay
9875 rs->waiting_for_stop_reply = 0;
9877 /* If the current general thread belonged to the process we just
9878 detached from or has exited, the remote side current general
9879 thread becomes undefined. Considering a case like this:
9881 - We just got here due to a detach.
9882 - The process that we're detaching from happens to immediately
9883 report a global breakpoint being hit in non-stop mode, in the
9884 same thread we had selected before.
9885 - GDB attaches to this process again.
9886 - This event happens to be the next event we handle.
9888 GDB would consider that the current general thread didn't need to
9889 be set on the stub side (with Hg), since for all it knew,
9890 GENERAL_THREAD hadn't changed.
9892 Notice that although in all-stop mode, the remote server always
9893 sets the current thread to the thread reporting the stop event,
9894 that doesn't happen in non-stop mode; in non-stop, the stub *must
9895 not* change the current thread when reporting a breakpoint hit,
9896 due to the decoupling of event reporting and event handling.
9898 To keep things simple, we always invalidate our notion of the
9900 record_currthread (rs, minus_one_ptid);
9902 /* Call common code to mark the inferior as not running. */
9903 generic_mourn_inferior ();
9905 if (!have_inferiors ())
9907 if (!remote_multi_process_p (rs))
9909 /* Check whether the target is running now - some remote stubs
9910 automatically restart after kill. */
9912 getpkt (&rs->buf, &rs->buf_size, 0);
9914 if (rs->buf[0] == 'S' || rs->buf[0] == 'T')
9916 /* Assume that the target has been restarted. Set
9917 inferior_ptid so that bits of core GDB realizes
9918 there's something here, e.g., so that the user can
9919 say "kill" again. */
9920 inferior_ptid = magic_null_ptid;
9927 extended_remote_target::supports_disable_randomization ()
9929 return packet_support (PACKET_QDisableRandomization) == PACKET_ENABLE;
9933 remote_target::extended_remote_disable_randomization (int val)
9935 struct remote_state *rs = get_remote_state ();
9938 xsnprintf (rs->buf, get_remote_packet_size (), "QDisableRandomization:%x",
9941 reply = remote_get_noisy_reply ();
9943 error (_("Target does not support QDisableRandomization."));
9944 if (strcmp (reply, "OK") != 0)
9945 error (_("Bogus QDisableRandomization reply from target: %s"), reply);
9949 remote_target::extended_remote_run (const std::string &args)
9951 struct remote_state *rs = get_remote_state ();
9953 const char *remote_exec_file = get_remote_exec_file ();
9955 /* If the user has disabled vRun support, or we have detected that
9956 support is not available, do not try it. */
9957 if (packet_support (PACKET_vRun) == PACKET_DISABLE)
9960 strcpy (rs->buf, "vRun;");
9961 len = strlen (rs->buf);
9963 if (strlen (remote_exec_file) * 2 + len >= get_remote_packet_size ())
9964 error (_("Remote file name too long for run packet"));
9965 len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf + len,
9966 strlen (remote_exec_file));
9972 gdb_argv argv (args.c_str ());
9973 for (i = 0; argv[i] != NULL; i++)
9975 if (strlen (argv[i]) * 2 + 1 + len >= get_remote_packet_size ())
9976 error (_("Argument list too long for run packet"));
9977 rs->buf[len++] = ';';
9978 len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf + len,
9983 rs->buf[len++] = '\0';
9986 getpkt (&rs->buf, &rs->buf_size, 0);
9988 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun]))
9991 /* We have a wait response. All is well. */
9993 case PACKET_UNKNOWN:
9996 if (remote_exec_file[0] == '\0')
9997 error (_("Running the default executable on the remote target failed; "
9998 "try \"set remote exec-file\"?"));
10000 error (_("Running \"%s\" on the remote target failed"),
10003 gdb_assert_not_reached (_("bad switch"));
10007 /* Helper function to send set/unset environment packets. ACTION is
10008 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
10009 or "QEnvironmentUnsetVariable". VALUE is the variable to be
10013 remote_target::send_environment_packet (const char *action,
10014 const char *packet,
10017 remote_state *rs = get_remote_state ();
10019 /* Convert the environment variable to an hex string, which
10020 is the best format to be transmitted over the wire. */
10021 std::string encoded_value = bin2hex ((const gdb_byte *) value,
10024 xsnprintf (rs->buf, get_remote_packet_size (),
10025 "%s:%s", packet, encoded_value.c_str ());
10028 getpkt (&rs->buf, &rs->buf_size, 0);
10029 if (strcmp (rs->buf, "OK") != 0)
10030 warning (_("Unable to %s environment variable '%s' on remote."),
10034 /* Helper function to handle the QEnvironment* packets. */
10037 remote_target::extended_remote_environment_support ()
10039 remote_state *rs = get_remote_state ();
10041 if (packet_support (PACKET_QEnvironmentReset) != PACKET_DISABLE)
10043 putpkt ("QEnvironmentReset");
10044 getpkt (&rs->buf, &rs->buf_size, 0);
10045 if (strcmp (rs->buf, "OK") != 0)
10046 warning (_("Unable to reset environment on remote."));
10049 gdb_environ *e = ¤t_inferior ()->environment;
10051 if (packet_support (PACKET_QEnvironmentHexEncoded) != PACKET_DISABLE)
10052 for (const std::string &el : e->user_set_env ())
10053 send_environment_packet ("set", "QEnvironmentHexEncoded",
10056 if (packet_support (PACKET_QEnvironmentUnset) != PACKET_DISABLE)
10057 for (const std::string &el : e->user_unset_env ())
10058 send_environment_packet ("unset", "QEnvironmentUnset", el.c_str ());
10061 /* Helper function to set the current working directory for the
10062 inferior in the remote target. */
10065 remote_target::extended_remote_set_inferior_cwd ()
10067 if (packet_support (PACKET_QSetWorkingDir) != PACKET_DISABLE)
10069 const char *inferior_cwd = get_inferior_cwd ();
10070 remote_state *rs = get_remote_state ();
10072 if (inferior_cwd != NULL)
10074 std::string hexpath = bin2hex ((const gdb_byte *) inferior_cwd,
10075 strlen (inferior_cwd));
10077 xsnprintf (rs->buf, get_remote_packet_size (),
10078 "QSetWorkingDir:%s", hexpath.c_str ());
10082 /* An empty inferior_cwd means that the user wants us to
10083 reset the remote server's inferior's cwd. */
10084 xsnprintf (rs->buf, get_remote_packet_size (),
10085 "QSetWorkingDir:");
10089 getpkt (&rs->buf, &rs->buf_size, 0);
10090 if (packet_ok (rs->buf,
10091 &remote_protocol_packets[PACKET_QSetWorkingDir])
10094 Remote replied unexpectedly while setting the inferior's working\n\
10101 /* In the extended protocol we want to be able to do things like
10102 "run" and have them basically work as expected. So we need
10103 a special create_inferior function. We support changing the
10104 executable file and the command line arguments, but not the
10108 extended_remote_target::create_inferior (const char *exec_file,
10109 const std::string &args,
10110 char **env, int from_tty)
10114 struct remote_state *rs = get_remote_state ();
10115 const char *remote_exec_file = get_remote_exec_file ();
10117 /* If running asynchronously, register the target file descriptor
10118 with the event loop. */
10119 if (target_can_async_p ())
10122 /* Disable address space randomization if requested (and supported). */
10123 if (supports_disable_randomization ())
10124 extended_remote_disable_randomization (disable_randomization);
10126 /* If startup-with-shell is on, we inform gdbserver to start the
10127 remote inferior using a shell. */
10128 if (packet_support (PACKET_QStartupWithShell) != PACKET_DISABLE)
10130 xsnprintf (rs->buf, get_remote_packet_size (),
10131 "QStartupWithShell:%d", startup_with_shell ? 1 : 0);
10133 getpkt (&rs->buf, &rs->buf_size, 0);
10134 if (strcmp (rs->buf, "OK") != 0)
10136 Remote replied unexpectedly while setting startup-with-shell: %s"),
10140 extended_remote_environment_support ();
10142 extended_remote_set_inferior_cwd ();
10144 /* Now restart the remote server. */
10145 run_worked = extended_remote_run (args) != -1;
10148 /* vRun was not supported. Fail if we need it to do what the
10150 if (remote_exec_file[0])
10151 error (_("Remote target does not support \"set remote exec-file\""));
10152 if (!args.empty ())
10153 error (_("Remote target does not support \"set args\" or run <ARGS>"));
10155 /* Fall back to "R". */
10156 extended_remote_restart ();
10159 if (!have_inferiors ())
10161 /* Clean up from the last time we ran, before we mark the target
10162 running again. This will mark breakpoints uninserted, and
10163 get_offsets may insert breakpoints. */
10164 init_thread_list ();
10165 init_wait_for_inferior ();
10168 /* vRun's success return is a stop reply. */
10169 stop_reply = run_worked ? rs->buf : NULL;
10170 add_current_inferior_and_thread (stop_reply);
10172 /* Get updated offsets, if the stub uses qOffsets. */
10177 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10178 the list of conditions (in agent expression bytecode format), if any, the
10179 target needs to evaluate. The output is placed into the packet buffer
10180 started from BUF and ended at BUF_END. */
10183 remote_add_target_side_condition (struct gdbarch *gdbarch,
10184 struct bp_target_info *bp_tgt, char *buf,
10187 if (bp_tgt->conditions.empty ())
10190 buf += strlen (buf);
10191 xsnprintf (buf, buf_end - buf, "%s", ";");
10194 /* Send conditions to the target. */
10195 for (agent_expr *aexpr : bp_tgt->conditions)
10197 xsnprintf (buf, buf_end - buf, "X%x,", aexpr->len);
10198 buf += strlen (buf);
10199 for (int i = 0; i < aexpr->len; ++i)
10200 buf = pack_hex_byte (buf, aexpr->buf[i]);
10207 remote_add_target_side_commands (struct gdbarch *gdbarch,
10208 struct bp_target_info *bp_tgt, char *buf)
10210 if (bp_tgt->tcommands.empty ())
10213 buf += strlen (buf);
10215 sprintf (buf, ";cmds:%x,", bp_tgt->persist);
10216 buf += strlen (buf);
10218 /* Concatenate all the agent expressions that are commands into the
10220 for (agent_expr *aexpr : bp_tgt->tcommands)
10222 sprintf (buf, "X%x,", aexpr->len);
10223 buf += strlen (buf);
10224 for (int i = 0; i < aexpr->len; ++i)
10225 buf = pack_hex_byte (buf, aexpr->buf[i]);
10230 /* Insert a breakpoint. On targets that have software breakpoint
10231 support, we ask the remote target to do the work; on targets
10232 which don't, we insert a traditional memory breakpoint. */
10235 remote_target::insert_breakpoint (struct gdbarch *gdbarch,
10236 struct bp_target_info *bp_tgt)
10238 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10239 If it succeeds, then set the support to PACKET_ENABLE. If it
10240 fails, and the user has explicitly requested the Z support then
10241 report an error, otherwise, mark it disabled and go on. */
10243 if (packet_support (PACKET_Z0) != PACKET_DISABLE)
10245 CORE_ADDR addr = bp_tgt->reqstd_address;
10246 struct remote_state *rs;
10249 /* Make sure the remote is pointing at the right process, if
10251 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10252 set_general_process ();
10254 rs = get_remote_state ();
10256 endbuf = rs->buf + get_remote_packet_size ();
10261 addr = (ULONGEST) remote_address_masked (addr);
10262 p += hexnumstr (p, addr);
10263 xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind);
10265 if (supports_evaluation_of_breakpoint_conditions ())
10266 remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
10268 if (can_run_breakpoint_commands ())
10269 remote_add_target_side_commands (gdbarch, bp_tgt, p);
10272 getpkt (&rs->buf, &rs->buf_size, 0);
10274 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0]))
10280 case PACKET_UNKNOWN:
10285 /* If this breakpoint has target-side commands but this stub doesn't
10286 support Z0 packets, throw error. */
10287 if (!bp_tgt->tcommands.empty ())
10288 throw_error (NOT_SUPPORTED_ERROR, _("\
10289 Target doesn't support breakpoints that have target side commands."));
10291 return memory_insert_breakpoint (this, gdbarch, bp_tgt);
10295 remote_target::remove_breakpoint (struct gdbarch *gdbarch,
10296 struct bp_target_info *bp_tgt,
10297 enum remove_bp_reason reason)
10299 CORE_ADDR addr = bp_tgt->placed_address;
10300 struct remote_state *rs = get_remote_state ();
10302 if (packet_support (PACKET_Z0) != PACKET_DISABLE)
10305 char *endbuf = rs->buf + get_remote_packet_size ();
10307 /* Make sure the remote is pointing at the right process, if
10309 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10310 set_general_process ();
10316 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
10317 p += hexnumstr (p, addr);
10318 xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind);
10321 getpkt (&rs->buf, &rs->buf_size, 0);
10323 return (rs->buf[0] == 'E');
10326 return memory_remove_breakpoint (this, gdbarch, bp_tgt, reason);
10329 static enum Z_packet_type
10330 watchpoint_to_Z_packet (int type)
10335 return Z_PACKET_WRITE_WP;
10338 return Z_PACKET_READ_WP;
10341 return Z_PACKET_ACCESS_WP;
10344 internal_error (__FILE__, __LINE__,
10345 _("hw_bp_to_z: bad watchpoint type %d"), type);
10350 remote_target::insert_watchpoint (CORE_ADDR addr, int len,
10351 enum target_hw_bp_type type, struct expression *cond)
10353 struct remote_state *rs = get_remote_state ();
10354 char *endbuf = rs->buf + get_remote_packet_size ();
10356 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
10358 if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE)
10361 /* Make sure the remote is pointing at the right process, if
10363 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10364 set_general_process ();
10366 xsnprintf (rs->buf, endbuf - rs->buf, "Z%x,", packet);
10367 p = strchr (rs->buf, '\0');
10368 addr = remote_address_masked (addr);
10369 p += hexnumstr (p, (ULONGEST) addr);
10370 xsnprintf (p, endbuf - p, ",%x", len);
10373 getpkt (&rs->buf, &rs->buf_size, 0);
10375 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
10379 case PACKET_UNKNOWN:
10384 internal_error (__FILE__, __LINE__,
10385 _("remote_insert_watchpoint: reached end of function"));
10389 remote_target::watchpoint_addr_within_range (CORE_ADDR addr,
10390 CORE_ADDR start, int length)
10392 CORE_ADDR diff = remote_address_masked (addr - start);
10394 return diff < length;
10399 remote_target::remove_watchpoint (CORE_ADDR addr, int len,
10400 enum target_hw_bp_type type, struct expression *cond)
10402 struct remote_state *rs = get_remote_state ();
10403 char *endbuf = rs->buf + get_remote_packet_size ();
10405 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
10407 if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE)
10410 /* Make sure the remote is pointing at the right process, if
10412 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10413 set_general_process ();
10415 xsnprintf (rs->buf, endbuf - rs->buf, "z%x,", packet);
10416 p = strchr (rs->buf, '\0');
10417 addr = remote_address_masked (addr);
10418 p += hexnumstr (p, (ULONGEST) addr);
10419 xsnprintf (p, endbuf - p, ",%x", len);
10421 getpkt (&rs->buf, &rs->buf_size, 0);
10423 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
10426 case PACKET_UNKNOWN:
10431 internal_error (__FILE__, __LINE__,
10432 _("remote_remove_watchpoint: reached end of function"));
10436 int remote_hw_watchpoint_limit = -1;
10437 int remote_hw_watchpoint_length_limit = -1;
10438 int remote_hw_breakpoint_limit = -1;
10441 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
10443 if (remote_hw_watchpoint_length_limit == 0)
10445 else if (remote_hw_watchpoint_length_limit < 0)
10447 else if (len <= remote_hw_watchpoint_length_limit)
10454 remote_target::can_use_hw_breakpoint (enum bptype type, int cnt, int ot)
10456 if (type == bp_hardware_breakpoint)
10458 if (remote_hw_breakpoint_limit == 0)
10460 else if (remote_hw_breakpoint_limit < 0)
10462 else if (cnt <= remote_hw_breakpoint_limit)
10467 if (remote_hw_watchpoint_limit == 0)
10469 else if (remote_hw_watchpoint_limit < 0)
10473 else if (cnt <= remote_hw_watchpoint_limit)
10479 /* The to_stopped_by_sw_breakpoint method of target remote. */
10482 remote_target::stopped_by_sw_breakpoint ()
10484 struct thread_info *thread = inferior_thread ();
10486 return (thread->priv != NULL
10487 && (get_remote_thread_info (thread)->stop_reason
10488 == TARGET_STOPPED_BY_SW_BREAKPOINT));
10491 /* The to_supports_stopped_by_sw_breakpoint method of target
10495 remote_target::supports_stopped_by_sw_breakpoint ()
10497 return (packet_support (PACKET_swbreak_feature) == PACKET_ENABLE);
10500 /* The to_stopped_by_hw_breakpoint method of target remote. */
10503 remote_target::stopped_by_hw_breakpoint ()
10505 struct thread_info *thread = inferior_thread ();
10507 return (thread->priv != NULL
10508 && (get_remote_thread_info (thread)->stop_reason
10509 == TARGET_STOPPED_BY_HW_BREAKPOINT));
10512 /* The to_supports_stopped_by_hw_breakpoint method of target
10516 remote_target::supports_stopped_by_hw_breakpoint ()
10518 return (packet_support (PACKET_hwbreak_feature) == PACKET_ENABLE);
10522 remote_target::stopped_by_watchpoint ()
10524 struct thread_info *thread = inferior_thread ();
10526 return (thread->priv != NULL
10527 && (get_remote_thread_info (thread)->stop_reason
10528 == TARGET_STOPPED_BY_WATCHPOINT));
10532 remote_target::stopped_data_address (CORE_ADDR *addr_p)
10534 struct thread_info *thread = inferior_thread ();
10536 if (thread->priv != NULL
10537 && (get_remote_thread_info (thread)->stop_reason
10538 == TARGET_STOPPED_BY_WATCHPOINT))
10540 *addr_p = get_remote_thread_info (thread)->watch_data_address;
10549 remote_target::insert_hw_breakpoint (struct gdbarch *gdbarch,
10550 struct bp_target_info *bp_tgt)
10552 CORE_ADDR addr = bp_tgt->reqstd_address;
10553 struct remote_state *rs;
10557 if (packet_support (PACKET_Z1) == PACKET_DISABLE)
10560 /* Make sure the remote is pointing at the right process, if
10562 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10563 set_general_process ();
10565 rs = get_remote_state ();
10567 endbuf = rs->buf + get_remote_packet_size ();
10573 addr = remote_address_masked (addr);
10574 p += hexnumstr (p, (ULONGEST) addr);
10575 xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind);
10577 if (supports_evaluation_of_breakpoint_conditions ())
10578 remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
10580 if (can_run_breakpoint_commands ())
10581 remote_add_target_side_commands (gdbarch, bp_tgt, p);
10584 getpkt (&rs->buf, &rs->buf_size, 0);
10586 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
10589 if (rs->buf[1] == '.')
10591 message = strchr (rs->buf + 2, '.');
10593 error (_("Remote failure reply: %s"), message + 1);
10596 case PACKET_UNKNOWN:
10601 internal_error (__FILE__, __LINE__,
10602 _("remote_insert_hw_breakpoint: reached end of function"));
10607 remote_target::remove_hw_breakpoint (struct gdbarch *gdbarch,
10608 struct bp_target_info *bp_tgt)
10611 struct remote_state *rs = get_remote_state ();
10613 char *endbuf = rs->buf + get_remote_packet_size ();
10615 if (packet_support (PACKET_Z1) == PACKET_DISABLE)
10618 /* Make sure the remote is pointing at the right process, if
10620 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10621 set_general_process ();
10627 addr = remote_address_masked (bp_tgt->placed_address);
10628 p += hexnumstr (p, (ULONGEST) addr);
10629 xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind);
10632 getpkt (&rs->buf, &rs->buf_size, 0);
10634 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
10637 case PACKET_UNKNOWN:
10642 internal_error (__FILE__, __LINE__,
10643 _("remote_remove_hw_breakpoint: reached end of function"));
10646 /* Verify memory using the "qCRC:" request. */
10649 remote_target::verify_memory (const gdb_byte *data, CORE_ADDR lma, ULONGEST size)
10651 struct remote_state *rs = get_remote_state ();
10652 unsigned long host_crc, target_crc;
10655 /* It doesn't make sense to use qCRC if the remote target is
10656 connected but not running. */
10657 if (target_has_execution && packet_support (PACKET_qCRC) != PACKET_DISABLE)
10659 enum packet_result result;
10661 /* Make sure the remote is pointing at the right process. */
10662 set_general_process ();
10664 /* FIXME: assumes lma can fit into long. */
10665 xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
10666 (long) lma, (long) size);
10669 /* Be clever; compute the host_crc before waiting for target
10671 host_crc = xcrc32 (data, size, 0xffffffff);
10673 getpkt (&rs->buf, &rs->buf_size, 0);
10675 result = packet_ok (rs->buf,
10676 &remote_protocol_packets[PACKET_qCRC]);
10677 if (result == PACKET_ERROR)
10679 else if (result == PACKET_OK)
10681 for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
10682 target_crc = target_crc * 16 + fromhex (*tmp);
10684 return (host_crc == target_crc);
10688 return simple_verify_memory (this, data, lma, size);
10691 /* compare-sections command
10693 With no arguments, compares each loadable section in the exec bfd
10694 with the same memory range on the target, and reports mismatches.
10695 Useful for verifying the image on the target against the exec file. */
10698 compare_sections_command (const char *args, int from_tty)
10701 const char *sectname;
10702 bfd_size_type size;
10705 int mismatched = 0;
10710 error (_("command cannot be used without an exec file"));
10712 if (args != NULL && strcmp (args, "-r") == 0)
10718 for (s = exec_bfd->sections; s; s = s->next)
10720 if (!(s->flags & SEC_LOAD))
10721 continue; /* Skip non-loadable section. */
10723 if (read_only && (s->flags & SEC_READONLY) == 0)
10724 continue; /* Skip writeable sections */
10726 size = bfd_get_section_size (s);
10728 continue; /* Skip zero-length section. */
10730 sectname = bfd_get_section_name (exec_bfd, s);
10731 if (args && strcmp (args, sectname) != 0)
10732 continue; /* Not the section selected by user. */
10734 matched = 1; /* Do this section. */
10737 gdb::byte_vector sectdata (size);
10738 bfd_get_section_contents (exec_bfd, s, sectdata.data (), 0, size);
10740 res = target_verify_memory (sectdata.data (), lma, size);
10743 error (_("target memory fault, section %s, range %s -- %s"), sectname,
10744 paddress (target_gdbarch (), lma),
10745 paddress (target_gdbarch (), lma + size));
10747 printf_filtered ("Section %s, range %s -- %s: ", sectname,
10748 paddress (target_gdbarch (), lma),
10749 paddress (target_gdbarch (), lma + size));
10751 printf_filtered ("matched.\n");
10754 printf_filtered ("MIS-MATCHED!\n");
10758 if (mismatched > 0)
10759 warning (_("One or more sections of the target image does not match\n\
10760 the loaded file\n"));
10761 if (args && !matched)
10762 printf_filtered (_("No loaded section named '%s'.\n"), args);
10765 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10766 into remote target. The number of bytes written to the remote
10767 target is returned, or -1 for error. */
10770 remote_target::remote_write_qxfer (const char *object_name,
10771 const char *annex, const gdb_byte *writebuf,
10772 ULONGEST offset, LONGEST len,
10773 ULONGEST *xfered_len,
10774 struct packet_config *packet)
10778 struct remote_state *rs = get_remote_state ();
10779 int max_size = get_memory_write_packet_size ();
10781 if (packet_config_support (packet) == PACKET_DISABLE)
10782 return TARGET_XFER_E_IO;
10784 /* Insert header. */
10785 i = snprintf (rs->buf, max_size,
10786 "qXfer:%s:write:%s:%s:",
10787 object_name, annex ? annex : "",
10788 phex_nz (offset, sizeof offset));
10789 max_size -= (i + 1);
10791 /* Escape as much data as fits into rs->buf. */
10792 buf_len = remote_escape_output
10793 (writebuf, len, 1, (gdb_byte *) rs->buf + i, &max_size, max_size);
10795 if (putpkt_binary (rs->buf, i + buf_len) < 0
10796 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
10797 || packet_ok (rs->buf, packet) != PACKET_OK)
10798 return TARGET_XFER_E_IO;
10800 unpack_varlen_hex (rs->buf, &n);
10803 return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
10806 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10807 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10808 number of bytes read is returned, or 0 for EOF, or -1 for error.
10809 The number of bytes read may be less than LEN without indicating an
10810 EOF. PACKET is checked and updated to indicate whether the remote
10811 target supports this object. */
10814 remote_target::remote_read_qxfer (const char *object_name,
10816 gdb_byte *readbuf, ULONGEST offset,
10818 ULONGEST *xfered_len,
10819 struct packet_config *packet)
10821 struct remote_state *rs = get_remote_state ();
10822 LONGEST i, n, packet_len;
10824 if (packet_config_support (packet) == PACKET_DISABLE)
10825 return TARGET_XFER_E_IO;
10827 /* Check whether we've cached an end-of-object packet that matches
10829 if (rs->finished_object)
10831 if (strcmp (object_name, rs->finished_object) == 0
10832 && strcmp (annex ? annex : "", rs->finished_annex) == 0
10833 && offset == rs->finished_offset)
10834 return TARGET_XFER_EOF;
10837 /* Otherwise, we're now reading something different. Discard
10839 xfree (rs->finished_object);
10840 xfree (rs->finished_annex);
10841 rs->finished_object = NULL;
10842 rs->finished_annex = NULL;
10845 /* Request only enough to fit in a single packet. The actual data
10846 may not, since we don't know how much of it will need to be escaped;
10847 the target is free to respond with slightly less data. We subtract
10848 five to account for the response type and the protocol frame. */
10849 n = std::min<LONGEST> (get_remote_packet_size () - 5, len);
10850 snprintf (rs->buf, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
10851 object_name, annex ? annex : "",
10852 phex_nz (offset, sizeof offset),
10853 phex_nz (n, sizeof n));
10854 i = putpkt (rs->buf);
10856 return TARGET_XFER_E_IO;
10859 packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0);
10860 if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)
10861 return TARGET_XFER_E_IO;
10863 if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
10864 error (_("Unknown remote qXfer reply: %s"), rs->buf);
10866 /* 'm' means there is (or at least might be) more data after this
10867 batch. That does not make sense unless there's at least one byte
10868 of data in this reply. */
10869 if (rs->buf[0] == 'm' && packet_len == 1)
10870 error (_("Remote qXfer reply contained no data."));
10872 /* Got some data. */
10873 i = remote_unescape_input ((gdb_byte *) rs->buf + 1,
10874 packet_len - 1, readbuf, n);
10876 /* 'l' is an EOF marker, possibly including a final block of data,
10877 or possibly empty. If we have the final block of a non-empty
10878 object, record this fact to bypass a subsequent partial read. */
10879 if (rs->buf[0] == 'l' && offset + i > 0)
10881 rs->finished_object = xstrdup (object_name);
10882 rs->finished_annex = xstrdup (annex ? annex : "");
10883 rs->finished_offset = offset + i;
10887 return TARGET_XFER_EOF;
10891 return TARGET_XFER_OK;
10895 enum target_xfer_status
10896 remote_target::xfer_partial (enum target_object object,
10897 const char *annex, gdb_byte *readbuf,
10898 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
10899 ULONGEST *xfered_len)
10901 struct remote_state *rs;
10905 int unit_size = gdbarch_addressable_memory_unit_size (target_gdbarch ());
10907 set_remote_traceframe ();
10908 set_general_thread (inferior_ptid);
10910 rs = get_remote_state ();
10912 /* Handle memory using the standard memory routines. */
10913 if (object == TARGET_OBJECT_MEMORY)
10915 /* If the remote target is connected but not running, we should
10916 pass this request down to a lower stratum (e.g. the executable
10918 if (!target_has_execution)
10919 return TARGET_XFER_EOF;
10921 if (writebuf != NULL)
10922 return remote_write_bytes (offset, writebuf, len, unit_size,
10925 return remote_read_bytes (offset, readbuf, len, unit_size,
10929 /* Handle SPU memory using qxfer packets. */
10930 if (object == TARGET_OBJECT_SPU)
10933 return remote_read_qxfer ("spu", annex, readbuf, offset, len,
10934 xfered_len, &remote_protocol_packets
10935 [PACKET_qXfer_spu_read]);
10937 return remote_write_qxfer ("spu", annex, writebuf, offset, len,
10938 xfered_len, &remote_protocol_packets
10939 [PACKET_qXfer_spu_write]);
10942 /* Handle extra signal info using qxfer packets. */
10943 if (object == TARGET_OBJECT_SIGNAL_INFO)
10946 return remote_read_qxfer ("siginfo", annex, readbuf, offset, len,
10947 xfered_len, &remote_protocol_packets
10948 [PACKET_qXfer_siginfo_read]);
10950 return remote_write_qxfer ("siginfo", annex,
10951 writebuf, offset, len, xfered_len,
10952 &remote_protocol_packets
10953 [PACKET_qXfer_siginfo_write]);
10956 if (object == TARGET_OBJECT_STATIC_TRACE_DATA)
10959 return remote_read_qxfer ("statictrace", annex,
10960 readbuf, offset, len, xfered_len,
10961 &remote_protocol_packets
10962 [PACKET_qXfer_statictrace_read]);
10964 return TARGET_XFER_E_IO;
10967 /* Only handle flash writes. */
10968 if (writebuf != NULL)
10972 case TARGET_OBJECT_FLASH:
10973 return remote_flash_write (offset, len, xfered_len,
10977 return TARGET_XFER_E_IO;
10981 /* Map pre-existing objects onto letters. DO NOT do this for new
10982 objects!!! Instead specify new query packets. */
10985 case TARGET_OBJECT_AVR:
10989 case TARGET_OBJECT_AUXV:
10990 gdb_assert (annex == NULL);
10991 return remote_read_qxfer ("auxv", annex, readbuf, offset, len,
10993 &remote_protocol_packets[PACKET_qXfer_auxv]);
10995 case TARGET_OBJECT_AVAILABLE_FEATURES:
10996 return remote_read_qxfer
10997 ("features", annex, readbuf, offset, len, xfered_len,
10998 &remote_protocol_packets[PACKET_qXfer_features]);
11000 case TARGET_OBJECT_LIBRARIES:
11001 return remote_read_qxfer
11002 ("libraries", annex, readbuf, offset, len, xfered_len,
11003 &remote_protocol_packets[PACKET_qXfer_libraries]);
11005 case TARGET_OBJECT_LIBRARIES_SVR4:
11006 return remote_read_qxfer
11007 ("libraries-svr4", annex, readbuf, offset, len, xfered_len,
11008 &remote_protocol_packets[PACKET_qXfer_libraries_svr4]);
11010 case TARGET_OBJECT_MEMORY_MAP:
11011 gdb_assert (annex == NULL);
11012 return remote_read_qxfer ("memory-map", annex, readbuf, offset, len,
11014 &remote_protocol_packets[PACKET_qXfer_memory_map]);
11016 case TARGET_OBJECT_OSDATA:
11017 /* Should only get here if we're connected. */
11018 gdb_assert (rs->remote_desc);
11019 return remote_read_qxfer
11020 ("osdata", annex, readbuf, offset, len, xfered_len,
11021 &remote_protocol_packets[PACKET_qXfer_osdata]);
11023 case TARGET_OBJECT_THREADS:
11024 gdb_assert (annex == NULL);
11025 return remote_read_qxfer ("threads", annex, readbuf, offset, len,
11027 &remote_protocol_packets[PACKET_qXfer_threads]);
11029 case TARGET_OBJECT_TRACEFRAME_INFO:
11030 gdb_assert (annex == NULL);
11031 return remote_read_qxfer
11032 ("traceframe-info", annex, readbuf, offset, len, xfered_len,
11033 &remote_protocol_packets[PACKET_qXfer_traceframe_info]);
11035 case TARGET_OBJECT_FDPIC:
11036 return remote_read_qxfer ("fdpic", annex, readbuf, offset, len,
11038 &remote_protocol_packets[PACKET_qXfer_fdpic]);
11040 case TARGET_OBJECT_OPENVMS_UIB:
11041 return remote_read_qxfer ("uib", annex, readbuf, offset, len,
11043 &remote_protocol_packets[PACKET_qXfer_uib]);
11045 case TARGET_OBJECT_BTRACE:
11046 return remote_read_qxfer ("btrace", annex, readbuf, offset, len,
11048 &remote_protocol_packets[PACKET_qXfer_btrace]);
11050 case TARGET_OBJECT_BTRACE_CONF:
11051 return remote_read_qxfer ("btrace-conf", annex, readbuf, offset,
11053 &remote_protocol_packets[PACKET_qXfer_btrace_conf]);
11055 case TARGET_OBJECT_EXEC_FILE:
11056 return remote_read_qxfer ("exec-file", annex, readbuf, offset,
11058 &remote_protocol_packets[PACKET_qXfer_exec_file]);
11061 return TARGET_XFER_E_IO;
11064 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
11065 large enough let the caller deal with it. */
11066 if (len < get_remote_packet_size ())
11067 return TARGET_XFER_E_IO;
11068 len = get_remote_packet_size ();
11070 /* Except for querying the minimum buffer size, target must be open. */
11071 if (!rs->remote_desc)
11072 error (_("remote query is only available after target open"));
11074 gdb_assert (annex != NULL);
11075 gdb_assert (readbuf != NULL);
11079 *p2++ = query_type;
11081 /* We used one buffer char for the remote protocol q command and
11082 another for the query type. As the remote protocol encapsulation
11083 uses 4 chars plus one extra in case we are debugging
11084 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11087 while (annex[i] && (i < (get_remote_packet_size () - 8)))
11089 /* Bad caller may have sent forbidden characters. */
11090 gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#');
11095 gdb_assert (annex[i] == '\0');
11097 i = putpkt (rs->buf);
11099 return TARGET_XFER_E_IO;
11101 getpkt (&rs->buf, &rs->buf_size, 0);
11102 strcpy ((char *) readbuf, rs->buf);
11104 *xfered_len = strlen ((char *) readbuf);
11105 return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
11108 /* Implementation of to_get_memory_xfer_limit. */
11111 remote_target::get_memory_xfer_limit ()
11113 return get_memory_write_packet_size ();
11117 remote_target::search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
11118 const gdb_byte *pattern, ULONGEST pattern_len,
11119 CORE_ADDR *found_addrp)
11121 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
11122 struct remote_state *rs = get_remote_state ();
11123 int max_size = get_memory_write_packet_size ();
11124 struct packet_config *packet =
11125 &remote_protocol_packets[PACKET_qSearch_memory];
11126 /* Number of packet bytes used to encode the pattern;
11127 this could be more than PATTERN_LEN due to escape characters. */
11128 int escaped_pattern_len;
11129 /* Amount of pattern that was encodable in the packet. */
11130 int used_pattern_len;
11133 ULONGEST found_addr;
11135 /* Don't go to the target if we don't have to. This is done before
11136 checking packet_config_support to avoid the possibility that a
11137 success for this edge case means the facility works in
11139 if (pattern_len > search_space_len)
11141 if (pattern_len == 0)
11143 *found_addrp = start_addr;
11147 /* If we already know the packet isn't supported, fall back to the simple
11148 way of searching memory. */
11150 if (packet_config_support (packet) == PACKET_DISABLE)
11152 /* Target doesn't provided special support, fall back and use the
11153 standard support (copy memory and do the search here). */
11154 return simple_search_memory (this, start_addr, search_space_len,
11155 pattern, pattern_len, found_addrp);
11158 /* Make sure the remote is pointing at the right process. */
11159 set_general_process ();
11161 /* Insert header. */
11162 i = snprintf (rs->buf, max_size,
11163 "qSearch:memory:%s;%s;",
11164 phex_nz (start_addr, addr_size),
11165 phex_nz (search_space_len, sizeof (search_space_len)));
11166 max_size -= (i + 1);
11168 /* Escape as much data as fits into rs->buf. */
11169 escaped_pattern_len =
11170 remote_escape_output (pattern, pattern_len, 1, (gdb_byte *) rs->buf + i,
11171 &used_pattern_len, max_size);
11173 /* Bail if the pattern is too large. */
11174 if (used_pattern_len != pattern_len)
11175 error (_("Pattern is too large to transmit to remote target."));
11177 if (putpkt_binary (rs->buf, i + escaped_pattern_len) < 0
11178 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
11179 || packet_ok (rs->buf, packet) != PACKET_OK)
11181 /* The request may not have worked because the command is not
11182 supported. If so, fall back to the simple way. */
11183 if (packet_config_support (packet) == PACKET_DISABLE)
11185 return simple_search_memory (this, start_addr, search_space_len,
11186 pattern, pattern_len, found_addrp);
11191 if (rs->buf[0] == '0')
11193 else if (rs->buf[0] == '1')
11196 if (rs->buf[1] != ',')
11197 error (_("Unknown qSearch:memory reply: %s"), rs->buf);
11198 unpack_varlen_hex (rs->buf + 2, &found_addr);
11199 *found_addrp = found_addr;
11202 error (_("Unknown qSearch:memory reply: %s"), rs->buf);
11208 remote_target::rcmd (const char *command, struct ui_file *outbuf)
11210 struct remote_state *rs = get_remote_state ();
11213 if (!rs->remote_desc)
11214 error (_("remote rcmd is only available after target open"));
11216 /* Send a NULL command across as an empty command. */
11217 if (command == NULL)
11220 /* The query prefix. */
11221 strcpy (rs->buf, "qRcmd,");
11222 p = strchr (rs->buf, '\0');
11224 if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/)
11225 > get_remote_packet_size ())
11226 error (_("\"monitor\" command ``%s'' is too long."), command);
11228 /* Encode the actual command. */
11229 bin2hex ((const gdb_byte *) command, p, strlen (command));
11231 if (putpkt (rs->buf) < 0)
11232 error (_("Communication problem with target."));
11234 /* get/display the response */
11239 /* XXX - see also remote_get_noisy_reply(). */
11240 QUIT; /* Allow user to bail out with ^C. */
11242 if (getpkt_sane (&rs->buf, &rs->buf_size, 0) == -1)
11244 /* Timeout. Continue to (try to) read responses.
11245 This is better than stopping with an error, assuming the stub
11246 is still executing the (long) monitor command.
11247 If needed, the user can interrupt gdb using C-c, obtaining
11248 an effect similar to stop on timeout. */
11252 if (buf[0] == '\0')
11253 error (_("Target does not support this command."));
11254 if (buf[0] == 'O' && buf[1] != 'K')
11256 remote_console_output (buf + 1); /* 'O' message from stub. */
11259 if (strcmp (buf, "OK") == 0)
11261 if (strlen (buf) == 3 && buf[0] == 'E'
11262 && isdigit (buf[1]) && isdigit (buf[2]))
11264 error (_("Protocol error with Rcmd"));
11266 for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
11268 char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
11270 fputc_unfiltered (c, outbuf);
11276 std::vector<mem_region>
11277 remote_target::memory_map ()
11279 std::vector<mem_region> result;
11280 gdb::optional<gdb::char_vector> text
11281 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP, NULL);
11284 result = parse_memory_map (text->data ());
11290 packet_command (const char *args, int from_tty)
11292 remote_target *remote = get_current_remote_target ();
11294 if (remote == nullptr)
11295 error (_("command can only be used with remote target"));
11297 remote->packet_command (args, from_tty);
11301 remote_target::packet_command (const char *args, int from_tty)
11304 error (_("remote-packet command requires packet text as argument"));
11306 puts_filtered ("sending: ");
11307 print_packet (args);
11308 puts_filtered ("\n");
11311 remote_state *rs = get_remote_state ();
11313 getpkt (&rs->buf, &rs->buf_size, 0);
11314 puts_filtered ("received: ");
11315 print_packet (rs->buf);
11316 puts_filtered ("\n");
11320 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11322 static void display_thread_info (struct gdb_ext_thread_info *info);
11324 static void threadset_test_cmd (char *cmd, int tty);
11326 static void threadalive_test (char *cmd, int tty);
11328 static void threadlist_test_cmd (char *cmd, int tty);
11330 int get_and_display_threadinfo (threadref *ref);
11332 static void threadinfo_test_cmd (char *cmd, int tty);
11334 static int thread_display_step (threadref *ref, void *context);
11336 static void threadlist_update_test_cmd (char *cmd, int tty);
11338 static void init_remote_threadtests (void);
11340 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11343 threadset_test_cmd (const char *cmd, int tty)
11345 int sample_thread = SAMPLE_THREAD;
11347 printf_filtered (_("Remote threadset test\n"));
11348 set_general_thread (sample_thread);
11353 threadalive_test (const char *cmd, int tty)
11355 int sample_thread = SAMPLE_THREAD;
11356 int pid = inferior_ptid.pid ();
11357 ptid_t ptid = ptid_t (pid, sample_thread, 0);
11359 if (remote_thread_alive (ptid))
11360 printf_filtered ("PASS: Thread alive test\n");
11362 printf_filtered ("FAIL: Thread alive test\n");
11365 void output_threadid (char *title, threadref *ref);
11368 output_threadid (char *title, threadref *ref)
11372 pack_threadid (&hexid[0], ref); /* Convert threead id into hex. */
11374 printf_filtered ("%s %s\n", title, (&hexid[0]));
11378 threadlist_test_cmd (const char *cmd, int tty)
11381 threadref nextthread;
11382 int done, result_count;
11383 threadref threadlist[3];
11385 printf_filtered ("Remote Threadlist test\n");
11386 if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
11387 &result_count, &threadlist[0]))
11388 printf_filtered ("FAIL: threadlist test\n");
11391 threadref *scan = threadlist;
11392 threadref *limit = scan + result_count;
11394 while (scan < limit)
11395 output_threadid (" thread ", scan++);
11400 display_thread_info (struct gdb_ext_thread_info *info)
11402 output_threadid ("Threadid: ", &info->threadid);
11403 printf_filtered ("Name: %s\n ", info->shortname);
11404 printf_filtered ("State: %s\n", info->display);
11405 printf_filtered ("other: %s\n\n", info->more_display);
11409 get_and_display_threadinfo (threadref *ref)
11413 struct gdb_ext_thread_info threadinfo;
11415 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
11416 | TAG_MOREDISPLAY | TAG_DISPLAY;
11417 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
11418 display_thread_info (&threadinfo);
11423 threadinfo_test_cmd (const char *cmd, int tty)
11425 int athread = SAMPLE_THREAD;
11429 int_to_threadref (&thread, athread);
11430 printf_filtered ("Remote Threadinfo test\n");
11431 if (!get_and_display_threadinfo (&thread))
11432 printf_filtered ("FAIL cannot get thread info\n");
11436 thread_display_step (threadref *ref, void *context)
11438 /* output_threadid(" threadstep ",ref); *//* simple test */
11439 return get_and_display_threadinfo (ref);
11443 threadlist_update_test_cmd (const char *cmd, int tty)
11445 printf_filtered ("Remote Threadlist update test\n");
11446 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
11450 init_remote_threadtests (void)
11452 add_com ("tlist", class_obscure, threadlist_test_cmd,
11453 _("Fetch and print the remote list of "
11454 "thread identifiers, one pkt only"));
11455 add_com ("tinfo", class_obscure, threadinfo_test_cmd,
11456 _("Fetch and display info about one thread"));
11457 add_com ("tset", class_obscure, threadset_test_cmd,
11458 _("Test setting to a different thread"));
11459 add_com ("tupd", class_obscure, threadlist_update_test_cmd,
11460 _("Iterate through updating all remote thread info"));
11461 add_com ("talive", class_obscure, threadalive_test,
11462 _(" Remote thread alive test "));
11467 /* Convert a thread ID to a string. Returns the string in a static
11471 remote_target::pid_to_str (ptid_t ptid)
11473 static char buf[64];
11474 struct remote_state *rs = get_remote_state ();
11476 if (ptid == null_ptid)
11477 return normal_pid_to_str (ptid);
11478 else if (ptid.is_pid ())
11480 /* Printing an inferior target id. */
11482 /* When multi-process extensions are off, there's no way in the
11483 remote protocol to know the remote process id, if there's any
11484 at all. There's one exception --- when we're connected with
11485 target extended-remote, and we manually attached to a process
11486 with "attach PID". We don't record anywhere a flag that
11487 allows us to distinguish that case from the case of
11488 connecting with extended-remote and the stub already being
11489 attached to a process, and reporting yes to qAttached, hence
11490 no smart special casing here. */
11491 if (!remote_multi_process_p (rs))
11493 xsnprintf (buf, sizeof buf, "Remote target");
11497 return normal_pid_to_str (ptid);
11501 if (magic_null_ptid == ptid)
11502 xsnprintf (buf, sizeof buf, "Thread <main>");
11503 else if (remote_multi_process_p (rs))
11504 if (ptid.lwp () == 0)
11505 return normal_pid_to_str (ptid);
11507 xsnprintf (buf, sizeof buf, "Thread %d.%ld",
11508 ptid.pid (), ptid.lwp ());
11510 xsnprintf (buf, sizeof buf, "Thread %ld",
11516 /* Get the address of the thread local variable in OBJFILE which is
11517 stored at OFFSET within the thread local storage for thread PTID. */
11520 remote_target::get_thread_local_address (ptid_t ptid, CORE_ADDR lm,
11523 if (packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE)
11525 struct remote_state *rs = get_remote_state ();
11527 char *endp = rs->buf + get_remote_packet_size ();
11528 enum packet_result result;
11530 strcpy (p, "qGetTLSAddr:");
11532 p = write_ptid (p, endp, ptid);
11534 p += hexnumstr (p, offset);
11536 p += hexnumstr (p, lm);
11540 getpkt (&rs->buf, &rs->buf_size, 0);
11541 result = packet_ok (rs->buf,
11542 &remote_protocol_packets[PACKET_qGetTLSAddr]);
11543 if (result == PACKET_OK)
11547 unpack_varlen_hex (rs->buf, &result);
11550 else if (result == PACKET_UNKNOWN)
11551 throw_error (TLS_GENERIC_ERROR,
11552 _("Remote target doesn't support qGetTLSAddr packet"));
11554 throw_error (TLS_GENERIC_ERROR,
11555 _("Remote target failed to process qGetTLSAddr request"));
11558 throw_error (TLS_GENERIC_ERROR,
11559 _("TLS not supported or disabled on this target"));
11564 /* Provide thread local base, i.e. Thread Information Block address.
11565 Returns 1 if ptid is found and thread_local_base is non zero. */
11568 remote_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr)
11570 if (packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE)
11572 struct remote_state *rs = get_remote_state ();
11574 char *endp = rs->buf + get_remote_packet_size ();
11575 enum packet_result result;
11577 strcpy (p, "qGetTIBAddr:");
11579 p = write_ptid (p, endp, ptid);
11583 getpkt (&rs->buf, &rs->buf_size, 0);
11584 result = packet_ok (rs->buf,
11585 &remote_protocol_packets[PACKET_qGetTIBAddr]);
11586 if (result == PACKET_OK)
11590 unpack_varlen_hex (rs->buf, &result);
11592 *addr = (CORE_ADDR) result;
11595 else if (result == PACKET_UNKNOWN)
11596 error (_("Remote target doesn't support qGetTIBAddr packet"));
11598 error (_("Remote target failed to process qGetTIBAddr request"));
11601 error (_("qGetTIBAddr not supported or disabled on this target"));
11606 /* Support for inferring a target description based on the current
11607 architecture and the size of a 'g' packet. While the 'g' packet
11608 can have any size (since optional registers can be left off the
11609 end), some sizes are easily recognizable given knowledge of the
11610 approximate architecture. */
11612 struct remote_g_packet_guess
11615 const struct target_desc *tdesc;
11617 typedef struct remote_g_packet_guess remote_g_packet_guess_s;
11618 DEF_VEC_O(remote_g_packet_guess_s);
11620 struct remote_g_packet_data
11622 VEC(remote_g_packet_guess_s) *guesses;
11625 static struct gdbarch_data *remote_g_packet_data_handle;
11628 remote_g_packet_data_init (struct obstack *obstack)
11630 return OBSTACK_ZALLOC (obstack, struct remote_g_packet_data);
11634 register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes,
11635 const struct target_desc *tdesc)
11637 struct remote_g_packet_data *data
11638 = ((struct remote_g_packet_data *)
11639 gdbarch_data (gdbarch, remote_g_packet_data_handle));
11640 struct remote_g_packet_guess new_guess, *guess;
11643 gdb_assert (tdesc != NULL);
11646 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
11648 if (guess->bytes == bytes)
11649 internal_error (__FILE__, __LINE__,
11650 _("Duplicate g packet description added for size %d"),
11653 new_guess.bytes = bytes;
11654 new_guess.tdesc = tdesc;
11655 VEC_safe_push (remote_g_packet_guess_s, data->guesses, &new_guess);
11658 /* Return 1 if remote_read_description would do anything on this target
11659 and architecture, 0 otherwise. */
11662 remote_read_description_p (struct target_ops *target)
11664 struct remote_g_packet_data *data
11665 = ((struct remote_g_packet_data *)
11666 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle));
11668 if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
11674 const struct target_desc *
11675 remote_target::read_description ()
11677 struct remote_g_packet_data *data
11678 = ((struct remote_g_packet_data *)
11679 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle));
11681 /* Do not try this during initial connection, when we do not know
11682 whether there is a running but stopped thread. */
11683 if (!target_has_execution || inferior_ptid == null_ptid)
11684 return beneath ()->read_description ();
11686 if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
11688 struct remote_g_packet_guess *guess;
11690 int bytes = send_g_packet ();
11693 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
11695 if (guess->bytes == bytes)
11696 return guess->tdesc;
11698 /* We discard the g packet. A minor optimization would be to
11699 hold on to it, and fill the register cache once we have selected
11700 an architecture, but it's too tricky to do safely. */
11703 return beneath ()->read_description ();
11706 /* Remote file transfer support. This is host-initiated I/O, not
11707 target-initiated; for target-initiated, see remote-fileio.c. */
11709 /* If *LEFT is at least the length of STRING, copy STRING to
11710 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11711 decrease *LEFT. Otherwise raise an error. */
11714 remote_buffer_add_string (char **buffer, int *left, const char *string)
11716 int len = strlen (string);
11719 error (_("Packet too long for target."));
11721 memcpy (*buffer, string, len);
11725 /* NUL-terminate the buffer as a convenience, if there is
11731 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11732 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11733 decrease *LEFT. Otherwise raise an error. */
11736 remote_buffer_add_bytes (char **buffer, int *left, const gdb_byte *bytes,
11739 if (2 * len > *left)
11740 error (_("Packet too long for target."));
11742 bin2hex (bytes, *buffer, len);
11743 *buffer += 2 * len;
11746 /* NUL-terminate the buffer as a convenience, if there is
11752 /* If *LEFT is large enough, convert VALUE to hex and add it to
11753 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11754 decrease *LEFT. Otherwise raise an error. */
11757 remote_buffer_add_int (char **buffer, int *left, ULONGEST value)
11759 int len = hexnumlen (value);
11762 error (_("Packet too long for target."));
11764 hexnumstr (*buffer, value);
11768 /* NUL-terminate the buffer as a convenience, if there is
11774 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11775 value, *REMOTE_ERRNO to the remote error number or zero if none
11776 was included, and *ATTACHMENT to point to the start of the annex
11777 if any. The length of the packet isn't needed here; there may
11778 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11780 Return 0 if the packet could be parsed, -1 if it could not. If
11781 -1 is returned, the other variables may not be initialized. */
11784 remote_hostio_parse_result (char *buffer, int *retcode,
11785 int *remote_errno, char **attachment)
11790 *attachment = NULL;
11792 if (buffer[0] != 'F')
11796 *retcode = strtol (&buffer[1], &p, 16);
11797 if (errno != 0 || p == &buffer[1])
11800 /* Check for ",errno". */
11804 *remote_errno = strtol (p + 1, &p2, 16);
11805 if (errno != 0 || p + 1 == p2)
11810 /* Check for ";attachment". If there is no attachment, the
11811 packet should end here. */
11814 *attachment = p + 1;
11817 else if (*p == '\0')
11823 /* Send a prepared I/O packet to the target and read its response.
11824 The prepared packet is in the global RS->BUF before this function
11825 is called, and the answer is there when we return.
11827 COMMAND_BYTES is the length of the request to send, which may include
11828 binary data. WHICH_PACKET is the packet configuration to check
11829 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11830 is set to the error number and -1 is returned. Otherwise the value
11831 returned by the function is returned.
11833 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11834 attachment is expected; an error will be reported if there's a
11835 mismatch. If one is found, *ATTACHMENT will be set to point into
11836 the packet buffer and *ATTACHMENT_LEN will be set to the
11837 attachment's length. */
11840 remote_target::remote_hostio_send_command (int command_bytes, int which_packet,
11841 int *remote_errno, char **attachment,
11842 int *attachment_len)
11844 struct remote_state *rs = get_remote_state ();
11845 int ret, bytes_read;
11846 char *attachment_tmp;
11848 if (packet_support (which_packet) == PACKET_DISABLE)
11850 *remote_errno = FILEIO_ENOSYS;
11854 putpkt_binary (rs->buf, command_bytes);
11855 bytes_read = getpkt_sane (&rs->buf, &rs->buf_size, 0);
11857 /* If it timed out, something is wrong. Don't try to parse the
11859 if (bytes_read < 0)
11861 *remote_errno = FILEIO_EINVAL;
11865 switch (packet_ok (rs->buf, &remote_protocol_packets[which_packet]))
11868 *remote_errno = FILEIO_EINVAL;
11870 case PACKET_UNKNOWN:
11871 *remote_errno = FILEIO_ENOSYS;
11877 if (remote_hostio_parse_result (rs->buf, &ret, remote_errno,
11880 *remote_errno = FILEIO_EINVAL;
11884 /* Make sure we saw an attachment if and only if we expected one. */
11885 if ((attachment_tmp == NULL && attachment != NULL)
11886 || (attachment_tmp != NULL && attachment == NULL))
11888 *remote_errno = FILEIO_EINVAL;
11892 /* If an attachment was found, it must point into the packet buffer;
11893 work out how many bytes there were. */
11894 if (attachment_tmp != NULL)
11896 *attachment = attachment_tmp;
11897 *attachment_len = bytes_read - (*attachment - rs->buf);
11903 /* See declaration.h. */
11906 readahead_cache::invalidate ()
11911 /* See declaration.h. */
11914 readahead_cache::invalidate_fd (int fd)
11916 if (this->fd == fd)
11920 /* Set the filesystem remote_hostio functions that take FILENAME
11921 arguments will use. Return 0 on success, or -1 if an error
11922 occurs (and set *REMOTE_ERRNO). */
11925 remote_target::remote_hostio_set_filesystem (struct inferior *inf,
11928 struct remote_state *rs = get_remote_state ();
11929 int required_pid = (inf == NULL || inf->fake_pid_p) ? 0 : inf->pid;
11931 int left = get_remote_packet_size () - 1;
11935 if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
11938 if (rs->fs_pid != -1 && required_pid == rs->fs_pid)
11941 remote_buffer_add_string (&p, &left, "vFile:setfs:");
11943 xsnprintf (arg, sizeof (arg), "%x", required_pid);
11944 remote_buffer_add_string (&p, &left, arg);
11946 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_setfs,
11947 remote_errno, NULL, NULL);
11949 if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
11953 rs->fs_pid = required_pid;
11958 /* Implementation of to_fileio_open. */
11961 remote_target::remote_hostio_open (inferior *inf, const char *filename,
11962 int flags, int mode, int warn_if_slow,
11965 struct remote_state *rs = get_remote_state ();
11967 int left = get_remote_packet_size () - 1;
11971 static int warning_issued = 0;
11973 printf_unfiltered (_("Reading %s from remote target...\n"),
11976 if (!warning_issued)
11978 warning (_("File transfers from remote targets can be slow."
11979 " Use \"set sysroot\" to access files locally"
11981 warning_issued = 1;
11985 if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
11988 remote_buffer_add_string (&p, &left, "vFile:open:");
11990 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
11991 strlen (filename));
11992 remote_buffer_add_string (&p, &left, ",");
11994 remote_buffer_add_int (&p, &left, flags);
11995 remote_buffer_add_string (&p, &left, ",");
11997 remote_buffer_add_int (&p, &left, mode);
11999 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_open,
12000 remote_errno, NULL, NULL);
12004 remote_target::fileio_open (struct inferior *inf, const char *filename,
12005 int flags, int mode, int warn_if_slow,
12008 return remote_hostio_open (inf, filename, flags, mode, warn_if_slow,
12012 /* Implementation of to_fileio_pwrite. */
12015 remote_target::remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
12016 ULONGEST offset, int *remote_errno)
12018 struct remote_state *rs = get_remote_state ();
12020 int left = get_remote_packet_size ();
12023 rs->readahead_cache.invalidate_fd (fd);
12025 remote_buffer_add_string (&p, &left, "vFile:pwrite:");
12027 remote_buffer_add_int (&p, &left, fd);
12028 remote_buffer_add_string (&p, &left, ",");
12030 remote_buffer_add_int (&p, &left, offset);
12031 remote_buffer_add_string (&p, &left, ",");
12033 p += remote_escape_output (write_buf, len, 1, (gdb_byte *) p, &out_len,
12034 get_remote_packet_size () - (p - rs->buf));
12036 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_pwrite,
12037 remote_errno, NULL, NULL);
12041 remote_target::fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
12042 ULONGEST offset, int *remote_errno)
12044 return remote_hostio_pwrite (fd, write_buf, len, offset, remote_errno);
12047 /* Helper for the implementation of to_fileio_pread. Read the file
12048 from the remote side with vFile:pread. */
12051 remote_target::remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len,
12052 ULONGEST offset, int *remote_errno)
12054 struct remote_state *rs = get_remote_state ();
12057 int left = get_remote_packet_size ();
12058 int ret, attachment_len;
12061 remote_buffer_add_string (&p, &left, "vFile:pread:");
12063 remote_buffer_add_int (&p, &left, fd);
12064 remote_buffer_add_string (&p, &left, ",");
12066 remote_buffer_add_int (&p, &left, len);
12067 remote_buffer_add_string (&p, &left, ",");
12069 remote_buffer_add_int (&p, &left, offset);
12071 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_pread,
12072 remote_errno, &attachment,
12078 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
12080 if (read_len != ret)
12081 error (_("Read returned %d, but %d bytes."), ret, (int) read_len);
12086 /* See declaration.h. */
12089 readahead_cache::pread (int fd, gdb_byte *read_buf, size_t len,
12093 && this->offset <= offset
12094 && offset < this->offset + this->bufsize)
12096 ULONGEST max = this->offset + this->bufsize;
12098 if (offset + len > max)
12099 len = max - offset;
12101 memcpy (read_buf, this->buf + offset - this->offset, len);
12108 /* Implementation of to_fileio_pread. */
12111 remote_target::remote_hostio_pread (int fd, gdb_byte *read_buf, int len,
12112 ULONGEST offset, int *remote_errno)
12115 struct remote_state *rs = get_remote_state ();
12116 readahead_cache *cache = &rs->readahead_cache;
12118 ret = cache->pread (fd, read_buf, len, offset);
12121 cache->hit_count++;
12124 fprintf_unfiltered (gdb_stdlog, "readahead cache hit %s\n",
12125 pulongest (cache->hit_count));
12129 cache->miss_count++;
12131 fprintf_unfiltered (gdb_stdlog, "readahead cache miss %s\n",
12132 pulongest (cache->miss_count));
12135 cache->offset = offset;
12136 cache->bufsize = get_remote_packet_size ();
12137 cache->buf = (gdb_byte *) xrealloc (cache->buf, cache->bufsize);
12139 ret = remote_hostio_pread_vFile (cache->fd, cache->buf, cache->bufsize,
12140 cache->offset, remote_errno);
12143 cache->invalidate_fd (fd);
12147 cache->bufsize = ret;
12148 return cache->pread (fd, read_buf, len, offset);
12152 remote_target::fileio_pread (int fd, gdb_byte *read_buf, int len,
12153 ULONGEST offset, int *remote_errno)
12155 return remote_hostio_pread (fd, read_buf, len, offset, remote_errno);
12158 /* Implementation of to_fileio_close. */
12161 remote_target::remote_hostio_close (int fd, int *remote_errno)
12163 struct remote_state *rs = get_remote_state ();
12165 int left = get_remote_packet_size () - 1;
12167 rs->readahead_cache.invalidate_fd (fd);
12169 remote_buffer_add_string (&p, &left, "vFile:close:");
12171 remote_buffer_add_int (&p, &left, fd);
12173 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_close,
12174 remote_errno, NULL, NULL);
12178 remote_target::fileio_close (int fd, int *remote_errno)
12180 return remote_hostio_close (fd, remote_errno);
12183 /* Implementation of to_fileio_unlink. */
12186 remote_target::remote_hostio_unlink (inferior *inf, const char *filename,
12189 struct remote_state *rs = get_remote_state ();
12191 int left = get_remote_packet_size () - 1;
12193 if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
12196 remote_buffer_add_string (&p, &left, "vFile:unlink:");
12198 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
12199 strlen (filename));
12201 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_unlink,
12202 remote_errno, NULL, NULL);
12206 remote_target::fileio_unlink (struct inferior *inf, const char *filename,
12209 return remote_hostio_unlink (inf, filename, remote_errno);
12212 /* Implementation of to_fileio_readlink. */
12214 gdb::optional<std::string>
12215 remote_target::fileio_readlink (struct inferior *inf, const char *filename,
12218 struct remote_state *rs = get_remote_state ();
12221 int left = get_remote_packet_size ();
12222 int len, attachment_len;
12225 if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
12228 remote_buffer_add_string (&p, &left, "vFile:readlink:");
12230 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
12231 strlen (filename));
12233 len = remote_hostio_send_command (p - rs->buf, PACKET_vFile_readlink,
12234 remote_errno, &attachment,
12240 std::string ret (len, '\0');
12242 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
12243 (gdb_byte *) &ret[0], len);
12244 if (read_len != len)
12245 error (_("Readlink returned %d, but %d bytes."), len, read_len);
12250 /* Implementation of to_fileio_fstat. */
12253 remote_target::fileio_fstat (int fd, struct stat *st, int *remote_errno)
12255 struct remote_state *rs = get_remote_state ();
12257 int left = get_remote_packet_size ();
12258 int attachment_len, ret;
12260 struct fio_stat fst;
12263 remote_buffer_add_string (&p, &left, "vFile:fstat:");
12265 remote_buffer_add_int (&p, &left, fd);
12267 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_fstat,
12268 remote_errno, &attachment,
12272 if (*remote_errno != FILEIO_ENOSYS)
12275 /* Strictly we should return -1, ENOSYS here, but when
12276 "set sysroot remote:" was implemented in August 2008
12277 BFD's need for a stat function was sidestepped with
12278 this hack. This was not remedied until March 2015
12279 so we retain the previous behavior to avoid breaking
12282 Note that the memset is a March 2015 addition; older
12283 GDBs set st_size *and nothing else* so the structure
12284 would have garbage in all other fields. This might
12285 break something but retaining the previous behavior
12286 here would be just too wrong. */
12288 memset (st, 0, sizeof (struct stat));
12289 st->st_size = INT_MAX;
12293 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
12294 (gdb_byte *) &fst, sizeof (fst));
12296 if (read_len != ret)
12297 error (_("vFile:fstat returned %d, but %d bytes."), ret, read_len);
12299 if (read_len != sizeof (fst))
12300 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12301 read_len, (int) sizeof (fst));
12303 remote_fileio_to_host_stat (&fst, st);
12308 /* Implementation of to_filesystem_is_local. */
12311 remote_target::filesystem_is_local ()
12313 /* Valgrind GDB presents itself as a remote target but works
12314 on the local filesystem: it does not implement remote get
12315 and users are not expected to set a sysroot. To handle
12316 this case we treat the remote filesystem as local if the
12317 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12318 does not support vFile:open. */
12319 if (strcmp (gdb_sysroot, TARGET_SYSROOT_PREFIX) == 0)
12321 enum packet_support ps = packet_support (PACKET_vFile_open);
12323 if (ps == PACKET_SUPPORT_UNKNOWN)
12325 int fd, remote_errno;
12327 /* Try opening a file to probe support. The supplied
12328 filename is irrelevant, we only care about whether
12329 the stub recognizes the packet or not. */
12330 fd = remote_hostio_open (NULL, "just probing",
12331 FILEIO_O_RDONLY, 0700, 0,
12335 remote_hostio_close (fd, &remote_errno);
12337 ps = packet_support (PACKET_vFile_open);
12340 if (ps == PACKET_DISABLE)
12342 static int warning_issued = 0;
12344 if (!warning_issued)
12346 warning (_("remote target does not support file"
12347 " transfer, attempting to access files"
12348 " from local filesystem."));
12349 warning_issued = 1;
12360 remote_fileio_errno_to_host (int errnum)
12366 case FILEIO_ENOENT:
12374 case FILEIO_EACCES:
12376 case FILEIO_EFAULT:
12380 case FILEIO_EEXIST:
12382 case FILEIO_ENODEV:
12384 case FILEIO_ENOTDIR:
12386 case FILEIO_EISDIR:
12388 case FILEIO_EINVAL:
12390 case FILEIO_ENFILE:
12392 case FILEIO_EMFILE:
12396 case FILEIO_ENOSPC:
12398 case FILEIO_ESPIPE:
12402 case FILEIO_ENOSYS:
12404 case FILEIO_ENAMETOOLONG:
12405 return ENAMETOOLONG;
12411 remote_hostio_error (int errnum)
12413 int host_error = remote_fileio_errno_to_host (errnum);
12415 if (host_error == -1)
12416 error (_("Unknown remote I/O error %d"), errnum);
12418 error (_("Remote I/O error: %s"), safe_strerror (host_error));
12421 /* A RAII wrapper around a remote file descriptor. */
12423 class scoped_remote_fd
12426 scoped_remote_fd (remote_target *remote, int fd)
12427 : m_remote (remote), m_fd (fd)
12431 ~scoped_remote_fd ()
12438 m_remote->remote_hostio_close (m_fd, &remote_errno);
12442 /* Swallow exception before it escapes the dtor. If
12443 something goes wrong, likely the connection is gone,
12444 and there's nothing else that can be done. */
12449 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd);
12451 /* Release ownership of the file descriptor, and return it. */
12452 int release () noexcept
12459 /* Return the owned file descriptor. */
12460 int get () const noexcept
12466 /* The remote target. */
12467 remote_target *m_remote;
12469 /* The owned remote I/O file descriptor. */
12474 remote_file_put (const char *local_file, const char *remote_file, int from_tty)
12476 remote_target *remote = get_current_remote_target ();
12478 if (remote == nullptr)
12479 error (_("command can only be used with remote target"));
12481 remote->remote_file_put (local_file, remote_file, from_tty);
12485 remote_target::remote_file_put (const char *local_file, const char *remote_file,
12488 int retcode, remote_errno, bytes, io_size;
12489 int bytes_in_buffer;
12493 gdb_file_up file = gdb_fopen_cloexec (local_file, "rb");
12495 perror_with_name (local_file);
12497 scoped_remote_fd fd
12498 (this, remote_hostio_open (NULL,
12499 remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT
12501 0700, 0, &remote_errno));
12502 if (fd.get () == -1)
12503 remote_hostio_error (remote_errno);
12505 /* Send up to this many bytes at once. They won't all fit in the
12506 remote packet limit, so we'll transfer slightly fewer. */
12507 io_size = get_remote_packet_size ();
12508 gdb::byte_vector buffer (io_size);
12510 bytes_in_buffer = 0;
12513 while (bytes_in_buffer || !saw_eof)
12517 bytes = fread (buffer.data () + bytes_in_buffer, 1,
12518 io_size - bytes_in_buffer,
12522 if (ferror (file.get ()))
12523 error (_("Error reading %s."), local_file);
12526 /* EOF. Unless there is something still in the
12527 buffer from the last iteration, we are done. */
12529 if (bytes_in_buffer == 0)
12537 bytes += bytes_in_buffer;
12538 bytes_in_buffer = 0;
12540 retcode = remote_hostio_pwrite (fd.get (), buffer.data (), bytes,
12541 offset, &remote_errno);
12544 remote_hostio_error (remote_errno);
12545 else if (retcode == 0)
12546 error (_("Remote write of %d bytes returned 0!"), bytes);
12547 else if (retcode < bytes)
12549 /* Short write. Save the rest of the read data for the next
12551 bytes_in_buffer = bytes - retcode;
12552 memmove (buffer.data (), buffer.data () + retcode, bytes_in_buffer);
12558 if (remote_hostio_close (fd.release (), &remote_errno))
12559 remote_hostio_error (remote_errno);
12562 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file);
12566 remote_file_get (const char *remote_file, const char *local_file, int from_tty)
12568 remote_target *remote = get_current_remote_target ();
12570 if (remote == nullptr)
12571 error (_("command can only be used with remote target"));
12573 remote->remote_file_get (remote_file, local_file, from_tty);
12577 remote_target::remote_file_get (const char *remote_file, const char *local_file,
12580 int remote_errno, bytes, io_size;
12583 scoped_remote_fd fd
12584 (this, remote_hostio_open (NULL,
12585 remote_file, FILEIO_O_RDONLY, 0, 0,
12587 if (fd.get () == -1)
12588 remote_hostio_error (remote_errno);
12590 gdb_file_up file = gdb_fopen_cloexec (local_file, "wb");
12592 perror_with_name (local_file);
12594 /* Send up to this many bytes at once. They won't all fit in the
12595 remote packet limit, so we'll transfer slightly fewer. */
12596 io_size = get_remote_packet_size ();
12597 gdb::byte_vector buffer (io_size);
12602 bytes = remote_hostio_pread (fd.get (), buffer.data (), io_size, offset,
12605 /* Success, but no bytes, means end-of-file. */
12608 remote_hostio_error (remote_errno);
12612 bytes = fwrite (buffer.data (), 1, bytes, file.get ());
12614 perror_with_name (local_file);
12617 if (remote_hostio_close (fd.release (), &remote_errno))
12618 remote_hostio_error (remote_errno);
12621 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file);
12625 remote_file_delete (const char *remote_file, int from_tty)
12627 remote_target *remote = get_current_remote_target ();
12629 if (remote == nullptr)
12630 error (_("command can only be used with remote target"));
12632 remote->remote_file_delete (remote_file, from_tty);
12636 remote_target::remote_file_delete (const char *remote_file, int from_tty)
12638 int retcode, remote_errno;
12640 retcode = remote_hostio_unlink (NULL, remote_file, &remote_errno);
12642 remote_hostio_error (remote_errno);
12645 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file);
12649 remote_put_command (const char *args, int from_tty)
12652 error_no_arg (_("file to put"));
12654 gdb_argv argv (args);
12655 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL)
12656 error (_("Invalid parameters to remote put"));
12658 remote_file_put (argv[0], argv[1], from_tty);
12662 remote_get_command (const char *args, int from_tty)
12665 error_no_arg (_("file to get"));
12667 gdb_argv argv (args);
12668 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL)
12669 error (_("Invalid parameters to remote get"));
12671 remote_file_get (argv[0], argv[1], from_tty);
12675 remote_delete_command (const char *args, int from_tty)
12678 error_no_arg (_("file to delete"));
12680 gdb_argv argv (args);
12681 if (argv[0] == NULL || argv[1] != NULL)
12682 error (_("Invalid parameters to remote delete"));
12684 remote_file_delete (argv[0], from_tty);
12688 remote_command (const char *args, int from_tty)
12690 help_list (remote_cmdlist, "remote ", all_commands, gdb_stdout);
12694 remote_target::can_execute_reverse ()
12696 if (packet_support (PACKET_bs) == PACKET_ENABLE
12697 || packet_support (PACKET_bc) == PACKET_ENABLE)
12704 remote_target::supports_non_stop ()
12710 remote_target::supports_disable_randomization ()
12712 /* Only supported in extended mode. */
12717 remote_target::supports_multi_process ()
12719 struct remote_state *rs = get_remote_state ();
12721 return remote_multi_process_p (rs);
12725 remote_supports_cond_tracepoints ()
12727 return packet_support (PACKET_ConditionalTracepoints) == PACKET_ENABLE;
12731 remote_target::supports_evaluation_of_breakpoint_conditions ()
12733 return packet_support (PACKET_ConditionalBreakpoints) == PACKET_ENABLE;
12737 remote_supports_fast_tracepoints ()
12739 return packet_support (PACKET_FastTracepoints) == PACKET_ENABLE;
12743 remote_supports_static_tracepoints ()
12745 return packet_support (PACKET_StaticTracepoints) == PACKET_ENABLE;
12749 remote_supports_install_in_trace ()
12751 return packet_support (PACKET_InstallInTrace) == PACKET_ENABLE;
12755 remote_target::supports_enable_disable_tracepoint ()
12757 return (packet_support (PACKET_EnableDisableTracepoints_feature)
12762 remote_target::supports_string_tracing ()
12764 return packet_support (PACKET_tracenz_feature) == PACKET_ENABLE;
12768 remote_target::can_run_breakpoint_commands ()
12770 return packet_support (PACKET_BreakpointCommands) == PACKET_ENABLE;
12774 remote_target::trace_init ()
12776 struct remote_state *rs = get_remote_state ();
12779 remote_get_noisy_reply ();
12780 if (strcmp (rs->buf, "OK") != 0)
12781 error (_("Target does not support this command."));
12784 /* Recursive routine to walk through command list including loops, and
12785 download packets for each command. */
12788 remote_target::remote_download_command_source (int num, ULONGEST addr,
12789 struct command_line *cmds)
12791 struct remote_state *rs = get_remote_state ();
12792 struct command_line *cmd;
12794 for (cmd = cmds; cmd; cmd = cmd->next)
12796 QUIT; /* Allow user to bail out with ^C. */
12797 strcpy (rs->buf, "QTDPsrc:");
12798 encode_source_string (num, addr, "cmd", cmd->line,
12799 rs->buf + strlen (rs->buf),
12800 rs->buf_size - strlen (rs->buf));
12802 remote_get_noisy_reply ();
12803 if (strcmp (rs->buf, "OK"))
12804 warning (_("Target does not support source download."));
12806 if (cmd->control_type == while_control
12807 || cmd->control_type == while_stepping_control)
12809 remote_download_command_source (num, addr, cmd->body_list_0.get ());
12811 QUIT; /* Allow user to bail out with ^C. */
12812 strcpy (rs->buf, "QTDPsrc:");
12813 encode_source_string (num, addr, "cmd", "end",
12814 rs->buf + strlen (rs->buf),
12815 rs->buf_size - strlen (rs->buf));
12817 remote_get_noisy_reply ();
12818 if (strcmp (rs->buf, "OK"))
12819 warning (_("Target does not support source download."));
12825 remote_target::download_tracepoint (struct bp_location *loc)
12827 #define BUF_SIZE 2048
12831 char buf[BUF_SIZE];
12832 std::vector<std::string> tdp_actions;
12833 std::vector<std::string> stepping_actions;
12835 struct breakpoint *b = loc->owner;
12836 struct tracepoint *t = (struct tracepoint *) b;
12837 struct remote_state *rs = get_remote_state ();
12839 encode_actions_rsp (loc, &tdp_actions, &stepping_actions);
12841 tpaddr = loc->address;
12842 sprintf_vma (addrbuf, tpaddr);
12843 xsnprintf (buf, BUF_SIZE, "QTDP:%x:%s:%c:%lx:%x", b->number,
12844 addrbuf, /* address */
12845 (b->enable_state == bp_enabled ? 'E' : 'D'),
12846 t->step_count, t->pass_count);
12847 /* Fast tracepoints are mostly handled by the target, but we can
12848 tell the target how big of an instruction block should be moved
12850 if (b->type == bp_fast_tracepoint)
12852 /* Only test for support at download time; we may not know
12853 target capabilities at definition time. */
12854 if (remote_supports_fast_tracepoints ())
12856 if (gdbarch_fast_tracepoint_valid_at (loc->gdbarch, tpaddr,
12858 xsnprintf (buf + strlen (buf), BUF_SIZE - strlen (buf), ":F%x",
12859 gdb_insn_length (loc->gdbarch, tpaddr));
12861 /* If it passed validation at definition but fails now,
12862 something is very wrong. */
12863 internal_error (__FILE__, __LINE__,
12864 _("Fast tracepoint not "
12865 "valid during download"));
12868 /* Fast tracepoints are functionally identical to regular
12869 tracepoints, so don't take lack of support as a reason to
12870 give up on the trace run. */
12871 warning (_("Target does not support fast tracepoints, "
12872 "downloading %d as regular tracepoint"), b->number);
12874 else if (b->type == bp_static_tracepoint)
12876 /* Only test for support at download time; we may not know
12877 target capabilities at definition time. */
12878 if (remote_supports_static_tracepoints ())
12880 struct static_tracepoint_marker marker;
12882 if (target_static_tracepoint_marker_at (tpaddr, &marker))
12883 strcat (buf, ":S");
12885 error (_("Static tracepoint not valid during download"));
12888 /* Fast tracepoints are functionally identical to regular
12889 tracepoints, so don't take lack of support as a reason
12890 to give up on the trace run. */
12891 error (_("Target does not support static tracepoints"));
12893 /* If the tracepoint has a conditional, make it into an agent
12894 expression and append to the definition. */
12897 /* Only test support at download time, we may not know target
12898 capabilities at definition time. */
12899 if (remote_supports_cond_tracepoints ())
12901 agent_expr_up aexpr = gen_eval_for_expr (tpaddr, loc->cond.get ());
12902 xsnprintf (buf + strlen (buf), BUF_SIZE - strlen (buf), ":X%x,",
12904 pkt = buf + strlen (buf);
12905 for (int ndx = 0; ndx < aexpr->len; ++ndx)
12906 pkt = pack_hex_byte (pkt, aexpr->buf[ndx]);
12910 warning (_("Target does not support conditional tracepoints, "
12911 "ignoring tp %d cond"), b->number);
12914 if (b->commands || *default_collect)
12917 remote_get_noisy_reply ();
12918 if (strcmp (rs->buf, "OK"))
12919 error (_("Target does not support tracepoints."));
12921 /* do_single_steps (t); */
12922 for (auto action_it = tdp_actions.begin ();
12923 action_it != tdp_actions.end (); action_it++)
12925 QUIT; /* Allow user to bail out with ^C. */
12927 bool has_more = (action_it != tdp_actions.end ()
12928 || !stepping_actions.empty ());
12930 xsnprintf (buf, BUF_SIZE, "QTDP:-%x:%s:%s%c",
12931 b->number, addrbuf, /* address */
12932 action_it->c_str (),
12933 has_more ? '-' : 0);
12935 remote_get_noisy_reply ();
12936 if (strcmp (rs->buf, "OK"))
12937 error (_("Error on target while setting tracepoints."));
12940 for (auto action_it = stepping_actions.begin ();
12941 action_it != stepping_actions.end (); action_it++)
12943 QUIT; /* Allow user to bail out with ^C. */
12945 bool is_first = action_it == stepping_actions.begin ();
12946 bool has_more = action_it != stepping_actions.end ();
12948 xsnprintf (buf, BUF_SIZE, "QTDP:-%x:%s:%s%s%s",
12949 b->number, addrbuf, /* address */
12950 is_first ? "S" : "",
12951 action_it->c_str (),
12952 has_more ? "-" : "");
12954 remote_get_noisy_reply ();
12955 if (strcmp (rs->buf, "OK"))
12956 error (_("Error on target while setting tracepoints."));
12959 if (packet_support (PACKET_TracepointSource) == PACKET_ENABLE)
12961 if (b->location != NULL)
12963 strcpy (buf, "QTDPsrc:");
12964 encode_source_string (b->number, loc->address, "at",
12965 event_location_to_string (b->location.get ()),
12966 buf + strlen (buf), 2048 - strlen (buf));
12968 remote_get_noisy_reply ();
12969 if (strcmp (rs->buf, "OK"))
12970 warning (_("Target does not support source download."));
12972 if (b->cond_string)
12974 strcpy (buf, "QTDPsrc:");
12975 encode_source_string (b->number, loc->address,
12976 "cond", b->cond_string, buf + strlen (buf),
12977 2048 - strlen (buf));
12979 remote_get_noisy_reply ();
12980 if (strcmp (rs->buf, "OK"))
12981 warning (_("Target does not support source download."));
12983 remote_download_command_source (b->number, loc->address,
12984 breakpoint_commands (b));
12989 remote_target::can_download_tracepoint ()
12991 struct remote_state *rs = get_remote_state ();
12992 struct trace_status *ts;
12995 /* Don't try to install tracepoints until we've relocated our
12996 symbols, and fetched and merged the target's tracepoint list with
12998 if (rs->starting_up)
13001 ts = current_trace_status ();
13002 status = get_trace_status (ts);
13004 if (status == -1 || !ts->running_known || !ts->running)
13007 /* If we are in a tracing experiment, but remote stub doesn't support
13008 installing tracepoint in trace, we have to return. */
13009 if (!remote_supports_install_in_trace ())
13017 remote_target::download_trace_state_variable (const trace_state_variable &tsv)
13019 struct remote_state *rs = get_remote_state ();
13022 xsnprintf (rs->buf, get_remote_packet_size (), "QTDV:%x:%s:%x:",
13023 tsv.number, phex ((ULONGEST) tsv.initial_value, 8),
13025 p = rs->buf + strlen (rs->buf);
13026 if ((p - rs->buf) + tsv.name.length () * 2 >= get_remote_packet_size ())
13027 error (_("Trace state variable name too long for tsv definition packet"));
13028 p += 2 * bin2hex ((gdb_byte *) (tsv.name.data ()), p, tsv.name.length ());
13031 remote_get_noisy_reply ();
13032 if (*rs->buf == '\0')
13033 error (_("Target does not support this command."));
13034 if (strcmp (rs->buf, "OK") != 0)
13035 error (_("Error on target while downloading trace state variable."));
13039 remote_target::enable_tracepoint (struct bp_location *location)
13041 struct remote_state *rs = get_remote_state ();
13044 sprintf_vma (addr_buf, location->address);
13045 xsnprintf (rs->buf, get_remote_packet_size (), "QTEnable:%x:%s",
13046 location->owner->number, addr_buf);
13048 remote_get_noisy_reply ();
13049 if (*rs->buf == '\0')
13050 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13051 if (strcmp (rs->buf, "OK") != 0)
13052 error (_("Error on target while enabling tracepoint."));
13056 remote_target::disable_tracepoint (struct bp_location *location)
13058 struct remote_state *rs = get_remote_state ();
13061 sprintf_vma (addr_buf, location->address);
13062 xsnprintf (rs->buf, get_remote_packet_size (), "QTDisable:%x:%s",
13063 location->owner->number, addr_buf);
13065 remote_get_noisy_reply ();
13066 if (*rs->buf == '\0')
13067 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13068 if (strcmp (rs->buf, "OK") != 0)
13069 error (_("Error on target while disabling tracepoint."));
13073 remote_target::trace_set_readonly_regions ()
13077 bfd_size_type size;
13083 return; /* No information to give. */
13085 struct remote_state *rs = get_remote_state ();
13087 strcpy (rs->buf, "QTro");
13088 offset = strlen (rs->buf);
13089 for (s = exec_bfd->sections; s; s = s->next)
13091 char tmp1[40], tmp2[40];
13094 if ((s->flags & SEC_LOAD) == 0 ||
13095 /* (s->flags & SEC_CODE) == 0 || */
13096 (s->flags & SEC_READONLY) == 0)
13100 vma = bfd_get_section_vma (abfd, s);
13101 size = bfd_get_section_size (s);
13102 sprintf_vma (tmp1, vma);
13103 sprintf_vma (tmp2, vma + size);
13104 sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2);
13105 if (offset + sec_length + 1 > rs->buf_size)
13107 if (packet_support (PACKET_qXfer_traceframe_info) != PACKET_ENABLE)
13109 Too many sections for read-only sections definition packet."));
13112 xsnprintf (rs->buf + offset, rs->buf_size - offset, ":%s,%s",
13114 offset += sec_length;
13119 getpkt (&rs->buf, &rs->buf_size, 0);
13124 remote_target::trace_start ()
13126 struct remote_state *rs = get_remote_state ();
13128 putpkt ("QTStart");
13129 remote_get_noisy_reply ();
13130 if (*rs->buf == '\0')
13131 error (_("Target does not support this command."));
13132 if (strcmp (rs->buf, "OK") != 0)
13133 error (_("Bogus reply from target: %s"), rs->buf);
13137 remote_target::get_trace_status (struct trace_status *ts)
13139 /* Initialize it just to avoid a GCC false warning. */
13141 /* FIXME we need to get register block size some other way. */
13142 extern int trace_regblock_size;
13143 enum packet_result result;
13144 struct remote_state *rs = get_remote_state ();
13146 if (packet_support (PACKET_qTStatus) == PACKET_DISABLE)
13149 trace_regblock_size
13150 = rs->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet;
13152 putpkt ("qTStatus");
13156 p = remote_get_noisy_reply ();
13158 CATCH (ex, RETURN_MASK_ERROR)
13160 if (ex.error != TARGET_CLOSE_ERROR)
13162 exception_fprintf (gdb_stderr, ex, "qTStatus: ");
13165 throw_exception (ex);
13169 result = packet_ok (p, &remote_protocol_packets[PACKET_qTStatus]);
13171 /* If the remote target doesn't do tracing, flag it. */
13172 if (result == PACKET_UNKNOWN)
13175 /* We're working with a live target. */
13176 ts->filename = NULL;
13179 error (_("Bogus trace status reply from target: %s"), rs->buf);
13181 /* Function 'parse_trace_status' sets default value of each field of
13182 'ts' at first, so we don't have to do it here. */
13183 parse_trace_status (p, ts);
13185 return ts->running;
13189 remote_target::get_tracepoint_status (struct breakpoint *bp,
13190 struct uploaded_tp *utp)
13192 struct remote_state *rs = get_remote_state ();
13194 struct bp_location *loc;
13195 struct tracepoint *tp = (struct tracepoint *) bp;
13196 size_t size = get_remote_packet_size ();
13201 tp->traceframe_usage = 0;
13202 for (loc = tp->loc; loc; loc = loc->next)
13204 /* If the tracepoint was never downloaded, don't go asking for
13206 if (tp->number_on_target == 0)
13208 xsnprintf (rs->buf, size, "qTP:%x:%s", tp->number_on_target,
13209 phex_nz (loc->address, 0));
13211 reply = remote_get_noisy_reply ();
13212 if (reply && *reply)
13215 parse_tracepoint_status (reply + 1, bp, utp);
13221 utp->hit_count = 0;
13222 utp->traceframe_usage = 0;
13223 xsnprintf (rs->buf, size, "qTP:%x:%s", utp->number,
13224 phex_nz (utp->addr, 0));
13226 reply = remote_get_noisy_reply ();
13227 if (reply && *reply)
13230 parse_tracepoint_status (reply + 1, bp, utp);
13236 remote_target::trace_stop ()
13238 struct remote_state *rs = get_remote_state ();
13241 remote_get_noisy_reply ();
13242 if (*rs->buf == '\0')
13243 error (_("Target does not support this command."));
13244 if (strcmp (rs->buf, "OK") != 0)
13245 error (_("Bogus reply from target: %s"), rs->buf);
13249 remote_target::trace_find (enum trace_find_type type, int num,
13250 CORE_ADDR addr1, CORE_ADDR addr2,
13253 struct remote_state *rs = get_remote_state ();
13254 char *endbuf = rs->buf + get_remote_packet_size ();
13256 int target_frameno = -1, target_tracept = -1;
13258 /* Lookups other than by absolute frame number depend on the current
13259 trace selected, so make sure it is correct on the remote end
13261 if (type != tfind_number)
13262 set_remote_traceframe ();
13265 strcpy (p, "QTFrame:");
13266 p = strchr (p, '\0');
13270 xsnprintf (p, endbuf - p, "%x", num);
13273 xsnprintf (p, endbuf - p, "pc:%s", phex_nz (addr1, 0));
13276 xsnprintf (p, endbuf - p, "tdp:%x", num);
13279 xsnprintf (p, endbuf - p, "range:%s:%s", phex_nz (addr1, 0),
13280 phex_nz (addr2, 0));
13282 case tfind_outside:
13283 xsnprintf (p, endbuf - p, "outside:%s:%s", phex_nz (addr1, 0),
13284 phex_nz (addr2, 0));
13287 error (_("Unknown trace find type %d"), type);
13291 reply = remote_get_noisy_reply ();
13292 if (*reply == '\0')
13293 error (_("Target does not support this command."));
13295 while (reply && *reply)
13300 target_frameno = (int) strtol (p, &reply, 16);
13302 error (_("Unable to parse trace frame number"));
13303 /* Don't update our remote traceframe number cache on failure
13304 to select a remote traceframe. */
13305 if (target_frameno == -1)
13310 target_tracept = (int) strtol (p, &reply, 16);
13312 error (_("Unable to parse tracepoint number"));
13314 case 'O': /* "OK"? */
13315 if (reply[1] == 'K' && reply[2] == '\0')
13318 error (_("Bogus reply from target: %s"), reply);
13321 error (_("Bogus reply from target: %s"), reply);
13324 *tpp = target_tracept;
13326 rs->remote_traceframe_number = target_frameno;
13327 return target_frameno;
13331 remote_target::get_trace_state_variable_value (int tsvnum, LONGEST *val)
13333 struct remote_state *rs = get_remote_state ();
13337 set_remote_traceframe ();
13339 xsnprintf (rs->buf, get_remote_packet_size (), "qTV:%x", tsvnum);
13341 reply = remote_get_noisy_reply ();
13342 if (reply && *reply)
13346 unpack_varlen_hex (reply + 1, &uval);
13347 *val = (LONGEST) uval;
13355 remote_target::save_trace_data (const char *filename)
13357 struct remote_state *rs = get_remote_state ();
13361 strcpy (p, "QTSave:");
13363 if ((p - rs->buf) + strlen (filename) * 2 >= get_remote_packet_size ())
13364 error (_("Remote file name too long for trace save packet"));
13365 p += 2 * bin2hex ((gdb_byte *) filename, p, strlen (filename));
13368 reply = remote_get_noisy_reply ();
13369 if (*reply == '\0')
13370 error (_("Target does not support this command."));
13371 if (strcmp (reply, "OK") != 0)
13372 error (_("Bogus reply from target: %s"), reply);
13376 /* This is basically a memory transfer, but needs to be its own packet
13377 because we don't know how the target actually organizes its trace
13378 memory, plus we want to be able to ask for as much as possible, but
13379 not be unhappy if we don't get as much as we ask for. */
13382 remote_target::get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len)
13384 struct remote_state *rs = get_remote_state ();
13390 strcpy (p, "qTBuffer:");
13392 p += hexnumstr (p, offset);
13394 p += hexnumstr (p, len);
13398 reply = remote_get_noisy_reply ();
13399 if (reply && *reply)
13401 /* 'l' by itself means we're at the end of the buffer and
13402 there is nothing more to get. */
13406 /* Convert the reply into binary. Limit the number of bytes to
13407 convert according to our passed-in buffer size, rather than
13408 what was returned in the packet; if the target is
13409 unexpectedly generous and gives us a bigger reply than we
13410 asked for, we don't want to crash. */
13411 rslt = hex2bin (reply, buf, len);
13415 /* Something went wrong, flag as an error. */
13420 remote_target::set_disconnected_tracing (int val)
13422 struct remote_state *rs = get_remote_state ();
13424 if (packet_support (PACKET_DisconnectedTracing_feature) == PACKET_ENABLE)
13428 xsnprintf (rs->buf, get_remote_packet_size (), "QTDisconnected:%x", val);
13430 reply = remote_get_noisy_reply ();
13431 if (*reply == '\0')
13432 error (_("Target does not support this command."));
13433 if (strcmp (reply, "OK") != 0)
13434 error (_("Bogus reply from target: %s"), reply);
13437 warning (_("Target does not support disconnected tracing."));
13441 remote_target::core_of_thread (ptid_t ptid)
13443 struct thread_info *info = find_thread_ptid (ptid);
13445 if (info != NULL && info->priv != NULL)
13446 return get_remote_thread_info (info)->core;
13452 remote_target::set_circular_trace_buffer (int val)
13454 struct remote_state *rs = get_remote_state ();
13457 xsnprintf (rs->buf, get_remote_packet_size (), "QTBuffer:circular:%x", val);
13459 reply = remote_get_noisy_reply ();
13460 if (*reply == '\0')
13461 error (_("Target does not support this command."));
13462 if (strcmp (reply, "OK") != 0)
13463 error (_("Bogus reply from target: %s"), reply);
13467 remote_target::traceframe_info ()
13469 gdb::optional<gdb::char_vector> text
13470 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO,
13473 return parse_traceframe_info (text->data ());
13478 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13479 instruction on which a fast tracepoint may be placed. Returns -1
13480 if the packet is not supported, and 0 if the minimum instruction
13481 length is unknown. */
13484 remote_target::get_min_fast_tracepoint_insn_len ()
13486 struct remote_state *rs = get_remote_state ();
13489 /* If we're not debugging a process yet, the IPA can't be
13491 if (!target_has_execution)
13494 /* Make sure the remote is pointing at the right process. */
13495 set_general_process ();
13497 xsnprintf (rs->buf, get_remote_packet_size (), "qTMinFTPILen");
13499 reply = remote_get_noisy_reply ();
13500 if (*reply == '\0')
13504 ULONGEST min_insn_len;
13506 unpack_varlen_hex (reply, &min_insn_len);
13508 return (int) min_insn_len;
13513 remote_target::set_trace_buffer_size (LONGEST val)
13515 if (packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE)
13517 struct remote_state *rs = get_remote_state ();
13518 char *buf = rs->buf;
13519 char *endbuf = rs->buf + get_remote_packet_size ();
13520 enum packet_result result;
13522 gdb_assert (val >= 0 || val == -1);
13523 buf += xsnprintf (buf, endbuf - buf, "QTBuffer:size:");
13524 /* Send -1 as literal "-1" to avoid host size dependency. */
13528 buf += hexnumstr (buf, (ULONGEST) -val);
13531 buf += hexnumstr (buf, (ULONGEST) val);
13534 remote_get_noisy_reply ();
13535 result = packet_ok (rs->buf,
13536 &remote_protocol_packets[PACKET_QTBuffer_size]);
13538 if (result != PACKET_OK)
13539 warning (_("Bogus reply from target: %s"), rs->buf);
13544 remote_target::set_trace_notes (const char *user, const char *notes,
13545 const char *stop_notes)
13547 struct remote_state *rs = get_remote_state ();
13549 char *buf = rs->buf;
13550 char *endbuf = rs->buf + get_remote_packet_size ();
13553 buf += xsnprintf (buf, endbuf - buf, "QTNotes:");
13556 buf += xsnprintf (buf, endbuf - buf, "user:");
13557 nbytes = bin2hex ((gdb_byte *) user, buf, strlen (user));
13563 buf += xsnprintf (buf, endbuf - buf, "notes:");
13564 nbytes = bin2hex ((gdb_byte *) notes, buf, strlen (notes));
13570 buf += xsnprintf (buf, endbuf - buf, "tstop:");
13571 nbytes = bin2hex ((gdb_byte *) stop_notes, buf, strlen (stop_notes));
13575 /* Ensure the buffer is terminated. */
13579 reply = remote_get_noisy_reply ();
13580 if (*reply == '\0')
13583 if (strcmp (reply, "OK") != 0)
13584 error (_("Bogus reply from target: %s"), reply);
13590 remote_target::use_agent (bool use)
13592 if (packet_support (PACKET_QAgent) != PACKET_DISABLE)
13594 struct remote_state *rs = get_remote_state ();
13596 /* If the stub supports QAgent. */
13597 xsnprintf (rs->buf, get_remote_packet_size (), "QAgent:%d", use);
13599 getpkt (&rs->buf, &rs->buf_size, 0);
13601 if (strcmp (rs->buf, "OK") == 0)
13612 remote_target::can_use_agent ()
13614 return (packet_support (PACKET_QAgent) != PACKET_DISABLE);
13617 struct btrace_target_info
13619 /* The ptid of the traced thread. */
13622 /* The obtained branch trace configuration. */
13623 struct btrace_config conf;
13626 /* Reset our idea of our target's btrace configuration. */
13629 remote_btrace_reset (remote_state *rs)
13631 memset (&rs->btrace_config, 0, sizeof (rs->btrace_config));
13634 /* Synchronize the configuration with the target. */
13637 remote_target::btrace_sync_conf (const btrace_config *conf)
13639 struct packet_config *packet;
13640 struct remote_state *rs;
13641 char *buf, *pos, *endbuf;
13643 rs = get_remote_state ();
13645 endbuf = buf + get_remote_packet_size ();
13647 packet = &remote_protocol_packets[PACKET_Qbtrace_conf_bts_size];
13648 if (packet_config_support (packet) == PACKET_ENABLE
13649 && conf->bts.size != rs->btrace_config.bts.size)
13652 pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
13656 getpkt (&buf, &rs->buf_size, 0);
13658 if (packet_ok (buf, packet) == PACKET_ERROR)
13660 if (buf[0] == 'E' && buf[1] == '.')
13661 error (_("Failed to configure the BTS buffer size: %s"), buf + 2);
13663 error (_("Failed to configure the BTS buffer size."));
13666 rs->btrace_config.bts.size = conf->bts.size;
13669 packet = &remote_protocol_packets[PACKET_Qbtrace_conf_pt_size];
13670 if (packet_config_support (packet) == PACKET_ENABLE
13671 && conf->pt.size != rs->btrace_config.pt.size)
13674 pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
13678 getpkt (&buf, &rs->buf_size, 0);
13680 if (packet_ok (buf, packet) == PACKET_ERROR)
13682 if (buf[0] == 'E' && buf[1] == '.')
13683 error (_("Failed to configure the trace buffer size: %s"), buf + 2);
13685 error (_("Failed to configure the trace buffer size."));
13688 rs->btrace_config.pt.size = conf->pt.size;
13692 /* Read the current thread's btrace configuration from the target and
13693 store it into CONF. */
13696 btrace_read_config (struct btrace_config *conf)
13698 gdb::optional<gdb::char_vector> xml
13699 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF, "");
13701 parse_xml_btrace_conf (conf, xml->data ());
13704 /* Maybe reopen target btrace. */
13707 remote_target::remote_btrace_maybe_reopen ()
13709 struct remote_state *rs = get_remote_state ();
13710 struct thread_info *tp;
13711 int btrace_target_pushed = 0;
13714 scoped_restore_current_thread restore_thread;
13716 ALL_NON_EXITED_THREADS (tp)
13718 set_general_thread (tp->ptid);
13720 memset (&rs->btrace_config, 0x00, sizeof (struct btrace_config));
13721 btrace_read_config (&rs->btrace_config);
13723 if (rs->btrace_config.format == BTRACE_FORMAT_NONE)
13726 #if !defined (HAVE_LIBIPT)
13727 if (rs->btrace_config.format == BTRACE_FORMAT_PT)
13732 warning (_("Target is recording using Intel Processor Trace "
13733 "but support was disabled at compile time."));
13738 #endif /* !defined (HAVE_LIBIPT) */
13740 /* Push target, once, but before anything else happens. This way our
13741 changes to the threads will be cleaned up by unpushing the target
13742 in case btrace_read_config () throws. */
13743 if (!btrace_target_pushed)
13745 btrace_target_pushed = 1;
13746 record_btrace_push_target ();
13747 printf_filtered (_("Target is recording using %s.\n"),
13748 btrace_format_string (rs->btrace_config.format));
13751 tp->btrace.target = XCNEW (struct btrace_target_info);
13752 tp->btrace.target->ptid = tp->ptid;
13753 tp->btrace.target->conf = rs->btrace_config;
13757 /* Enable branch tracing. */
13759 struct btrace_target_info *
13760 remote_target::enable_btrace (ptid_t ptid, const struct btrace_config *conf)
13762 struct btrace_target_info *tinfo = NULL;
13763 struct packet_config *packet = NULL;
13764 struct remote_state *rs = get_remote_state ();
13765 char *buf = rs->buf;
13766 char *endbuf = rs->buf + get_remote_packet_size ();
13768 switch (conf->format)
13770 case BTRACE_FORMAT_BTS:
13771 packet = &remote_protocol_packets[PACKET_Qbtrace_bts];
13774 case BTRACE_FORMAT_PT:
13775 packet = &remote_protocol_packets[PACKET_Qbtrace_pt];
13779 if (packet == NULL || packet_config_support (packet) != PACKET_ENABLE)
13780 error (_("Target does not support branch tracing."));
13782 btrace_sync_conf (conf);
13784 set_general_thread (ptid);
13786 buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
13788 getpkt (&rs->buf, &rs->buf_size, 0);
13790 if (packet_ok (rs->buf, packet) == PACKET_ERROR)
13792 if (rs->buf[0] == 'E' && rs->buf[1] == '.')
13793 error (_("Could not enable branch tracing for %s: %s"),
13794 target_pid_to_str (ptid), rs->buf + 2);
13796 error (_("Could not enable branch tracing for %s."),
13797 target_pid_to_str (ptid));
13800 tinfo = XCNEW (struct btrace_target_info);
13801 tinfo->ptid = ptid;
13803 /* If we fail to read the configuration, we lose some information, but the
13804 tracing itself is not impacted. */
13807 btrace_read_config (&tinfo->conf);
13809 CATCH (err, RETURN_MASK_ERROR)
13811 if (err.message != NULL)
13812 warning ("%s", err.message);
13819 /* Disable branch tracing. */
13822 remote_target::disable_btrace (struct btrace_target_info *tinfo)
13824 struct packet_config *packet = &remote_protocol_packets[PACKET_Qbtrace_off];
13825 struct remote_state *rs = get_remote_state ();
13826 char *buf = rs->buf;
13827 char *endbuf = rs->buf + get_remote_packet_size ();
13829 if (packet_config_support (packet) != PACKET_ENABLE)
13830 error (_("Target does not support branch tracing."));
13832 set_general_thread (tinfo->ptid);
13834 buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
13836 getpkt (&rs->buf, &rs->buf_size, 0);
13838 if (packet_ok (rs->buf, packet) == PACKET_ERROR)
13840 if (rs->buf[0] == 'E' && rs->buf[1] == '.')
13841 error (_("Could not disable branch tracing for %s: %s"),
13842 target_pid_to_str (tinfo->ptid), rs->buf + 2);
13844 error (_("Could not disable branch tracing for %s."),
13845 target_pid_to_str (tinfo->ptid));
13851 /* Teardown branch tracing. */
13854 remote_target::teardown_btrace (struct btrace_target_info *tinfo)
13856 /* We must not talk to the target during teardown. */
13860 /* Read the branch trace. */
13863 remote_target::read_btrace (struct btrace_data *btrace,
13864 struct btrace_target_info *tinfo,
13865 enum btrace_read_type type)
13867 struct packet_config *packet = &remote_protocol_packets[PACKET_qXfer_btrace];
13870 if (packet_config_support (packet) != PACKET_ENABLE)
13871 error (_("Target does not support branch tracing."));
13873 #if !defined(HAVE_LIBEXPAT)
13874 error (_("Cannot process branch tracing result. XML parsing not supported."));
13879 case BTRACE_READ_ALL:
13882 case BTRACE_READ_NEW:
13885 case BTRACE_READ_DELTA:
13889 internal_error (__FILE__, __LINE__,
13890 _("Bad branch tracing read type: %u."),
13891 (unsigned int) type);
13894 gdb::optional<gdb::char_vector> xml
13895 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE, annex);
13897 return BTRACE_ERR_UNKNOWN;
13899 parse_xml_btrace (btrace, xml->data ());
13901 return BTRACE_ERR_NONE;
13904 const struct btrace_config *
13905 remote_target::btrace_conf (const struct btrace_target_info *tinfo)
13907 return &tinfo->conf;
13911 remote_target::augmented_libraries_svr4_read ()
13913 return (packet_support (PACKET_augmented_libraries_svr4_read_feature)
13917 /* Implementation of to_load. */
13920 remote_target::load (const char *name, int from_tty)
13922 generic_load (name, from_tty);
13925 /* Accepts an integer PID; returns a string representing a file that
13926 can be opened on the remote side to get the symbols for the child
13927 process. Returns NULL if the operation is not supported. */
13930 remote_target::pid_to_exec_file (int pid)
13932 static gdb::optional<gdb::char_vector> filename;
13933 struct inferior *inf;
13934 char *annex = NULL;
13936 if (packet_support (PACKET_qXfer_exec_file) != PACKET_ENABLE)
13939 inf = find_inferior_pid (pid);
13941 internal_error (__FILE__, __LINE__,
13942 _("not currently attached to process %d"), pid);
13944 if (!inf->fake_pid_p)
13946 const int annex_size = 9;
13948 annex = (char *) alloca (annex_size);
13949 xsnprintf (annex, annex_size, "%x", pid);
13952 filename = target_read_stralloc (current_top_target (),
13953 TARGET_OBJECT_EXEC_FILE, annex);
13955 return filename ? filename->data () : nullptr;
13958 /* Implement the to_can_do_single_step target_ops method. */
13961 remote_target::can_do_single_step ()
13963 /* We can only tell whether target supports single step or not by
13964 supported s and S vCont actions if the stub supports vContSupported
13965 feature. If the stub doesn't support vContSupported feature,
13966 we have conservatively to think target doesn't supports single
13968 if (packet_support (PACKET_vContSupported) == PACKET_ENABLE)
13970 struct remote_state *rs = get_remote_state ();
13972 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
13973 remote_vcont_probe ();
13975 return rs->supports_vCont.s && rs->supports_vCont.S;
13981 /* Implementation of the to_execution_direction method for the remote
13984 enum exec_direction_kind
13985 remote_target::execution_direction ()
13987 struct remote_state *rs = get_remote_state ();
13989 return rs->last_resume_exec_dir;
13992 /* Return pointer to the thread_info struct which corresponds to
13993 THREAD_HANDLE (having length HANDLE_LEN). */
13996 remote_target::thread_handle_to_thread_info (const gdb_byte *thread_handle,
14000 struct thread_info *tp;
14002 ALL_NON_EXITED_THREADS (tp)
14004 remote_thread_info *priv = get_remote_thread_info (tp);
14006 if (tp->inf == inf && priv != NULL)
14008 if (handle_len != priv->thread_handle.size ())
14009 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14010 handle_len, priv->thread_handle.size ());
14011 if (memcmp (thread_handle, priv->thread_handle.data (),
14021 remote_target::can_async_p ()
14023 struct remote_state *rs = get_remote_state ();
14025 /* We don't go async if the user has explicitly prevented it with the
14026 "maint set target-async" command. */
14027 if (!target_async_permitted)
14030 /* We're async whenever the serial device is. */
14031 return serial_can_async_p (rs->remote_desc);
14035 remote_target::is_async_p ()
14037 struct remote_state *rs = get_remote_state ();
14039 if (!target_async_permitted)
14040 /* We only enable async when the user specifically asks for it. */
14043 /* We're async whenever the serial device is. */
14044 return serial_is_async_p (rs->remote_desc);
14047 /* Pass the SERIAL event on and up to the client. One day this code
14048 will be able to delay notifying the client of an event until the
14049 point where an entire packet has been received. */
14051 static serial_event_ftype remote_async_serial_handler;
14054 remote_async_serial_handler (struct serial *scb, void *context)
14056 /* Don't propogate error information up to the client. Instead let
14057 the client find out about the error by querying the target. */
14058 inferior_event_handler (INF_REG_EVENT, NULL);
14062 remote_async_inferior_event_handler (gdb_client_data data)
14064 inferior_event_handler (INF_REG_EVENT, data);
14068 remote_target::async (int enable)
14070 struct remote_state *rs = get_remote_state ();
14074 serial_async (rs->remote_desc, remote_async_serial_handler, rs);
14076 /* If there are pending events in the stop reply queue tell the
14077 event loop to process them. */
14078 if (!rs->stop_reply_queue.empty ())
14079 mark_async_event_handler (rs->remote_async_inferior_event_token);
14080 /* For simplicity, below we clear the pending events token
14081 without remembering whether it is marked, so here we always
14082 mark it. If there's actually no pending notification to
14083 process, this ends up being a no-op (other than a spurious
14084 event-loop wakeup). */
14085 if (target_is_non_stop_p ())
14086 mark_async_event_handler (rs->notif_state->get_pending_events_token);
14090 serial_async (rs->remote_desc, NULL, NULL);
14091 /* If the core is disabling async, it doesn't want to be
14092 disturbed with target events. Clear all async event sources
14094 clear_async_event_handler (rs->remote_async_inferior_event_token);
14095 if (target_is_non_stop_p ())
14096 clear_async_event_handler (rs->notif_state->get_pending_events_token);
14100 /* Implementation of the to_thread_events method. */
14103 remote_target::thread_events (int enable)
14105 struct remote_state *rs = get_remote_state ();
14106 size_t size = get_remote_packet_size ();
14108 if (packet_support (PACKET_QThreadEvents) == PACKET_DISABLE)
14111 xsnprintf (rs->buf, size, "QThreadEvents:%x", enable ? 1 : 0);
14113 getpkt (&rs->buf, &rs->buf_size, 0);
14115 switch (packet_ok (rs->buf,
14116 &remote_protocol_packets[PACKET_QThreadEvents]))
14119 if (strcmp (rs->buf, "OK") != 0)
14120 error (_("Remote refused setting thread events: %s"), rs->buf);
14123 warning (_("Remote failure reply: %s"), rs->buf);
14125 case PACKET_UNKNOWN:
14131 set_remote_cmd (const char *args, int from_tty)
14133 help_list (remote_set_cmdlist, "set remote ", all_commands, gdb_stdout);
14137 show_remote_cmd (const char *args, int from_tty)
14139 /* We can't just use cmd_show_list here, because we want to skip
14140 the redundant "show remote Z-packet" and the legacy aliases. */
14141 struct cmd_list_element *list = remote_show_cmdlist;
14142 struct ui_out *uiout = current_uiout;
14144 ui_out_emit_tuple tuple_emitter (uiout, "showlist");
14145 for (; list != NULL; list = list->next)
14146 if (strcmp (list->name, "Z-packet") == 0)
14148 else if (list->type == not_set_cmd)
14149 /* Alias commands are exactly like the original, except they
14150 don't have the normal type. */
14154 ui_out_emit_tuple option_emitter (uiout, "option");
14156 uiout->field_string ("name", list->name);
14157 uiout->text (": ");
14158 if (list->type == show_cmd)
14159 do_show_command (NULL, from_tty, list);
14161 cmd_func (list, NULL, from_tty);
14166 /* Function to be called whenever a new objfile (shlib) is detected. */
14168 remote_new_objfile (struct objfile *objfile)
14170 remote_target *remote = get_current_remote_target ();
14172 if (remote != NULL) /* Have a remote connection. */
14173 remote->remote_check_symbols ();
14176 /* Pull all the tracepoints defined on the target and create local
14177 data structures representing them. We don't want to create real
14178 tracepoints yet, we don't want to mess up the user's existing
14182 remote_target::upload_tracepoints (struct uploaded_tp **utpp)
14184 struct remote_state *rs = get_remote_state ();
14187 /* Ask for a first packet of tracepoint definition. */
14189 getpkt (&rs->buf, &rs->buf_size, 0);
14191 while (*p && *p != 'l')
14193 parse_tracepoint_definition (p, utpp);
14194 /* Ask for another packet of tracepoint definition. */
14196 getpkt (&rs->buf, &rs->buf_size, 0);
14203 remote_target::upload_trace_state_variables (struct uploaded_tsv **utsvp)
14205 struct remote_state *rs = get_remote_state ();
14208 /* Ask for a first packet of variable definition. */
14210 getpkt (&rs->buf, &rs->buf_size, 0);
14212 while (*p && *p != 'l')
14214 parse_tsv_definition (p, utsvp);
14215 /* Ask for another packet of variable definition. */
14217 getpkt (&rs->buf, &rs->buf_size, 0);
14223 /* The "set/show range-stepping" show hook. */
14226 show_range_stepping (struct ui_file *file, int from_tty,
14227 struct cmd_list_element *c,
14230 fprintf_filtered (file,
14231 _("Debugger's willingness to use range stepping "
14232 "is %s.\n"), value);
14235 /* Return true if the vCont;r action is supported by the remote
14239 remote_target::vcont_r_supported ()
14241 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
14242 remote_vcont_probe ();
14244 return (packet_support (PACKET_vCont) == PACKET_ENABLE
14245 && get_remote_state ()->supports_vCont.r);
14248 /* The "set/show range-stepping" set hook. */
14251 set_range_stepping (const char *ignore_args, int from_tty,
14252 struct cmd_list_element *c)
14254 /* When enabling, check whether range stepping is actually supported
14255 by the target, and warn if not. */
14256 if (use_range_stepping)
14258 remote_target *remote = get_current_remote_target ();
14260 || !remote->vcont_r_supported ())
14261 warning (_("Range stepping is not supported by the current target"));
14266 _initialize_remote (void)
14268 struct cmd_list_element *cmd;
14269 const char *cmd_name;
14271 /* architecture specific data */
14272 remote_g_packet_data_handle =
14273 gdbarch_data_register_pre_init (remote_g_packet_data_init);
14276 = register_program_space_data_with_cleanup (NULL,
14277 remote_pspace_data_cleanup);
14279 add_target (remote_target_info, remote_target::open);
14280 add_target (extended_remote_target_info, extended_remote_target::open);
14282 /* Hook into new objfile notification. */
14283 gdb::observers::new_objfile.attach (remote_new_objfile);
14286 init_remote_threadtests ();
14289 /* set/show remote ... */
14291 add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
14292 Remote protocol specific variables\n\
14293 Configure various remote-protocol specific variables such as\n\
14294 the packets being used"),
14295 &remote_set_cmdlist, "set remote ",
14296 0 /* allow-unknown */, &setlist);
14297 add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\
14298 Remote protocol specific variables\n\
14299 Configure various remote-protocol specific variables such as\n\
14300 the packets being used"),
14301 &remote_show_cmdlist, "show remote ",
14302 0 /* allow-unknown */, &showlist);
14304 add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\
14305 Compare section data on target to the exec file.\n\
14306 Argument is a single section name (default: all loaded sections).\n\
14307 To compare only read-only loaded sections, specify the -r option."),
14310 add_cmd ("packet", class_maintenance, packet_command, _("\
14311 Send an arbitrary packet to a remote target.\n\
14312 maintenance packet TEXT\n\
14313 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14314 this command sends the string TEXT to the inferior, and displays the\n\
14315 response packet. GDB supplies the initial `$' character, and the\n\
14316 terminating `#' character and checksum."),
14319 add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
14320 Set whether to send break if interrupted."), _("\
14321 Show whether to send break if interrupted."), _("\
14322 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14323 set_remotebreak, show_remotebreak,
14324 &setlist, &showlist);
14325 cmd_name = "remotebreak";
14326 cmd = lookup_cmd (&cmd_name, setlist, "", -1, 1);
14327 deprecate_cmd (cmd, "set remote interrupt-sequence");
14328 cmd_name = "remotebreak"; /* needed because lookup_cmd updates the pointer */
14329 cmd = lookup_cmd (&cmd_name, showlist, "", -1, 1);
14330 deprecate_cmd (cmd, "show remote interrupt-sequence");
14332 add_setshow_enum_cmd ("interrupt-sequence", class_support,
14333 interrupt_sequence_modes, &interrupt_sequence_mode,
14335 Set interrupt sequence to remote target."), _("\
14336 Show interrupt sequence to remote target."), _("\
14337 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14338 NULL, show_interrupt_sequence,
14339 &remote_set_cmdlist,
14340 &remote_show_cmdlist);
14342 add_setshow_boolean_cmd ("interrupt-on-connect", class_support,
14343 &interrupt_on_connect, _("\
14344 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14345 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14346 If set, interrupt sequence is sent to remote target."),
14348 &remote_set_cmdlist, &remote_show_cmdlist);
14350 /* Install commands for configuring memory read/write packets. */
14352 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\
14353 Set the maximum number of bytes per memory write packet (deprecated)."),
14355 add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\
14356 Show the maximum number of bytes per memory write packet (deprecated)."),
14358 add_cmd ("memory-write-packet-size", no_class,
14359 set_memory_write_packet_size, _("\
14360 Set the maximum number of bytes per memory-write packet.\n\
14361 Specify the number of bytes in a packet or 0 (zero) for the\n\
14362 default packet size. The actual limit is further reduced\n\
14363 dependent on the target. Specify ``fixed'' to disable the\n\
14364 further restriction and ``limit'' to enable that restriction."),
14365 &remote_set_cmdlist);
14366 add_cmd ("memory-read-packet-size", no_class,
14367 set_memory_read_packet_size, _("\
14368 Set the maximum number of bytes per memory-read packet.\n\
14369 Specify the number of bytes in a packet or 0 (zero) for the\n\
14370 default packet size. The actual limit is further reduced\n\
14371 dependent on the target. Specify ``fixed'' to disable the\n\
14372 further restriction and ``limit'' to enable that restriction."),
14373 &remote_set_cmdlist);
14374 add_cmd ("memory-write-packet-size", no_class,
14375 show_memory_write_packet_size,
14376 _("Show the maximum number of bytes per memory-write packet."),
14377 &remote_show_cmdlist);
14378 add_cmd ("memory-read-packet-size", no_class,
14379 show_memory_read_packet_size,
14380 _("Show the maximum number of bytes per memory-read packet."),
14381 &remote_show_cmdlist);
14383 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class,
14384 &remote_hw_watchpoint_limit, _("\
14385 Set the maximum number of target hardware watchpoints."), _("\
14386 Show the maximum number of target hardware watchpoints."), _("\
14387 Specify \"unlimited\" for unlimited hardware watchpoints."),
14388 NULL, show_hardware_watchpoint_limit,
14389 &remote_set_cmdlist,
14390 &remote_show_cmdlist);
14391 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14393 &remote_hw_watchpoint_length_limit, _("\
14394 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14395 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14396 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14397 NULL, show_hardware_watchpoint_length_limit,
14398 &remote_set_cmdlist, &remote_show_cmdlist);
14399 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class,
14400 &remote_hw_breakpoint_limit, _("\
14401 Set the maximum number of target hardware breakpoints."), _("\
14402 Show the maximum number of target hardware breakpoints."), _("\
14403 Specify \"unlimited\" for unlimited hardware breakpoints."),
14404 NULL, show_hardware_breakpoint_limit,
14405 &remote_set_cmdlist, &remote_show_cmdlist);
14407 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure,
14408 &remote_address_size, _("\
14409 Set the maximum size of the address (in bits) in a memory packet."), _("\
14410 Show the maximum size of the address (in bits) in a memory packet."), NULL,
14412 NULL, /* FIXME: i18n: */
14413 &setlist, &showlist);
14415 init_all_packet_configs ();
14417 add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
14418 "X", "binary-download", 1);
14420 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont],
14421 "vCont", "verbose-resume", 0);
14423 add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals],
14424 "QPassSignals", "pass-signals", 0);
14426 add_packet_config_cmd (&remote_protocol_packets[PACKET_QCatchSyscalls],
14427 "QCatchSyscalls", "catch-syscalls", 0);
14429 add_packet_config_cmd (&remote_protocol_packets[PACKET_QProgramSignals],
14430 "QProgramSignals", "program-signals", 0);
14432 add_packet_config_cmd (&remote_protocol_packets[PACKET_QSetWorkingDir],
14433 "QSetWorkingDir", "set-working-dir", 0);
14435 add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartupWithShell],
14436 "QStartupWithShell", "startup-with-shell", 0);
14438 add_packet_config_cmd (&remote_protocol_packets
14439 [PACKET_QEnvironmentHexEncoded],
14440 "QEnvironmentHexEncoded", "environment-hex-encoded",
14443 add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentReset],
14444 "QEnvironmentReset", "environment-reset",
14447 add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentUnset],
14448 "QEnvironmentUnset", "environment-unset",
14451 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
14452 "qSymbol", "symbol-lookup", 0);
14454 add_packet_config_cmd (&remote_protocol_packets[PACKET_P],
14455 "P", "set-register", 1);
14457 add_packet_config_cmd (&remote_protocol_packets[PACKET_p],
14458 "p", "fetch-register", 1);
14460 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0],
14461 "Z0", "software-breakpoint", 0);
14463 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1],
14464 "Z1", "hardware-breakpoint", 0);
14466 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2],
14467 "Z2", "write-watchpoint", 0);
14469 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3],
14470 "Z3", "read-watchpoint", 0);
14472 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4],
14473 "Z4", "access-watchpoint", 0);
14475 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv],
14476 "qXfer:auxv:read", "read-aux-vector", 0);
14478 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_exec_file],
14479 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14481 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features],
14482 "qXfer:features:read", "target-features", 0);
14484 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries],
14485 "qXfer:libraries:read", "library-info", 0);
14487 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries_svr4],
14488 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14490 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
14491 "qXfer:memory-map:read", "memory-map", 0);
14493 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_read],
14494 "qXfer:spu:read", "read-spu-object", 0);
14496 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write],
14497 "qXfer:spu:write", "write-spu-object", 0);
14499 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata],
14500 "qXfer:osdata:read", "osdata", 0);
14502 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_threads],
14503 "qXfer:threads:read", "threads", 0);
14505 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_read],
14506 "qXfer:siginfo:read", "read-siginfo-object", 0);
14508 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_write],
14509 "qXfer:siginfo:write", "write-siginfo-object", 0);
14511 add_packet_config_cmd
14512 (&remote_protocol_packets[PACKET_qXfer_traceframe_info],
14513 "qXfer:traceframe-info:read", "traceframe-info", 0);
14515 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_uib],
14516 "qXfer:uib:read", "unwind-info-block", 0);
14518 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
14519 "qGetTLSAddr", "get-thread-local-storage-address",
14522 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTIBAddr],
14523 "qGetTIBAddr", "get-thread-information-block-address",
14526 add_packet_config_cmd (&remote_protocol_packets[PACKET_bc],
14527 "bc", "reverse-continue", 0);
14529 add_packet_config_cmd (&remote_protocol_packets[PACKET_bs],
14530 "bs", "reverse-step", 0);
14532 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported],
14533 "qSupported", "supported-packets", 0);
14535 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSearch_memory],
14536 "qSearch:memory", "search-memory", 0);
14538 add_packet_config_cmd (&remote_protocol_packets[PACKET_qTStatus],
14539 "qTStatus", "trace-status", 0);
14541 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_setfs],
14542 "vFile:setfs", "hostio-setfs", 0);
14544 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_open],
14545 "vFile:open", "hostio-open", 0);
14547 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pread],
14548 "vFile:pread", "hostio-pread", 0);
14550 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pwrite],
14551 "vFile:pwrite", "hostio-pwrite", 0);
14553 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_close],
14554 "vFile:close", "hostio-close", 0);
14556 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_unlink],
14557 "vFile:unlink", "hostio-unlink", 0);
14559 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_readlink],
14560 "vFile:readlink", "hostio-readlink", 0);
14562 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_fstat],
14563 "vFile:fstat", "hostio-fstat", 0);
14565 add_packet_config_cmd (&remote_protocol_packets[PACKET_vAttach],
14566 "vAttach", "attach", 0);
14568 add_packet_config_cmd (&remote_protocol_packets[PACKET_vRun],
14571 add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartNoAckMode],
14572 "QStartNoAckMode", "noack", 0);
14574 add_packet_config_cmd (&remote_protocol_packets[PACKET_vKill],
14575 "vKill", "kill", 0);
14577 add_packet_config_cmd (&remote_protocol_packets[PACKET_qAttached],
14578 "qAttached", "query-attached", 0);
14580 add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints],
14581 "ConditionalTracepoints",
14582 "conditional-tracepoints", 0);
14584 add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalBreakpoints],
14585 "ConditionalBreakpoints",
14586 "conditional-breakpoints", 0);
14588 add_packet_config_cmd (&remote_protocol_packets[PACKET_BreakpointCommands],
14589 "BreakpointCommands",
14590 "breakpoint-commands", 0);
14592 add_packet_config_cmd (&remote_protocol_packets[PACKET_FastTracepoints],
14593 "FastTracepoints", "fast-tracepoints", 0);
14595 add_packet_config_cmd (&remote_protocol_packets[PACKET_TracepointSource],
14596 "TracepointSource", "TracepointSource", 0);
14598 add_packet_config_cmd (&remote_protocol_packets[PACKET_QAllow],
14599 "QAllow", "allow", 0);
14601 add_packet_config_cmd (&remote_protocol_packets[PACKET_StaticTracepoints],
14602 "StaticTracepoints", "static-tracepoints", 0);
14604 add_packet_config_cmd (&remote_protocol_packets[PACKET_InstallInTrace],
14605 "InstallInTrace", "install-in-trace", 0);
14607 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read],
14608 "qXfer:statictrace:read", "read-sdata-object", 0);
14610 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_fdpic],
14611 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14613 add_packet_config_cmd (&remote_protocol_packets[PACKET_QDisableRandomization],
14614 "QDisableRandomization", "disable-randomization", 0);
14616 add_packet_config_cmd (&remote_protocol_packets[PACKET_QAgent],
14617 "QAgent", "agent", 0);
14619 add_packet_config_cmd (&remote_protocol_packets[PACKET_QTBuffer_size],
14620 "QTBuffer:size", "trace-buffer-size", 0);
14622 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_off],
14623 "Qbtrace:off", "disable-btrace", 0);
14625 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_bts],
14626 "Qbtrace:bts", "enable-btrace-bts", 0);
14628 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_pt],
14629 "Qbtrace:pt", "enable-btrace-pt", 0);
14631 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace],
14632 "qXfer:btrace", "read-btrace", 0);
14634 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace_conf],
14635 "qXfer:btrace-conf", "read-btrace-conf", 0);
14637 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_bts_size],
14638 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14640 add_packet_config_cmd (&remote_protocol_packets[PACKET_multiprocess_feature],
14641 "multiprocess-feature", "multiprocess-feature", 0);
14643 add_packet_config_cmd (&remote_protocol_packets[PACKET_swbreak_feature],
14644 "swbreak-feature", "swbreak-feature", 0);
14646 add_packet_config_cmd (&remote_protocol_packets[PACKET_hwbreak_feature],
14647 "hwbreak-feature", "hwbreak-feature", 0);
14649 add_packet_config_cmd (&remote_protocol_packets[PACKET_fork_event_feature],
14650 "fork-event-feature", "fork-event-feature", 0);
14652 add_packet_config_cmd (&remote_protocol_packets[PACKET_vfork_event_feature],
14653 "vfork-event-feature", "vfork-event-feature", 0);
14655 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_pt_size],
14656 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14658 add_packet_config_cmd (&remote_protocol_packets[PACKET_vContSupported],
14659 "vContSupported", "verbose-resume-supported", 0);
14661 add_packet_config_cmd (&remote_protocol_packets[PACKET_exec_event_feature],
14662 "exec-event-feature", "exec-event-feature", 0);
14664 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCtrlC],
14665 "vCtrlC", "ctrl-c", 0);
14667 add_packet_config_cmd (&remote_protocol_packets[PACKET_QThreadEvents],
14668 "QThreadEvents", "thread-events", 0);
14670 add_packet_config_cmd (&remote_protocol_packets[PACKET_no_resumed],
14671 "N stop reply", "no-resumed-stop-reply", 0);
14673 /* Assert that we've registered "set remote foo-packet" commands
14674 for all packet configs. */
14678 for (i = 0; i < PACKET_MAX; i++)
14680 /* Ideally all configs would have a command associated. Some
14681 still don't though. */
14686 case PACKET_QNonStop:
14687 case PACKET_EnableDisableTracepoints_feature:
14688 case PACKET_tracenz_feature:
14689 case PACKET_DisconnectedTracing_feature:
14690 case PACKET_augmented_libraries_svr4_read_feature:
14692 /* Additions to this list need to be well justified:
14693 pre-existing packets are OK; new packets are not. */
14701 /* This catches both forgetting to add a config command, and
14702 forgetting to remove a packet from the exception list. */
14703 gdb_assert (excepted == (remote_protocol_packets[i].name == NULL));
14707 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14708 Z sub-packet has its own set and show commands, but users may
14709 have sets to this variable in their .gdbinit files (or in their
14711 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
14712 &remote_Z_packet_detect, _("\
14713 Set use of remote protocol `Z' packets"), _("\
14714 Show use of remote protocol `Z' packets "), _("\
14715 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14717 set_remote_protocol_Z_packet_cmd,
14718 show_remote_protocol_Z_packet_cmd,
14719 /* FIXME: i18n: Use of remote protocol
14720 `Z' packets is %s. */
14721 &remote_set_cmdlist, &remote_show_cmdlist);
14723 add_prefix_cmd ("remote", class_files, remote_command, _("\
14724 Manipulate files on the remote system\n\
14725 Transfer files to and from the remote target system."),
14726 &remote_cmdlist, "remote ",
14727 0 /* allow-unknown */, &cmdlist);
14729 add_cmd ("put", class_files, remote_put_command,
14730 _("Copy a local file to the remote system."),
14733 add_cmd ("get", class_files, remote_get_command,
14734 _("Copy a remote file to the local system."),
14737 add_cmd ("delete", class_files, remote_delete_command,
14738 _("Delete a remote file."),
14741 add_setshow_string_noescape_cmd ("exec-file", class_files,
14742 &remote_exec_file_var, _("\
14743 Set the remote pathname for \"run\""), _("\
14744 Show the remote pathname for \"run\""), NULL,
14745 set_remote_exec_file,
14746 show_remote_exec_file,
14747 &remote_set_cmdlist,
14748 &remote_show_cmdlist);
14750 add_setshow_boolean_cmd ("range-stepping", class_run,
14751 &use_range_stepping, _("\
14752 Enable or disable range stepping."), _("\
14753 Show whether target-assisted range stepping is enabled."), _("\
14754 If on, and the target supports it, when stepping a source line, GDB\n\
14755 tells the target to step the corresponding range of addresses itself instead\n\
14756 of issuing multiple single-steps. This speeds up source level\n\
14757 stepping. If off, GDB always issues single-steps, even if range\n\
14758 stepping is supported by the target. The default is on."),
14759 set_range_stepping,
14760 show_range_stepping,
14764 /* Eventually initialize fileio. See fileio.c */
14765 initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);
14767 /* Take advantage of the fact that the TID field is not used, to tag
14768 special ptids with it set to != 0. */
14769 magic_null_ptid = ptid_t (42000, -1, 1);
14770 not_sent_ptid = ptid_t (42000, -2, 1);
14771 any_thread_ptid = ptid_t (42000, 0, 1);