1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2022 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 "process-stratum-target.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 "gdbsupport/filestuff.h"
46 #include "gdbsupport/rsp-low.h"
50 #include "gdbsupport/gdb_sys_time.h"
52 #include "gdbsupport/event-loop.h"
53 #include "event-top.h"
61 #include "remote-fileio.h"
62 #include "gdb/fileio.h"
64 #include "xml-support.h"
66 #include "memory-map.h"
68 #include "tracepoint.h"
71 #include "gdbsupport/agent.h"
73 #include "record-btrace.h"
75 #include "gdbsupport/scoped_restore.h"
76 #include "gdbsupport/environ.h"
77 #include "gdbsupport/byte-vector.h"
78 #include "gdbsupport/search.h"
80 #include <unordered_map>
81 #include "async-event.h"
82 #include "gdbsupport/selftest.h"
84 /* The remote target. */
86 static const char remote_doc
[] = N_("\
87 Use a remote computer via a serial line, using a gdb-specific protocol.\n\
88 Specify the serial device it is connected to\n\
89 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
93 bool remote_debug
= false;
95 #define OPAQUETHREADBYTES 8
97 /* a 64 bit opaque identifier */
98 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
100 struct gdb_ext_thread_info
;
101 struct threads_listing_context
;
102 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
103 struct protocol_feature
;
107 typedef std::unique_ptr
<stop_reply
> stop_reply_up
;
109 /* Generic configuration support for packets the stub optionally
110 supports. Allows the user to specify the use of the packet as well
111 as allowing GDB to auto-detect support in the remote stub. */
115 PACKET_SUPPORT_UNKNOWN
= 0,
120 /* Analyze a packet's return value and update the packet config
130 struct threads_listing_context
;
132 /* Stub vCont actions support.
134 Each field is a boolean flag indicating whether the stub reports
135 support for the corresponding action. */
137 struct vCont_action_support
152 /* About this many threadids fit in a packet. */
154 #define MAXTHREADLISTRESULTS 32
156 /* Data for the vFile:pread readahead cache. */
158 struct readahead_cache
160 /* Invalidate the readahead cache. */
163 /* Invalidate the readahead cache if it is holding data for FD. */
164 void invalidate_fd (int fd
);
166 /* Serve pread from the readahead cache. Returns number of bytes
167 read, or 0 if the request can't be served from the cache. */
168 int pread (int fd
, gdb_byte
*read_buf
, size_t len
, ULONGEST offset
);
170 /* The file descriptor for the file that is being cached. -1 if the
174 /* The offset into the file that the cache buffer corresponds
178 /* The buffer holding the cache contents. */
179 gdb_byte
*buf
= nullptr;
180 /* The buffer's size. We try to read as much as fits into a packet
184 /* Cache hit and miss counters. */
185 ULONGEST hit_count
= 0;
186 ULONGEST miss_count
= 0;
189 /* Description of the remote protocol for a given architecture. */
193 long offset
; /* Offset into G packet. */
194 long regnum
; /* GDB's internal register number. */
195 LONGEST pnum
; /* Remote protocol register number. */
196 int in_g_packet
; /* Always part of G packet. */
197 /* long size in bytes; == register_size (target_gdbarch (), regnum);
199 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
203 struct remote_arch_state
205 explicit remote_arch_state (struct gdbarch
*gdbarch
);
207 /* Description of the remote protocol registers. */
208 long sizeof_g_packet
;
210 /* Description of the remote protocol registers indexed by REGNUM
211 (making an array gdbarch_num_regs in size). */
212 std::unique_ptr
<packet_reg
[]> regs
;
214 /* This is the size (in chars) of the first response to the ``g''
215 packet. It is used as a heuristic when determining the maximum
216 size of memory-read and memory-write packets. A target will
217 typically only reserve a buffer large enough to hold the ``g''
218 packet. The size does not include packet overhead (headers and
220 long actual_register_packet_size
;
222 /* This is the maximum size (in chars) of a non read/write packet.
223 It is also used as a cap on the size of read/write packets. */
224 long remote_packet_size
;
227 /* Description of the remote protocol state for the currently
228 connected target. This is per-target state, and independent of the
229 selected architecture. */
238 /* Get the remote arch state for GDBARCH. */
239 struct remote_arch_state
*get_remote_arch_state (struct gdbarch
*gdbarch
);
243 /* A buffer to use for incoming packets, and its current size. The
244 buffer is grown dynamically for larger incoming packets.
245 Outgoing packets may also be constructed in this buffer.
246 The size of the buffer is always at least REMOTE_PACKET_SIZE;
247 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
249 gdb::char_vector buf
;
251 /* True if we're going through initial connection setup (finding out
252 about the remote side's threads, relocating symbols, etc.). */
253 bool starting_up
= false;
255 /* If we negotiated packet size explicitly (and thus can bypass
256 heuristics for the largest packet size that will not overflow
257 a buffer in the stub), this will be set to that packet size.
258 Otherwise zero, meaning to use the guessed size. */
259 long explicit_packet_size
= 0;
261 /* True, if in no ack mode. That is, neither GDB nor the stub will
262 expect acks from each other. The connection is assumed to be
264 bool noack_mode
= false;
266 /* True if we're connected in extended remote mode. */
267 bool extended
= false;
269 /* True if we resumed the target and we're waiting for the target to
270 stop. In the mean time, we can't start another command/query.
271 The remote server wouldn't be ready to process it, so we'd
272 timeout waiting for a reply that would never come and eventually
273 we'd close the connection. This can happen in asynchronous mode
274 because we allow GDB commands while the target is running. */
275 bool waiting_for_stop_reply
= false;
277 /* The status of the stub support for the various vCont actions. */
278 vCont_action_support supports_vCont
;
279 /* Whether vCont support was probed already. This is a workaround
280 until packet_support is per-connection. */
281 bool supports_vCont_probed
;
283 /* True if the user has pressed Ctrl-C, but the target hasn't
284 responded to that. */
285 bool ctrlc_pending_p
= false;
287 /* True if we saw a Ctrl-C while reading or writing from/to the
288 remote descriptor. At that point it is not safe to send a remote
289 interrupt packet, so we instead remember we saw the Ctrl-C and
290 process it once we're done with sending/receiving the current
291 packet, which should be shortly. If however that takes too long,
292 and the user presses Ctrl-C again, we offer to disconnect. */
293 bool got_ctrlc_during_io
= false;
295 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
296 remote_open knows that we don't have a file open when the program
298 struct serial
*remote_desc
= nullptr;
300 /* These are the threads which we last sent to the remote system. The
301 TID member will be -1 for all or -2 for not sent yet. */
302 ptid_t general_thread
= null_ptid
;
303 ptid_t continue_thread
= null_ptid
;
305 /* This is the traceframe which we last selected on the remote system.
306 It will be -1 if no traceframe is selected. */
307 int remote_traceframe_number
= -1;
309 char *last_pass_packet
= nullptr;
311 /* The last QProgramSignals packet sent to the target. We bypass
312 sending a new program signals list down to the target if the new
313 packet is exactly the same as the last we sent. IOW, we only let
314 the target know about program signals list changes. */
315 char *last_program_signals_packet
= nullptr;
317 gdb_signal last_sent_signal
= GDB_SIGNAL_0
;
319 bool last_sent_step
= false;
321 /* The execution direction of the last resume we got. */
322 exec_direction_kind last_resume_exec_dir
= EXEC_FORWARD
;
324 char *finished_object
= nullptr;
325 char *finished_annex
= nullptr;
326 ULONGEST finished_offset
= 0;
328 /* Should we try the 'ThreadInfo' query packet?
330 This variable (NOT available to the user: auto-detect only!)
331 determines whether GDB will use the new, simpler "ThreadInfo"
332 query or the older, more complex syntax for thread queries.
333 This is an auto-detect variable (set to true at each connect,
334 and set to false when the target fails to recognize it). */
335 bool use_threadinfo_query
= false;
336 bool use_threadextra_query
= false;
338 threadref echo_nextthread
{};
339 threadref nextthread
{};
340 threadref resultthreadlist
[MAXTHREADLISTRESULTS
] {};
342 /* The state of remote notification. */
343 struct remote_notif_state
*notif_state
= nullptr;
345 /* The branch trace configuration. */
346 struct btrace_config btrace_config
{};
348 /* The argument to the last "vFile:setfs:" packet we sent, used
349 to avoid sending repeated unnecessary "vFile:setfs:" packets.
350 Initialized to -1 to indicate that no "vFile:setfs:" packet
351 has yet been sent. */
354 /* A readahead cache for vFile:pread. Often, reading a binary
355 involves a sequence of small reads. E.g., when parsing an ELF
356 file. A readahead cache helps mostly the case of remote
357 debugging on a connection with higher latency, due to the
358 request/reply nature of the RSP. We only cache data for a single
359 file descriptor at a time. */
360 struct readahead_cache readahead_cache
;
362 /* The list of already fetched and acknowledged stop events. This
363 queue is used for notification Stop, and other notifications
364 don't need queue for their events, because the notification
365 events of Stop can't be consumed immediately, so that events
366 should be queued first, and be consumed by remote_wait_{ns,as}
367 one per time. Other notifications can consume their events
368 immediately, so queue is not needed for them. */
369 std::vector
<stop_reply_up
> stop_reply_queue
;
371 /* Asynchronous signal handle registered as event loop source for
372 when we have pending events ready to be passed to the core. */
373 struct async_event_handler
*remote_async_inferior_event_token
= nullptr;
375 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
376 ``forever'' still use the normal timeout mechanism. This is
377 currently used by the ASYNC code to guarentee that target reads
378 during the initial connect always time-out. Once getpkt has been
379 modified to return a timeout indication and, in turn
380 remote_wait()/wait_for_inferior() have gained a timeout parameter
382 int wait_forever_enabled_p
= 1;
385 /* Mapping of remote protocol data for each gdbarch. Usually there
386 is only one entry here, though we may see more with stubs that
387 support multi-process. */
388 std::unordered_map
<struct gdbarch
*, remote_arch_state
>
392 static const target_info remote_target_info
= {
394 N_("Remote target using gdb-specific protocol"),
398 class remote_target
: public process_stratum_target
401 remote_target () = default;
402 ~remote_target () override
;
404 const target_info
&info () const override
405 { return remote_target_info
; }
407 const char *connection_string () override
;
409 thread_control_capabilities
get_thread_control_capabilities () override
410 { return tc_schedlock
; }
412 /* Open a remote connection. */
413 static void open (const char *, int);
415 void close () override
;
417 void detach (inferior
*, int) override
;
418 void disconnect (const char *, int) override
;
420 void commit_resumed () override
;
421 void resume (ptid_t
, int, enum gdb_signal
) override
;
422 ptid_t
wait (ptid_t
, struct target_waitstatus
*, target_wait_flags
) override
;
423 bool has_pending_events () override
;
425 void fetch_registers (struct regcache
*, int) override
;
426 void store_registers (struct regcache
*, int) override
;
427 void prepare_to_store (struct regcache
*) override
;
429 int insert_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
431 int remove_breakpoint (struct gdbarch
*, struct bp_target_info
*,
432 enum remove_bp_reason
) override
;
435 bool stopped_by_sw_breakpoint () override
;
436 bool supports_stopped_by_sw_breakpoint () override
;
438 bool stopped_by_hw_breakpoint () override
;
440 bool supports_stopped_by_hw_breakpoint () override
;
442 bool stopped_by_watchpoint () override
;
444 bool stopped_data_address (CORE_ADDR
*) override
;
446 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
448 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
450 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
452 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
454 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
456 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
457 struct expression
*) override
;
459 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
460 struct expression
*) override
;
462 void kill () override
;
464 void load (const char *, int) override
;
466 void mourn_inferior () override
;
468 void pass_signals (gdb::array_view
<const unsigned char>) override
;
470 int set_syscall_catchpoint (int, bool, int,
471 gdb::array_view
<const int>) override
;
473 void program_signals (gdb::array_view
<const unsigned char>) override
;
475 bool thread_alive (ptid_t ptid
) override
;
477 const char *thread_name (struct thread_info
*) override
;
479 void update_thread_list () override
;
481 std::string
pid_to_str (ptid_t
) override
;
483 const char *extra_thread_info (struct thread_info
*) override
;
485 ptid_t
get_ada_task_ptid (long lwp
, ULONGEST thread
) override
;
487 thread_info
*thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
489 inferior
*inf
) override
;
491 gdb::byte_vector
thread_info_to_thread_handle (struct thread_info
*tp
)
494 void stop (ptid_t
) override
;
496 void interrupt () override
;
498 void pass_ctrlc () override
;
500 enum target_xfer_status
xfer_partial (enum target_object object
,
503 const gdb_byte
*writebuf
,
504 ULONGEST offset
, ULONGEST len
,
505 ULONGEST
*xfered_len
) override
;
507 ULONGEST
get_memory_xfer_limit () override
;
509 void rcmd (const char *command
, struct ui_file
*output
) override
;
511 char *pid_to_exec_file (int pid
) override
;
513 void log_command (const char *cmd
) override
515 serial_log_command (this, cmd
);
518 CORE_ADDR
get_thread_local_address (ptid_t ptid
,
519 CORE_ADDR load_module_addr
,
520 CORE_ADDR offset
) override
;
522 bool can_execute_reverse () override
;
524 std::vector
<mem_region
> memory_map () override
;
526 void flash_erase (ULONGEST address
, LONGEST length
) override
;
528 void flash_done () override
;
530 const struct target_desc
*read_description () override
;
532 int search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
533 const gdb_byte
*pattern
, ULONGEST pattern_len
,
534 CORE_ADDR
*found_addrp
) override
;
536 bool can_async_p () override
;
538 bool is_async_p () override
;
540 void async (int) override
;
542 int async_wait_fd () override
;
544 void thread_events (int) override
;
546 int can_do_single_step () override
;
548 void terminal_inferior () override
;
550 void terminal_ours () override
;
552 bool supports_non_stop () override
;
554 bool supports_multi_process () override
;
556 bool supports_disable_randomization () override
;
558 bool filesystem_is_local () override
;
561 int fileio_open (struct inferior
*inf
, const char *filename
,
562 int flags
, int mode
, int warn_if_slow
,
563 int *target_errno
) override
;
565 int fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
566 ULONGEST offset
, int *target_errno
) override
;
568 int fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
569 ULONGEST offset
, int *target_errno
) override
;
571 int fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
) override
;
573 int fileio_close (int fd
, int *target_errno
) override
;
575 int fileio_unlink (struct inferior
*inf
,
576 const char *filename
,
577 int *target_errno
) override
;
579 gdb::optional
<std::string
>
580 fileio_readlink (struct inferior
*inf
,
581 const char *filename
,
582 int *target_errno
) override
;
584 bool supports_enable_disable_tracepoint () override
;
586 bool supports_string_tracing () override
;
588 bool supports_evaluation_of_breakpoint_conditions () override
;
590 bool can_run_breakpoint_commands () override
;
592 void trace_init () override
;
594 void download_tracepoint (struct bp_location
*location
) override
;
596 bool can_download_tracepoint () override
;
598 void download_trace_state_variable (const trace_state_variable
&tsv
) override
;
600 void enable_tracepoint (struct bp_location
*location
) override
;
602 void disable_tracepoint (struct bp_location
*location
) override
;
604 void trace_set_readonly_regions () override
;
606 void trace_start () override
;
608 int get_trace_status (struct trace_status
*ts
) override
;
610 void get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
613 void trace_stop () override
;
615 int trace_find (enum trace_find_type type
, int num
,
616 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
) override
;
618 bool get_trace_state_variable_value (int tsv
, LONGEST
*val
) override
;
620 int save_trace_data (const char *filename
) override
;
622 int upload_tracepoints (struct uploaded_tp
**utpp
) override
;
624 int upload_trace_state_variables (struct uploaded_tsv
**utsvp
) override
;
626 LONGEST
get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
) override
;
628 int get_min_fast_tracepoint_insn_len () override
;
630 void set_disconnected_tracing (int val
) override
;
632 void set_circular_trace_buffer (int val
) override
;
634 void set_trace_buffer_size (LONGEST val
) override
;
636 bool set_trace_notes (const char *user
, const char *notes
,
637 const char *stopnotes
) override
;
639 int core_of_thread (ptid_t ptid
) override
;
641 int verify_memory (const gdb_byte
*data
,
642 CORE_ADDR memaddr
, ULONGEST size
) override
;
645 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
647 void set_permissions () override
;
649 bool static_tracepoint_marker_at (CORE_ADDR
,
650 struct static_tracepoint_marker
*marker
)
653 std::vector
<static_tracepoint_marker
>
654 static_tracepoint_markers_by_strid (const char *id
) override
;
656 traceframe_info_up
traceframe_info () override
;
658 bool use_agent (bool use
) override
;
659 bool can_use_agent () override
;
661 struct btrace_target_info
*
662 enable_btrace (thread_info
*tp
, const struct btrace_config
*conf
) override
;
664 void disable_btrace (struct btrace_target_info
*tinfo
) override
;
666 void teardown_btrace (struct btrace_target_info
*tinfo
) override
;
668 enum btrace_error
read_btrace (struct btrace_data
*data
,
669 struct btrace_target_info
*btinfo
,
670 enum btrace_read_type type
) override
;
672 const struct btrace_config
*btrace_conf (const struct btrace_target_info
*) override
;
673 bool augmented_libraries_svr4_read () override
;
674 void follow_fork (inferior
*, ptid_t
, target_waitkind
, bool, bool) override
;
675 void follow_exec (inferior
*, ptid_t
, const char *) override
;
676 int insert_fork_catchpoint (int) override
;
677 int remove_fork_catchpoint (int) override
;
678 int insert_vfork_catchpoint (int) override
;
679 int remove_vfork_catchpoint (int) override
;
680 int insert_exec_catchpoint (int) override
;
681 int remove_exec_catchpoint (int) override
;
682 enum exec_direction_kind
execution_direction () override
;
684 bool supports_memory_tagging () override
;
686 bool fetch_memtags (CORE_ADDR address
, size_t len
,
687 gdb::byte_vector
&tags
, int type
) override
;
689 bool store_memtags (CORE_ADDR address
, size_t len
,
690 const gdb::byte_vector
&tags
, int type
) override
;
692 public: /* Remote specific methods. */
694 void remote_download_command_source (int num
, ULONGEST addr
,
695 struct command_line
*cmds
);
697 void remote_file_put (const char *local_file
, const char *remote_file
,
699 void remote_file_get (const char *remote_file
, const char *local_file
,
701 void remote_file_delete (const char *remote_file
, int from_tty
);
703 int remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
704 ULONGEST offset
, int *remote_errno
);
705 int remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
706 ULONGEST offset
, int *remote_errno
);
707 int remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
708 ULONGEST offset
, int *remote_errno
);
710 int remote_hostio_send_command (int command_bytes
, int which_packet
,
711 int *remote_errno
, const char **attachment
,
712 int *attachment_len
);
713 int remote_hostio_set_filesystem (struct inferior
*inf
,
715 /* We should get rid of this and use fileio_open directly. */
716 int remote_hostio_open (struct inferior
*inf
, const char *filename
,
717 int flags
, int mode
, int warn_if_slow
,
719 int remote_hostio_close (int fd
, int *remote_errno
);
721 int remote_hostio_unlink (inferior
*inf
, const char *filename
,
724 struct remote_state
*get_remote_state ();
726 long get_remote_packet_size (void);
727 long get_memory_packet_size (struct memory_packet_config
*config
);
729 long get_memory_write_packet_size ();
730 long get_memory_read_packet_size ();
732 char *append_pending_thread_resumptions (char *p
, char *endp
,
734 static void open_1 (const char *name
, int from_tty
, int extended_p
);
735 void start_remote (int from_tty
, int extended_p
);
736 void remote_detach_1 (struct inferior
*inf
, int from_tty
);
738 char *append_resumption (char *p
, char *endp
,
739 ptid_t ptid
, int step
, gdb_signal siggnal
);
740 int remote_resume_with_vcont (ptid_t scope_ptid
, int step
,
743 thread_info
*add_current_inferior_and_thread (const char *wait_status
);
745 ptid_t
wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
746 target_wait_flags options
);
747 ptid_t
wait_as (ptid_t ptid
, target_waitstatus
*status
,
748 target_wait_flags options
);
750 ptid_t
process_stop_reply (struct stop_reply
*stop_reply
,
751 target_waitstatus
*status
);
753 ptid_t select_thread_for_ambiguous_stop_reply
754 (const struct target_waitstatus
&status
);
756 void remote_notice_new_inferior (ptid_t currthread
, bool executing
);
758 void print_one_stopped_thread (thread_info
*thread
);
759 void process_initial_stop_replies (int from_tty
);
761 thread_info
*remote_add_thread (ptid_t ptid
, bool running
, bool executing
,
764 void btrace_sync_conf (const btrace_config
*conf
);
766 void remote_btrace_maybe_reopen ();
768 void remove_new_fork_children (threads_listing_context
*context
);
769 void kill_new_fork_children (inferior
*inf
);
770 void discard_pending_stop_replies (struct inferior
*inf
);
771 int stop_reply_queue_length ();
773 void check_pending_events_prevent_wildcard_vcont
774 (bool *may_global_wildcard_vcont
);
776 void discard_pending_stop_replies_in_queue ();
777 struct stop_reply
*remote_notif_remove_queued_reply (ptid_t ptid
);
778 struct stop_reply
*queued_stop_reply (ptid_t ptid
);
779 int peek_stop_reply (ptid_t ptid
);
780 void remote_parse_stop_reply (const char *buf
, stop_reply
*event
);
782 void remote_stop_ns (ptid_t ptid
);
783 void remote_interrupt_as ();
784 void remote_interrupt_ns ();
786 char *remote_get_noisy_reply ();
787 int remote_query_attached (int pid
);
788 inferior
*remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
791 ptid_t
remote_current_thread (ptid_t oldpid
);
792 ptid_t
get_current_thread (const char *wait_status
);
794 void set_thread (ptid_t ptid
, int gen
);
795 void set_general_thread (ptid_t ptid
);
796 void set_continue_thread (ptid_t ptid
);
797 void set_general_process ();
799 char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
801 int remote_unpack_thread_info_response (const char *pkt
, threadref
*expectedref
,
802 gdb_ext_thread_info
*info
);
803 int remote_get_threadinfo (threadref
*threadid
, int fieldset
,
804 gdb_ext_thread_info
*info
);
806 int parse_threadlist_response (const char *pkt
, int result_limit
,
807 threadref
*original_echo
,
808 threadref
*resultlist
,
810 int remote_get_threadlist (int startflag
, threadref
*nextthread
,
811 int result_limit
, int *done
, int *result_count
,
812 threadref
*threadlist
);
814 int remote_threadlist_iterator (rmt_thread_action stepfunction
,
815 void *context
, int looplimit
);
817 int remote_get_threads_with_ql (threads_listing_context
*context
);
818 int remote_get_threads_with_qxfer (threads_listing_context
*context
);
819 int remote_get_threads_with_qthreadinfo (threads_listing_context
*context
);
821 void extended_remote_restart ();
825 void remote_check_symbols ();
827 void remote_supported_packet (const struct protocol_feature
*feature
,
828 enum packet_support support
,
829 const char *argument
);
831 void remote_query_supported ();
833 void remote_packet_size (const protocol_feature
*feature
,
834 packet_support support
, const char *value
);
836 void remote_serial_quit_handler ();
838 void remote_detach_pid (int pid
);
840 void remote_vcont_probe ();
842 void remote_resume_with_hc (ptid_t ptid
, int step
,
845 void send_interrupt_sequence ();
846 void interrupt_query ();
848 void remote_notif_get_pending_events (notif_client
*nc
);
850 int fetch_register_using_p (struct regcache
*regcache
,
852 int send_g_packet ();
853 void process_g_packet (struct regcache
*regcache
);
854 void fetch_registers_using_g (struct regcache
*regcache
);
855 int store_register_using_P (const struct regcache
*regcache
,
857 void store_registers_using_G (const struct regcache
*regcache
);
859 void set_remote_traceframe ();
861 void check_binary_download (CORE_ADDR addr
);
863 target_xfer_status
remote_write_bytes_aux (const char *header
,
865 const gdb_byte
*myaddr
,
868 ULONGEST
*xfered_len_units
,
872 target_xfer_status
remote_write_bytes (CORE_ADDR memaddr
,
873 const gdb_byte
*myaddr
, ULONGEST len
,
874 int unit_size
, ULONGEST
*xfered_len
);
876 target_xfer_status
remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
878 int unit_size
, ULONGEST
*xfered_len_units
);
880 target_xfer_status
remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
884 ULONGEST
*xfered_len
);
886 target_xfer_status
remote_read_bytes (CORE_ADDR memaddr
,
887 gdb_byte
*myaddr
, ULONGEST len
,
889 ULONGEST
*xfered_len
);
891 packet_result
remote_send_printf (const char *format
, ...)
892 ATTRIBUTE_PRINTF (2, 3);
894 target_xfer_status
remote_flash_write (ULONGEST address
,
895 ULONGEST length
, ULONGEST
*xfered_len
,
896 const gdb_byte
*data
);
898 int readchar (int timeout
);
900 void remote_serial_write (const char *str
, int len
);
902 int putpkt (const char *buf
);
903 int putpkt_binary (const char *buf
, int cnt
);
905 int putpkt (const gdb::char_vector
&buf
)
907 return putpkt (buf
.data ());
911 long read_frame (gdb::char_vector
*buf_p
);
912 void getpkt (gdb::char_vector
*buf
, int forever
);
913 int getpkt_or_notif_sane_1 (gdb::char_vector
*buf
, int forever
,
914 int expecting_notif
, int *is_notif
);
915 int getpkt_sane (gdb::char_vector
*buf
, int forever
);
916 int getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
918 int remote_vkill (int pid
);
919 void remote_kill_k ();
921 void extended_remote_disable_randomization (int val
);
922 int extended_remote_run (const std::string
&args
);
924 void send_environment_packet (const char *action
,
928 void extended_remote_environment_support ();
929 void extended_remote_set_inferior_cwd ();
931 target_xfer_status
remote_write_qxfer (const char *object_name
,
933 const gdb_byte
*writebuf
,
934 ULONGEST offset
, LONGEST len
,
935 ULONGEST
*xfered_len
,
936 struct packet_config
*packet
);
938 target_xfer_status
remote_read_qxfer (const char *object_name
,
940 gdb_byte
*readbuf
, ULONGEST offset
,
942 ULONGEST
*xfered_len
,
943 struct packet_config
*packet
);
945 void push_stop_reply (struct stop_reply
*new_event
);
947 bool vcont_r_supported ();
951 bool start_remote_1 (int from_tty
, int extended_p
);
953 /* The remote state. Don't reference this directly. Use the
954 get_remote_state method instead. */
955 remote_state m_remote_state
;
958 static const target_info extended_remote_target_info
= {
960 N_("Extended remote target using gdb-specific protocol"),
964 /* Set up the extended remote target by extending the standard remote
965 target and adding to it. */
967 class extended_remote_target final
: public remote_target
970 const target_info
&info () const override
971 { return extended_remote_target_info
; }
973 /* Open an extended-remote connection. */
974 static void open (const char *, int);
976 bool can_create_inferior () override
{ return true; }
977 void create_inferior (const char *, const std::string
&,
978 char **, int) override
;
980 void detach (inferior
*, int) override
;
982 bool can_attach () override
{ return true; }
983 void attach (const char *, int) override
;
985 void post_attach (int) override
;
986 bool supports_disable_randomization () override
;
989 struct stop_reply
: public notif_event
993 /* The identifier of the thread about this event */
996 /* The remote state this event is associated with. When the remote
997 connection, represented by a remote_state object, is closed,
998 all the associated stop_reply events should be released. */
999 struct remote_state
*rs
;
1001 struct target_waitstatus ws
;
1003 /* The architecture associated with the expedited registers. */
1006 /* Expedited registers. This makes remote debugging a bit more
1007 efficient for those targets that provide critical registers as
1008 part of their normal status mechanism (as another roundtrip to
1009 fetch them is avoided). */
1010 std::vector
<cached_reg_t
> regcache
;
1012 enum target_stop_reason stop_reason
;
1014 CORE_ADDR watch_data_address
;
1019 /* Return TARGET as a remote_target if it is one, else nullptr. */
1021 static remote_target
*
1022 as_remote_target (process_stratum_target
*target
)
1024 return dynamic_cast<remote_target
*> (target
);
1030 is_remote_target (process_stratum_target
*target
)
1032 return as_remote_target (target
) != nullptr;
1035 /* Per-program-space data key. */
1036 static const struct program_space_key
<char, gdb::xfree_deleter
<char>>
1039 /* The variable registered as the control variable used by the
1040 remote exec-file commands. While the remote exec-file setting is
1041 per-program-space, the set/show machinery uses this as the
1042 location of the remote exec-file value. */
1043 static std::string remote_exec_file_var
;
1045 /* The size to align memory write packets, when practical. The protocol
1046 does not guarantee any alignment, and gdb will generate short
1047 writes and unaligned writes, but even as a best-effort attempt this
1048 can improve bulk transfers. For instance, if a write is misaligned
1049 relative to the target's data bus, the stub may need to make an extra
1050 round trip fetching data from the target. This doesn't make a
1051 huge difference, but it's easy to do, so we try to be helpful.
1053 The alignment chosen is arbitrary; usually data bus width is
1054 important here, not the possibly larger cache line size. */
1055 enum { REMOTE_ALIGN_WRITES
= 16 };
1057 /* Prototypes for local functions. */
1059 static int hexnumlen (ULONGEST num
);
1061 static int stubhex (int ch
);
1063 static int hexnumstr (char *, ULONGEST
);
1065 static int hexnumnstr (char *, ULONGEST
, int);
1067 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
1069 static int stub_unpack_int (const char *buff
, int fieldlength
);
1071 struct packet_config
;
1073 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
1075 struct cmd_list_element
*c
,
1078 static ptid_t
read_ptid (const char *buf
, const char **obuf
);
1080 static void remote_async_inferior_event_handler (gdb_client_data
);
1082 static bool remote_read_description_p (struct target_ops
*target
);
1084 static void remote_console_output (const char *msg
);
1086 static void remote_btrace_reset (remote_state
*rs
);
1088 static void remote_unpush_and_throw (remote_target
*target
);
1092 static struct cmd_list_element
*remote_cmdlist
;
1094 /* For "set remote" and "show remote". */
1096 static struct cmd_list_element
*remote_set_cmdlist
;
1097 static struct cmd_list_element
*remote_show_cmdlist
;
1099 /* Controls whether GDB is willing to use range stepping. */
1101 static bool use_range_stepping
= true;
1103 /* From the remote target's point of view, each thread is in one of these three
1105 enum class resume_state
1107 /* Not resumed - we haven't been asked to resume this thread. */
1110 /* We have been asked to resume this thread, but haven't sent a vCont action
1111 for it yet. We'll need to consider it next time commit_resume is
1113 RESUMED_PENDING_VCONT
,
1115 /* We have been asked to resume this thread, and we have sent a vCont action
1120 /* Information about a thread's pending vCont-resume. Used when a thread is in
1121 the remote_resume_state::RESUMED_PENDING_VCONT state. remote_target::resume
1122 stores this information which is then picked up by
1123 remote_target::commit_resume to know which is the proper action for this
1124 thread to include in the vCont packet. */
1125 struct resumed_pending_vcont_info
1127 /* True if the last resume call for this thread was a step request, false
1128 if a continue request. */
1131 /* The signal specified in the last resume call for this thread. */
1135 /* Private data that we'll store in (struct thread_info)->priv. */
1136 struct remote_thread_info
: public private_thread_info
1142 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1143 sequence of bytes. */
1144 gdb::byte_vector thread_handle
;
1146 /* Whether the target stopped for a breakpoint/watchpoint. */
1147 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1149 /* This is set to the data address of the access causing the target
1150 to stop for a watchpoint. */
1151 CORE_ADDR watch_data_address
= 0;
1153 /* Get the thread's resume state. */
1154 enum resume_state
get_resume_state () const
1156 return m_resume_state
;
1159 /* Put the thread in the NOT_RESUMED state. */
1160 void set_not_resumed ()
1162 m_resume_state
= resume_state::NOT_RESUMED
;
1165 /* Put the thread in the RESUMED_PENDING_VCONT state. */
1166 void set_resumed_pending_vcont (bool step
, gdb_signal sig
)
1168 m_resume_state
= resume_state::RESUMED_PENDING_VCONT
;
1169 m_resumed_pending_vcont_info
.step
= step
;
1170 m_resumed_pending_vcont_info
.sig
= sig
;
1173 /* Get the information this thread's pending vCont-resumption.
1175 Must only be called if the thread is in the RESUMED_PENDING_VCONT resume
1177 const struct resumed_pending_vcont_info
&resumed_pending_vcont_info () const
1179 gdb_assert (m_resume_state
== resume_state::RESUMED_PENDING_VCONT
);
1181 return m_resumed_pending_vcont_info
;
1184 /* Put the thread in the VCONT_RESUMED state. */
1187 m_resume_state
= resume_state::RESUMED
;
1191 /* Resume state for this thread. This is used to implement vCont action
1192 coalescing (only when the target operates in non-stop mode).
1194 remote_target::resume moves the thread to the RESUMED_PENDING_VCONT state,
1195 which notes that this thread must be considered in the next commit_resume
1198 remote_target::commit_resume sends a vCont packet with actions for the
1199 threads in the RESUMED_PENDING_VCONT state and moves them to the
1200 VCONT_RESUMED state.
1202 When reporting a stop to the core for a thread, that thread is moved back
1203 to the NOT_RESUMED state. */
1204 enum resume_state m_resume_state
= resume_state::NOT_RESUMED
;
1206 /* Extra info used if the thread is in the RESUMED_PENDING_VCONT state. */
1207 struct resumed_pending_vcont_info m_resumed_pending_vcont_info
;
1210 remote_state::remote_state ()
1215 remote_state::~remote_state ()
1217 xfree (this->last_pass_packet
);
1218 xfree (this->last_program_signals_packet
);
1219 xfree (this->finished_object
);
1220 xfree (this->finished_annex
);
1223 /* Utility: generate error from an incoming stub packet. */
1225 trace_error (char *buf
)
1228 return; /* not an error msg */
1231 case '1': /* malformed packet error */
1232 if (*++buf
== '0') /* general case: */
1233 error (_("remote.c: error in outgoing packet."));
1235 error (_("remote.c: error in outgoing packet at field #%ld."),
1236 strtol (buf
, NULL
, 16));
1238 error (_("Target returns error code '%s'."), buf
);
1242 /* Utility: wait for reply from stub, while accepting "O" packets. */
1245 remote_target::remote_get_noisy_reply ()
1247 struct remote_state
*rs
= get_remote_state ();
1249 do /* Loop on reply from remote stub. */
1253 QUIT
; /* Allow user to bail out with ^C. */
1254 getpkt (&rs
->buf
, 0);
1255 buf
= rs
->buf
.data ();
1258 else if (startswith (buf
, "qRelocInsn:"))
1261 CORE_ADDR from
, to
, org_to
;
1263 int adjusted_size
= 0;
1266 p
= buf
+ strlen ("qRelocInsn:");
1267 pp
= unpack_varlen_hex (p
, &ul
);
1269 error (_("invalid qRelocInsn packet: %s"), buf
);
1273 unpack_varlen_hex (p
, &ul
);
1280 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1283 catch (const gdb_exception
&ex
)
1285 if (ex
.error
== MEMORY_ERROR
)
1287 /* Propagate memory errors silently back to the
1288 target. The stub may have limited the range of
1289 addresses we can write to, for example. */
1293 /* Something unexpectedly bad happened. Be verbose
1294 so we can tell what, and propagate the error back
1295 to the stub, so it doesn't get stuck waiting for
1297 exception_fprintf (gdb_stderr
, ex
,
1298 _("warning: relocating instruction: "));
1305 adjusted_size
= to
- org_to
;
1307 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1311 else if (buf
[0] == 'O' && buf
[1] != 'K')
1312 remote_console_output (buf
+ 1); /* 'O' message from stub */
1314 return buf
; /* Here's the actual reply. */
1319 struct remote_arch_state
*
1320 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1322 remote_arch_state
*rsa
;
1324 auto it
= this->m_arch_states
.find (gdbarch
);
1325 if (it
== this->m_arch_states
.end ())
1327 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1328 std::forward_as_tuple (gdbarch
),
1329 std::forward_as_tuple (gdbarch
));
1330 rsa
= &p
.first
->second
;
1332 /* Make sure that the packet buffer is plenty big enough for
1333 this architecture. */
1334 if (this->buf
.size () < rsa
->remote_packet_size
)
1335 this->buf
.resize (2 * rsa
->remote_packet_size
);
1343 /* Fetch the global remote target state. */
1346 remote_target::get_remote_state ()
1348 /* Make sure that the remote architecture state has been
1349 initialized, because doing so might reallocate rs->buf. Any
1350 function which calls getpkt also needs to be mindful of changes
1351 to rs->buf, but this call limits the number of places which run
1353 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1355 return &m_remote_state
;
1358 /* Fetch the remote exec-file from the current program space. */
1361 get_remote_exec_file (void)
1363 char *remote_exec_file
;
1365 remote_exec_file
= remote_pspace_data
.get (current_program_space
);
1366 if (remote_exec_file
== NULL
)
1369 return remote_exec_file
;
1372 /* Set the remote exec file for PSPACE. */
1375 set_pspace_remote_exec_file (struct program_space
*pspace
,
1376 const char *remote_exec_file
)
1378 char *old_file
= remote_pspace_data
.get (pspace
);
1381 remote_pspace_data
.set (pspace
, xstrdup (remote_exec_file
));
1384 /* The "set/show remote exec-file" set command hook. */
1387 set_remote_exec_file (const char *ignored
, int from_tty
,
1388 struct cmd_list_element
*c
)
1390 set_pspace_remote_exec_file (current_program_space
,
1391 remote_exec_file_var
.c_str ());
1394 /* The "set/show remote exec-file" show command hook. */
1397 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1398 struct cmd_list_element
*cmd
, const char *value
)
1400 gdb_printf (file
, "%s\n", get_remote_exec_file ());
1404 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1406 int regnum
, num_remote_regs
, offset
;
1407 struct packet_reg
**remote_regs
;
1409 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1411 struct packet_reg
*r
= ®s
[regnum
];
1413 if (register_size (gdbarch
, regnum
) == 0)
1414 /* Do not try to fetch zero-sized (placeholder) registers. */
1417 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1422 /* Define the g/G packet format as the contents of each register
1423 with a remote protocol number, in order of ascending protocol
1426 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1427 for (num_remote_regs
= 0, regnum
= 0;
1428 regnum
< gdbarch_num_regs (gdbarch
);
1430 if (regs
[regnum
].pnum
!= -1)
1431 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1433 std::sort (remote_regs
, remote_regs
+ num_remote_regs
,
1434 [] (const packet_reg
*a
, const packet_reg
*b
)
1435 { return a
->pnum
< b
->pnum
; });
1437 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1439 remote_regs
[regnum
]->in_g_packet
= 1;
1440 remote_regs
[regnum
]->offset
= offset
;
1441 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1447 /* Given the architecture described by GDBARCH, return the remote
1448 protocol register's number and the register's offset in the g/G
1449 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1450 If the target does not have a mapping for REGNUM, return false,
1451 otherwise, return true. */
1454 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1455 int *pnum
, int *poffset
)
1457 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1459 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1461 map_regcache_remote_table (gdbarch
, regs
.data ());
1463 *pnum
= regs
[regnum
].pnum
;
1464 *poffset
= regs
[regnum
].offset
;
1469 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1471 /* Use the architecture to build a regnum<->pnum table, which will be
1472 1:1 unless a feature set specifies otherwise. */
1473 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1475 /* Record the maximum possible size of the g packet - it may turn out
1477 this->sizeof_g_packet
1478 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1480 /* Default maximum number of characters in a packet body. Many
1481 remote stubs have a hardwired buffer size of 400 bytes
1482 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1483 as the maximum packet-size to ensure that the packet and an extra
1484 NUL character can always fit in the buffer. This stops GDB
1485 trashing stubs that try to squeeze an extra NUL into what is
1486 already a full buffer (As of 1999-12-04 that was most stubs). */
1487 this->remote_packet_size
= 400 - 1;
1489 /* This one is filled in when a ``g'' packet is received. */
1490 this->actual_register_packet_size
= 0;
1492 /* Should rsa->sizeof_g_packet needs more space than the
1493 default, adjust the size accordingly. Remember that each byte is
1494 encoded as two characters. 32 is the overhead for the packet
1495 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1496 (``$NN:G...#NN'') is a better guess, the below has been padded a
1498 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1499 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1502 /* Get a pointer to the current remote target. If not connected to a
1503 remote target, return NULL. */
1505 static remote_target
*
1506 get_current_remote_target ()
1508 target_ops
*proc_target
= current_inferior ()->process_target ();
1509 return dynamic_cast<remote_target
*> (proc_target
);
1512 /* Return the current allowed size of a remote packet. This is
1513 inferred from the current architecture, and should be used to
1514 limit the length of outgoing packets. */
1516 remote_target::get_remote_packet_size ()
1518 struct remote_state
*rs
= get_remote_state ();
1519 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1521 if (rs
->explicit_packet_size
)
1522 return rs
->explicit_packet_size
;
1524 return rsa
->remote_packet_size
;
1527 static struct packet_reg
*
1528 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1531 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1535 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1537 gdb_assert (r
->regnum
== regnum
);
1542 static struct packet_reg
*
1543 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1548 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1550 struct packet_reg
*r
= &rsa
->regs
[i
];
1552 if (r
->pnum
== pnum
)
1558 /* Allow the user to specify what sequence to send to the remote
1559 when he requests a program interruption: Although ^C is usually
1560 what remote systems expect (this is the default, here), it is
1561 sometimes preferable to send a break. On other systems such
1562 as the Linux kernel, a break followed by g, which is Magic SysRq g
1563 is required in order to interrupt the execution. */
1564 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1565 const char interrupt_sequence_break
[] = "BREAK";
1566 const char interrupt_sequence_break_g
[] = "BREAK-g";
1567 static const char *const interrupt_sequence_modes
[] =
1569 interrupt_sequence_control_c
,
1570 interrupt_sequence_break
,
1571 interrupt_sequence_break_g
,
1574 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1577 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1578 struct cmd_list_element
*c
,
1581 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1583 _("Send the ASCII ETX character (Ctrl-c) "
1584 "to the remote target to interrupt the "
1585 "execution of the program.\n"));
1586 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1588 _("send a break signal to the remote target "
1589 "to interrupt the execution of the program.\n"));
1590 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1592 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1593 "the remote target to interrupt the execution "
1594 "of Linux kernel.\n"));
1596 internal_error (__FILE__
, __LINE__
,
1597 _("Invalid value for interrupt_sequence_mode: %s."),
1598 interrupt_sequence_mode
);
1601 /* This boolean variable specifies whether interrupt_sequence is sent
1602 to the remote target when gdb connects to it.
1603 This is mostly needed when you debug the Linux kernel: The Linux kernel
1604 expects BREAK g which is Magic SysRq g for connecting gdb. */
1605 static bool interrupt_on_connect
= false;
1607 /* This variable is used to implement the "set/show remotebreak" commands.
1608 Since these commands are now deprecated in favor of "set/show remote
1609 interrupt-sequence", it no longer has any effect on the code. */
1610 static bool remote_break
;
1613 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1616 interrupt_sequence_mode
= interrupt_sequence_break
;
1618 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1622 show_remotebreak (struct ui_file
*file
, int from_tty
,
1623 struct cmd_list_element
*c
,
1628 /* This variable sets the number of bits in an address that are to be
1629 sent in a memory ("M" or "m") packet. Normally, after stripping
1630 leading zeros, the entire address would be sent. This variable
1631 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1632 initial implementation of remote.c restricted the address sent in
1633 memory packets to ``host::sizeof long'' bytes - (typically 32
1634 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1635 address was never sent. Since fixing this bug may cause a break in
1636 some remote targets this variable is principally provided to
1637 facilitate backward compatibility. */
1639 static unsigned int remote_address_size
;
1642 /* User configurable variables for the number of characters in a
1643 memory read/write packet. MIN (rsa->remote_packet_size,
1644 rsa->sizeof_g_packet) is the default. Some targets need smaller
1645 values (fifo overruns, et.al.) and some users need larger values
1646 (speed up transfers). The variables ``preferred_*'' (the user
1647 request), ``current_*'' (what was actually set) and ``forced_*''
1648 (Positive - a soft limit, negative - a hard limit). */
1650 struct memory_packet_config
1657 /* The default max memory-write-packet-size, when the setting is
1658 "fixed". The 16k is historical. (It came from older GDB's using
1659 alloca for buffers and the knowledge (folklore?) that some hosts
1660 don't cope very well with large alloca calls.) */
1661 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1663 /* The minimum remote packet size for memory transfers. Ensures we
1664 can write at least one byte. */
1665 #define MIN_MEMORY_PACKET_SIZE 20
1667 /* Get the memory packet size, assuming it is fixed. */
1670 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1672 gdb_assert (config
->fixed_p
);
1674 if (config
->size
<= 0)
1675 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1677 return config
->size
;
1680 /* Compute the current size of a read/write packet. Since this makes
1681 use of ``actual_register_packet_size'' the computation is dynamic. */
1684 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1686 struct remote_state
*rs
= get_remote_state ();
1687 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1690 if (config
->fixed_p
)
1691 what_they_get
= get_fixed_memory_packet_size (config
);
1694 what_they_get
= get_remote_packet_size ();
1695 /* Limit the packet to the size specified by the user. */
1696 if (config
->size
> 0
1697 && what_they_get
> config
->size
)
1698 what_they_get
= config
->size
;
1700 /* Limit it to the size of the targets ``g'' response unless we have
1701 permission from the stub to use a larger packet size. */
1702 if (rs
->explicit_packet_size
== 0
1703 && rsa
->actual_register_packet_size
> 0
1704 && what_they_get
> rsa
->actual_register_packet_size
)
1705 what_they_get
= rsa
->actual_register_packet_size
;
1707 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1708 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1710 /* Make sure there is room in the global buffer for this packet
1711 (including its trailing NUL byte). */
1712 if (rs
->buf
.size () < what_they_get
+ 1)
1713 rs
->buf
.resize (2 * what_they_get
);
1715 return what_they_get
;
1718 /* Update the size of a read/write packet. If they user wants
1719 something really big then do a sanity check. */
1722 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1724 int fixed_p
= config
->fixed_p
;
1725 long size
= config
->size
;
1728 error (_("Argument required (integer, `fixed' or `limited')."));
1729 else if (strcmp (args
, "hard") == 0
1730 || strcmp (args
, "fixed") == 0)
1732 else if (strcmp (args
, "soft") == 0
1733 || strcmp (args
, "limit") == 0)
1739 size
= strtoul (args
, &end
, 0);
1741 error (_("Invalid %s (bad syntax)."), config
->name
);
1743 /* Instead of explicitly capping the size of a packet to or
1744 disallowing it, the user is allowed to set the size to
1745 something arbitrarily large. */
1749 if (fixed_p
&& !config
->fixed_p
)
1751 /* So that the query shows the correct value. */
1752 long query_size
= (size
<= 0
1753 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1756 if (! query (_("The target may not be able to correctly handle a %s\n"
1757 "of %ld bytes. Change the packet size? "),
1758 config
->name
, query_size
))
1759 error (_("Packet size not changed."));
1761 /* Update the config. */
1762 config
->fixed_p
= fixed_p
;
1763 config
->size
= size
;
1767 show_memory_packet_size (struct memory_packet_config
*config
)
1769 if (config
->size
== 0)
1770 gdb_printf (_("The %s is 0 (default). "), config
->name
);
1772 gdb_printf (_("The %s is %ld. "), config
->name
, config
->size
);
1773 if (config
->fixed_p
)
1774 gdb_printf (_("Packets are fixed at %ld bytes.\n"),
1775 get_fixed_memory_packet_size (config
));
1778 remote_target
*remote
= get_current_remote_target ();
1781 gdb_printf (_("Packets are limited to %ld bytes.\n"),
1782 remote
->get_memory_packet_size (config
));
1784 gdb_puts ("The actual limit will be further reduced "
1785 "dependent on the target.\n");
1789 /* FIXME: needs to be per-remote-target. */
1790 static struct memory_packet_config memory_write_packet_config
=
1792 "memory-write-packet-size",
1796 set_memory_write_packet_size (const char *args
, int from_tty
)
1798 set_memory_packet_size (args
, &memory_write_packet_config
);
1802 show_memory_write_packet_size (const char *args
, int from_tty
)
1804 show_memory_packet_size (&memory_write_packet_config
);
1807 /* Show the number of hardware watchpoints that can be used. */
1810 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1811 struct cmd_list_element
*c
,
1814 gdb_printf (file
, _("The maximum number of target hardware "
1815 "watchpoints is %s.\n"), value
);
1818 /* Show the length limit (in bytes) for hardware watchpoints. */
1821 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1822 struct cmd_list_element
*c
,
1825 gdb_printf (file
, _("The maximum length (in bytes) of a target "
1826 "hardware watchpoint is %s.\n"), value
);
1829 /* Show the number of hardware breakpoints that can be used. */
1832 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1833 struct cmd_list_element
*c
,
1836 gdb_printf (file
, _("The maximum number of target hardware "
1837 "breakpoints is %s.\n"), value
);
1840 /* Controls the maximum number of characters to display in the debug output
1841 for each remote packet. The remaining characters are omitted. */
1843 static int remote_packet_max_chars
= 512;
1845 /* Show the maximum number of characters to display for each remote packet
1846 when remote debugging is enabled. */
1849 show_remote_packet_max_chars (struct ui_file
*file
, int from_tty
,
1850 struct cmd_list_element
*c
,
1853 gdb_printf (file
, _("Number of remote packet characters to "
1854 "display is %s.\n"), value
);
1858 remote_target::get_memory_write_packet_size ()
1860 return get_memory_packet_size (&memory_write_packet_config
);
1863 /* FIXME: needs to be per-remote-target. */
1864 static struct memory_packet_config memory_read_packet_config
=
1866 "memory-read-packet-size",
1870 set_memory_read_packet_size (const char *args
, int from_tty
)
1872 set_memory_packet_size (args
, &memory_read_packet_config
);
1876 show_memory_read_packet_size (const char *args
, int from_tty
)
1878 show_memory_packet_size (&memory_read_packet_config
);
1882 remote_target::get_memory_read_packet_size ()
1884 long size
= get_memory_packet_size (&memory_read_packet_config
);
1886 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1887 extra buffer size argument before the memory read size can be
1888 increased beyond this. */
1889 if (size
> get_remote_packet_size ())
1890 size
= get_remote_packet_size ();
1896 struct packet_config
1901 /* If auto, GDB auto-detects support for this packet or feature,
1902 either through qSupported, or by trying the packet and looking
1903 at the response. If true, GDB assumes the target supports this
1904 packet. If false, the packet is disabled. Configs that don't
1905 have an associated command always have this set to auto. */
1906 enum auto_boolean detect
;
1908 /* The "show remote foo-packet" command created for this packet. */
1909 cmd_list_element
*show_cmd
;
1911 /* Does the target support this packet? */
1912 enum packet_support support
;
1915 static enum packet_support
packet_config_support (struct packet_config
*config
);
1916 static enum packet_support
packet_support (int packet
);
1919 show_packet_config_cmd (ui_file
*file
, struct packet_config
*config
)
1921 const char *support
= "internal-error";
1923 switch (packet_config_support (config
))
1926 support
= "enabled";
1928 case PACKET_DISABLE
:
1929 support
= "disabled";
1931 case PACKET_SUPPORT_UNKNOWN
:
1932 support
= "unknown";
1935 switch (config
->detect
)
1937 case AUTO_BOOLEAN_AUTO
:
1939 _("Support for the `%s' packet "
1940 "is auto-detected, currently %s.\n"),
1941 config
->name
, support
);
1943 case AUTO_BOOLEAN_TRUE
:
1944 case AUTO_BOOLEAN_FALSE
:
1946 _("Support for the `%s' packet is currently %s.\n"),
1947 config
->name
, support
);
1953 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1954 const char *title
, int legacy
)
1956 config
->name
= name
;
1957 config
->title
= title
;
1958 gdb::unique_xmalloc_ptr
<char> set_doc
1959 = xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1961 gdb::unique_xmalloc_ptr
<char> show_doc
1962 = xstrprintf ("Show current use of remote protocol `%s' (%s) packet.",
1964 /* set/show TITLE-packet {auto,on,off} */
1965 gdb::unique_xmalloc_ptr
<char> cmd_name
= xstrprintf ("%s-packet", title
);
1966 set_show_commands cmds
1967 = add_setshow_auto_boolean_cmd (cmd_name
.release (), class_obscure
,
1968 &config
->detect
, set_doc
.get (),
1969 show_doc
.get (), NULL
, /* help_doc */
1971 show_remote_protocol_packet_cmd
,
1972 &remote_set_cmdlist
, &remote_show_cmdlist
);
1973 config
->show_cmd
= cmds
.show
;
1975 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1978 /* It's not clear who should take ownership of the LEGACY_NAME string
1979 created below, so, for now, place the string into a static vector
1980 which ensures the strings is released when GDB exits. */
1981 static std::vector
<gdb::unique_xmalloc_ptr
<char>> legacy_names
;
1982 gdb::unique_xmalloc_ptr
<char> legacy_name
1983 = xstrprintf ("%s-packet", name
);
1984 add_alias_cmd (legacy_name
.get (), cmds
.set
, class_obscure
, 0,
1985 &remote_set_cmdlist
);
1986 add_alias_cmd (legacy_name
.get (), cmds
.show
, class_obscure
, 0,
1987 &remote_show_cmdlist
);
1988 legacy_names
.emplace_back (std::move (legacy_name
));
1992 static enum packet_result
1993 packet_check_result (const char *buf
)
1997 /* The stub recognized the packet request. Check that the
1998 operation succeeded. */
2000 && isxdigit (buf
[1]) && isxdigit (buf
[2])
2002 /* "Enn" - definitely an error. */
2003 return PACKET_ERROR
;
2005 /* Always treat "E." as an error. This will be used for
2006 more verbose error messages, such as E.memtypes. */
2007 if (buf
[0] == 'E' && buf
[1] == '.')
2008 return PACKET_ERROR
;
2010 /* The packet may or may not be OK. Just assume it is. */
2014 /* The stub does not support the packet. */
2015 return PACKET_UNKNOWN
;
2018 static enum packet_result
2019 packet_check_result (const gdb::char_vector
&buf
)
2021 return packet_check_result (buf
.data ());
2024 static enum packet_result
2025 packet_ok (const char *buf
, struct packet_config
*config
)
2027 enum packet_result result
;
2029 if (config
->detect
!= AUTO_BOOLEAN_TRUE
2030 && config
->support
== PACKET_DISABLE
)
2031 internal_error (__FILE__
, __LINE__
,
2032 _("packet_ok: attempt to use a disabled packet"));
2034 result
= packet_check_result (buf
);
2039 /* The stub recognized the packet request. */
2040 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
2042 remote_debug_printf ("Packet %s (%s) is supported",
2043 config
->name
, config
->title
);
2044 config
->support
= PACKET_ENABLE
;
2047 case PACKET_UNKNOWN
:
2048 /* The stub does not support the packet. */
2049 if (config
->detect
== AUTO_BOOLEAN_AUTO
2050 && config
->support
== PACKET_ENABLE
)
2052 /* If the stub previously indicated that the packet was
2053 supported then there is a protocol error. */
2054 error (_("Protocol error: %s (%s) conflicting enabled responses."),
2055 config
->name
, config
->title
);
2057 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
2059 /* The user set it wrong. */
2060 error (_("Enabled packet %s (%s) not recognized by stub"),
2061 config
->name
, config
->title
);
2064 remote_debug_printf ("Packet %s (%s) is NOT supported",
2065 config
->name
, config
->title
);
2066 config
->support
= PACKET_DISABLE
;
2073 static enum packet_result
2074 packet_ok (const gdb::char_vector
&buf
, struct packet_config
*config
)
2076 return packet_ok (buf
.data (), config
);
2093 PACKET_vFile_pwrite
,
2095 PACKET_vFile_unlink
,
2096 PACKET_vFile_readlink
,
2099 PACKET_qXfer_features
,
2100 PACKET_qXfer_exec_file
,
2101 PACKET_qXfer_libraries
,
2102 PACKET_qXfer_libraries_svr4
,
2103 PACKET_qXfer_memory_map
,
2104 PACKET_qXfer_osdata
,
2105 PACKET_qXfer_threads
,
2106 PACKET_qXfer_statictrace_read
,
2107 PACKET_qXfer_traceframe_info
,
2113 PACKET_QPassSignals
,
2114 PACKET_QCatchSyscalls
,
2115 PACKET_QProgramSignals
,
2116 PACKET_QSetWorkingDir
,
2117 PACKET_QStartupWithShell
,
2118 PACKET_QEnvironmentHexEncoded
,
2119 PACKET_QEnvironmentReset
,
2120 PACKET_QEnvironmentUnset
,
2122 PACKET_qSearch_memory
,
2125 PACKET_QStartNoAckMode
,
2127 PACKET_qXfer_siginfo_read
,
2128 PACKET_qXfer_siginfo_write
,
2131 /* Support for conditional tracepoints. */
2132 PACKET_ConditionalTracepoints
,
2134 /* Support for target-side breakpoint conditions. */
2135 PACKET_ConditionalBreakpoints
,
2137 /* Support for target-side breakpoint commands. */
2138 PACKET_BreakpointCommands
,
2140 /* Support for fast tracepoints. */
2141 PACKET_FastTracepoints
,
2143 /* Support for static tracepoints. */
2144 PACKET_StaticTracepoints
,
2146 /* Support for installing tracepoints while a trace experiment is
2148 PACKET_InstallInTrace
,
2152 PACKET_TracepointSource
,
2155 PACKET_QDisableRandomization
,
2157 PACKET_QTBuffer_size
,
2161 PACKET_qXfer_btrace
,
2163 /* Support for the QNonStop packet. */
2166 /* Support for the QThreadEvents packet. */
2167 PACKET_QThreadEvents
,
2169 /* Support for multi-process extensions. */
2170 PACKET_multiprocess_feature
,
2172 /* Support for enabling and disabling tracepoints while a trace
2173 experiment is running. */
2174 PACKET_EnableDisableTracepoints_feature
,
2176 /* Support for collecting strings using the tracenz bytecode. */
2177 PACKET_tracenz_feature
,
2179 /* Support for continuing to run a trace experiment while GDB is
2181 PACKET_DisconnectedTracing_feature
,
2183 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2184 PACKET_augmented_libraries_svr4_read_feature
,
2186 /* Support for the qXfer:btrace-conf:read packet. */
2187 PACKET_qXfer_btrace_conf
,
2189 /* Support for the Qbtrace-conf:bts:size packet. */
2190 PACKET_Qbtrace_conf_bts_size
,
2192 /* Support for swbreak+ feature. */
2193 PACKET_swbreak_feature
,
2195 /* Support for hwbreak+ feature. */
2196 PACKET_hwbreak_feature
,
2198 /* Support for fork events. */
2199 PACKET_fork_event_feature
,
2201 /* Support for vfork events. */
2202 PACKET_vfork_event_feature
,
2204 /* Support for the Qbtrace-conf:pt:size packet. */
2205 PACKET_Qbtrace_conf_pt_size
,
2207 /* Support for exec events. */
2208 PACKET_exec_event_feature
,
2210 /* Support for query supported vCont actions. */
2211 PACKET_vContSupported
,
2213 /* Support remote CTRL-C. */
2216 /* Support TARGET_WAITKIND_NO_RESUMED. */
2219 /* Support for memory tagging, allocation tag fetch/store
2220 packets and the tag violation stop replies. */
2221 PACKET_memory_tagging_feature
,
2226 /* FIXME: needs to be per-remote-target. Ignoring this for now,
2227 assuming all remote targets are the same server (thus all support
2228 the same packets). */
2229 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
2231 /* Returns the packet's corresponding "set remote foo-packet" command
2232 state. See struct packet_config for more details. */
2234 static enum auto_boolean
2235 packet_set_cmd_state (int packet
)
2237 return remote_protocol_packets
[packet
].detect
;
2240 /* Returns whether a given packet or feature is supported. This takes
2241 into account the state of the corresponding "set remote foo-packet"
2242 command, which may be used to bypass auto-detection. */
2244 static enum packet_support
2245 packet_config_support (struct packet_config
*config
)
2247 switch (config
->detect
)
2249 case AUTO_BOOLEAN_TRUE
:
2250 return PACKET_ENABLE
;
2251 case AUTO_BOOLEAN_FALSE
:
2252 return PACKET_DISABLE
;
2253 case AUTO_BOOLEAN_AUTO
:
2254 return config
->support
;
2256 gdb_assert_not_reached ("bad switch");
2260 /* Same as packet_config_support, but takes the packet's enum value as
2263 static enum packet_support
2264 packet_support (int packet
)
2266 struct packet_config
*config
= &remote_protocol_packets
[packet
];
2268 return packet_config_support (config
);
2272 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
2273 struct cmd_list_element
*c
,
2276 struct packet_config
*packet
;
2277 gdb_assert (c
->var
.has_value ());
2279 for (packet
= remote_protocol_packets
;
2280 packet
< &remote_protocol_packets
[PACKET_MAX
];
2283 if (c
== packet
->show_cmd
)
2285 show_packet_config_cmd (file
, packet
);
2289 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
2293 /* Should we try one of the 'Z' requests? */
2297 Z_PACKET_SOFTWARE_BP
,
2298 Z_PACKET_HARDWARE_BP
,
2305 /* For compatibility with older distributions. Provide a ``set remote
2306 Z-packet ...'' command that updates all the Z packet types. */
2308 static enum auto_boolean remote_Z_packet_detect
;
2311 set_remote_protocol_Z_packet_cmd (const char *args
, int from_tty
,
2312 struct cmd_list_element
*c
)
2316 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2317 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
2321 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
2322 struct cmd_list_element
*c
,
2327 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2329 show_packet_config_cmd (file
, &remote_protocol_packets
[PACKET_Z0
+ i
]);
2333 /* Returns true if the multi-process extensions are in effect. */
2336 remote_multi_process_p (struct remote_state
*rs
)
2338 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
2341 /* Returns true if fork events are supported. */
2344 remote_fork_event_p (struct remote_state
*rs
)
2346 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
2349 /* Returns true if vfork events are supported. */
2352 remote_vfork_event_p (struct remote_state
*rs
)
2354 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
2357 /* Returns true if exec events are supported. */
2360 remote_exec_event_p (struct remote_state
*rs
)
2362 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
2365 /* Returns true if memory tagging is supported, false otherwise. */
2368 remote_memory_tagging_p ()
2370 return packet_support (PACKET_memory_tagging_feature
) == PACKET_ENABLE
;
2373 /* Insert fork catchpoint target routine. If fork events are enabled
2374 then return success, nothing more to do. */
2377 remote_target::insert_fork_catchpoint (int pid
)
2379 struct remote_state
*rs
= get_remote_state ();
2381 return !remote_fork_event_p (rs
);
2384 /* Remove fork catchpoint target routine. Nothing to do, just
2388 remote_target::remove_fork_catchpoint (int pid
)
2393 /* Insert vfork catchpoint target routine. If vfork events are enabled
2394 then return success, nothing more to do. */
2397 remote_target::insert_vfork_catchpoint (int pid
)
2399 struct remote_state
*rs
= get_remote_state ();
2401 return !remote_vfork_event_p (rs
);
2404 /* Remove vfork catchpoint target routine. Nothing to do, just
2408 remote_target::remove_vfork_catchpoint (int pid
)
2413 /* Insert exec catchpoint target routine. If exec events are
2414 enabled, just return success. */
2417 remote_target::insert_exec_catchpoint (int pid
)
2419 struct remote_state
*rs
= get_remote_state ();
2421 return !remote_exec_event_p (rs
);
2424 /* Remove exec catchpoint target routine. Nothing to do, just
2428 remote_target::remove_exec_catchpoint (int pid
)
2435 /* Take advantage of the fact that the TID field is not used, to tag
2436 special ptids with it set to != 0. */
2437 static const ptid_t
magic_null_ptid (42000, -1, 1);
2438 static const ptid_t
not_sent_ptid (42000, -2, 1);
2439 static const ptid_t
any_thread_ptid (42000, 0, 1);
2441 /* Find out if the stub attached to PID (and hence GDB should offer to
2442 detach instead of killing it when bailing out). */
2445 remote_target::remote_query_attached (int pid
)
2447 struct remote_state
*rs
= get_remote_state ();
2448 size_t size
= get_remote_packet_size ();
2450 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
2453 if (remote_multi_process_p (rs
))
2454 xsnprintf (rs
->buf
.data (), size
, "qAttached:%x", pid
);
2456 xsnprintf (rs
->buf
.data (), size
, "qAttached");
2459 getpkt (&rs
->buf
, 0);
2461 switch (packet_ok (rs
->buf
,
2462 &remote_protocol_packets
[PACKET_qAttached
]))
2465 if (strcmp (rs
->buf
.data (), "1") == 0)
2469 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
2471 case PACKET_UNKNOWN
:
2478 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2479 has been invented by GDB, instead of reported by the target. Since
2480 we can be connected to a remote system before before knowing about
2481 any inferior, mark the target with execution when we find the first
2482 inferior. If ATTACHED is 1, then we had just attached to this
2483 inferior. If it is 0, then we just created this inferior. If it
2484 is -1, then try querying the remote stub to find out if it had
2485 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2486 attempt to open this inferior's executable as the main executable
2487 if no main executable is open already. */
2490 remote_target::remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
2493 struct inferior
*inf
;
2495 /* Check whether this process we're learning about is to be
2496 considered attached, or if is to be considered to have been
2497 spawned by the stub. */
2499 attached
= remote_query_attached (pid
);
2501 if (gdbarch_has_global_solist (target_gdbarch ()))
2503 /* If the target shares code across all inferiors, then every
2504 attach adds a new inferior. */
2505 inf
= add_inferior (pid
);
2507 /* ... and every inferior is bound to the same program space.
2508 However, each inferior may still have its own address
2510 inf
->aspace
= maybe_new_address_space ();
2511 inf
->pspace
= current_program_space
;
2515 /* In the traditional debugging scenario, there's a 1-1 match
2516 between program/address spaces. We simply bind the inferior
2517 to the program space's address space. */
2518 inf
= current_inferior ();
2520 /* However, if the current inferior is already bound to a
2521 process, find some other empty inferior. */
2525 for (inferior
*it
: all_inferiors ())
2534 /* Since all inferiors were already bound to a process, add
2536 inf
= add_inferior_with_spaces ();
2538 switch_to_inferior_no_thread (inf
);
2539 inf
->push_target (this);
2540 inferior_appeared (inf
, pid
);
2543 inf
->attach_flag
= attached
;
2544 inf
->fake_pid_p
= fake_pid_p
;
2546 /* If no main executable is currently open then attempt to
2547 open the file that was executed to create this inferior. */
2548 if (try_open_exec
&& get_exec_file (0) == NULL
)
2549 exec_file_locate_attach (pid
, 0, 1);
2551 /* Check for exec file mismatch, and let the user solve it. */
2552 validate_exec_file (1);
2557 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2558 static remote_thread_info
*get_remote_thread_info (remote_target
*target
,
2561 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2562 according to EXECUTING and RUNNING respectively. If SILENT_P (or the
2563 remote_state::starting_up flag) is true then the new thread is added
2564 silently, otherwise the new thread will be announced to the user. */
2567 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
,
2570 struct remote_state
*rs
= get_remote_state ();
2571 struct thread_info
*thread
;
2573 /* GDB historically didn't pull threads in the initial connection
2574 setup. If the remote target doesn't even have a concept of
2575 threads (e.g., a bare-metal target), even if internally we
2576 consider that a single-threaded target, mentioning a new thread
2577 might be confusing to the user. Be silent then, preserving the
2578 age old behavior. */
2579 if (rs
->starting_up
|| silent_p
)
2580 thread
= add_thread_silent (this, ptid
);
2582 thread
= add_thread (this, ptid
);
2584 /* We start by assuming threads are resumed. That state then gets updated
2585 when we process a matching stop reply. */
2586 get_remote_thread_info (thread
)->set_resumed ();
2588 set_executing (this, ptid
, executing
);
2589 set_running (this, ptid
, running
);
2594 /* Come here when we learn about a thread id from the remote target.
2595 It may be the first time we hear about such thread, so take the
2596 opportunity to add it to GDB's thread list. In case this is the
2597 first time we're noticing its corresponding inferior, add it to
2598 GDB's inferior list as well. EXECUTING indicates whether the
2599 thread is (internally) executing or stopped. */
2602 remote_target::remote_notice_new_inferior (ptid_t currthread
, bool executing
)
2604 /* In non-stop mode, we assume new found threads are (externally)
2605 running until proven otherwise with a stop reply. In all-stop,
2606 we can only get here if all threads are stopped. */
2607 bool running
= target_is_non_stop_p ();
2609 /* If this is a new thread, add it to GDB's thread list.
2610 If we leave it up to WFI to do this, bad things will happen. */
2612 thread_info
*tp
= find_thread_ptid (this, currthread
);
2613 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2615 /* We're seeing an event on a thread id we knew had exited.
2616 This has to be a new thread reusing the old id. Add it. */
2617 remote_add_thread (currthread
, running
, executing
, false);
2621 if (!in_thread_list (this, currthread
))
2623 struct inferior
*inf
= NULL
;
2624 int pid
= currthread
.pid ();
2626 if (inferior_ptid
.is_pid ()
2627 && pid
== inferior_ptid
.pid ())
2629 /* inferior_ptid has no thread member yet. This can happen
2630 with the vAttach -> remote_wait,"TAAthread:" path if the
2631 stub doesn't support qC. This is the first stop reported
2632 after an attach, so this is the main thread. Update the
2633 ptid in the thread list. */
2634 if (in_thread_list (this, ptid_t (pid
)))
2635 thread_change_ptid (this, inferior_ptid
, currthread
);
2639 = remote_add_thread (currthread
, running
, executing
, false);
2640 switch_to_thread (thr
);
2645 if (magic_null_ptid
== inferior_ptid
)
2647 /* inferior_ptid is not set yet. This can happen with the
2648 vRun -> remote_wait,"TAAthread:" path if the stub
2649 doesn't support qC. This is the first stop reported
2650 after an attach, so this is the main thread. Update the
2651 ptid in the thread list. */
2652 thread_change_ptid (this, inferior_ptid
, currthread
);
2656 /* When connecting to a target remote, or to a target
2657 extended-remote which already was debugging an inferior, we
2658 may not know about it yet. Add it before adding its child
2659 thread, so notifications are emitted in a sensible order. */
2660 if (find_inferior_pid (this, currthread
.pid ()) == NULL
)
2662 struct remote_state
*rs
= get_remote_state ();
2663 bool fake_pid_p
= !remote_multi_process_p (rs
);
2665 inf
= remote_add_inferior (fake_pid_p
,
2666 currthread
.pid (), -1, 1);
2669 /* This is really a new thread. Add it. */
2670 thread_info
*new_thr
2671 = remote_add_thread (currthread
, running
, executing
, false);
2673 /* If we found a new inferior, let the common code do whatever
2674 it needs to with it (e.g., read shared libraries, insert
2675 breakpoints), unless we're just setting up an all-stop
2679 struct remote_state
*rs
= get_remote_state ();
2681 if (!rs
->starting_up
)
2682 notice_new_inferior (new_thr
, executing
, 0);
2687 /* Return THREAD's private thread data, creating it if necessary. */
2689 static remote_thread_info
*
2690 get_remote_thread_info (thread_info
*thread
)
2692 gdb_assert (thread
!= NULL
);
2694 if (thread
->priv
== NULL
)
2695 thread
->priv
.reset (new remote_thread_info
);
2697 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2700 /* Return PTID's private thread data, creating it if necessary. */
2702 static remote_thread_info
*
2703 get_remote_thread_info (remote_target
*target
, ptid_t ptid
)
2705 thread_info
*thr
= find_thread_ptid (target
, ptid
);
2706 return get_remote_thread_info (thr
);
2709 /* Call this function as a result of
2710 1) A halt indication (T packet) containing a thread id
2711 2) A direct query of currthread
2712 3) Successful execution of set thread */
2715 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2717 rs
->general_thread
= currthread
;
2720 /* If 'QPassSignals' is supported, tell the remote stub what signals
2721 it can simply pass through to the inferior without reporting. */
2724 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2726 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2728 char *pass_packet
, *p
;
2730 struct remote_state
*rs
= get_remote_state ();
2732 gdb_assert (pass_signals
.size () < 256);
2733 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2735 if (pass_signals
[i
])
2738 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2739 strcpy (pass_packet
, "QPassSignals:");
2740 p
= pass_packet
+ strlen (pass_packet
);
2741 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2743 if (pass_signals
[i
])
2746 *p
++ = tohex (i
>> 4);
2747 *p
++ = tohex (i
& 15);
2756 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2758 putpkt (pass_packet
);
2759 getpkt (&rs
->buf
, 0);
2760 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2761 xfree (rs
->last_pass_packet
);
2762 rs
->last_pass_packet
= pass_packet
;
2765 xfree (pass_packet
);
2769 /* If 'QCatchSyscalls' is supported, tell the remote stub
2770 to report syscalls to GDB. */
2773 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2774 gdb::array_view
<const int> syscall_counts
)
2776 const char *catch_packet
;
2777 enum packet_result result
;
2780 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2782 /* Not supported. */
2786 if (needed
&& any_count
== 0)
2788 /* Count how many syscalls are to be caught. */
2789 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2791 if (syscall_counts
[i
] != 0)
2796 remote_debug_printf ("pid %d needed %d any_count %d n_sysno %d",
2797 pid
, needed
, any_count
, n_sysno
);
2799 std::string built_packet
;
2802 /* Prepare a packet with the sysno list, assuming max 8+1
2803 characters for a sysno. If the resulting packet size is too
2804 big, fallback on the non-selective packet. */
2805 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2806 built_packet
.reserve (maxpktsz
);
2807 built_packet
= "QCatchSyscalls:1";
2810 /* Add in each syscall to be caught. */
2811 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2813 if (syscall_counts
[i
] != 0)
2814 string_appendf (built_packet
, ";%zx", i
);
2817 if (built_packet
.size () > get_remote_packet_size ())
2819 /* catch_packet too big. Fallback to less efficient
2820 non selective mode, with GDB doing the filtering. */
2821 catch_packet
= "QCatchSyscalls:1";
2824 catch_packet
= built_packet
.c_str ();
2827 catch_packet
= "QCatchSyscalls:0";
2829 struct remote_state
*rs
= get_remote_state ();
2831 putpkt (catch_packet
);
2832 getpkt (&rs
->buf
, 0);
2833 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2834 if (result
== PACKET_OK
)
2840 /* If 'QProgramSignals' is supported, tell the remote stub what
2841 signals it should pass through to the inferior when detaching. */
2844 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2846 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2850 struct remote_state
*rs
= get_remote_state ();
2852 gdb_assert (signals
.size () < 256);
2853 for (size_t i
= 0; i
< signals
.size (); i
++)
2858 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2859 strcpy (packet
, "QProgramSignals:");
2860 p
= packet
+ strlen (packet
);
2861 for (size_t i
= 0; i
< signals
.size (); i
++)
2863 if (signal_pass_state (i
))
2866 *p
++ = tohex (i
>> 4);
2867 *p
++ = tohex (i
& 15);
2876 if (!rs
->last_program_signals_packet
2877 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2880 getpkt (&rs
->buf
, 0);
2881 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2882 xfree (rs
->last_program_signals_packet
);
2883 rs
->last_program_signals_packet
= packet
;
2890 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2891 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2892 thread. If GEN is set, set the general thread, if not, then set
2893 the step/continue thread. */
2895 remote_target::set_thread (ptid_t ptid
, int gen
)
2897 struct remote_state
*rs
= get_remote_state ();
2898 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2899 char *buf
= rs
->buf
.data ();
2900 char *endbuf
= buf
+ get_remote_packet_size ();
2906 *buf
++ = gen
? 'g' : 'c';
2907 if (ptid
== magic_null_ptid
)
2908 xsnprintf (buf
, endbuf
- buf
, "0");
2909 else if (ptid
== any_thread_ptid
)
2910 xsnprintf (buf
, endbuf
- buf
, "0");
2911 else if (ptid
== minus_one_ptid
)
2912 xsnprintf (buf
, endbuf
- buf
, "-1");
2914 write_ptid (buf
, endbuf
, ptid
);
2916 getpkt (&rs
->buf
, 0);
2918 rs
->general_thread
= ptid
;
2920 rs
->continue_thread
= ptid
;
2924 remote_target::set_general_thread (ptid_t ptid
)
2926 set_thread (ptid
, 1);
2930 remote_target::set_continue_thread (ptid_t ptid
)
2932 set_thread (ptid
, 0);
2935 /* Change the remote current process. Which thread within the process
2936 ends up selected isn't important, as long as it is the same process
2937 as what INFERIOR_PTID points to.
2939 This comes from that fact that there is no explicit notion of
2940 "selected process" in the protocol. The selected process for
2941 general operations is the process the selected general thread
2945 remote_target::set_general_process ()
2947 struct remote_state
*rs
= get_remote_state ();
2949 /* If the remote can't handle multiple processes, don't bother. */
2950 if (!remote_multi_process_p (rs
))
2953 /* We only need to change the remote current thread if it's pointing
2954 at some other process. */
2955 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2956 set_general_thread (inferior_ptid
);
2960 /* Return nonzero if this is the main thread that we made up ourselves
2961 to model non-threaded targets as single-threaded. */
2964 remote_thread_always_alive (ptid_t ptid
)
2966 if (ptid
== magic_null_ptid
)
2967 /* The main thread is always alive. */
2970 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2971 /* The main thread is always alive. This can happen after a
2972 vAttach, if the remote side doesn't support
2979 /* Return nonzero if the thread PTID is still alive on the remote
2983 remote_target::thread_alive (ptid_t ptid
)
2985 struct remote_state
*rs
= get_remote_state ();
2988 /* Check if this is a thread that we made up ourselves to model
2989 non-threaded targets as single-threaded. */
2990 if (remote_thread_always_alive (ptid
))
2993 p
= rs
->buf
.data ();
2994 endp
= p
+ get_remote_packet_size ();
2997 write_ptid (p
, endp
, ptid
);
3000 getpkt (&rs
->buf
, 0);
3001 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
3004 /* Return a pointer to a thread name if we know it and NULL otherwise.
3005 The thread_info object owns the memory for the name. */
3008 remote_target::thread_name (struct thread_info
*info
)
3010 if (info
->priv
!= NULL
)
3012 const std::string
&name
= get_remote_thread_info (info
)->name
;
3013 return !name
.empty () ? name
.c_str () : NULL
;
3019 /* About these extended threadlist and threadinfo packets. They are
3020 variable length packets but, the fields within them are often fixed
3021 length. They are redundant enough to send over UDP as is the
3022 remote protocol in general. There is a matching unit test module
3025 /* WARNING: This threadref data structure comes from the remote O.S.,
3026 libstub protocol encoding, and remote.c. It is not particularly
3029 /* Right now, the internal structure is int. We want it to be bigger.
3030 Plan to fix this. */
3032 typedef int gdb_threadref
; /* Internal GDB thread reference. */
3034 /* gdb_ext_thread_info is an internal GDB data structure which is
3035 equivalent to the reply of the remote threadinfo packet. */
3037 struct gdb_ext_thread_info
3039 threadref threadid
; /* External form of thread reference. */
3040 int active
; /* Has state interesting to GDB?
3042 char display
[256]; /* Brief state display, name,
3043 blocked/suspended. */
3044 char shortname
[32]; /* To be used to name threads. */
3045 char more_display
[256]; /* Long info, statistics, queue depth,
3049 /* The volume of remote transfers can be limited by submitting
3050 a mask containing bits specifying the desired information.
3051 Use a union of these values as the 'selection' parameter to
3052 get_thread_info. FIXME: Make these TAG names more thread specific. */
3054 #define TAG_THREADID 1
3055 #define TAG_EXISTS 2
3056 #define TAG_DISPLAY 4
3057 #define TAG_THREADNAME 8
3058 #define TAG_MOREDISPLAY 16
3060 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
3062 static const char *unpack_nibble (const char *buf
, int *val
);
3064 static const char *unpack_byte (const char *buf
, int *value
);
3066 static char *pack_int (char *buf
, int value
);
3068 static const char *unpack_int (const char *buf
, int *value
);
3070 static const char *unpack_string (const char *src
, char *dest
, int length
);
3072 static char *pack_threadid (char *pkt
, threadref
*id
);
3074 static const char *unpack_threadid (const char *inbuf
, threadref
*id
);
3076 void int_to_threadref (threadref
*id
, int value
);
3078 static int threadref_to_int (threadref
*ref
);
3080 static void copy_threadref (threadref
*dest
, threadref
*src
);
3082 static int threadmatch (threadref
*dest
, threadref
*src
);
3084 static char *pack_threadinfo_request (char *pkt
, int mode
,
3087 static char *pack_threadlist_request (char *pkt
, int startflag
,
3089 threadref
*nextthread
);
3091 static int remote_newthread_step (threadref
*ref
, void *context
);
3094 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
3095 buffer we're allowed to write to. Returns
3096 BUF+CHARACTERS_WRITTEN. */
3099 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
3102 struct remote_state
*rs
= get_remote_state ();
3104 if (remote_multi_process_p (rs
))
3108 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
3110 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
3114 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
3116 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
3121 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
3122 last parsed char. Returns null_ptid if no thread id is found, and
3123 throws an error if the thread id has an invalid format. */
3126 read_ptid (const char *buf
, const char **obuf
)
3128 const char *p
= buf
;
3130 ULONGEST pid
= 0, tid
= 0;
3134 /* Multi-process ptid. */
3135 pp
= unpack_varlen_hex (p
+ 1, &pid
);
3137 error (_("invalid remote ptid: %s"), p
);
3140 pp
= unpack_varlen_hex (p
+ 1, &tid
);
3143 return ptid_t (pid
, tid
);
3146 /* No multi-process. Just a tid. */
3147 pp
= unpack_varlen_hex (p
, &tid
);
3149 /* Return null_ptid when no thread id is found. */
3157 /* Since the stub is not sending a process id, default to what's
3158 current_inferior, unless it doesn't have a PID yet. If so,
3159 then since there's no way to know the pid of the reported
3160 threads, use the magic number. */
3161 inferior
*inf
= current_inferior ();
3163 pid
= magic_null_ptid
.pid ();
3169 return ptid_t (pid
, tid
);
3175 if (ch
>= 'a' && ch
<= 'f')
3176 return ch
- 'a' + 10;
3177 if (ch
>= '0' && ch
<= '9')
3179 if (ch
>= 'A' && ch
<= 'F')
3180 return ch
- 'A' + 10;
3185 stub_unpack_int (const char *buff
, int fieldlength
)
3192 nibble
= stubhex (*buff
++);
3196 retval
= retval
<< 4;
3202 unpack_nibble (const char *buf
, int *val
)
3204 *val
= fromhex (*buf
++);
3209 unpack_byte (const char *buf
, int *value
)
3211 *value
= stub_unpack_int (buf
, 2);
3216 pack_int (char *buf
, int value
)
3218 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3219 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3220 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3221 buf
= pack_hex_byte (buf
, (value
& 0xff));
3226 unpack_int (const char *buf
, int *value
)
3228 *value
= stub_unpack_int (buf
, 8);
3232 #if 0 /* Currently unused, uncomment when needed. */
3233 static char *pack_string (char *pkt
, char *string
);
3236 pack_string (char *pkt
, char *string
)
3241 len
= strlen (string
);
3243 len
= 200; /* Bigger than most GDB packets, junk??? */
3244 pkt
= pack_hex_byte (pkt
, len
);
3248 if ((ch
== '\0') || (ch
== '#'))
3249 ch
= '*'; /* Protect encapsulation. */
3254 #endif /* 0 (unused) */
3257 unpack_string (const char *src
, char *dest
, int length
)
3266 pack_threadid (char *pkt
, threadref
*id
)
3269 unsigned char *altid
;
3271 altid
= (unsigned char *) id
;
3272 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3274 pkt
= pack_hex_byte (pkt
, *altid
++);
3280 unpack_threadid (const char *inbuf
, threadref
*id
)
3283 const char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3286 altref
= (char *) id
;
3288 while (inbuf
< limit
)
3290 x
= stubhex (*inbuf
++);
3291 y
= stubhex (*inbuf
++);
3292 *altref
++ = (x
<< 4) | y
;
3297 /* Externally, threadrefs are 64 bits but internally, they are still
3298 ints. This is due to a mismatch of specifications. We would like
3299 to use 64bit thread references internally. This is an adapter
3303 int_to_threadref (threadref
*id
, int value
)
3305 unsigned char *scan
;
3307 scan
= (unsigned char *) id
;
3313 *scan
++ = (value
>> 24) & 0xff;
3314 *scan
++ = (value
>> 16) & 0xff;
3315 *scan
++ = (value
>> 8) & 0xff;
3316 *scan
++ = (value
& 0xff);
3320 threadref_to_int (threadref
*ref
)
3323 unsigned char *scan
;
3329 value
= (value
<< 8) | ((*scan
++) & 0xff);
3334 copy_threadref (threadref
*dest
, threadref
*src
)
3337 unsigned char *csrc
, *cdest
;
3339 csrc
= (unsigned char *) src
;
3340 cdest
= (unsigned char *) dest
;
3347 threadmatch (threadref
*dest
, threadref
*src
)
3349 /* Things are broken right now, so just assume we got a match. */
3351 unsigned char *srcp
, *destp
;
3353 srcp
= (char *) src
;
3354 destp
= (char *) dest
;
3358 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3365 threadid:1, # always request threadid
3372 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3375 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3377 *pkt
++ = 'q'; /* Info Query */
3378 *pkt
++ = 'P'; /* process or thread info */
3379 pkt
= pack_int (pkt
, mode
); /* mode */
3380 pkt
= pack_threadid (pkt
, id
); /* threadid */
3381 *pkt
= '\0'; /* terminate */
3385 /* These values tag the fields in a thread info response packet. */
3386 /* Tagging the fields allows us to request specific fields and to
3387 add more fields as time goes by. */
3389 #define TAG_THREADID 1 /* Echo the thread identifier. */
3390 #define TAG_EXISTS 2 /* Is this process defined enough to
3391 fetch registers and its stack? */
3392 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3393 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3394 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3398 remote_target::remote_unpack_thread_info_response (const char *pkt
,
3399 threadref
*expectedref
,
3400 gdb_ext_thread_info
*info
)
3402 struct remote_state
*rs
= get_remote_state ();
3406 const char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3409 /* info->threadid = 0; FIXME: implement zero_threadref. */
3411 info
->display
[0] = '\0';
3412 info
->shortname
[0] = '\0';
3413 info
->more_display
[0] = '\0';
3415 /* Assume the characters indicating the packet type have been
3417 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3418 pkt
= unpack_threadid (pkt
, &ref
);
3421 warning (_("Incomplete response to threadinfo request."));
3422 if (!threadmatch (&ref
, expectedref
))
3423 { /* This is an answer to a different request. */
3424 warning (_("ERROR RMT Thread info mismatch."));
3427 copy_threadref (&info
->threadid
, &ref
);
3429 /* Loop on tagged fields , try to bail if something goes wrong. */
3431 /* Packets are terminated with nulls. */
3432 while ((pkt
< limit
) && mask
&& *pkt
)
3434 pkt
= unpack_int (pkt
, &tag
); /* tag */
3435 pkt
= unpack_byte (pkt
, &length
); /* length */
3436 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3438 warning (_("ERROR RMT: threadinfo tag mismatch."));
3442 if (tag
== TAG_THREADID
)
3446 warning (_("ERROR RMT: length of threadid is not 16."));
3450 pkt
= unpack_threadid (pkt
, &ref
);
3451 mask
= mask
& ~TAG_THREADID
;
3454 if (tag
== TAG_EXISTS
)
3456 info
->active
= stub_unpack_int (pkt
, length
);
3458 mask
= mask
& ~(TAG_EXISTS
);
3461 warning (_("ERROR RMT: 'exists' length too long."));
3467 if (tag
== TAG_THREADNAME
)
3469 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3470 mask
= mask
& ~TAG_THREADNAME
;
3473 if (tag
== TAG_DISPLAY
)
3475 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3476 mask
= mask
& ~TAG_DISPLAY
;
3479 if (tag
== TAG_MOREDISPLAY
)
3481 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3482 mask
= mask
& ~TAG_MOREDISPLAY
;
3485 warning (_("ERROR RMT: unknown thread info tag."));
3486 break; /* Not a tag we know about. */
3492 remote_target::remote_get_threadinfo (threadref
*threadid
,
3494 gdb_ext_thread_info
*info
)
3496 struct remote_state
*rs
= get_remote_state ();
3499 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3501 getpkt (&rs
->buf
, 0);
3503 if (rs
->buf
[0] == '\0')
3506 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3511 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3514 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3515 threadref
*nextthread
)
3517 *pkt
++ = 'q'; /* info query packet */
3518 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3519 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3520 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3521 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3526 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3529 remote_target::parse_threadlist_response (const char *pkt
, int result_limit
,
3530 threadref
*original_echo
,
3531 threadref
*resultlist
,
3534 struct remote_state
*rs
= get_remote_state ();
3535 int count
, resultcount
, done
;
3538 /* Assume the 'q' and 'M chars have been stripped. */
3539 const char *limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3540 /* done parse past here */
3541 pkt
= unpack_byte (pkt
, &count
); /* count field */
3542 pkt
= unpack_nibble (pkt
, &done
);
3543 /* The first threadid is the argument threadid. */
3544 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3545 while ((count
-- > 0) && (pkt
< limit
))
3547 pkt
= unpack_threadid (pkt
, resultlist
++);
3548 if (resultcount
++ >= result_limit
)
3556 /* Fetch the next batch of threads from the remote. Returns -1 if the
3557 qL packet is not supported, 0 on error and 1 on success. */
3560 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3561 int result_limit
, int *done
, int *result_count
,
3562 threadref
*threadlist
)
3564 struct remote_state
*rs
= get_remote_state ();
3567 /* Truncate result limit to be smaller than the packet size. */
3568 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3569 >= get_remote_packet_size ())
3570 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3572 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3575 getpkt (&rs
->buf
, 0);
3576 if (rs
->buf
[0] == '\0')
3578 /* Packet not supported. */
3583 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3584 &rs
->echo_nextthread
, threadlist
, done
);
3586 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3588 /* FIXME: This is a good reason to drop the packet. */
3589 /* Possibly, there is a duplicate response. */
3591 retransmit immediatly - race conditions
3592 retransmit after timeout - yes
3594 wait for packet, then exit
3596 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3597 return 0; /* I choose simply exiting. */
3599 if (*result_count
<= 0)
3603 warning (_("RMT ERROR : failed to get remote thread list."));
3606 return result
; /* break; */
3608 if (*result_count
> result_limit
)
3611 warning (_("RMT ERROR: threadlist response longer than requested."));
3617 /* Fetch the list of remote threads, with the qL packet, and call
3618 STEPFUNCTION for each thread found. Stops iterating and returns 1
3619 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3620 STEPFUNCTION returns false. If the packet is not supported,
3624 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3625 void *context
, int looplimit
)
3627 struct remote_state
*rs
= get_remote_state ();
3628 int done
, i
, result_count
;
3636 if (loopcount
++ > looplimit
)
3639 warning (_("Remote fetch threadlist -infinite loop-."));
3642 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3643 MAXTHREADLISTRESULTS
,
3644 &done
, &result_count
,
3645 rs
->resultthreadlist
);
3648 /* Clear for later iterations. */
3650 /* Setup to resume next batch of thread references, set nextthread. */
3651 if (result_count
>= 1)
3652 copy_threadref (&rs
->nextthread
,
3653 &rs
->resultthreadlist
[result_count
- 1]);
3655 while (result_count
--)
3657 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3667 /* A thread found on the remote target. */
3671 explicit thread_item (ptid_t ptid_
)
3675 thread_item (thread_item
&&other
) = default;
3676 thread_item
&operator= (thread_item
&&other
) = default;
3678 DISABLE_COPY_AND_ASSIGN (thread_item
);
3680 /* The thread's PTID. */
3683 /* The thread's extra info. */
3686 /* The thread's name. */
3689 /* The core the thread was running on. -1 if not known. */
3692 /* The thread handle associated with the thread. */
3693 gdb::byte_vector thread_handle
;
3696 /* Context passed around to the various methods listing remote
3697 threads. As new threads are found, they're added to the ITEMS
3700 struct threads_listing_context
3702 /* Return true if this object contains an entry for a thread with ptid
3705 bool contains_thread (ptid_t ptid
) const
3707 auto match_ptid
= [&] (const thread_item
&item
)
3709 return item
.ptid
== ptid
;
3712 auto it
= std::find_if (this->items
.begin (),
3716 return it
!= this->items
.end ();
3719 /* Remove the thread with ptid PTID. */
3721 void remove_thread (ptid_t ptid
)
3723 auto match_ptid
= [&] (const thread_item
&item
)
3725 return item
.ptid
== ptid
;
3728 auto it
= std::remove_if (this->items
.begin (),
3732 if (it
!= this->items
.end ())
3733 this->items
.erase (it
);
3736 /* The threads found on the remote target. */
3737 std::vector
<thread_item
> items
;
3741 remote_newthread_step (threadref
*ref
, void *data
)
3743 struct threads_listing_context
*context
3744 = (struct threads_listing_context
*) data
;
3745 int pid
= inferior_ptid
.pid ();
3746 int lwp
= threadref_to_int (ref
);
3747 ptid_t
ptid (pid
, lwp
);
3749 context
->items
.emplace_back (ptid
);
3751 return 1; /* continue iterator */
3754 #define CRAZY_MAX_THREADS 1000
3757 remote_target::remote_current_thread (ptid_t oldpid
)
3759 struct remote_state
*rs
= get_remote_state ();
3762 getpkt (&rs
->buf
, 0);
3763 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3768 result
= read_ptid (&rs
->buf
[2], &obuf
);
3770 remote_debug_printf ("warning: garbage in qC reply");
3778 /* List remote threads using the deprecated qL packet. */
3781 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3783 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3784 CRAZY_MAX_THREADS
) >= 0)
3790 #if defined(HAVE_LIBEXPAT)
3793 start_thread (struct gdb_xml_parser
*parser
,
3794 const struct gdb_xml_element
*element
,
3796 std::vector
<gdb_xml_value
> &attributes
)
3798 struct threads_listing_context
*data
3799 = (struct threads_listing_context
*) user_data
;
3800 struct gdb_xml_value
*attr
;
3802 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3803 ptid_t ptid
= read_ptid (id
, NULL
);
3805 data
->items
.emplace_back (ptid
);
3806 thread_item
&item
= data
->items
.back ();
3808 attr
= xml_find_attribute (attributes
, "core");
3810 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3812 attr
= xml_find_attribute (attributes
, "name");
3814 item
.name
= (const char *) attr
->value
.get ();
3816 attr
= xml_find_attribute (attributes
, "handle");
3818 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3822 end_thread (struct gdb_xml_parser
*parser
,
3823 const struct gdb_xml_element
*element
,
3824 void *user_data
, const char *body_text
)
3826 struct threads_listing_context
*data
3827 = (struct threads_listing_context
*) user_data
;
3829 if (body_text
!= NULL
&& *body_text
!= '\0')
3830 data
->items
.back ().extra
= body_text
;
3833 const struct gdb_xml_attribute thread_attributes
[] = {
3834 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3835 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3836 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3837 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3838 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3841 const struct gdb_xml_element thread_children
[] = {
3842 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3845 const struct gdb_xml_element threads_children
[] = {
3846 { "thread", thread_attributes
, thread_children
,
3847 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3848 start_thread
, end_thread
},
3849 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3852 const struct gdb_xml_element threads_elements
[] = {
3853 { "threads", NULL
, threads_children
,
3854 GDB_XML_EF_NONE
, NULL
, NULL
},
3855 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3860 /* List remote threads using qXfer:threads:read. */
3863 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3865 #if defined(HAVE_LIBEXPAT)
3866 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3868 gdb::optional
<gdb::char_vector
> xml
3869 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3871 if (xml
&& (*xml
)[0] != '\0')
3873 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3874 threads_elements
, xml
->data (), context
);
3884 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3887 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3889 struct remote_state
*rs
= get_remote_state ();
3891 if (rs
->use_threadinfo_query
)
3895 putpkt ("qfThreadInfo");
3896 getpkt (&rs
->buf
, 0);
3897 bufp
= rs
->buf
.data ();
3898 if (bufp
[0] != '\0') /* q packet recognized */
3900 while (*bufp
++ == 'm') /* reply contains one or more TID */
3904 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3905 context
->items
.emplace_back (ptid
);
3907 while (*bufp
++ == ','); /* comma-separated list */
3908 putpkt ("qsThreadInfo");
3909 getpkt (&rs
->buf
, 0);
3910 bufp
= rs
->buf
.data ();
3916 /* Packet not recognized. */
3917 rs
->use_threadinfo_query
= 0;
3924 /* Return true if INF only has one non-exited thread. */
3927 has_single_non_exited_thread (inferior
*inf
)
3930 for (thread_info
*tp ATTRIBUTE_UNUSED
: inf
->non_exited_threads ())
3936 /* Implement the to_update_thread_list function for the remote
3940 remote_target::update_thread_list ()
3942 struct threads_listing_context context
;
3945 /* We have a few different mechanisms to fetch the thread list. Try
3946 them all, starting with the most preferred one first, falling
3947 back to older methods. */
3948 if (remote_get_threads_with_qxfer (&context
)
3949 || remote_get_threads_with_qthreadinfo (&context
)
3950 || remote_get_threads_with_ql (&context
))
3954 if (context
.items
.empty ()
3955 && remote_thread_always_alive (inferior_ptid
))
3957 /* Some targets don't really support threads, but still
3958 reply an (empty) thread list in response to the thread
3959 listing packets, instead of replying "packet not
3960 supported". Exit early so we don't delete the main
3965 /* CONTEXT now holds the current thread list on the remote
3966 target end. Delete GDB-side threads no longer found on the
3968 for (thread_info
*tp
: all_threads_safe ())
3970 if (tp
->inf
->process_target () != this)
3973 if (!context
.contains_thread (tp
->ptid
))
3975 /* Do not remove the thread if it is the last thread in
3976 the inferior. This situation happens when we have a
3977 pending exit process status to process. Otherwise we
3978 may end up with a seemingly live inferior (i.e. pid
3979 != 0) that has no threads. */
3980 if (has_single_non_exited_thread (tp
->inf
))
3988 /* Remove any unreported fork child threads from CONTEXT so
3989 that we don't interfere with follow fork, which is where
3990 creation of such threads is handled. */
3991 remove_new_fork_children (&context
);
3993 /* And now add threads we don't know about yet to our list. */
3994 for (thread_item
&item
: context
.items
)
3996 if (item
.ptid
!= null_ptid
)
3998 /* In non-stop mode, we assume new found threads are
3999 executing until proven otherwise with a stop reply.
4000 In all-stop, we can only get here if all threads are
4002 bool executing
= target_is_non_stop_p ();
4004 remote_notice_new_inferior (item
.ptid
, executing
);
4006 thread_info
*tp
= find_thread_ptid (this, item
.ptid
);
4007 remote_thread_info
*info
= get_remote_thread_info (tp
);
4008 info
->core
= item
.core
;
4009 info
->extra
= std::move (item
.extra
);
4010 info
->name
= std::move (item
.name
);
4011 info
->thread_handle
= std::move (item
.thread_handle
);
4018 /* If no thread listing method is supported, then query whether
4019 each known thread is alive, one by one, with the T packet.
4020 If the target doesn't support threads at all, then this is a
4021 no-op. See remote_thread_alive. */
4027 * Collect a descriptive string about the given thread.
4028 * The target may say anything it wants to about the thread
4029 * (typically info about its blocked / runnable state, name, etc.).
4030 * This string will appear in the info threads display.
4032 * Optional: targets are not required to implement this function.
4036 remote_target::extra_thread_info (thread_info
*tp
)
4038 struct remote_state
*rs
= get_remote_state ();
4041 struct gdb_ext_thread_info threadinfo
;
4043 if (rs
->remote_desc
== 0) /* paranoia */
4044 internal_error (__FILE__
, __LINE__
,
4045 _("remote_threads_extra_info"));
4047 if (tp
->ptid
== magic_null_ptid
4048 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
4049 /* This is the main thread which was added by GDB. The remote
4050 server doesn't know about it. */
4053 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
4055 /* If already have cached info, use it. */
4056 if (!extra
.empty ())
4057 return extra
.c_str ();
4059 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
4061 /* If we're using qXfer:threads:read, then the extra info is
4062 included in the XML. So if we didn't have anything cached,
4063 it's because there's really no extra info. */
4067 if (rs
->use_threadextra_query
)
4069 char *b
= rs
->buf
.data ();
4070 char *endb
= b
+ get_remote_packet_size ();
4072 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
4074 write_ptid (b
, endb
, tp
->ptid
);
4077 getpkt (&rs
->buf
, 0);
4078 if (rs
->buf
[0] != 0)
4080 extra
.resize (strlen (rs
->buf
.data ()) / 2);
4081 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
4082 return extra
.c_str ();
4086 /* If the above query fails, fall back to the old method. */
4087 rs
->use_threadextra_query
= 0;
4088 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
4089 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
4090 int_to_threadref (&id
, tp
->ptid
.lwp ());
4091 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
4092 if (threadinfo
.active
)
4094 if (*threadinfo
.shortname
)
4095 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
4096 if (*threadinfo
.display
)
4098 if (!extra
.empty ())
4100 string_appendf (extra
, " State: %s", threadinfo
.display
);
4102 if (*threadinfo
.more_display
)
4104 if (!extra
.empty ())
4106 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
4108 return extra
.c_str ();
4115 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
4116 struct static_tracepoint_marker
*marker
)
4118 struct remote_state
*rs
= get_remote_state ();
4119 char *p
= rs
->buf
.data ();
4121 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
4123 p
+= hexnumstr (p
, addr
);
4125 getpkt (&rs
->buf
, 0);
4126 p
= rs
->buf
.data ();
4129 error (_("Remote failure reply: %s"), p
);
4133 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
4140 std::vector
<static_tracepoint_marker
>
4141 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
4143 struct remote_state
*rs
= get_remote_state ();
4144 std::vector
<static_tracepoint_marker
> markers
;
4146 static_tracepoint_marker marker
;
4148 /* Ask for a first packet of static tracepoint marker
4151 getpkt (&rs
->buf
, 0);
4152 p
= rs
->buf
.data ();
4154 error (_("Remote failure reply: %s"), p
);
4160 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
4162 if (strid
== NULL
|| marker
.str_id
== strid
)
4163 markers
.push_back (std::move (marker
));
4165 while (*p
++ == ','); /* comma-separated list */
4166 /* Ask for another packet of static tracepoint definition. */
4168 getpkt (&rs
->buf
, 0);
4169 p
= rs
->buf
.data ();
4176 /* Implement the to_get_ada_task_ptid function for the remote targets. */
4179 remote_target::get_ada_task_ptid (long lwp
, ULONGEST thread
)
4181 return ptid_t (inferior_ptid
.pid (), lwp
);
4185 /* Restart the remote side; this is an extended protocol operation. */
4188 remote_target::extended_remote_restart ()
4190 struct remote_state
*rs
= get_remote_state ();
4192 /* Send the restart command; for reasons I don't understand the
4193 remote side really expects a number after the "R". */
4194 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
4197 remote_fileio_reset ();
4200 /* Clean up connection to a remote debugger. */
4203 remote_target::close ()
4205 /* Make sure we leave stdin registered in the event loop. */
4208 trace_reset_local_state ();
4213 remote_target::~remote_target ()
4215 struct remote_state
*rs
= get_remote_state ();
4217 /* Check for NULL because we may get here with a partially
4218 constructed target/connection. */
4219 if (rs
->remote_desc
== nullptr)
4222 serial_close (rs
->remote_desc
);
4224 /* We are destroying the remote target, so we should discard
4225 everything of this target. */
4226 discard_pending_stop_replies_in_queue ();
4228 if (rs
->remote_async_inferior_event_token
)
4229 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4231 delete rs
->notif_state
;
4234 /* Query the remote side for the text, data and bss offsets. */
4237 remote_target::get_offsets ()
4239 struct remote_state
*rs
= get_remote_state ();
4242 int lose
, num_segments
= 0, do_sections
, do_segments
;
4243 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4245 if (current_program_space
->symfile_object_file
== NULL
)
4248 putpkt ("qOffsets");
4249 getpkt (&rs
->buf
, 0);
4250 buf
= rs
->buf
.data ();
4252 if (buf
[0] == '\000')
4253 return; /* Return silently. Stub doesn't support
4257 warning (_("Remote failure reply: %s"), buf
);
4261 /* Pick up each field in turn. This used to be done with scanf, but
4262 scanf will make trouble if CORE_ADDR size doesn't match
4263 conversion directives correctly. The following code will work
4264 with any size of CORE_ADDR. */
4265 text_addr
= data_addr
= bss_addr
= 0;
4269 if (startswith (ptr
, "Text="))
4272 /* Don't use strtol, could lose on big values. */
4273 while (*ptr
&& *ptr
!= ';')
4274 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4276 if (startswith (ptr
, ";Data="))
4279 while (*ptr
&& *ptr
!= ';')
4280 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4285 if (!lose
&& startswith (ptr
, ";Bss="))
4288 while (*ptr
&& *ptr
!= ';')
4289 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4291 if (bss_addr
!= data_addr
)
4292 warning (_("Target reported unsupported offsets: %s"), buf
);
4297 else if (startswith (ptr
, "TextSeg="))
4300 /* Don't use strtol, could lose on big values. */
4301 while (*ptr
&& *ptr
!= ';')
4302 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4305 if (startswith (ptr
, ";DataSeg="))
4308 while (*ptr
&& *ptr
!= ';')
4309 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4317 error (_("Malformed response to offset query, %s"), buf
);
4318 else if (*ptr
!= '\0')
4319 warning (_("Target reported unsupported offsets: %s"), buf
);
4321 objfile
*objf
= current_program_space
->symfile_object_file
;
4322 section_offsets offs
= objf
->section_offsets
;
4324 symfile_segment_data_up data
= get_symfile_segment_data (objf
->obfd
);
4325 do_segments
= (data
!= NULL
);
4326 do_sections
= num_segments
== 0;
4328 if (num_segments
> 0)
4330 segments
[0] = text_addr
;
4331 segments
[1] = data_addr
;
4333 /* If we have two segments, we can still try to relocate everything
4334 by assuming that the .text and .data offsets apply to the whole
4335 text and data segments. Convert the offsets given in the packet
4336 to base addresses for symfile_map_offsets_to_segments. */
4337 else if (data
!= nullptr && data
->segments
.size () == 2)
4339 segments
[0] = data
->segments
[0].base
+ text_addr
;
4340 segments
[1] = data
->segments
[1].base
+ data_addr
;
4343 /* If the object file has only one segment, assume that it is text
4344 rather than data; main programs with no writable data are rare,
4345 but programs with no code are useless. Of course the code might
4346 have ended up in the data segment... to detect that we would need
4347 the permissions here. */
4348 else if (data
&& data
->segments
.size () == 1)
4350 segments
[0] = data
->segments
[0].base
+ text_addr
;
4353 /* There's no way to relocate by segment. */
4359 int ret
= symfile_map_offsets_to_segments (objf
->obfd
,
4361 num_segments
, segments
);
4363 if (ret
== 0 && !do_sections
)
4364 error (_("Can not handle qOffsets TextSeg "
4365 "response with this symbol file"));
4373 offs
[SECT_OFF_TEXT (objf
)] = text_addr
;
4375 /* This is a temporary kludge to force data and bss to use the
4376 same offsets because that's what nlmconv does now. The real
4377 solution requires changes to the stub and remote.c that I
4378 don't have time to do right now. */
4380 offs
[SECT_OFF_DATA (objf
)] = data_addr
;
4381 offs
[SECT_OFF_BSS (objf
)] = data_addr
;
4384 objfile_relocate (objf
, offs
);
4387 /* Send interrupt_sequence to remote target. */
4390 remote_target::send_interrupt_sequence ()
4392 struct remote_state
*rs
= get_remote_state ();
4394 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4395 remote_serial_write ("\x03", 1);
4396 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4397 serial_send_break (rs
->remote_desc
);
4398 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4400 serial_send_break (rs
->remote_desc
);
4401 remote_serial_write ("g", 1);
4404 internal_error (__FILE__
, __LINE__
,
4405 _("Invalid value for interrupt_sequence_mode: %s."),
4406 interrupt_sequence_mode
);
4410 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4411 and extract the PTID. Returns NULL_PTID if not found. */
4414 stop_reply_extract_thread (const char *stop_reply
)
4416 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4420 /* Txx r:val ; r:val (...) */
4423 /* Look for "register" named "thread". */
4428 p1
= strchr (p
, ':');
4432 if (strncmp (p
, "thread", p1
- p
) == 0)
4433 return read_ptid (++p1
, &p
);
4435 p1
= strchr (p
, ';');
4447 /* Determine the remote side's current thread. If we have a stop
4448 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4449 "thread" register we can extract the current thread from. If not,
4450 ask the remote which is the current thread with qC. The former
4451 method avoids a roundtrip. */
4454 remote_target::get_current_thread (const char *wait_status
)
4456 ptid_t ptid
= null_ptid
;
4458 /* Note we don't use remote_parse_stop_reply as that makes use of
4459 the target architecture, which we haven't yet fully determined at
4461 if (wait_status
!= NULL
)
4462 ptid
= stop_reply_extract_thread (wait_status
);
4463 if (ptid
== null_ptid
)
4464 ptid
= remote_current_thread (inferior_ptid
);
4469 /* Query the remote target for which is the current thread/process,
4470 add it to our tables, and update INFERIOR_PTID. The caller is
4471 responsible for setting the state such that the remote end is ready
4472 to return the current thread.
4474 This function is called after handling the '?' or 'vRun' packets,
4475 whose response is a stop reply from which we can also try
4476 extracting the thread. If the target doesn't support the explicit
4477 qC query, we infer the current thread from that stop reply, passed
4478 in in WAIT_STATUS, which may be NULL.
4480 The function returns pointer to the main thread of the inferior. */
4483 remote_target::add_current_inferior_and_thread (const char *wait_status
)
4485 struct remote_state
*rs
= get_remote_state ();
4486 bool fake_pid_p
= false;
4488 switch_to_no_thread ();
4490 /* Now, if we have thread information, update the current thread's
4492 ptid_t curr_ptid
= get_current_thread (wait_status
);
4494 if (curr_ptid
!= null_ptid
)
4496 if (!remote_multi_process_p (rs
))
4501 /* Without this, some commands which require an active target
4502 (such as kill) won't work. This variable serves (at least)
4503 double duty as both the pid of the target process (if it has
4504 such), and as a flag indicating that a target is active. */
4505 curr_ptid
= magic_null_ptid
;
4509 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4511 /* Add the main thread and switch to it. Don't try reading
4512 registers yet, since we haven't fetched the target description
4514 thread_info
*tp
= add_thread_silent (this, curr_ptid
);
4515 switch_to_thread_no_regs (tp
);
4520 /* Print info about a thread that was found already stopped on
4524 remote_target::print_one_stopped_thread (thread_info
*thread
)
4526 target_waitstatus ws
;
4528 /* If there is a pending waitstatus, use it. If there isn't it's because
4529 the thread's stop was reported with TARGET_WAITKIND_STOPPED / GDB_SIGNAL_0
4530 and process_initial_stop_replies decided it wasn't interesting to save
4531 and report to the core. */
4532 if (thread
->has_pending_waitstatus ())
4534 ws
= thread
->pending_waitstatus ();
4535 thread
->clear_pending_waitstatus ();
4539 ws
.set_stopped (GDB_SIGNAL_0
);
4542 switch_to_thread (thread
);
4543 thread
->set_stop_pc (get_frame_pc (get_current_frame ()));
4544 set_current_sal_from_frame (get_current_frame ());
4546 /* For "info program". */
4547 set_last_target_status (this, thread
->ptid
, ws
);
4549 if (ws
.kind () == TARGET_WAITKIND_STOPPED
)
4551 enum gdb_signal sig
= ws
.sig ();
4553 if (signal_print_state (sig
))
4554 gdb::observers::signal_received
.notify (sig
);
4556 gdb::observers::normal_stop
.notify (NULL
, 1);
4559 /* Process all initial stop replies the remote side sent in response
4560 to the ? packet. These indicate threads that were already stopped
4561 on initial connection. We mark these threads as stopped and print
4562 their current frame before giving the user the prompt. */
4565 remote_target::process_initial_stop_replies (int from_tty
)
4567 int pending_stop_replies
= stop_reply_queue_length ();
4568 struct thread_info
*selected
= NULL
;
4569 struct thread_info
*lowest_stopped
= NULL
;
4570 struct thread_info
*first
= NULL
;
4572 /* This is only used when the target is non-stop. */
4573 gdb_assert (target_is_non_stop_p ());
4575 /* Consume the initial pending events. */
4576 while (pending_stop_replies
-- > 0)
4578 ptid_t waiton_ptid
= minus_one_ptid
;
4580 struct target_waitstatus ws
;
4581 int ignore_event
= 0;
4583 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4585 print_target_wait_results (waiton_ptid
, event_ptid
, ws
);
4589 case TARGET_WAITKIND_IGNORE
:
4590 case TARGET_WAITKIND_NO_RESUMED
:
4591 case TARGET_WAITKIND_SIGNALLED
:
4592 case TARGET_WAITKIND_EXITED
:
4593 /* We shouldn't see these, but if we do, just ignore. */
4594 remote_debug_printf ("event ignored");
4605 thread_info
*evthread
= find_thread_ptid (this, event_ptid
);
4607 if (ws
.kind () == TARGET_WAITKIND_STOPPED
)
4609 enum gdb_signal sig
= ws
.sig ();
4611 /* Stubs traditionally report SIGTRAP as initial signal,
4612 instead of signal 0. Suppress it. */
4613 if (sig
== GDB_SIGNAL_TRAP
)
4615 evthread
->set_stop_signal (sig
);
4616 ws
.set_stopped (sig
);
4619 if (ws
.kind () != TARGET_WAITKIND_STOPPED
4620 || ws
.sig () != GDB_SIGNAL_0
)
4621 evthread
->set_pending_waitstatus (ws
);
4623 set_executing (this, event_ptid
, false);
4624 set_running (this, event_ptid
, false);
4625 get_remote_thread_info (evthread
)->set_not_resumed ();
4628 /* "Notice" the new inferiors before anything related to
4629 registers/memory. */
4630 for (inferior
*inf
: all_non_exited_inferiors (this))
4632 inf
->needs_setup
= 1;
4636 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4637 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4642 /* If all-stop on top of non-stop, pause all threads. Note this
4643 records the threads' stop pc, so must be done after "noticing"
4648 /* At this point, the remote target is not async. It needs to be for
4649 the poll in stop_all_threads to consider events from it, so enable
4651 gdb_assert (!this->is_async_p ());
4652 SCOPE_EXIT
{ target_async (0); };
4654 stop_all_threads ("remote connect in all-stop");
4657 /* If all threads of an inferior were already stopped, we
4658 haven't setup the inferior yet. */
4659 for (inferior
*inf
: all_non_exited_inferiors (this))
4661 if (inf
->needs_setup
)
4663 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4664 switch_to_thread_no_regs (thread
);
4670 /* Now go over all threads that are stopped, and print their current
4671 frame. If all-stop, then if there's a signalled thread, pick
4673 for (thread_info
*thread
: all_non_exited_threads (this))
4679 thread
->set_running (false);
4680 else if (thread
->state
!= THREAD_STOPPED
)
4683 if (selected
== nullptr && thread
->has_pending_waitstatus ())
4686 if (lowest_stopped
== NULL
4687 || thread
->inf
->num
< lowest_stopped
->inf
->num
4688 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4689 lowest_stopped
= thread
;
4692 print_one_stopped_thread (thread
);
4695 /* In all-stop, we only print the status of one thread, and leave
4696 others with their status pending. */
4699 thread_info
*thread
= selected
;
4701 thread
= lowest_stopped
;
4705 print_one_stopped_thread (thread
);
4709 /* Mark a remote_target as marking (by setting the starting_up flag within
4710 its remote_state) for the lifetime of this object. The reference count
4711 on the remote target is temporarily incremented, to prevent the target
4712 being deleted under our feet. */
4714 struct scoped_mark_target_starting
4716 /* Constructor, TARGET is the target to be marked as starting, its
4717 reference count will be incremented. */
4718 scoped_mark_target_starting (remote_target
*target
)
4719 : m_remote_target (target
)
4721 m_remote_target
->incref ();
4722 remote_state
*rs
= m_remote_target
->get_remote_state ();
4723 rs
->starting_up
= true;
4726 /* Destructor, mark the target being worked on as no longer starting, and
4727 decrement the reference count. */
4728 ~scoped_mark_target_starting ()
4730 remote_state
*rs
= m_remote_target
->get_remote_state ();
4731 rs
->starting_up
= false;
4732 decref_target (m_remote_target
);
4737 /* The target on which we are operating. */
4738 remote_target
*m_remote_target
;
4741 /* Helper for remote_target::start_remote, start the remote connection and
4742 sync state. Return true if everything goes OK, otherwise, return false.
4743 This function exists so that the scoped_restore created within it will
4744 expire before we return to remote_target::start_remote. */
4747 remote_target::start_remote_1 (int from_tty
, int extended_p
)
4749 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
4751 struct remote_state
*rs
= get_remote_state ();
4752 struct packet_config
*noack_config
;
4754 /* Signal other parts that we're going through the initial setup,
4755 and so things may not be stable yet. E.g., we don't try to
4756 install tracepoints until we've relocated symbols. Also, a
4757 Ctrl-C before we're connected and synced up can't interrupt the
4758 target. Instead, it offers to drop the (potentially wedged)
4760 scoped_mark_target_starting
target_is_starting (this);
4764 if (interrupt_on_connect
)
4765 send_interrupt_sequence ();
4767 /* Ack any packet which the remote side has already sent. */
4768 remote_serial_write ("+", 1);
4770 /* The first packet we send to the target is the optional "supported
4771 packets" request. If the target can answer this, it will tell us
4772 which later probes to skip. */
4773 remote_query_supported ();
4775 /* If the stub wants to get a QAllow, compose one and send it. */
4776 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4779 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4780 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4781 as a reply to known packet. For packet "vFile:setfs:" it is an
4782 invalid reply and GDB would return error in
4783 remote_hostio_set_filesystem, making remote files access impossible.
4784 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4785 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4787 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4789 putpkt (v_mustreplyempty
);
4790 getpkt (&rs
->buf
, 0);
4791 if (strcmp (rs
->buf
.data (), "OK") == 0)
4792 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4793 else if (strcmp (rs
->buf
.data (), "") != 0)
4794 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4798 /* Next, we possibly activate noack mode.
4800 If the QStartNoAckMode packet configuration is set to AUTO,
4801 enable noack mode if the stub reported a wish for it with
4804 If set to TRUE, then enable noack mode even if the stub didn't
4805 report it in qSupported. If the stub doesn't reply OK, the
4806 session ends with an error.
4808 If FALSE, then don't activate noack mode, regardless of what the
4809 stub claimed should be the default with qSupported. */
4811 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4812 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4814 putpkt ("QStartNoAckMode");
4815 getpkt (&rs
->buf
, 0);
4816 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4822 /* Tell the remote that we are using the extended protocol. */
4824 getpkt (&rs
->buf
, 0);
4827 /* Let the target know which signals it is allowed to pass down to
4829 update_signals_program_target ();
4831 /* Next, if the target can specify a description, read it. We do
4832 this before anything involving memory or registers. */
4833 target_find_description ();
4835 /* Next, now that we know something about the target, update the
4836 address spaces in the program spaces. */
4837 update_address_spaces ();
4839 /* On OSs where the list of libraries is global to all
4840 processes, we fetch them early. */
4841 if (gdbarch_has_global_solist (target_gdbarch ()))
4842 solib_add (NULL
, from_tty
, auto_solib_add
);
4844 if (target_is_non_stop_p ())
4846 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4847 error (_("Non-stop mode requested, but remote "
4848 "does not support non-stop"));
4850 putpkt ("QNonStop:1");
4851 getpkt (&rs
->buf
, 0);
4853 if (strcmp (rs
->buf
.data (), "OK") != 0)
4854 error (_("Remote refused setting non-stop mode with: %s"),
4857 /* Find about threads and processes the stub is already
4858 controlling. We default to adding them in the running state.
4859 The '?' query below will then tell us about which threads are
4861 this->update_thread_list ();
4863 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4865 /* Don't assume that the stub can operate in all-stop mode.
4866 Request it explicitly. */
4867 putpkt ("QNonStop:0");
4868 getpkt (&rs
->buf
, 0);
4870 if (strcmp (rs
->buf
.data (), "OK") != 0)
4871 error (_("Remote refused setting all-stop mode with: %s"),
4875 /* Upload TSVs regardless of whether the target is running or not. The
4876 remote stub, such as GDBserver, may have some predefined or builtin
4877 TSVs, even if the target is not running. */
4878 if (get_trace_status (current_trace_status ()) != -1)
4880 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4882 upload_trace_state_variables (&uploaded_tsvs
);
4883 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4886 /* Check whether the target is running now. */
4888 getpkt (&rs
->buf
, 0);
4890 if (!target_is_non_stop_p ())
4892 char *wait_status
= NULL
;
4894 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4897 error (_("The target is not running (try extended-remote?)"));
4902 /* Save the reply for later. */
4903 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4904 strcpy (wait_status
, rs
->buf
.data ());
4907 /* Fetch thread list. */
4908 target_update_thread_list ();
4910 /* Let the stub know that we want it to return the thread. */
4911 set_continue_thread (minus_one_ptid
);
4913 if (thread_count (this) == 0)
4915 /* Target has no concept of threads at all. GDB treats
4916 non-threaded target as single-threaded; add a main
4918 thread_info
*tp
= add_current_inferior_and_thread (wait_status
);
4919 get_remote_thread_info (tp
)->set_resumed ();
4923 /* We have thread information; select the thread the target
4924 says should be current. If we're reconnecting to a
4925 multi-threaded program, this will ideally be the thread
4926 that last reported an event before GDB disconnected. */
4927 ptid_t curr_thread
= get_current_thread (wait_status
);
4928 if (curr_thread
== null_ptid
)
4930 /* Odd... The target was able to list threads, but not
4931 tell us which thread was current (no "thread"
4932 register in T stop reply?). Just pick the first
4933 thread in the thread list then. */
4935 remote_debug_printf ("warning: couldn't determine remote "
4936 "current thread; picking first in list.");
4938 for (thread_info
*tp
: all_non_exited_threads (this,
4941 switch_to_thread (tp
);
4946 switch_to_thread (find_thread_ptid (this, curr_thread
));
4949 /* init_wait_for_inferior should be called before get_offsets in order
4950 to manage `inserted' flag in bp loc in a correct state.
4951 breakpoint_init_inferior, called from init_wait_for_inferior, set
4952 `inserted' flag to 0, while before breakpoint_re_set, called from
4953 start_remote, set `inserted' flag to 1. In the initialization of
4954 inferior, breakpoint_init_inferior should be called first, and then
4955 breakpoint_re_set can be called. If this order is broken, state of
4956 `inserted' flag is wrong, and cause some problems on breakpoint
4958 init_wait_for_inferior ();
4960 get_offsets (); /* Get text, data & bss offsets. */
4962 /* If we could not find a description using qXfer, and we know
4963 how to do it some other way, try again. This is not
4964 supported for non-stop; it could be, but it is tricky if
4965 there are no stopped threads when we connect. */
4966 if (remote_read_description_p (this)
4967 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4969 target_clear_description ();
4970 target_find_description ();
4973 /* Use the previously fetched status. */
4974 gdb_assert (wait_status
!= NULL
);
4975 struct notif_event
*reply
4976 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
4977 push_stop_reply ((struct stop_reply
*) reply
);
4979 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4983 /* Clear WFI global state. Do this before finding about new
4984 threads and inferiors, and setting the current inferior.
4985 Otherwise we would clear the proceed status of the current
4986 inferior when we want its stop_soon state to be preserved
4987 (see notice_new_inferior). */
4988 init_wait_for_inferior ();
4990 /* In non-stop, we will either get an "OK", meaning that there
4991 are no stopped threads at this time; or, a regular stop
4992 reply. In the latter case, there may be more than one thread
4993 stopped --- we pull them all out using the vStopped
4995 if (strcmp (rs
->buf
.data (), "OK") != 0)
4997 struct notif_client
*notif
= ¬if_client_stop
;
4999 /* remote_notif_get_pending_replies acks this one, and gets
5001 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
5002 = remote_notif_parse (this, notif
, rs
->buf
.data ());
5003 remote_notif_get_pending_events (notif
);
5006 if (thread_count (this) == 0)
5009 error (_("The target is not running (try extended-remote?)"));
5013 /* Report all signals during attach/startup. */
5016 /* If there are already stopped threads, mark them stopped and
5017 report their stops before giving the prompt to the user. */
5018 process_initial_stop_replies (from_tty
);
5020 if (target_can_async_p ())
5024 /* If we connected to a live target, do some additional setup. */
5025 if (target_has_execution ())
5027 /* No use without a symbol-file. */
5028 if (current_program_space
->symfile_object_file
)
5029 remote_check_symbols ();
5032 /* Possibly the target has been engaged in a trace run started
5033 previously; find out where things are at. */
5034 if (get_trace_status (current_trace_status ()) != -1)
5036 struct uploaded_tp
*uploaded_tps
= NULL
;
5038 if (current_trace_status ()->running
)
5039 gdb_printf (_("Trace is already running on the target.\n"));
5041 upload_tracepoints (&uploaded_tps
);
5043 merge_uploaded_tracepoints (&uploaded_tps
);
5046 /* Possibly the target has been engaged in a btrace record started
5047 previously; find out where things are at. */
5048 remote_btrace_maybe_reopen ();
5053 /* Start the remote connection and sync state. */
5056 remote_target::start_remote (int from_tty
, int extended_p
)
5058 if (start_remote_1 (from_tty
, extended_p
)
5059 && breakpoints_should_be_inserted_now ())
5060 insert_breakpoints ();
5064 remote_target::connection_string ()
5066 remote_state
*rs
= get_remote_state ();
5068 if (rs
->remote_desc
->name
!= NULL
)
5069 return rs
->remote_desc
->name
;
5074 /* Open a connection to a remote debugger.
5075 NAME is the filename used for communication. */
5078 remote_target::open (const char *name
, int from_tty
)
5080 open_1 (name
, from_tty
, 0);
5083 /* Open a connection to a remote debugger using the extended
5084 remote gdb protocol. NAME is the filename used for communication. */
5087 extended_remote_target::open (const char *name
, int from_tty
)
5089 open_1 (name
, from_tty
, 1 /*extended_p */);
5092 /* Reset all packets back to "unknown support". Called when opening a
5093 new connection to a remote target. */
5096 reset_all_packet_configs_support (void)
5100 for (i
= 0; i
< PACKET_MAX
; i
++)
5101 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
5104 /* Initialize all packet configs. */
5107 init_all_packet_configs (void)
5111 for (i
= 0; i
< PACKET_MAX
; i
++)
5113 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
5114 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
5118 /* Symbol look-up. */
5121 remote_target::remote_check_symbols ()
5126 /* It doesn't make sense to send a qSymbol packet for an inferior that
5127 doesn't have execution, because the remote side doesn't know about
5128 inferiors without execution. */
5129 gdb_assert (target_has_execution ());
5131 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
5134 /* Make sure the remote is pointing at the right process. Note
5135 there's no way to select "no process". */
5136 set_general_process ();
5138 /* Allocate a message buffer. We can't reuse the input buffer in RS,
5139 because we need both at the same time. */
5140 gdb::char_vector
msg (get_remote_packet_size ());
5141 gdb::char_vector
reply (get_remote_packet_size ());
5143 /* Invite target to request symbol lookups. */
5145 putpkt ("qSymbol::");
5147 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
5149 while (startswith (reply
.data (), "qSymbol:"))
5151 struct bound_minimal_symbol sym
;
5154 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
5157 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
5158 if (sym
.minsym
== NULL
)
5159 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
5163 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
5164 CORE_ADDR sym_addr
= sym
.value_address ();
5166 /* If this is a function address, return the start of code
5167 instead of any data function descriptor. */
5168 sym_addr
= gdbarch_convert_from_func_ptr_addr
5169 (target_gdbarch (), sym_addr
, current_inferior ()->top_target ());
5171 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
5172 phex_nz (sym_addr
, addr_size
), &reply
[8]);
5175 putpkt (msg
.data ());
5180 static struct serial
*
5181 remote_serial_open (const char *name
)
5183 static int udp_warning
= 0;
5185 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
5186 of in ser-tcp.c, because it is the remote protocol assuming that the
5187 serial connection is reliable and not the serial connection promising
5189 if (!udp_warning
&& startswith (name
, "udp:"))
5191 warning (_("The remote protocol may be unreliable over UDP.\n"
5192 "Some events may be lost, rendering further debugging "
5197 return serial_open (name
);
5200 /* Inform the target of our permission settings. The permission flags
5201 work without this, but if the target knows the settings, it can do
5202 a couple things. First, it can add its own check, to catch cases
5203 that somehow manage to get by the permissions checks in target
5204 methods. Second, if the target is wired to disallow particular
5205 settings (for instance, a system in the field that is not set up to
5206 be able to stop at a breakpoint), it can object to any unavailable
5210 remote_target::set_permissions ()
5212 struct remote_state
*rs
= get_remote_state ();
5214 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
5215 "WriteReg:%x;WriteMem:%x;"
5216 "InsertBreak:%x;InsertTrace:%x;"
5217 "InsertFastTrace:%x;Stop:%x",
5218 may_write_registers
, may_write_memory
,
5219 may_insert_breakpoints
, may_insert_tracepoints
,
5220 may_insert_fast_tracepoints
, may_stop
);
5222 getpkt (&rs
->buf
, 0);
5224 /* If the target didn't like the packet, warn the user. Do not try
5225 to undo the user's settings, that would just be maddening. */
5226 if (strcmp (rs
->buf
.data (), "OK") != 0)
5227 warning (_("Remote refused setting permissions with: %s"),
5231 /* This type describes each known response to the qSupported
5233 struct protocol_feature
5235 /* The name of this protocol feature. */
5238 /* The default for this protocol feature. */
5239 enum packet_support default_support
;
5241 /* The function to call when this feature is reported, or after
5242 qSupported processing if the feature is not supported.
5243 The first argument points to this structure. The second
5244 argument indicates whether the packet requested support be
5245 enabled, disabled, or probed (or the default, if this function
5246 is being called at the end of processing and this feature was
5247 not reported). The third argument may be NULL; if not NULL, it
5248 is a NUL-terminated string taken from the packet following
5249 this feature's name and an equals sign. */
5250 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5251 enum packet_support
, const char *);
5253 /* The corresponding packet for this feature. Only used if
5254 FUNC is remote_supported_packet. */
5259 remote_supported_packet (remote_target
*remote
,
5260 const struct protocol_feature
*feature
,
5261 enum packet_support support
,
5262 const char *argument
)
5266 warning (_("Remote qSupported response supplied an unexpected value for"
5267 " \"%s\"."), feature
->name
);
5271 remote_protocol_packets
[feature
->packet
].support
= support
;
5275 remote_target::remote_packet_size (const protocol_feature
*feature
,
5276 enum packet_support support
, const char *value
)
5278 struct remote_state
*rs
= get_remote_state ();
5283 if (support
!= PACKET_ENABLE
)
5286 if (value
== NULL
|| *value
== '\0')
5288 warning (_("Remote target reported \"%s\" without a size."),
5294 packet_size
= strtol (value
, &value_end
, 16);
5295 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5297 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5298 feature
->name
, value
);
5302 /* Record the new maximum packet size. */
5303 rs
->explicit_packet_size
= packet_size
;
5307 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5308 enum packet_support support
, const char *value
)
5310 remote
->remote_packet_size (feature
, support
, value
);
5313 static const struct protocol_feature remote_protocol_features
[] = {
5314 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5315 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5316 PACKET_qXfer_auxv
},
5317 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5318 PACKET_qXfer_exec_file
},
5319 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5320 PACKET_qXfer_features
},
5321 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5322 PACKET_qXfer_libraries
},
5323 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5324 PACKET_qXfer_libraries_svr4
},
5325 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5326 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5327 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5328 PACKET_qXfer_memory_map
},
5329 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5330 PACKET_qXfer_osdata
},
5331 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5332 PACKET_qXfer_threads
},
5333 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5334 PACKET_qXfer_traceframe_info
},
5335 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5336 PACKET_QPassSignals
},
5337 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5338 PACKET_QCatchSyscalls
},
5339 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5340 PACKET_QProgramSignals
},
5341 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5342 PACKET_QSetWorkingDir
},
5343 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5344 PACKET_QStartupWithShell
},
5345 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5346 PACKET_QEnvironmentHexEncoded
},
5347 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5348 PACKET_QEnvironmentReset
},
5349 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5350 PACKET_QEnvironmentUnset
},
5351 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5352 PACKET_QStartNoAckMode
},
5353 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5354 PACKET_multiprocess_feature
},
5355 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5356 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5357 PACKET_qXfer_siginfo_read
},
5358 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5359 PACKET_qXfer_siginfo_write
},
5360 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5361 PACKET_ConditionalTracepoints
},
5362 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5363 PACKET_ConditionalBreakpoints
},
5364 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5365 PACKET_BreakpointCommands
},
5366 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5367 PACKET_FastTracepoints
},
5368 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5369 PACKET_StaticTracepoints
},
5370 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5371 PACKET_InstallInTrace
},
5372 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5373 PACKET_DisconnectedTracing_feature
},
5374 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5376 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5378 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5379 PACKET_TracepointSource
},
5380 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5382 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5383 PACKET_EnableDisableTracepoints_feature
},
5384 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5385 PACKET_qXfer_fdpic
},
5386 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5388 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5389 PACKET_QDisableRandomization
},
5390 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5391 { "QTBuffer:size", PACKET_DISABLE
,
5392 remote_supported_packet
, PACKET_QTBuffer_size
},
5393 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5394 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5395 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5396 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5397 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5398 PACKET_qXfer_btrace
},
5399 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5400 PACKET_qXfer_btrace_conf
},
5401 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5402 PACKET_Qbtrace_conf_bts_size
},
5403 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5404 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5405 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5406 PACKET_fork_event_feature
},
5407 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5408 PACKET_vfork_event_feature
},
5409 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5410 PACKET_exec_event_feature
},
5411 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5412 PACKET_Qbtrace_conf_pt_size
},
5413 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5414 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5415 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5416 { "memory-tagging", PACKET_DISABLE
, remote_supported_packet
,
5417 PACKET_memory_tagging_feature
},
5420 static char *remote_support_xml
;
5422 /* Register string appended to "xmlRegisters=" in qSupported query. */
5425 register_remote_support_xml (const char *xml
)
5427 #if defined(HAVE_LIBEXPAT)
5428 if (remote_support_xml
== NULL
)
5429 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5432 char *copy
= xstrdup (remote_support_xml
+ 13);
5434 char *p
= strtok_r (copy
, ",", &saveptr
);
5438 if (strcmp (p
, xml
) == 0)
5445 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5448 remote_support_xml
= reconcat (remote_support_xml
,
5449 remote_support_xml
, ",", xml
,
5456 remote_query_supported_append (std::string
*msg
, const char *append
)
5460 msg
->append (append
);
5464 remote_target::remote_query_supported ()
5466 struct remote_state
*rs
= get_remote_state ();
5469 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5471 /* The packet support flags are handled differently for this packet
5472 than for most others. We treat an error, a disabled packet, and
5473 an empty response identically: any features which must be reported
5474 to be used will be automatically disabled. An empty buffer
5475 accomplishes this, since that is also the representation for a list
5476 containing no features. */
5479 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5483 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5484 remote_query_supported_append (&q
, "multiprocess+");
5486 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5487 remote_query_supported_append (&q
, "swbreak+");
5488 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5489 remote_query_supported_append (&q
, "hwbreak+");
5491 remote_query_supported_append (&q
, "qRelocInsn+");
5493 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5494 != AUTO_BOOLEAN_FALSE
)
5495 remote_query_supported_append (&q
, "fork-events+");
5496 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5497 != AUTO_BOOLEAN_FALSE
)
5498 remote_query_supported_append (&q
, "vfork-events+");
5499 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5500 != AUTO_BOOLEAN_FALSE
)
5501 remote_query_supported_append (&q
, "exec-events+");
5503 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5504 remote_query_supported_append (&q
, "vContSupported+");
5506 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5507 remote_query_supported_append (&q
, "QThreadEvents+");
5509 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5510 remote_query_supported_append (&q
, "no-resumed+");
5512 if (packet_set_cmd_state (PACKET_memory_tagging_feature
)
5513 != AUTO_BOOLEAN_FALSE
)
5514 remote_query_supported_append (&q
, "memory-tagging+");
5516 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5517 the qSupported:xmlRegisters=i386 handling. */
5518 if (remote_support_xml
!= NULL
5519 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5520 remote_query_supported_append (&q
, remote_support_xml
);
5522 q
= "qSupported:" + q
;
5523 putpkt (q
.c_str ());
5525 getpkt (&rs
->buf
, 0);
5527 /* If an error occured, warn, but do not return - just reset the
5528 buffer to empty and go on to disable features. */
5529 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5532 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5537 memset (seen
, 0, sizeof (seen
));
5539 next
= rs
->buf
.data ();
5542 enum packet_support is_supported
;
5543 char *p
, *end
, *name_end
, *value
;
5545 /* First separate out this item from the rest of the packet. If
5546 there's another item after this, we overwrite the separator
5547 (terminated strings are much easier to work with). */
5549 end
= strchr (p
, ';');
5552 end
= p
+ strlen (p
);
5562 warning (_("empty item in \"qSupported\" response"));
5567 name_end
= strchr (p
, '=');
5570 /* This is a name=value entry. */
5571 is_supported
= PACKET_ENABLE
;
5572 value
= name_end
+ 1;
5581 is_supported
= PACKET_ENABLE
;
5585 is_supported
= PACKET_DISABLE
;
5589 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5593 warning (_("unrecognized item \"%s\" "
5594 "in \"qSupported\" response"), p
);
5600 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5601 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5603 const struct protocol_feature
*feature
;
5606 feature
= &remote_protocol_features
[i
];
5607 feature
->func (this, feature
, is_supported
, value
);
5612 /* If we increased the packet size, make sure to increase the global
5613 buffer size also. We delay this until after parsing the entire
5614 qSupported packet, because this is the same buffer we were
5616 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5617 rs
->buf
.resize (rs
->explicit_packet_size
);
5619 /* Handle the defaults for unmentioned features. */
5620 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5623 const struct protocol_feature
*feature
;
5625 feature
= &remote_protocol_features
[i
];
5626 feature
->func (this, feature
, feature
->default_support
, NULL
);
5630 /* Serial QUIT handler for the remote serial descriptor.
5632 Defers handling a Ctrl-C until we're done with the current
5633 command/response packet sequence, unless:
5635 - We're setting up the connection. Don't send a remote interrupt
5636 request, as we're not fully synced yet. Quit immediately
5639 - The target has been resumed in the foreground
5640 (target_terminal::is_ours is false) with a synchronous resume
5641 packet, and we're blocked waiting for the stop reply, thus a
5642 Ctrl-C should be immediately sent to the target.
5644 - We get a second Ctrl-C while still within the same serial read or
5645 write. In that case the serial is seemingly wedged --- offer to
5648 - We see a second Ctrl-C without target response, after having
5649 previously interrupted the target. In that case the target/stub
5650 is probably wedged --- offer to quit/disconnect.
5654 remote_target::remote_serial_quit_handler ()
5656 struct remote_state
*rs
= get_remote_state ();
5658 if (check_quit_flag ())
5660 /* If we're starting up, we're not fully synced yet. Quit
5662 if (rs
->starting_up
)
5664 else if (rs
->got_ctrlc_during_io
)
5666 if (query (_("The target is not responding to GDB commands.\n"
5667 "Stop debugging it? ")))
5668 remote_unpush_and_throw (this);
5670 /* If ^C has already been sent once, offer to disconnect. */
5671 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5673 /* All-stop protocol, and blocked waiting for stop reply. Send
5674 an interrupt request. */
5675 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5676 target_interrupt ();
5678 rs
->got_ctrlc_during_io
= 1;
5682 /* The remote_target that is current while the quit handler is
5683 overridden with remote_serial_quit_handler. */
5684 static remote_target
*curr_quit_handler_target
;
5687 remote_serial_quit_handler ()
5689 curr_quit_handler_target
->remote_serial_quit_handler ();
5692 /* Remove the remote target from the target stack of each inferior
5693 that is using it. Upper targets depend on it so remove them
5697 remote_unpush_target (remote_target
*target
)
5699 /* We have to unpush the target from all inferiors, even those that
5701 scoped_restore_current_inferior restore_current_inferior
;
5703 for (inferior
*inf
: all_inferiors (target
))
5705 switch_to_inferior_no_thread (inf
);
5706 pop_all_targets_at_and_above (process_stratum
);
5707 generic_mourn_inferior ();
5710 /* Don't rely on target_close doing this when the target is popped
5711 from the last remote inferior above, because something may be
5712 holding a reference to the target higher up on the stack, meaning
5713 target_close won't be called yet. We lost the connection to the
5714 target, so clear these now, otherwise we may later throw
5715 TARGET_CLOSE_ERROR while trying to tell the remote target to
5717 fileio_handles_invalidate_target (target
);
5721 remote_unpush_and_throw (remote_target
*target
)
5723 remote_unpush_target (target
);
5724 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5728 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5730 remote_target
*curr_remote
= get_current_remote_target ();
5733 error (_("To open a remote debug connection, you need to specify what\n"
5734 "serial device is attached to the remote system\n"
5735 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5737 /* If we're connected to a running target, target_preopen will kill it.
5738 Ask this question first, before target_preopen has a chance to kill
5740 if (curr_remote
!= NULL
&& !target_has_execution ())
5743 && !query (_("Already connected to a remote target. Disconnect? ")))
5744 error (_("Still connected."));
5747 /* Here the possibly existing remote target gets unpushed. */
5748 target_preopen (from_tty
);
5750 remote_fileio_reset ();
5751 reopen_exec_file ();
5752 reread_symbols (from_tty
);
5754 remote_target
*remote
5755 = (extended_p
? new extended_remote_target () : new remote_target ());
5756 target_ops_up
target_holder (remote
);
5758 remote_state
*rs
= remote
->get_remote_state ();
5760 /* See FIXME above. */
5761 if (!target_async_permitted
)
5762 rs
->wait_forever_enabled_p
= 1;
5764 rs
->remote_desc
= remote_serial_open (name
);
5765 if (!rs
->remote_desc
)
5766 perror_with_name (name
);
5768 if (baud_rate
!= -1)
5770 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5772 /* The requested speed could not be set. Error out to
5773 top level after closing remote_desc. Take care to
5774 set remote_desc to NULL to avoid closing remote_desc
5776 serial_close (rs
->remote_desc
);
5777 rs
->remote_desc
= NULL
;
5778 perror_with_name (name
);
5782 serial_setparity (rs
->remote_desc
, serial_parity
);
5783 serial_raw (rs
->remote_desc
);
5785 /* If there is something sitting in the buffer we might take it as a
5786 response to a command, which would be bad. */
5787 serial_flush_input (rs
->remote_desc
);
5791 gdb_puts ("Remote debugging using ");
5796 /* Switch to using the remote target now. */
5797 current_inferior ()->push_target (std::move (target_holder
));
5799 /* Register extra event sources in the event loop. */
5800 rs
->remote_async_inferior_event_token
5801 = create_async_event_handler (remote_async_inferior_event_handler
, nullptr,
5803 rs
->notif_state
= remote_notif_state_allocate (remote
);
5805 /* Reset the target state; these things will be queried either by
5806 remote_query_supported or as they are needed. */
5807 reset_all_packet_configs_support ();
5808 rs
->explicit_packet_size
= 0;
5810 rs
->extended
= extended_p
;
5811 rs
->waiting_for_stop_reply
= 0;
5812 rs
->ctrlc_pending_p
= 0;
5813 rs
->got_ctrlc_during_io
= 0;
5815 rs
->general_thread
= not_sent_ptid
;
5816 rs
->continue_thread
= not_sent_ptid
;
5817 rs
->remote_traceframe_number
= -1;
5819 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5821 /* Probe for ability to use "ThreadInfo" query, as required. */
5822 rs
->use_threadinfo_query
= 1;
5823 rs
->use_threadextra_query
= 1;
5825 rs
->readahead_cache
.invalidate ();
5827 if (target_async_permitted
)
5829 /* FIXME: cagney/1999-09-23: During the initial connection it is
5830 assumed that the target is already ready and able to respond to
5831 requests. Unfortunately remote_start_remote() eventually calls
5832 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5833 around this. Eventually a mechanism that allows
5834 wait_for_inferior() to expect/get timeouts will be
5836 rs
->wait_forever_enabled_p
= 0;
5839 /* First delete any symbols previously loaded from shared libraries. */
5840 no_shared_libraries (NULL
, 0);
5842 /* Start the remote connection. If error() or QUIT, discard this
5843 target (we'd otherwise be in an inconsistent state) and then
5844 propogate the error on up the exception chain. This ensures that
5845 the caller doesn't stumble along blindly assuming that the
5846 function succeeded. The CLI doesn't have this problem but other
5847 UI's, such as MI do.
5849 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5850 this function should return an error indication letting the
5851 caller restore the previous state. Unfortunately the command
5852 ``target remote'' is directly wired to this function making that
5853 impossible. On a positive note, the CLI side of this problem has
5854 been fixed - the function set_cmd_context() makes it possible for
5855 all the ``target ....'' commands to share a common callback
5856 function. See cli-dump.c. */
5861 remote
->start_remote (from_tty
, extended_p
);
5863 catch (const gdb_exception
&ex
)
5865 /* Pop the partially set up target - unless something else did
5866 already before throwing the exception. */
5867 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5868 remote_unpush_target (remote
);
5873 remote_btrace_reset (rs
);
5875 if (target_async_permitted
)
5876 rs
->wait_forever_enabled_p
= 1;
5879 /* Determine if WS represents a fork status. */
5882 is_fork_status (target_waitkind kind
)
5884 return (kind
== TARGET_WAITKIND_FORKED
5885 || kind
== TARGET_WAITKIND_VFORKED
);
5888 /* Return THREAD's pending status if it is a pending fork parent, else
5891 static const target_waitstatus
*
5892 thread_pending_fork_status (struct thread_info
*thread
)
5894 const target_waitstatus
&ws
5895 = (thread
->has_pending_waitstatus ()
5896 ? thread
->pending_waitstatus ()
5897 : thread
->pending_follow
);
5899 if (!is_fork_status (ws
.kind ()))
5905 /* Detach the specified process. */
5908 remote_target::remote_detach_pid (int pid
)
5910 struct remote_state
*rs
= get_remote_state ();
5912 /* This should not be necessary, but the handling for D;PID in
5913 GDBserver versions prior to 8.2 incorrectly assumes that the
5914 selected process points to the same process we're detaching,
5915 leading to misbehavior (and possibly GDBserver crashing) when it
5916 does not. Since it's easy and cheap, work around it by forcing
5917 GDBserver to select GDB's current process. */
5918 set_general_process ();
5920 if (remote_multi_process_p (rs
))
5921 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5923 strcpy (rs
->buf
.data (), "D");
5926 getpkt (&rs
->buf
, 0);
5928 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5930 else if (rs
->buf
[0] == '\0')
5931 error (_("Remote doesn't know how to detach"));
5933 error (_("Can't detach process."));
5936 /* This detaches a program to which we previously attached, using
5937 inferior_ptid to identify the process. After this is done, GDB
5938 can be used to debug some other program. We better not have left
5939 any breakpoints in the target program or it'll die when it hits
5943 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5945 int pid
= inferior_ptid
.pid ();
5946 struct remote_state
*rs
= get_remote_state ();
5949 if (!target_has_execution ())
5950 error (_("No process to detach from."));
5952 target_announce_detach (from_tty
);
5954 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
5956 /* If we're in breakpoints-always-inserted mode, or the inferior
5957 is running, we have to remove breakpoints before detaching.
5958 We don't do this in common code instead because not all
5959 targets support removing breakpoints while the target is
5960 running. The remote target / gdbserver does, though. */
5961 remove_breakpoints_inf (current_inferior ());
5964 /* Tell the remote target to detach. */
5965 remote_detach_pid (pid
);
5967 /* Exit only if this is the only active inferior. */
5968 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors (this) == 1)
5969 gdb_puts (_("Ending remote debugging.\n"));
5971 /* See if any thread of the inferior we are detaching has a pending fork
5972 status. In that case, we must detach from the child resulting from
5974 for (thread_info
*thread
: inf
->non_exited_threads ())
5976 const target_waitstatus
*ws
= thread_pending_fork_status (thread
);
5981 remote_detach_pid (ws
->child_ptid ().pid ());
5984 /* Check also for any pending fork events in the stop reply queue. */
5985 remote_notif_get_pending_events (¬if_client_stop
);
5986 for (stop_reply_up
&reply
: rs
->stop_reply_queue
)
5988 if (reply
->ptid
.pid () != pid
)
5991 if (!is_fork_status (reply
->ws
.kind ()))
5994 remote_detach_pid (reply
->ws
.child_ptid ().pid ());
5997 thread_info
*tp
= find_thread_ptid (this, inferior_ptid
);
5999 /* Check to see if we are detaching a fork parent. Note that if we
6000 are detaching a fork child, tp == NULL. */
6001 is_fork_parent
= (tp
!= NULL
6002 && tp
->pending_follow
.kind () == TARGET_WAITKIND_FORKED
);
6004 /* If doing detach-on-fork, we don't mourn, because that will delete
6005 breakpoints that should be available for the followed inferior. */
6006 if (!is_fork_parent
)
6008 /* Save the pid as a string before mourning, since that will
6009 unpush the remote target, and we need the string after. */
6010 std::string infpid
= target_pid_to_str (ptid_t (pid
));
6012 target_mourn_inferior (inferior_ptid
);
6013 if (print_inferior_events
)
6014 gdb_printf (_("[Inferior %d (%s) detached]\n"),
6015 inf
->num
, infpid
.c_str ());
6019 switch_to_no_thread ();
6020 detach_inferior (current_inferior ());
6025 remote_target::detach (inferior
*inf
, int from_tty
)
6027 remote_detach_1 (inf
, from_tty
);
6031 extended_remote_target::detach (inferior
*inf
, int from_tty
)
6033 remote_detach_1 (inf
, from_tty
);
6036 /* Target follow-fork function for remote targets. On entry, and
6037 at return, the current inferior is the fork parent.
6039 Note that although this is currently only used for extended-remote,
6040 it is named remote_follow_fork in anticipation of using it for the
6041 remote target as well. */
6044 remote_target::follow_fork (inferior
*child_inf
, ptid_t child_ptid
,
6045 target_waitkind fork_kind
, bool follow_child
,
6048 process_stratum_target::follow_fork (child_inf
, child_ptid
,
6049 fork_kind
, follow_child
, detach_fork
);
6051 struct remote_state
*rs
= get_remote_state ();
6053 if ((fork_kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
6054 || (fork_kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
6056 /* When following the parent and detaching the child, we detach
6057 the child here. For the case of following the child and
6058 detaching the parent, the detach is done in the target-
6059 independent follow fork code in infrun.c. We can't use
6060 target_detach when detaching an unfollowed child because
6061 the client side doesn't know anything about the child. */
6062 if (detach_fork
&& !follow_child
)
6064 /* Detach the fork child. */
6065 remote_detach_pid (child_ptid
.pid ());
6070 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
6071 in the program space of the new inferior. */
6074 remote_target::follow_exec (inferior
*follow_inf
, ptid_t ptid
,
6075 const char *execd_pathname
)
6077 process_stratum_target::follow_exec (follow_inf
, ptid
, execd_pathname
);
6079 /* We know that this is a target file name, so if it has the "target:"
6080 prefix we strip it off before saving it in the program space. */
6081 if (is_target_filename (execd_pathname
))
6082 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
6084 set_pspace_remote_exec_file (follow_inf
->pspace
, execd_pathname
);
6087 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
6090 remote_target::disconnect (const char *args
, int from_tty
)
6093 error (_("Argument given to \"disconnect\" when remotely debugging."));
6095 /* Make sure we unpush even the extended remote targets. Calling
6096 target_mourn_inferior won't unpush, and
6097 remote_target::mourn_inferior won't unpush if there is more than
6098 one inferior left. */
6099 remote_unpush_target (this);
6102 gdb_puts ("Ending remote debugging.\n");
6105 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
6106 be chatty about it. */
6109 extended_remote_target::attach (const char *args
, int from_tty
)
6111 struct remote_state
*rs
= get_remote_state ();
6113 char *wait_status
= NULL
;
6115 pid
= parse_pid_to_attach (args
);
6117 /* Remote PID can be freely equal to getpid, do not check it here the same
6118 way as in other targets. */
6120 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
6121 error (_("This target does not support attaching to a process"));
6123 target_announce_attach (from_tty
, pid
);
6125 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
6127 getpkt (&rs
->buf
, 0);
6129 switch (packet_ok (rs
->buf
,
6130 &remote_protocol_packets
[PACKET_vAttach
]))
6133 if (!target_is_non_stop_p ())
6135 /* Save the reply for later. */
6136 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
6137 strcpy (wait_status
, rs
->buf
.data ());
6139 else if (strcmp (rs
->buf
.data (), "OK") != 0)
6140 error (_("Attaching to %s failed with: %s"),
6141 target_pid_to_str (ptid_t (pid
)).c_str (),
6144 case PACKET_UNKNOWN
:
6145 error (_("This target does not support attaching to a process"));
6147 error (_("Attaching to %s failed"),
6148 target_pid_to_str (ptid_t (pid
)).c_str ());
6151 switch_to_inferior_no_thread (remote_add_inferior (false, pid
, 1, 0));
6153 inferior_ptid
= ptid_t (pid
);
6155 if (target_is_non_stop_p ())
6157 /* Get list of threads. */
6158 update_thread_list ();
6160 thread_info
*thread
= first_thread_of_inferior (current_inferior ());
6161 if (thread
!= nullptr)
6162 switch_to_thread (thread
);
6164 /* Invalidate our notion of the remote current thread. */
6165 record_currthread (rs
, minus_one_ptid
);
6169 /* Now, if we have thread information, update the main thread's
6171 ptid_t curr_ptid
= remote_current_thread (ptid_t (pid
));
6173 /* Add the main thread to the thread list. We add the thread
6174 silently in this case (the final true parameter). */
6175 thread_info
*thr
= remote_add_thread (curr_ptid
, true, true, true);
6177 switch_to_thread (thr
);
6180 /* Next, if the target can specify a description, read it. We do
6181 this before anything involving memory or registers. */
6182 target_find_description ();
6184 if (!target_is_non_stop_p ())
6186 /* Use the previously fetched status. */
6187 gdb_assert (wait_status
!= NULL
);
6189 struct notif_event
*reply
6190 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
6192 push_stop_reply ((struct stop_reply
*) reply
);
6196 gdb_assert (wait_status
== NULL
);
6198 gdb_assert (target_can_async_p ());
6202 /* Implementation of the to_post_attach method. */
6205 extended_remote_target::post_attach (int pid
)
6207 /* Get text, data & bss offsets. */
6210 /* In certain cases GDB might not have had the chance to start
6211 symbol lookup up until now. This could happen if the debugged
6212 binary is not using shared libraries, the vsyscall page is not
6213 present (on Linux) and the binary itself hadn't changed since the
6214 debugging process was started. */
6215 if (current_program_space
->symfile_object_file
!= NULL
)
6216 remote_check_symbols();
6220 /* Check for the availability of vCont. This function should also check
6224 remote_target::remote_vcont_probe ()
6226 remote_state
*rs
= get_remote_state ();
6229 strcpy (rs
->buf
.data (), "vCont?");
6231 getpkt (&rs
->buf
, 0);
6232 buf
= rs
->buf
.data ();
6234 /* Make sure that the features we assume are supported. */
6235 if (startswith (buf
, "vCont"))
6238 int support_c
, support_C
;
6240 rs
->supports_vCont
.s
= 0;
6241 rs
->supports_vCont
.S
= 0;
6244 rs
->supports_vCont
.t
= 0;
6245 rs
->supports_vCont
.r
= 0;
6246 while (p
&& *p
== ';')
6249 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6250 rs
->supports_vCont
.s
= 1;
6251 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6252 rs
->supports_vCont
.S
= 1;
6253 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6255 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6257 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6258 rs
->supports_vCont
.t
= 1;
6259 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6260 rs
->supports_vCont
.r
= 1;
6262 p
= strchr (p
, ';');
6265 /* If c, and C are not all supported, we can't use vCont. Clearing
6266 BUF will make packet_ok disable the packet. */
6267 if (!support_c
|| !support_C
)
6271 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
6272 rs
->supports_vCont_probed
= true;
6275 /* Helper function for building "vCont" resumptions. Write a
6276 resumption to P. ENDP points to one-passed-the-end of the buffer
6277 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
6278 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
6279 resumed thread should be single-stepped and/or signalled. If PTID
6280 equals minus_one_ptid, then all threads are resumed; if PTID
6281 represents a process, then all threads of the process are
6285 remote_target::append_resumption (char *p
, char *endp
,
6286 ptid_t ptid
, int step
, gdb_signal siggnal
)
6288 struct remote_state
*rs
= get_remote_state ();
6290 if (step
&& siggnal
!= GDB_SIGNAL_0
)
6291 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
6293 /* GDB is willing to range step. */
6294 && use_range_stepping
6295 /* Target supports range stepping. */
6296 && rs
->supports_vCont
.r
6297 /* We don't currently support range stepping multiple
6298 threads with a wildcard (though the protocol allows it,
6299 so stubs shouldn't make an active effort to forbid
6301 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6303 struct thread_info
*tp
;
6305 if (ptid
== minus_one_ptid
)
6307 /* If we don't know about the target thread's tid, then
6308 we're resuming magic_null_ptid (see caller). */
6309 tp
= find_thread_ptid (this, magic_null_ptid
);
6312 tp
= find_thread_ptid (this, ptid
);
6313 gdb_assert (tp
!= NULL
);
6315 if (tp
->control
.may_range_step
)
6317 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6319 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6320 phex_nz (tp
->control
.step_range_start
,
6322 phex_nz (tp
->control
.step_range_end
,
6326 p
+= xsnprintf (p
, endp
- p
, ";s");
6329 p
+= xsnprintf (p
, endp
- p
, ";s");
6330 else if (siggnal
!= GDB_SIGNAL_0
)
6331 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6333 p
+= xsnprintf (p
, endp
- p
, ";c");
6335 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6339 /* All (-1) threads of process. */
6340 nptid
= ptid_t (ptid
.pid (), -1);
6342 p
+= xsnprintf (p
, endp
- p
, ":");
6343 p
= write_ptid (p
, endp
, nptid
);
6345 else if (ptid
!= minus_one_ptid
)
6347 p
+= xsnprintf (p
, endp
- p
, ":");
6348 p
= write_ptid (p
, endp
, ptid
);
6354 /* Clear the thread's private info on resume. */
6357 resume_clear_thread_private_info (struct thread_info
*thread
)
6359 if (thread
->priv
!= NULL
)
6361 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6363 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6364 priv
->watch_data_address
= 0;
6368 /* Append a vCont continue-with-signal action for threads that have a
6369 non-zero stop signal. */
6372 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6375 for (thread_info
*thread
: all_non_exited_threads (this, ptid
))
6376 if (inferior_ptid
!= thread
->ptid
6377 && thread
->stop_signal () != GDB_SIGNAL_0
)
6379 p
= append_resumption (p
, endp
, thread
->ptid
,
6380 0, thread
->stop_signal ());
6381 thread
->set_stop_signal (GDB_SIGNAL_0
);
6382 resume_clear_thread_private_info (thread
);
6388 /* Set the target running, using the packets that use Hc
6392 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6395 struct remote_state
*rs
= get_remote_state ();
6398 rs
->last_sent_signal
= siggnal
;
6399 rs
->last_sent_step
= step
;
6401 /* The c/s/C/S resume packets use Hc, so set the continue
6403 if (ptid
== minus_one_ptid
)
6404 set_continue_thread (any_thread_ptid
);
6406 set_continue_thread (ptid
);
6408 for (thread_info
*thread
: all_non_exited_threads (this))
6409 resume_clear_thread_private_info (thread
);
6411 buf
= rs
->buf
.data ();
6412 if (::execution_direction
== EXEC_REVERSE
)
6414 /* We don't pass signals to the target in reverse exec mode. */
6415 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6416 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6419 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6420 error (_("Remote reverse-step not supported."));
6421 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6422 error (_("Remote reverse-continue not supported."));
6424 strcpy (buf
, step
? "bs" : "bc");
6426 else if (siggnal
!= GDB_SIGNAL_0
)
6428 buf
[0] = step
? 'S' : 'C';
6429 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6430 buf
[2] = tohex (((int) siggnal
) & 0xf);
6434 strcpy (buf
, step
? "s" : "c");
6439 /* Resume the remote inferior by using a "vCont" packet. SCOPE_PTID,
6440 STEP, and SIGGNAL have the same meaning as in target_resume. This
6441 function returns non-zero iff it resumes the inferior.
6443 This function issues a strict subset of all possible vCont commands
6447 remote_target::remote_resume_with_vcont (ptid_t scope_ptid
, int step
,
6448 enum gdb_signal siggnal
)
6450 struct remote_state
*rs
= get_remote_state ();
6454 /* No reverse execution actions defined for vCont. */
6455 if (::execution_direction
== EXEC_REVERSE
)
6458 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6459 remote_vcont_probe ();
6461 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6464 p
= rs
->buf
.data ();
6465 endp
= p
+ get_remote_packet_size ();
6467 /* If we could generate a wider range of packets, we'd have to worry
6468 about overflowing BUF. Should there be a generic
6469 "multi-part-packet" packet? */
6471 p
+= xsnprintf (p
, endp
- p
, "vCont");
6473 if (scope_ptid
== magic_null_ptid
)
6475 /* MAGIC_NULL_PTID means that we don't have any active threads,
6476 so we don't have any TID numbers the inferior will
6477 understand. Make sure to only send forms that do not specify
6479 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6481 else if (scope_ptid
== minus_one_ptid
|| scope_ptid
.is_pid ())
6483 /* Resume all threads (of all processes, or of a single
6484 process), with preference for INFERIOR_PTID. This assumes
6485 inferior_ptid belongs to the set of all threads we are about
6487 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6489 /* Step inferior_ptid, with or without signal. */
6490 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6493 /* Also pass down any pending signaled resumption for other
6494 threads not the current. */
6495 p
= append_pending_thread_resumptions (p
, endp
, scope_ptid
);
6497 /* And continue others without a signal. */
6498 append_resumption (p
, endp
, scope_ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6502 /* Scheduler locking; resume only SCOPE_PTID. */
6503 append_resumption (p
, endp
, scope_ptid
, step
, siggnal
);
6506 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6509 if (target_is_non_stop_p ())
6511 /* In non-stop, the stub replies to vCont with "OK". The stop
6512 reply will be reported asynchronously by means of a `%Stop'
6514 getpkt (&rs
->buf
, 0);
6515 if (strcmp (rs
->buf
.data (), "OK") != 0)
6516 error (_("Unexpected vCont reply in non-stop mode: %s"),
6523 /* Tell the remote machine to resume. */
6526 remote_target::resume (ptid_t scope_ptid
, int step
, enum gdb_signal siggnal
)
6528 struct remote_state
*rs
= get_remote_state ();
6530 /* When connected in non-stop mode, the core resumes threads
6531 individually. Resuming remote threads directly in target_resume
6532 would thus result in sending one packet per thread. Instead, to
6533 minimize roundtrip latency, here we just store the resume
6534 request (put the thread in RESUMED_PENDING_VCONT state); the actual remote
6535 resumption will be done in remote_target::commit_resume, where we'll be
6536 able to do vCont action coalescing. */
6537 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6539 remote_thread_info
*remote_thr
6540 = get_remote_thread_info (inferior_thread ());
6542 /* We don't expect the core to ask to resume an already resumed (from
6543 its point of view) thread. */
6544 gdb_assert (remote_thr
->get_resume_state () == resume_state::NOT_RESUMED
);
6546 remote_thr
->set_resumed_pending_vcont (step
, siggnal
);
6548 /* There's actually nothing that says that the core can't
6549 request a wildcard resume in non-stop mode, though. It's
6550 just that we know it doesn't currently, so we don't bother
6552 gdb_assert (scope_ptid
== inferior_ptid
);
6556 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6557 (explained in remote-notif.c:handle_notification) so
6558 remote_notif_process is not called. We need find a place where
6559 it is safe to start a 'vNotif' sequence. It is good to do it
6560 before resuming inferior, because inferior was stopped and no RSP
6561 traffic at that moment. */
6562 if (!target_is_non_stop_p ())
6563 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6565 rs
->last_resume_exec_dir
= ::execution_direction
;
6567 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6568 if (!remote_resume_with_vcont (scope_ptid
, step
, siggnal
))
6569 remote_resume_with_hc (scope_ptid
, step
, siggnal
);
6571 /* Update resumed state tracked by the remote target. */
6572 for (thread_info
*tp
: all_non_exited_threads (this, scope_ptid
))
6573 get_remote_thread_info (tp
)->set_resumed ();
6575 /* We've just told the target to resume. The remote server will
6576 wait for the inferior to stop, and then send a stop reply. In
6577 the mean time, we can't start another command/query ourselves
6578 because the stub wouldn't be ready to process it. This applies
6579 only to the base all-stop protocol, however. In non-stop (which
6580 only supports vCont), the stub replies with an "OK", and is
6581 immediate able to process further serial input. */
6582 if (!target_is_non_stop_p ())
6583 rs
->waiting_for_stop_reply
= 1;
6586 /* Private per-inferior info for target remote processes. */
6588 struct remote_inferior
: public private_inferior
6590 /* Whether we can send a wildcard vCont for this process. */
6591 bool may_wildcard_vcont
= true;
6594 /* Get the remote private inferior data associated to INF. */
6596 static remote_inferior
*
6597 get_remote_inferior (inferior
*inf
)
6599 if (inf
->priv
== NULL
)
6600 inf
->priv
.reset (new remote_inferior
);
6602 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6605 /* Class used to track the construction of a vCont packet in the
6606 outgoing packet buffer. This is used to send multiple vCont
6607 packets if we have more actions than would fit a single packet. */
6612 explicit vcont_builder (remote_target
*remote
)
6619 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6624 /* The remote target. */
6625 remote_target
*m_remote
;
6627 /* Pointer to the first action. P points here if no action has been
6629 char *m_first_action
;
6631 /* Where the next action will be appended. */
6634 /* The end of the buffer. Must never write past this. */
6638 /* Prepare the outgoing buffer for a new vCont packet. */
6641 vcont_builder::restart ()
6643 struct remote_state
*rs
= m_remote
->get_remote_state ();
6645 m_p
= rs
->buf
.data ();
6646 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6647 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6648 m_first_action
= m_p
;
6651 /* If the vCont packet being built has any action, send it to the
6655 vcont_builder::flush ()
6657 struct remote_state
*rs
;
6659 if (m_p
== m_first_action
)
6662 rs
= m_remote
->get_remote_state ();
6663 m_remote
->putpkt (rs
->buf
);
6664 m_remote
->getpkt (&rs
->buf
, 0);
6665 if (strcmp (rs
->buf
.data (), "OK") != 0)
6666 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6669 /* The largest action is range-stepping, with its two addresses. This
6670 is more than sufficient. If a new, bigger action is created, it'll
6671 quickly trigger a failed assertion in append_resumption (and we'll
6673 #define MAX_ACTION_SIZE 200
6675 /* Append a new vCont action in the outgoing packet being built. If
6676 the action doesn't fit the packet along with previous actions, push
6677 what we've got so far to the remote end and start over a new vCont
6678 packet (with the new action). */
6681 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6683 char buf
[MAX_ACTION_SIZE
+ 1];
6685 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6686 ptid
, step
, siggnal
);
6688 /* Check whether this new action would fit in the vCont packet along
6689 with previous actions. If not, send what we've got so far and
6690 start a new vCont packet. */
6691 size_t rsize
= endp
- buf
;
6692 if (rsize
> m_endp
- m_p
)
6697 /* Should now fit. */
6698 gdb_assert (rsize
<= m_endp
- m_p
);
6701 memcpy (m_p
, buf
, rsize
);
6706 /* to_commit_resume implementation. */
6709 remote_target::commit_resumed ()
6711 /* If connected in all-stop mode, we'd send the remote resume
6712 request directly from remote_resume. Likewise if
6713 reverse-debugging, as there are no defined vCont actions for
6714 reverse execution. */
6715 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6718 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6719 instead of resuming all threads of each process individually.
6720 However, if any thread of a process must remain halted, we can't
6721 send wildcard resumes and must send one action per thread.
6723 Care must be taken to not resume threads/processes the server
6724 side already told us are stopped, but the core doesn't know about
6725 yet, because the events are still in the vStopped notification
6728 #1 => vCont s:p1.1;c
6730 #3 <= %Stopped T05 p1.1
6735 #8 (infrun handles the stop for p1.1 and continues stepping)
6736 #9 => vCont s:p1.1;c
6738 The last vCont above would resume thread p1.2 by mistake, because
6739 the server has no idea that the event for p1.2 had not been
6742 The server side must similarly ignore resume actions for the
6743 thread that has a pending %Stopped notification (and any other
6744 threads with events pending), until GDB acks the notification
6745 with vStopped. Otherwise, e.g., the following case is
6748 #1 => g (or any other packet)
6750 #3 <= %Stopped T05 p1.2
6751 #4 => vCont s:p1.1;c
6754 Above, the server must not resume thread p1.2. GDB can't know
6755 that p1.2 stopped until it acks the %Stopped notification, and
6756 since from GDB's perspective all threads should be running, it
6759 Finally, special care must also be given to handling fork/vfork
6760 events. A (v)fork event actually tells us that two processes
6761 stopped -- the parent and the child. Until we follow the fork,
6762 we must not resume the child. Therefore, if we have a pending
6763 fork follow, we must not send a global wildcard resume action
6764 (vCont;c). We can still send process-wide wildcards though. */
6766 /* Start by assuming a global wildcard (vCont;c) is possible. */
6767 bool may_global_wildcard_vcont
= true;
6769 /* And assume every process is individually wildcard-able too. */
6770 for (inferior
*inf
: all_non_exited_inferiors (this))
6772 remote_inferior
*priv
= get_remote_inferior (inf
);
6774 priv
->may_wildcard_vcont
= true;
6777 /* Check for any pending events (not reported or processed yet) and
6778 disable process and global wildcard resumes appropriately. */
6779 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6781 bool any_pending_vcont_resume
= false;
6783 for (thread_info
*tp
: all_non_exited_threads (this))
6785 remote_thread_info
*priv
= get_remote_thread_info (tp
);
6787 /* If a thread of a process is not meant to be resumed, then we
6788 can't wildcard that process. */
6789 if (priv
->get_resume_state () == resume_state::NOT_RESUMED
)
6791 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6793 /* And if we can't wildcard a process, we can't wildcard
6794 everything either. */
6795 may_global_wildcard_vcont
= false;
6799 if (priv
->get_resume_state () == resume_state::RESUMED_PENDING_VCONT
)
6800 any_pending_vcont_resume
= true;
6802 /* If a thread is the parent of an unfollowed fork, then we
6803 can't do a global wildcard, as that would resume the fork
6805 if (thread_pending_fork_status (tp
) != nullptr)
6806 may_global_wildcard_vcont
= false;
6809 /* We didn't have any resumed thread pending a vCont resume, so nothing to
6811 if (!any_pending_vcont_resume
)
6814 /* Now let's build the vCont packet(s). Actions must be appended
6815 from narrower to wider scopes (thread -> process -> global). If
6816 we end up with too many actions for a single packet vcont_builder
6817 flushes the current vCont packet to the remote side and starts a
6819 struct vcont_builder
vcont_builder (this);
6821 /* Threads first. */
6822 for (thread_info
*tp
: all_non_exited_threads (this))
6824 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6826 /* If the thread was previously vCont-resumed, no need to send a specific
6827 action for it. If we didn't receive a resume request for it, don't
6828 send an action for it either. */
6829 if (remote_thr
->get_resume_state () != resume_state::RESUMED_PENDING_VCONT
)
6832 gdb_assert (!thread_is_in_step_over_chain (tp
));
6834 /* We should never be commit-resuming a thread that has a stop reply.
6835 Otherwise, we would end up reporting a stop event for a thread while
6836 it is running on the remote target. */
6837 remote_state
*rs
= get_remote_state ();
6838 for (const auto &stop_reply
: rs
->stop_reply_queue
)
6839 gdb_assert (stop_reply
->ptid
!= tp
->ptid
);
6841 const resumed_pending_vcont_info
&info
6842 = remote_thr
->resumed_pending_vcont_info ();
6844 /* Check if we need to send a specific action for this thread. If not,
6845 it will be included in a wildcard resume instead. */
6846 if (info
.step
|| info
.sig
!= GDB_SIGNAL_0
6847 || !get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6848 vcont_builder
.push_action (tp
->ptid
, info
.step
, info
.sig
);
6850 remote_thr
->set_resumed ();
6853 /* Now check whether we can send any process-wide wildcard. This is
6854 to avoid sending a global wildcard in the case nothing is
6855 supposed to be resumed. */
6856 bool any_process_wildcard
= false;
6858 for (inferior
*inf
: all_non_exited_inferiors (this))
6860 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6862 any_process_wildcard
= true;
6867 if (any_process_wildcard
)
6869 /* If all processes are wildcard-able, then send a single "c"
6870 action, otherwise, send an "all (-1) threads of process"
6871 continue action for each running process, if any. */
6872 if (may_global_wildcard_vcont
)
6874 vcont_builder
.push_action (minus_one_ptid
,
6875 false, GDB_SIGNAL_0
);
6879 for (inferior
*inf
: all_non_exited_inferiors (this))
6881 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6883 vcont_builder
.push_action (ptid_t (inf
->pid
),
6884 false, GDB_SIGNAL_0
);
6890 vcont_builder
.flush ();
6893 /* Implementation of target_has_pending_events. */
6896 remote_target::has_pending_events ()
6898 if (target_can_async_p ())
6900 remote_state
*rs
= get_remote_state ();
6902 if (async_event_handler_marked (rs
->remote_async_inferior_event_token
))
6905 /* Note that BUFCNT can be negative, indicating sticky
6907 if (rs
->remote_desc
->bufcnt
!= 0)
6915 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6916 thread, all threads of a remote process, or all threads of all
6920 remote_target::remote_stop_ns (ptid_t ptid
)
6922 struct remote_state
*rs
= get_remote_state ();
6923 char *p
= rs
->buf
.data ();
6924 char *endp
= p
+ get_remote_packet_size ();
6926 /* If any thread that needs to stop was resumed but pending a vCont
6927 resume, generate a phony stop_reply. However, first check
6928 whether the thread wasn't resumed with a signal. Generating a
6929 phony stop in that case would result in losing the signal. */
6930 bool needs_commit
= false;
6931 for (thread_info
*tp
: all_non_exited_threads (this, ptid
))
6933 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6935 if (remote_thr
->get_resume_state ()
6936 == resume_state::RESUMED_PENDING_VCONT
)
6938 const resumed_pending_vcont_info
&info
6939 = remote_thr
->resumed_pending_vcont_info ();
6940 if (info
.sig
!= GDB_SIGNAL_0
)
6942 /* This signal must be forwarded to the inferior. We
6943 could commit-resume just this thread, but its simpler
6944 to just commit-resume everything. */
6945 needs_commit
= true;
6954 for (thread_info
*tp
: all_non_exited_threads (this, ptid
))
6956 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6958 if (remote_thr
->get_resume_state ()
6959 == resume_state::RESUMED_PENDING_VCONT
)
6961 remote_debug_printf ("Enqueueing phony stop reply for thread pending "
6962 "vCont-resume (%d, %ld, %s)", tp
->ptid
.pid(),
6964 pulongest (tp
->ptid
.tid ()));
6966 /* Check that the thread wasn't resumed with a signal.
6967 Generating a phony stop would result in losing the
6969 const resumed_pending_vcont_info
&info
6970 = remote_thr
->resumed_pending_vcont_info ();
6971 gdb_assert (info
.sig
== GDB_SIGNAL_0
);
6973 stop_reply
*sr
= new stop_reply ();
6974 sr
->ptid
= tp
->ptid
;
6976 sr
->ws
.set_stopped (GDB_SIGNAL_0
);
6977 sr
->arch
= tp
->inf
->gdbarch
;
6978 sr
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6979 sr
->watch_data_address
= 0;
6981 this->push_stop_reply (sr
);
6983 /* Pretend that this thread was actually resumed on the
6984 remote target, then stopped. If we leave it in the
6985 RESUMED_PENDING_VCONT state and the commit_resumed
6986 method is called while the stop reply is still in the
6987 queue, we'll end up reporting a stop event to the core
6988 for that thread while it is running on the remote
6989 target... that would be bad. */
6990 remote_thr
->set_resumed ();
6994 /* FIXME: This supports_vCont_probed check is a workaround until
6995 packet_support is per-connection. */
6996 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
6997 || !rs
->supports_vCont_probed
)
6998 remote_vcont_probe ();
7000 if (!rs
->supports_vCont
.t
)
7001 error (_("Remote server does not support stopping threads"));
7003 if (ptid
== minus_one_ptid
7004 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
7005 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
7010 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
7013 /* All (-1) threads of process. */
7014 nptid
= ptid_t (ptid
.pid (), -1);
7017 /* Small optimization: if we already have a stop reply for
7018 this thread, no use in telling the stub we want this
7020 if (peek_stop_reply (ptid
))
7026 write_ptid (p
, endp
, nptid
);
7029 /* In non-stop, we get an immediate OK reply. The stop reply will
7030 come in asynchronously by notification. */
7032 getpkt (&rs
->buf
, 0);
7033 if (strcmp (rs
->buf
.data (), "OK") != 0)
7034 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
7038 /* All-stop version of target_interrupt. Sends a break or a ^C to
7039 interrupt the remote target. It is undefined which thread of which
7040 process reports the interrupt. */
7043 remote_target::remote_interrupt_as ()
7045 struct remote_state
*rs
= get_remote_state ();
7047 rs
->ctrlc_pending_p
= 1;
7049 /* If the inferior is stopped already, but the core didn't know
7050 about it yet, just ignore the request. The pending stop events
7051 will be collected in remote_wait. */
7052 if (stop_reply_queue_length () > 0)
7055 /* Send interrupt_sequence to remote target. */
7056 send_interrupt_sequence ();
7059 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
7060 the remote target. It is undefined which thread of which process
7061 reports the interrupt. Throws an error if the packet is not
7062 supported by the server. */
7065 remote_target::remote_interrupt_ns ()
7067 struct remote_state
*rs
= get_remote_state ();
7068 char *p
= rs
->buf
.data ();
7069 char *endp
= p
+ get_remote_packet_size ();
7071 xsnprintf (p
, endp
- p
, "vCtrlC");
7073 /* In non-stop, we get an immediate OK reply. The stop reply will
7074 come in asynchronously by notification. */
7076 getpkt (&rs
->buf
, 0);
7078 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
7082 case PACKET_UNKNOWN
:
7083 error (_("No support for interrupting the remote target."));
7085 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
7089 /* Implement the to_stop function for the remote targets. */
7092 remote_target::stop (ptid_t ptid
)
7094 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
7096 if (target_is_non_stop_p ())
7097 remote_stop_ns (ptid
);
7100 /* We don't currently have a way to transparently pause the
7101 remote target in all-stop mode. Interrupt it instead. */
7102 remote_interrupt_as ();
7106 /* Implement the to_interrupt function for the remote targets. */
7109 remote_target::interrupt ()
7111 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
7113 if (target_is_non_stop_p ())
7114 remote_interrupt_ns ();
7116 remote_interrupt_as ();
7119 /* Implement the to_pass_ctrlc function for the remote targets. */
7122 remote_target::pass_ctrlc ()
7124 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
7126 struct remote_state
*rs
= get_remote_state ();
7128 /* If we're starting up, we're not fully synced yet. Quit
7130 if (rs
->starting_up
)
7132 /* If ^C has already been sent once, offer to disconnect. */
7133 else if (rs
->ctrlc_pending_p
)
7136 target_interrupt ();
7139 /* Ask the user what to do when an interrupt is received. */
7142 remote_target::interrupt_query ()
7144 struct remote_state
*rs
= get_remote_state ();
7146 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
7148 if (query (_("The target is not responding to interrupt requests.\n"
7149 "Stop debugging it? ")))
7151 remote_unpush_target (this);
7152 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
7157 if (query (_("Interrupted while waiting for the program.\n"
7158 "Give up waiting? ")))
7163 /* Enable/disable target terminal ownership. Most targets can use
7164 terminal groups to control terminal ownership. Remote targets are
7165 different in that explicit transfer of ownership to/from GDB/target
7169 remote_target::terminal_inferior ()
7171 /* NOTE: At this point we could also register our selves as the
7172 recipient of all input. Any characters typed could then be
7173 passed on down to the target. */
7177 remote_target::terminal_ours ()
7182 remote_console_output (const char *msg
)
7186 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
7189 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
7193 gdb_stdtarg
->puts (tb
);
7195 gdb_stdtarg
->flush ();
7198 /* Return the length of the stop reply queue. */
7201 remote_target::stop_reply_queue_length ()
7203 remote_state
*rs
= get_remote_state ();
7204 return rs
->stop_reply_queue
.size ();
7208 remote_notif_stop_parse (remote_target
*remote
,
7209 struct notif_client
*self
, const char *buf
,
7210 struct notif_event
*event
)
7212 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
7216 remote_notif_stop_ack (remote_target
*remote
,
7217 struct notif_client
*self
, const char *buf
,
7218 struct notif_event
*event
)
7220 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
7223 putpkt (remote
, self
->ack_command
);
7225 /* Kind can be TARGET_WAITKIND_IGNORE if we have meanwhile discarded
7226 the notification. It was left in the queue because we need to
7227 acknowledge it and pull the rest of the notifications out. */
7228 if (stop_reply
->ws
.kind () != TARGET_WAITKIND_IGNORE
)
7229 remote
->push_stop_reply (stop_reply
);
7233 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
7234 struct notif_client
*self
)
7236 /* We can't get pending events in remote_notif_process for
7237 notification stop, and we have to do this in remote_wait_ns
7238 instead. If we fetch all queued events from stub, remote stub
7239 may exit and we have no chance to process them back in
7241 remote_state
*rs
= remote
->get_remote_state ();
7242 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7246 stop_reply::~stop_reply ()
7248 for (cached_reg_t
®
: regcache
)
7252 static notif_event_up
7253 remote_notif_stop_alloc_reply ()
7255 return notif_event_up (new struct stop_reply ());
7258 /* A client of notification Stop. */
7260 struct notif_client notif_client_stop
=
7264 remote_notif_stop_parse
,
7265 remote_notif_stop_ack
,
7266 remote_notif_stop_can_get_pending_events
,
7267 remote_notif_stop_alloc_reply
,
7271 /* If CONTEXT contains any fork child threads that have not been
7272 reported yet, remove them from the CONTEXT list. If such a
7273 thread exists it is because we are stopped at a fork catchpoint
7274 and have not yet called follow_fork, which will set up the
7275 host-side data structures for the new process. */
7278 remote_target::remove_new_fork_children (threads_listing_context
*context
)
7280 struct notif_client
*notif
= ¬if_client_stop
;
7282 /* For any threads stopped at a fork event, remove the corresponding
7283 fork child threads from the CONTEXT list. */
7284 for (thread_info
*thread
: all_non_exited_threads (this))
7286 const target_waitstatus
*ws
= thread_pending_fork_status (thread
);
7291 context
->remove_thread (ws
->child_ptid ());
7294 /* Check for any pending fork events (not reported or processed yet)
7295 in process PID and remove those fork child threads from the
7296 CONTEXT list as well. */
7297 remote_notif_get_pending_events (notif
);
7298 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7299 if (event
->ws
.kind () == TARGET_WAITKIND_FORKED
7300 || event
->ws
.kind () == TARGET_WAITKIND_VFORKED
)
7301 context
->remove_thread (event
->ws
.child_ptid ());
7302 else if (event
->ws
.kind () == TARGET_WAITKIND_THREAD_EXITED
)
7303 context
->remove_thread (event
->ptid
);
7306 /* Check whether any event pending in the vStopped queue would prevent a
7307 global or process wildcard vCont action. Set *may_global_wildcard to
7308 false if we can't do a global wildcard (vCont;c), and clear the event
7309 inferior's may_wildcard_vcont flag if we can't do a process-wide
7310 wildcard resume (vCont;c:pPID.-1). */
7313 remote_target::check_pending_events_prevent_wildcard_vcont
7314 (bool *may_global_wildcard
)
7316 struct notif_client
*notif
= ¬if_client_stop
;
7318 remote_notif_get_pending_events (notif
);
7319 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7321 if (event
->ws
.kind () == TARGET_WAITKIND_NO_RESUMED
7322 || event
->ws
.kind () == TARGET_WAITKIND_NO_HISTORY
)
7325 if (event
->ws
.kind () == TARGET_WAITKIND_FORKED
7326 || event
->ws
.kind () == TARGET_WAITKIND_VFORKED
)
7327 *may_global_wildcard
= false;
7329 /* This may be the first time we heard about this process.
7330 Regardless, we must not do a global wildcard resume, otherwise
7331 we'd resume this process too. */
7332 *may_global_wildcard
= false;
7333 if (event
->ptid
!= null_ptid
)
7335 inferior
*inf
= find_inferior_ptid (this, event
->ptid
);
7337 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7342 /* Discard all pending stop replies of inferior INF. */
7345 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7347 struct stop_reply
*reply
;
7348 struct remote_state
*rs
= get_remote_state ();
7349 struct remote_notif_state
*rns
= rs
->notif_state
;
7351 /* This function can be notified when an inferior exists. When the
7352 target is not remote, the notification state is NULL. */
7353 if (rs
->remote_desc
== NULL
)
7356 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7358 /* Discard the in-flight notification. */
7359 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7361 /* Leave the notification pending, since the server expects that
7362 we acknowledge it with vStopped. But clear its contents, so
7363 that later on when we acknowledge it, we also discard it. */
7365 ("discarding in-flight notification: ptid: %s, ws: %s\n",
7366 reply
->ptid
.to_string().c_str(),
7367 reply
->ws
.to_string ().c_str ());
7368 reply
->ws
.set_ignore ();
7371 /* Discard the stop replies we have already pulled with
7373 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7374 rs
->stop_reply_queue
.end (),
7375 [=] (const stop_reply_up
&event
)
7377 return event
->ptid
.pid () == inf
->pid
;
7379 for (auto it
= iter
; it
!= rs
->stop_reply_queue
.end (); ++it
)
7381 ("discarding queued stop reply: ptid: %s, ws: %s\n",
7382 reply
->ptid
.to_string().c_str(),
7383 reply
->ws
.to_string ().c_str ());
7384 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7387 /* Discard the stop replies for RS in stop_reply_queue. */
7390 remote_target::discard_pending_stop_replies_in_queue ()
7392 remote_state
*rs
= get_remote_state ();
7394 /* Discard the stop replies we have already pulled with
7396 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7397 rs
->stop_reply_queue
.end (),
7398 [=] (const stop_reply_up
&event
)
7400 return event
->rs
== rs
;
7402 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7405 /* Remove the first reply in 'stop_reply_queue' which matches
7409 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7411 remote_state
*rs
= get_remote_state ();
7413 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7414 rs
->stop_reply_queue
.end (),
7415 [=] (const stop_reply_up
&event
)
7417 return event
->ptid
.matches (ptid
);
7419 struct stop_reply
*result
;
7420 if (iter
== rs
->stop_reply_queue
.end ())
7424 result
= iter
->release ();
7425 rs
->stop_reply_queue
.erase (iter
);
7429 gdb_printf (gdb_stdlog
,
7430 "notif: discard queued event: 'Stop' in %s\n",
7431 ptid
.to_string ().c_str ());
7436 /* Look for a queued stop reply belonging to PTID. If one is found,
7437 remove it from the queue, and return it. Returns NULL if none is
7438 found. If there are still queued events left to process, tell the
7439 event loop to get back to target_wait soon. */
7442 remote_target::queued_stop_reply (ptid_t ptid
)
7444 remote_state
*rs
= get_remote_state ();
7445 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7447 if (!rs
->stop_reply_queue
.empty () && target_can_async_p ())
7449 /* There's still at least an event left. */
7450 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7456 /* Push a fully parsed stop reply in the stop reply queue. Since we
7457 know that we now have at least one queued event left to pass to the
7458 core side, tell the event loop to get back to target_wait soon. */
7461 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7463 remote_state
*rs
= get_remote_state ();
7464 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7467 gdb_printf (gdb_stdlog
,
7468 "notif: push 'Stop' %s to queue %d\n",
7469 new_event
->ptid
.to_string ().c_str (),
7470 int (rs
->stop_reply_queue
.size ()));
7472 /* Mark the pending event queue only if async mode is currently enabled.
7473 If async mode is not currently enabled, then, if it later becomes
7474 enabled, and there are events in this queue, we will mark the event
7475 token at that point, see remote_target::async. */
7476 if (target_is_async_p ())
7477 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7480 /* Returns true if we have a stop reply for PTID. */
7483 remote_target::peek_stop_reply (ptid_t ptid
)
7485 remote_state
*rs
= get_remote_state ();
7486 for (auto &event
: rs
->stop_reply_queue
)
7487 if (ptid
== event
->ptid
7488 && event
->ws
.kind () == TARGET_WAITKIND_STOPPED
)
7493 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7494 starting with P and ending with PEND matches PREFIX. */
7497 strprefix (const char *p
, const char *pend
, const char *prefix
)
7499 for ( ; p
< pend
; p
++, prefix
++)
7502 return *prefix
== '\0';
7505 /* Parse the stop reply in BUF. Either the function succeeds, and the
7506 result is stored in EVENT, or throws an error. */
7509 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7511 remote_arch_state
*rsa
= NULL
;
7516 event
->ptid
= null_ptid
;
7517 event
->rs
= get_remote_state ();
7518 event
->ws
.set_ignore ();
7519 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7520 event
->regcache
.clear ();
7525 case 'T': /* Status with PC, SP, FP, ... */
7526 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7527 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7529 n... = register number
7530 r... = register contents
7533 p
= &buf
[3]; /* after Txx */
7539 p1
= strchr (p
, ':');
7541 error (_("Malformed packet(a) (missing colon): %s\n\
7545 error (_("Malformed packet(a) (missing register number): %s\n\
7549 /* Some "registers" are actually extended stop information.
7550 Note if you're adding a new entry here: GDB 7.9 and
7551 earlier assume that all register "numbers" that start
7552 with an hex digit are real register numbers. Make sure
7553 the server only sends such a packet if it knows the
7554 client understands it. */
7556 if (strprefix (p
, p1
, "thread"))
7557 event
->ptid
= read_ptid (++p1
, &p
);
7558 else if (strprefix (p
, p1
, "syscall_entry"))
7562 p
= unpack_varlen_hex (++p1
, &sysno
);
7563 event
->ws
.set_syscall_entry ((int) sysno
);
7565 else if (strprefix (p
, p1
, "syscall_return"))
7569 p
= unpack_varlen_hex (++p1
, &sysno
);
7570 event
->ws
.set_syscall_return ((int) sysno
);
7572 else if (strprefix (p
, p1
, "watch")
7573 || strprefix (p
, p1
, "rwatch")
7574 || strprefix (p
, p1
, "awatch"))
7576 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7577 p
= unpack_varlen_hex (++p1
, &addr
);
7578 event
->watch_data_address
= (CORE_ADDR
) addr
;
7580 else if (strprefix (p
, p1
, "swbreak"))
7582 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7584 /* Make sure the stub doesn't forget to indicate support
7586 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7587 error (_("Unexpected swbreak stop reason"));
7589 /* The value part is documented as "must be empty",
7590 though we ignore it, in case we ever decide to make
7591 use of it in a backward compatible way. */
7592 p
= strchrnul (p1
+ 1, ';');
7594 else if (strprefix (p
, p1
, "hwbreak"))
7596 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7598 /* Make sure the stub doesn't forget to indicate support
7600 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7601 error (_("Unexpected hwbreak stop reason"));
7604 p
= strchrnul (p1
+ 1, ';');
7606 else if (strprefix (p
, p1
, "library"))
7608 event
->ws
.set_loaded ();
7609 p
= strchrnul (p1
+ 1, ';');
7611 else if (strprefix (p
, p1
, "replaylog"))
7613 event
->ws
.set_no_history ();
7614 /* p1 will indicate "begin" or "end", but it makes
7615 no difference for now, so ignore it. */
7616 p
= strchrnul (p1
+ 1, ';');
7618 else if (strprefix (p
, p1
, "core"))
7622 p
= unpack_varlen_hex (++p1
, &c
);
7625 else if (strprefix (p
, p1
, "fork"))
7626 event
->ws
.set_forked (read_ptid (++p1
, &p
));
7627 else if (strprefix (p
, p1
, "vfork"))
7628 event
->ws
.set_vforked (read_ptid (++p1
, &p
));
7629 else if (strprefix (p
, p1
, "vforkdone"))
7631 event
->ws
.set_vfork_done ();
7632 p
= strchrnul (p1
+ 1, ';');
7634 else if (strprefix (p
, p1
, "exec"))
7639 /* Determine the length of the execd pathname. */
7640 p
= unpack_varlen_hex (++p1
, &ignored
);
7641 pathlen
= (p
- p1
) / 2;
7643 /* Save the pathname for event reporting and for
7644 the next run command. */
7645 gdb::unique_xmalloc_ptr
<char> pathname
7646 ((char *) xmalloc (pathlen
+ 1));
7647 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7648 pathname
.get ()[pathlen
] = '\0';
7650 /* This is freed during event handling. */
7651 event
->ws
.set_execd (std::move (pathname
));
7653 /* Skip the registers included in this packet, since
7654 they may be for an architecture different from the
7655 one used by the original program. */
7658 else if (strprefix (p
, p1
, "create"))
7660 event
->ws
.set_thread_created ();
7661 p
= strchrnul (p1
+ 1, ';');
7670 p
= strchrnul (p1
+ 1, ';');
7675 /* Maybe a real ``P'' register number. */
7676 p_temp
= unpack_varlen_hex (p
, &pnum
);
7677 /* If the first invalid character is the colon, we got a
7678 register number. Otherwise, it's an unknown stop
7682 /* If we haven't parsed the event's thread yet, find
7683 it now, in order to find the architecture of the
7684 reported expedited registers. */
7685 if (event
->ptid
== null_ptid
)
7687 /* If there is no thread-id information then leave
7688 the event->ptid as null_ptid. Later in
7689 process_stop_reply we will pick a suitable
7691 const char *thr
= strstr (p1
+ 1, ";thread:");
7693 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7700 = (event
->ptid
== null_ptid
7702 : find_inferior_ptid (this, event
->ptid
));
7703 /* If this is the first time we learn anything
7704 about this process, skip the registers
7705 included in this packet, since we don't yet
7706 know which architecture to use to parse them.
7707 We'll determine the architecture later when
7708 we process the stop reply and retrieve the
7709 target description, via
7710 remote_notice_new_inferior ->
7711 post_create_inferior. */
7714 p
= strchrnul (p1
+ 1, ';');
7719 event
->arch
= inf
->gdbarch
;
7720 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7724 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7725 cached_reg_t cached_reg
;
7728 error (_("Remote sent bad register number %s: %s\n\
7730 hex_string (pnum
), p
, buf
);
7732 cached_reg
.num
= reg
->regnum
;
7733 cached_reg
.data
= (gdb_byte
*)
7734 xmalloc (register_size (event
->arch
, reg
->regnum
));
7737 fieldsize
= hex2bin (p
, cached_reg
.data
,
7738 register_size (event
->arch
, reg
->regnum
));
7740 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7741 warning (_("Remote reply is too short: %s"), buf
);
7743 event
->regcache
.push_back (cached_reg
);
7747 /* Not a number. Silently skip unknown optional
7749 p
= strchrnul (p1
+ 1, ';');
7754 error (_("Remote register badly formatted: %s\nhere: %s"),
7759 if (event
->ws
.kind () != TARGET_WAITKIND_IGNORE
)
7763 case 'S': /* Old style status, just signal only. */
7767 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7768 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7769 event
->ws
.set_stopped ((enum gdb_signal
) sig
);
7771 event
->ws
.set_stopped (GDB_SIGNAL_UNKNOWN
);
7774 case 'w': /* Thread exited. */
7778 p
= unpack_varlen_hex (&buf
[1], &value
);
7779 event
->ws
.set_thread_exited (value
);
7781 error (_("stop reply packet badly formatted: %s"), buf
);
7782 event
->ptid
= read_ptid (++p
, NULL
);
7785 case 'W': /* Target exited. */
7790 /* GDB used to accept only 2 hex chars here. Stubs should
7791 only send more if they detect GDB supports multi-process
7793 p
= unpack_varlen_hex (&buf
[1], &value
);
7797 /* The remote process exited. */
7798 event
->ws
.set_exited (value
);
7802 /* The remote process exited with a signal. */
7803 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7804 event
->ws
.set_signalled ((enum gdb_signal
) value
);
7806 event
->ws
.set_signalled (GDB_SIGNAL_UNKNOWN
);
7809 /* If no process is specified, return null_ptid, and let the
7810 caller figure out the right process to use. */
7820 else if (startswith (p
, "process:"))
7824 p
+= sizeof ("process:") - 1;
7825 unpack_varlen_hex (p
, &upid
);
7829 error (_("unknown stop reply packet: %s"), buf
);
7832 error (_("unknown stop reply packet: %s"), buf
);
7833 event
->ptid
= ptid_t (pid
);
7837 event
->ws
.set_no_resumed ();
7838 event
->ptid
= minus_one_ptid
;
7843 /* When the stub wants to tell GDB about a new notification reply, it
7844 sends a notification (%Stop, for example). Those can come it at
7845 any time, hence, we have to make sure that any pending
7846 putpkt/getpkt sequence we're making is finished, before querying
7847 the stub for more events with the corresponding ack command
7848 (vStopped, for example). E.g., if we started a vStopped sequence
7849 immediately upon receiving the notification, something like this
7857 1.6) <-- (registers reply to step #1.3)
7859 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7862 To solve this, whenever we parse a %Stop notification successfully,
7863 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7864 doing whatever we were doing:
7870 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7871 2.5) <-- (registers reply to step #2.3)
7873 Eventually after step #2.5, we return to the event loop, which
7874 notices there's an event on the
7875 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7876 associated callback --- the function below. At this point, we're
7877 always safe to start a vStopped sequence. :
7880 2.7) <-- T05 thread:2
7886 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7888 struct remote_state
*rs
= get_remote_state ();
7890 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7893 gdb_printf (gdb_stdlog
,
7894 "notif: process: '%s' ack pending event\n",
7898 nc
->ack (this, nc
, rs
->buf
.data (),
7899 rs
->notif_state
->pending_event
[nc
->id
]);
7900 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7904 getpkt (&rs
->buf
, 0);
7905 if (strcmp (rs
->buf
.data (), "OK") == 0)
7908 remote_notif_ack (this, nc
, rs
->buf
.data ());
7914 gdb_printf (gdb_stdlog
,
7915 "notif: process: '%s' no pending reply\n",
7920 /* Wrapper around remote_target::remote_notif_get_pending_events to
7921 avoid having to export the whole remote_target class. */
7924 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7926 remote
->remote_notif_get_pending_events (nc
);
7929 /* Called from process_stop_reply when the stop packet we are responding
7930 to didn't include a process-id or thread-id. STATUS is the stop event
7931 we are responding to.
7933 It is the task of this function to select a suitable thread (or process)
7934 and return its ptid, this is the thread (or process) we will assume the
7935 stop event came from.
7937 In some cases there isn't really any choice about which thread (or
7938 process) is selected, a basic remote with a single process containing a
7939 single thread might choose not to send any process-id or thread-id in
7940 its stop packets, this function will select and return the one and only
7943 However, if a target supports multiple threads (or processes) and still
7944 doesn't include a thread-id (or process-id) in its stop packet then
7945 first, this is a badly behaving target, and second, we're going to have
7946 to select a thread (or process) at random and use that. This function
7947 will print a warning to the user if it detects that there is the
7948 possibility that GDB is guessing which thread (or process) to
7951 Note that this is called before GDB fetches the updated thread list from the
7952 target. So it's possible for the stop reply to be ambiguous and for GDB to
7953 not realize it. For example, if there's initially one thread, the target
7954 spawns a second thread, and then sends a stop reply without an id that
7955 concerns the first thread. GDB will assume the stop reply is about the
7956 first thread - the only thread it knows about - without printing a warning.
7957 Anyway, if the remote meant for the stop reply to be about the second thread,
7958 then it would be really broken, because GDB doesn't know about that thread
7962 remote_target::select_thread_for_ambiguous_stop_reply
7963 (const target_waitstatus
&status
)
7965 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
7967 /* Some stop events apply to all threads in an inferior, while others
7968 only apply to a single thread. */
7969 bool process_wide_stop
7970 = (status
.kind () == TARGET_WAITKIND_EXITED
7971 || status
.kind () == TARGET_WAITKIND_SIGNALLED
);
7973 remote_debug_printf ("process_wide_stop = %d", process_wide_stop
);
7975 thread_info
*first_resumed_thread
= nullptr;
7976 bool ambiguous
= false;
7978 /* Consider all non-exited threads of the target, find the first resumed
7980 for (thread_info
*thr
: all_non_exited_threads (this))
7982 remote_thread_info
*remote_thr
= get_remote_thread_info (thr
);
7984 if (remote_thr
->get_resume_state () != resume_state::RESUMED
)
7987 if (first_resumed_thread
== nullptr)
7988 first_resumed_thread
= thr
;
7989 else if (!process_wide_stop
7990 || first_resumed_thread
->ptid
.pid () != thr
->ptid
.pid ())
7994 gdb_assert (first_resumed_thread
!= nullptr);
7996 remote_debug_printf ("first resumed thread is %s",
7997 pid_to_str (first_resumed_thread
->ptid
).c_str ());
7998 remote_debug_printf ("is this guess ambiguous? = %d", ambiguous
);
8000 /* Warn if the remote target is sending ambiguous stop replies. */
8003 static bool warned
= false;
8007 /* If you are seeing this warning then the remote target has
8008 stopped without specifying a thread-id, but the target
8009 does have multiple threads (or inferiors), and so GDB is
8010 having to guess which thread stopped.
8012 Examples of what might cause this are the target sending
8013 and 'S' stop packet, or a 'T' stop packet and not
8014 including a thread-id.
8016 Additionally, the target might send a 'W' or 'X packet
8017 without including a process-id, when the target has
8018 multiple running inferiors. */
8019 if (process_wide_stop
)
8020 warning (_("multi-inferior target stopped without "
8021 "sending a process-id, using first "
8022 "non-exited inferior"));
8024 warning (_("multi-threaded target stopped without "
8025 "sending a thread-id, using first "
8026 "non-exited thread"));
8031 /* If this is a stop for all threads then don't use a particular threads
8032 ptid, instead create a new ptid where only the pid field is set. */
8033 if (process_wide_stop
)
8034 return ptid_t (first_resumed_thread
->ptid
.pid ());
8036 return first_resumed_thread
->ptid
;
8039 /* Called when it is decided that STOP_REPLY holds the info of the
8040 event that is to be returned to the core. This function always
8041 destroys STOP_REPLY. */
8044 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
8045 struct target_waitstatus
*status
)
8047 *status
= stop_reply
->ws
;
8048 ptid_t ptid
= stop_reply
->ptid
;
8050 /* If no thread/process was reported by the stub then select a suitable
8052 if (ptid
== null_ptid
)
8053 ptid
= select_thread_for_ambiguous_stop_reply (*status
);
8054 gdb_assert (ptid
!= null_ptid
);
8056 if (status
->kind () != TARGET_WAITKIND_EXITED
8057 && status
->kind () != TARGET_WAITKIND_SIGNALLED
8058 && status
->kind () != TARGET_WAITKIND_NO_RESUMED
)
8060 /* Expedited registers. */
8061 if (!stop_reply
->regcache
.empty ())
8063 struct regcache
*regcache
8064 = get_thread_arch_regcache (this, ptid
, stop_reply
->arch
);
8066 for (cached_reg_t
®
: stop_reply
->regcache
)
8068 regcache
->raw_supply (reg
.num
, reg
.data
);
8072 stop_reply
->regcache
.clear ();
8075 remote_notice_new_inferior (ptid
, false);
8076 remote_thread_info
*remote_thr
= get_remote_thread_info (this, ptid
);
8077 remote_thr
->core
= stop_reply
->core
;
8078 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
8079 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
8081 if (target_is_non_stop_p ())
8083 /* If the target works in non-stop mode, a stop-reply indicates that
8084 only this thread stopped. */
8085 remote_thr
->set_not_resumed ();
8089 /* If the target works in all-stop mode, a stop-reply indicates that
8090 all the target's threads stopped. */
8091 for (thread_info
*tp
: all_non_exited_threads (this))
8092 get_remote_thread_info (tp
)->set_not_resumed ();
8100 /* The non-stop mode version of target_wait. */
8103 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
8104 target_wait_flags options
)
8106 struct remote_state
*rs
= get_remote_state ();
8107 struct stop_reply
*stop_reply
;
8111 /* If in non-stop mode, get out of getpkt even if a
8112 notification is received. */
8114 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
8117 if (ret
!= -1 && !is_notif
)
8120 case 'E': /* Error of some sort. */
8121 /* We're out of sync with the target now. Did it continue
8122 or not? We can't tell which thread it was in non-stop,
8123 so just ignore this. */
8124 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
8126 case 'O': /* Console output. */
8127 remote_console_output (&rs
->buf
[1]);
8130 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
8134 /* Acknowledge a pending stop reply that may have arrived in the
8136 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
8137 remote_notif_get_pending_events (¬if_client_stop
);
8139 /* If indeed we noticed a stop reply, we're done. */
8140 stop_reply
= queued_stop_reply (ptid
);
8141 if (stop_reply
!= NULL
)
8142 return process_stop_reply (stop_reply
, status
);
8144 /* Still no event. If we're just polling for an event, then
8145 return to the event loop. */
8146 if (options
& TARGET_WNOHANG
)
8148 status
->set_ignore ();
8149 return minus_one_ptid
;
8152 /* Otherwise do a blocking wait. */
8153 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
8157 /* Return the first resumed thread. */
8160 first_remote_resumed_thread (remote_target
*target
)
8162 for (thread_info
*tp
: all_non_exited_threads (target
, minus_one_ptid
))
8168 /* Wait until the remote machine stops, then return, storing status in
8169 STATUS just as `wait' would. */
8172 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
,
8173 target_wait_flags options
)
8175 struct remote_state
*rs
= get_remote_state ();
8176 ptid_t event_ptid
= null_ptid
;
8178 struct stop_reply
*stop_reply
;
8182 status
->set_ignore ();
8184 stop_reply
= queued_stop_reply (ptid
);
8185 if (stop_reply
!= NULL
)
8187 /* None of the paths that push a stop reply onto the queue should
8188 have set the waiting_for_stop_reply flag. */
8189 gdb_assert (!rs
->waiting_for_stop_reply
);
8190 event_ptid
= process_stop_reply (stop_reply
, status
);
8194 int forever
= ((options
& TARGET_WNOHANG
) == 0
8195 && rs
->wait_forever_enabled_p
);
8197 if (!rs
->waiting_for_stop_reply
)
8199 status
->set_no_resumed ();
8200 return minus_one_ptid
;
8203 /* FIXME: cagney/1999-09-27: If we're in async mode we should
8204 _never_ wait for ever -> test on target_is_async_p().
8205 However, before we do that we need to ensure that the caller
8206 knows how to take the target into/out of async mode. */
8208 int ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
8210 /* GDB gets a notification. Return to core as this event is
8212 if (ret
!= -1 && is_notif
)
8213 return minus_one_ptid
;
8215 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
8216 return minus_one_ptid
;
8218 buf
= rs
->buf
.data ();
8220 /* Assume that the target has acknowledged Ctrl-C unless we receive
8221 an 'F' or 'O' packet. */
8222 if (buf
[0] != 'F' && buf
[0] != 'O')
8223 rs
->ctrlc_pending_p
= 0;
8227 case 'E': /* Error of some sort. */
8228 /* We're out of sync with the target now. Did it continue or
8229 not? Not is more likely, so report a stop. */
8230 rs
->waiting_for_stop_reply
= 0;
8232 warning (_("Remote failure reply: %s"), buf
);
8233 status
->set_stopped (GDB_SIGNAL_0
);
8235 case 'F': /* File-I/O request. */
8236 /* GDB may access the inferior memory while handling the File-I/O
8237 request, but we don't want GDB accessing memory while waiting
8238 for a stop reply. See the comments in putpkt_binary. Set
8239 waiting_for_stop_reply to 0 temporarily. */
8240 rs
->waiting_for_stop_reply
= 0;
8241 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
8242 rs
->ctrlc_pending_p
= 0;
8243 /* GDB handled the File-I/O request, and the target is running
8244 again. Keep waiting for events. */
8245 rs
->waiting_for_stop_reply
= 1;
8247 case 'N': case 'T': case 'S': case 'X': case 'W':
8249 /* There is a stop reply to handle. */
8250 rs
->waiting_for_stop_reply
= 0;
8253 = (struct stop_reply
*) remote_notif_parse (this,
8257 event_ptid
= process_stop_reply (stop_reply
, status
);
8260 case 'O': /* Console output. */
8261 remote_console_output (buf
+ 1);
8264 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
8266 /* Zero length reply means that we tried 'S' or 'C' and the
8267 remote system doesn't support it. */
8268 target_terminal::ours_for_output ();
8270 ("Can't send signals to this remote system. %s not sent.\n",
8271 gdb_signal_to_name (rs
->last_sent_signal
));
8272 rs
->last_sent_signal
= GDB_SIGNAL_0
;
8273 target_terminal::inferior ();
8275 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
8281 warning (_("Invalid remote reply: %s"), buf
);
8286 if (status
->kind () == TARGET_WAITKIND_NO_RESUMED
)
8287 return minus_one_ptid
;
8288 else if (status
->kind () == TARGET_WAITKIND_IGNORE
)
8290 /* Nothing interesting happened. If we're doing a non-blocking
8291 poll, we're done. Otherwise, go back to waiting. */
8292 if (options
& TARGET_WNOHANG
)
8293 return minus_one_ptid
;
8297 else if (status
->kind () != TARGET_WAITKIND_EXITED
8298 && status
->kind () != TARGET_WAITKIND_SIGNALLED
)
8300 if (event_ptid
!= null_ptid
)
8301 record_currthread (rs
, event_ptid
);
8303 event_ptid
= first_remote_resumed_thread (this);
8307 /* A process exit. Invalidate our notion of current thread. */
8308 record_currthread (rs
, minus_one_ptid
);
8309 /* It's possible that the packet did not include a pid. */
8310 if (event_ptid
== null_ptid
)
8311 event_ptid
= first_remote_resumed_thread (this);
8312 /* EVENT_PTID could still be NULL_PTID. Double-check. */
8313 if (event_ptid
== null_ptid
)
8314 event_ptid
= magic_null_ptid
;
8320 /* Wait until the remote machine stops, then return, storing status in
8321 STATUS just as `wait' would. */
8324 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
8325 target_wait_flags options
)
8327 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
8329 remote_state
*rs
= get_remote_state ();
8331 /* Start by clearing the flag that asks for our wait method to be called,
8332 we'll mark it again at the end if needed. If the target is not in
8333 async mode then the async token should not be marked. */
8334 if (target_is_async_p ())
8335 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
8337 gdb_assert (!async_event_handler_marked
8338 (rs
->remote_async_inferior_event_token
));
8342 if (target_is_non_stop_p ())
8343 event_ptid
= wait_ns (ptid
, status
, options
);
8345 event_ptid
= wait_as (ptid
, status
, options
);
8347 if (target_is_async_p ())
8349 /* If there are events left in the queue, or unacknowledged
8350 notifications, then tell the event loop to call us again. */
8351 if (!rs
->stop_reply_queue
.empty ()
8352 || rs
->notif_state
->pending_event
[notif_client_stop
.id
] != nullptr)
8353 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
8359 /* Fetch a single register using a 'p' packet. */
8362 remote_target::fetch_register_using_p (struct regcache
*regcache
,
8365 struct gdbarch
*gdbarch
= regcache
->arch ();
8366 struct remote_state
*rs
= get_remote_state ();
8368 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8371 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
8374 if (reg
->pnum
== -1)
8377 p
= rs
->buf
.data ();
8379 p
+= hexnumstr (p
, reg
->pnum
);
8382 getpkt (&rs
->buf
, 0);
8384 buf
= rs
->buf
.data ();
8386 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
8390 case PACKET_UNKNOWN
:
8393 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
8394 gdbarch_register_name (regcache
->arch (),
8399 /* If this register is unfetchable, tell the regcache. */
8402 regcache
->raw_supply (reg
->regnum
, NULL
);
8406 /* Otherwise, parse and supply the value. */
8412 error (_("fetch_register_using_p: early buf termination"));
8414 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8417 regcache
->raw_supply (reg
->regnum
, regp
);
8421 /* Fetch the registers included in the target's 'g' packet. */
8424 remote_target::send_g_packet ()
8426 struct remote_state
*rs
= get_remote_state ();
8429 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
8431 getpkt (&rs
->buf
, 0);
8432 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8433 error (_("Could not read registers; remote failure reply '%s'"),
8436 /* We can get out of synch in various cases. If the first character
8437 in the buffer is not a hex character, assume that has happened
8438 and try to fetch another packet to read. */
8439 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
8440 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
8441 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
8442 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
8444 remote_debug_printf ("Bad register packet; fetching a new packet");
8445 getpkt (&rs
->buf
, 0);
8448 buf_len
= strlen (rs
->buf
.data ());
8450 /* Sanity check the received packet. */
8451 if (buf_len
% 2 != 0)
8452 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
8458 remote_target::process_g_packet (struct regcache
*regcache
)
8460 struct gdbarch
*gdbarch
= regcache
->arch ();
8461 struct remote_state
*rs
= get_remote_state ();
8462 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8467 buf_len
= strlen (rs
->buf
.data ());
8469 /* Further sanity checks, with knowledge of the architecture. */
8470 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
8471 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8473 rsa
->sizeof_g_packet
, buf_len
/ 2,
8476 /* Save the size of the packet sent to us by the target. It is used
8477 as a heuristic when determining the max size of packets that the
8478 target can safely receive. */
8479 if (rsa
->actual_register_packet_size
== 0)
8480 rsa
->actual_register_packet_size
= buf_len
;
8482 /* If this is smaller than we guessed the 'g' packet would be,
8483 update our records. A 'g' reply that doesn't include a register's
8484 value implies either that the register is not available, or that
8485 the 'p' packet must be used. */
8486 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8488 long sizeof_g_packet
= buf_len
/ 2;
8490 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8492 long offset
= rsa
->regs
[i
].offset
;
8493 long reg_size
= register_size (gdbarch
, i
);
8495 if (rsa
->regs
[i
].pnum
== -1)
8498 if (offset
>= sizeof_g_packet
)
8499 rsa
->regs
[i
].in_g_packet
= 0;
8500 else if (offset
+ reg_size
> sizeof_g_packet
)
8501 error (_("Truncated register %d in remote 'g' packet"), i
);
8503 rsa
->regs
[i
].in_g_packet
= 1;
8506 /* Looks valid enough, we can assume this is the correct length
8507 for a 'g' packet. It's important not to adjust
8508 rsa->sizeof_g_packet if we have truncated registers otherwise
8509 this "if" won't be run the next time the method is called
8510 with a packet of the same size and one of the internal errors
8511 below will trigger instead. */
8512 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8515 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8517 /* Unimplemented registers read as all bits zero. */
8518 memset (regs
, 0, rsa
->sizeof_g_packet
);
8520 /* Reply describes registers byte by byte, each byte encoded as two
8521 hex characters. Suck them all up, then supply them to the
8522 register cacheing/storage mechanism. */
8524 p
= rs
->buf
.data ();
8525 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8527 if (p
[0] == 0 || p
[1] == 0)
8528 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8529 internal_error (__FILE__
, __LINE__
,
8530 _("unexpected end of 'g' packet reply"));
8532 if (p
[0] == 'x' && p
[1] == 'x')
8533 regs
[i
] = 0; /* 'x' */
8535 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8539 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8541 struct packet_reg
*r
= &rsa
->regs
[i
];
8542 long reg_size
= register_size (gdbarch
, i
);
8546 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8547 /* This shouldn't happen - we adjusted in_g_packet above. */
8548 internal_error (__FILE__
, __LINE__
,
8549 _("unexpected end of 'g' packet reply"));
8550 else if (rs
->buf
[r
->offset
* 2] == 'x')
8552 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8553 /* The register isn't available, mark it as such (at
8554 the same time setting the value to zero). */
8555 regcache
->raw_supply (r
->regnum
, NULL
);
8558 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8564 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8567 process_g_packet (regcache
);
8570 /* Make the remote selected traceframe match GDB's selected
8574 remote_target::set_remote_traceframe ()
8577 struct remote_state
*rs
= get_remote_state ();
8579 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8582 /* Avoid recursion, remote_trace_find calls us again. */
8583 rs
->remote_traceframe_number
= get_traceframe_number ();
8585 newnum
= target_trace_find (tfind_number
,
8586 get_traceframe_number (), 0, 0, NULL
);
8588 /* Should not happen. If it does, all bets are off. */
8589 if (newnum
!= get_traceframe_number ())
8590 warning (_("could not set remote traceframe"));
8594 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8596 struct gdbarch
*gdbarch
= regcache
->arch ();
8597 struct remote_state
*rs
= get_remote_state ();
8598 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8601 set_remote_traceframe ();
8602 set_general_thread (regcache
->ptid ());
8606 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8608 gdb_assert (reg
!= NULL
);
8610 /* If this register might be in the 'g' packet, try that first -
8611 we are likely to read more than one register. If this is the
8612 first 'g' packet, we might be overly optimistic about its
8613 contents, so fall back to 'p'. */
8614 if (reg
->in_g_packet
)
8616 fetch_registers_using_g (regcache
);
8617 if (reg
->in_g_packet
)
8621 if (fetch_register_using_p (regcache
, reg
))
8624 /* This register is not available. */
8625 regcache
->raw_supply (reg
->regnum
, NULL
);
8630 fetch_registers_using_g (regcache
);
8632 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8633 if (!rsa
->regs
[i
].in_g_packet
)
8634 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8636 /* This register is not available. */
8637 regcache
->raw_supply (i
, NULL
);
8641 /* Prepare to store registers. Since we may send them all (using a
8642 'G' request), we have to read out the ones we don't want to change
8646 remote_target::prepare_to_store (struct regcache
*regcache
)
8648 struct remote_state
*rs
= get_remote_state ();
8649 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8652 /* Make sure the entire registers array is valid. */
8653 switch (packet_support (PACKET_P
))
8655 case PACKET_DISABLE
:
8656 case PACKET_SUPPORT_UNKNOWN
:
8657 /* Make sure all the necessary registers are cached. */
8658 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8659 if (rsa
->regs
[i
].in_g_packet
)
8660 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8667 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8668 packet was not recognized. */
8671 remote_target::store_register_using_P (const struct regcache
*regcache
,
8674 struct gdbarch
*gdbarch
= regcache
->arch ();
8675 struct remote_state
*rs
= get_remote_state ();
8676 /* Try storing a single register. */
8677 char *buf
= rs
->buf
.data ();
8678 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8681 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8684 if (reg
->pnum
== -1)
8687 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8688 p
= buf
+ strlen (buf
);
8689 regcache
->raw_collect (reg
->regnum
, regp
);
8690 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8692 getpkt (&rs
->buf
, 0);
8694 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8699 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8700 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8701 case PACKET_UNKNOWN
:
8704 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8708 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8709 contents of the register cache buffer. FIXME: ignores errors. */
8712 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8714 struct remote_state
*rs
= get_remote_state ();
8715 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8719 /* Extract all the registers in the regcache copying them into a
8724 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8725 memset (regs
, 0, rsa
->sizeof_g_packet
);
8726 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8728 struct packet_reg
*r
= &rsa
->regs
[i
];
8731 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8735 /* Command describes registers byte by byte,
8736 each byte encoded as two hex characters. */
8737 p
= rs
->buf
.data ();
8739 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8741 getpkt (&rs
->buf
, 0);
8742 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8743 error (_("Could not write registers; remote failure reply '%s'"),
8747 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8748 of the register cache buffer. FIXME: ignores errors. */
8751 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8753 struct gdbarch
*gdbarch
= regcache
->arch ();
8754 struct remote_state
*rs
= get_remote_state ();
8755 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8758 set_remote_traceframe ();
8759 set_general_thread (regcache
->ptid ());
8763 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8765 gdb_assert (reg
!= NULL
);
8767 /* Always prefer to store registers using the 'P' packet if
8768 possible; we often change only a small number of registers.
8769 Sometimes we change a larger number; we'd need help from a
8770 higher layer to know to use 'G'. */
8771 if (store_register_using_P (regcache
, reg
))
8774 /* For now, don't complain if we have no way to write the
8775 register. GDB loses track of unavailable registers too
8776 easily. Some day, this may be an error. We don't have
8777 any way to read the register, either... */
8778 if (!reg
->in_g_packet
)
8781 store_registers_using_G (regcache
);
8785 store_registers_using_G (regcache
);
8787 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8788 if (!rsa
->regs
[i
].in_g_packet
)
8789 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8790 /* See above for why we do not issue an error here. */
8795 /* Return the number of hex digits in num. */
8798 hexnumlen (ULONGEST num
)
8802 for (i
= 0; num
!= 0; i
++)
8805 return std::max (i
, 1);
8808 /* Set BUF to the minimum number of hex digits representing NUM. */
8811 hexnumstr (char *buf
, ULONGEST num
)
8813 int len
= hexnumlen (num
);
8815 return hexnumnstr (buf
, num
, len
);
8819 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8822 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8828 for (i
= width
- 1; i
>= 0; i
--)
8830 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8837 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8840 remote_address_masked (CORE_ADDR addr
)
8842 unsigned int address_size
= remote_address_size
;
8844 /* If "remoteaddresssize" was not set, default to target address size. */
8846 address_size
= gdbarch_addr_bit (target_gdbarch ());
8848 if (address_size
> 0
8849 && address_size
< (sizeof (ULONGEST
) * 8))
8851 /* Only create a mask when that mask can safely be constructed
8852 in a ULONGEST variable. */
8855 mask
= (mask
<< address_size
) - 1;
8861 /* Determine whether the remote target supports binary downloading.
8862 This is accomplished by sending a no-op memory write of zero length
8863 to the target at the specified address. It does not suffice to send
8864 the whole packet, since many stubs strip the eighth bit and
8865 subsequently compute a wrong checksum, which causes real havoc with
8868 NOTE: This can still lose if the serial line is not eight-bit
8869 clean. In cases like this, the user should clear "remote
8873 remote_target::check_binary_download (CORE_ADDR addr
)
8875 struct remote_state
*rs
= get_remote_state ();
8877 switch (packet_support (PACKET_X
))
8879 case PACKET_DISABLE
:
8883 case PACKET_SUPPORT_UNKNOWN
:
8887 p
= rs
->buf
.data ();
8889 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8891 p
+= hexnumstr (p
, (ULONGEST
) 0);
8895 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8896 getpkt (&rs
->buf
, 0);
8898 if (rs
->buf
[0] == '\0')
8900 remote_debug_printf ("binary downloading NOT supported by target");
8901 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8905 remote_debug_printf ("binary downloading supported by target");
8906 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8913 /* Helper function to resize the payload in order to try to get a good
8914 alignment. We try to write an amount of data such that the next write will
8915 start on an address aligned on REMOTE_ALIGN_WRITES. */
8918 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8920 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8923 /* Write memory data directly to the remote machine.
8924 This does not inform the data cache; the data cache uses this.
8925 HEADER is the starting part of the packet.
8926 MEMADDR is the address in the remote memory space.
8927 MYADDR is the address of the buffer in our space.
8928 LEN_UNITS is the number of addressable units to write.
8929 UNIT_SIZE is the length in bytes of an addressable unit.
8930 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8931 should send data as binary ('X'), or hex-encoded ('M').
8933 The function creates packet of the form
8934 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8936 where encoding of <DATA> is terminated by PACKET_FORMAT.
8938 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8941 Return the transferred status, error or OK (an
8942 'enum target_xfer_status' value). Save the number of addressable units
8943 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8945 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8946 exchange between gdb and the stub could look like (?? in place of the
8952 -> $M1000,3:eeeeffffeeee#??
8956 <- eeeeffffeeeedddd */
8959 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8960 const gdb_byte
*myaddr
,
8963 ULONGEST
*xfered_len_units
,
8964 char packet_format
, int use_length
)
8966 struct remote_state
*rs
= get_remote_state ();
8972 int payload_capacity_bytes
;
8973 int payload_length_bytes
;
8975 if (packet_format
!= 'X' && packet_format
!= 'M')
8976 internal_error (__FILE__
, __LINE__
,
8977 _("remote_write_bytes_aux: bad packet format"));
8980 return TARGET_XFER_EOF
;
8982 payload_capacity_bytes
= get_memory_write_packet_size ();
8984 /* The packet buffer will be large enough for the payload;
8985 get_memory_packet_size ensures this. */
8988 /* Compute the size of the actual payload by subtracting out the
8989 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8991 payload_capacity_bytes
-= strlen ("$,:#NN");
8993 /* The comma won't be used. */
8994 payload_capacity_bytes
+= 1;
8995 payload_capacity_bytes
-= strlen (header
);
8996 payload_capacity_bytes
-= hexnumlen (memaddr
);
8998 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
9000 strcat (rs
->buf
.data (), header
);
9001 p
= rs
->buf
.data () + strlen (header
);
9003 /* Compute a best guess of the number of bytes actually transfered. */
9004 if (packet_format
== 'X')
9006 /* Best guess at number of bytes that will fit. */
9007 todo_units
= std::min (len_units
,
9008 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
9010 payload_capacity_bytes
-= hexnumlen (todo_units
);
9011 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
9015 /* Number of bytes that will fit. */
9017 = std::min (len_units
,
9018 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
9020 payload_capacity_bytes
-= hexnumlen (todo_units
);
9021 todo_units
= std::min (todo_units
,
9022 (payload_capacity_bytes
/ unit_size
) / 2);
9025 if (todo_units
<= 0)
9026 internal_error (__FILE__
, __LINE__
,
9027 _("minimum packet size too small to write data"));
9029 /* If we already need another packet, then try to align the end
9030 of this packet to a useful boundary. */
9031 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
9032 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
9034 /* Append "<memaddr>". */
9035 memaddr
= remote_address_masked (memaddr
);
9036 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
9043 /* Append the length and retain its location and size. It may need to be
9044 adjusted once the packet body has been created. */
9046 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
9054 /* Append the packet body. */
9055 if (packet_format
== 'X')
9057 /* Binary mode. Send target system values byte by byte, in
9058 increasing byte addresses. Only escape certain critical
9060 payload_length_bytes
=
9061 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
9062 &units_written
, payload_capacity_bytes
);
9064 /* If not all TODO units fit, then we'll need another packet. Make
9065 a second try to keep the end of the packet aligned. Don't do
9066 this if the packet is tiny. */
9067 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
9071 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
9073 if (new_todo_units
!= units_written
)
9074 payload_length_bytes
=
9075 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
9076 (gdb_byte
*) p
, &units_written
,
9077 payload_capacity_bytes
);
9080 p
+= payload_length_bytes
;
9081 if (use_length
&& units_written
< todo_units
)
9083 /* Escape chars have filled up the buffer prematurely,
9084 and we have actually sent fewer units than planned.
9085 Fix-up the length field of the packet. Use the same
9086 number of characters as before. */
9087 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
9089 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
9094 /* Normal mode: Send target system values byte by byte, in
9095 increasing byte addresses. Each byte is encoded as a two hex
9097 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
9098 units_written
= todo_units
;
9101 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
9102 getpkt (&rs
->buf
, 0);
9104 if (rs
->buf
[0] == 'E')
9105 return TARGET_XFER_E_IO
;
9107 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
9108 send fewer units than we'd planned. */
9109 *xfered_len_units
= (ULONGEST
) units_written
;
9110 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
9113 /* Write memory data directly to the remote machine.
9114 This does not inform the data cache; the data cache uses this.
9115 MEMADDR is the address in the remote memory space.
9116 MYADDR is the address of the buffer in our space.
9117 LEN is the number of bytes.
9119 Return the transferred status, error or OK (an
9120 'enum target_xfer_status' value). Save the number of bytes
9121 transferred in *XFERED_LEN. Only transfer a single packet. */
9124 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
9125 ULONGEST len
, int unit_size
,
9126 ULONGEST
*xfered_len
)
9128 const char *packet_format
= NULL
;
9130 /* Check whether the target supports binary download. */
9131 check_binary_download (memaddr
);
9133 switch (packet_support (PACKET_X
))
9136 packet_format
= "X";
9138 case PACKET_DISABLE
:
9139 packet_format
= "M";
9141 case PACKET_SUPPORT_UNKNOWN
:
9142 internal_error (__FILE__
, __LINE__
,
9143 _("remote_write_bytes: bad internal state"));
9145 internal_error (__FILE__
, __LINE__
, _("bad switch"));
9148 return remote_write_bytes_aux (packet_format
,
9149 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
9150 packet_format
[0], 1);
9153 /* Read memory data directly from the remote machine.
9154 This does not use the data cache; the data cache uses this.
9155 MEMADDR is the address in the remote memory space.
9156 MYADDR is the address of the buffer in our space.
9157 LEN_UNITS is the number of addressable memory units to read..
9158 UNIT_SIZE is the length in bytes of an addressable unit.
9160 Return the transferred status, error or OK (an
9161 'enum target_xfer_status' value). Save the number of bytes
9162 transferred in *XFERED_LEN_UNITS.
9164 See the comment of remote_write_bytes_aux for an example of
9165 memory read/write exchange between gdb and the stub. */
9168 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
9170 int unit_size
, ULONGEST
*xfered_len_units
)
9172 struct remote_state
*rs
= get_remote_state ();
9173 int buf_size_bytes
; /* Max size of packet output buffer. */
9178 buf_size_bytes
= get_memory_read_packet_size ();
9179 /* The packet buffer will be large enough for the payload;
9180 get_memory_packet_size ensures this. */
9182 /* Number of units that will fit. */
9183 todo_units
= std::min (len_units
,
9184 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
9186 /* Construct "m"<memaddr>","<len>". */
9187 memaddr
= remote_address_masked (memaddr
);
9188 p
= rs
->buf
.data ();
9190 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
9192 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
9195 getpkt (&rs
->buf
, 0);
9196 if (rs
->buf
[0] == 'E'
9197 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
9198 && rs
->buf
[3] == '\0')
9199 return TARGET_XFER_E_IO
;
9200 /* Reply describes memory byte by byte, each byte encoded as two hex
9202 p
= rs
->buf
.data ();
9203 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
9204 /* Return what we have. Let higher layers handle partial reads. */
9205 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
9206 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
9209 /* Using the set of read-only target sections of remote, read live
9212 For interface/parameters/return description see target.h,
9216 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
9220 ULONGEST
*xfered_len
)
9222 const struct target_section
*secp
;
9224 secp
= target_section_by_addr (this, memaddr
);
9226 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
9228 ULONGEST memend
= memaddr
+ len
;
9230 const target_section_table
*table
= target_get_section_table (this);
9231 for (const target_section
&p
: *table
)
9233 if (memaddr
>= p
.addr
)
9235 if (memend
<= p
.endaddr
)
9237 /* Entire transfer is within this section. */
9238 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
9241 else if (memaddr
>= p
.endaddr
)
9243 /* This section ends before the transfer starts. */
9248 /* This section overlaps the transfer. Just do half. */
9249 len
= p
.endaddr
- memaddr
;
9250 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
9257 return TARGET_XFER_EOF
;
9260 /* Similar to remote_read_bytes_1, but it reads from the remote stub
9261 first if the requested memory is unavailable in traceframe.
9262 Otherwise, fall back to remote_read_bytes_1. */
9265 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
9266 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
9267 ULONGEST
*xfered_len
)
9270 return TARGET_XFER_EOF
;
9272 if (get_traceframe_number () != -1)
9274 std::vector
<mem_range
> available
;
9276 /* If we fail to get the set of available memory, then the
9277 target does not support querying traceframe info, and so we
9278 attempt reading from the traceframe anyway (assuming the
9279 target implements the old QTro packet then). */
9280 if (traceframe_available_memory (&available
, memaddr
, len
))
9282 if (available
.empty () || available
[0].start
!= memaddr
)
9284 enum target_xfer_status res
;
9286 /* Don't read into the traceframe's available
9288 if (!available
.empty ())
9290 LONGEST oldlen
= len
;
9292 len
= available
[0].start
- memaddr
;
9293 gdb_assert (len
<= oldlen
);
9296 /* This goes through the topmost target again. */
9297 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
9298 len
, unit_size
, xfered_len
);
9299 if (res
== TARGET_XFER_OK
)
9300 return TARGET_XFER_OK
;
9303 /* No use trying further, we know some memory starting
9304 at MEMADDR isn't available. */
9306 return (*xfered_len
!= 0) ?
9307 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
9311 /* Don't try to read more than how much is available, in
9312 case the target implements the deprecated QTro packet to
9313 cater for older GDBs (the target's knowledge of read-only
9314 sections may be outdated by now). */
9315 len
= available
[0].length
;
9319 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
9324 /* Sends a packet with content determined by the printf format string
9325 FORMAT and the remaining arguments, then gets the reply. Returns
9326 whether the packet was a success, a failure, or unknown. */
9329 remote_target::remote_send_printf (const char *format
, ...)
9331 struct remote_state
*rs
= get_remote_state ();
9332 int max_size
= get_remote_packet_size ();
9335 va_start (ap
, format
);
9338 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
9342 if (size
>= max_size
)
9343 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
9345 if (putpkt (rs
->buf
) < 0)
9346 error (_("Communication problem with target."));
9349 getpkt (&rs
->buf
, 0);
9351 return packet_check_result (rs
->buf
);
9354 /* Flash writing can take quite some time. We'll set
9355 effectively infinite timeout for flash operations.
9356 In future, we'll need to decide on a better approach. */
9357 static const int remote_flash_timeout
= 1000;
9360 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
9362 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
9363 enum packet_result ret
;
9364 scoped_restore restore_timeout
9365 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9367 ret
= remote_send_printf ("vFlashErase:%s,%s",
9368 phex (address
, addr_size
),
9372 case PACKET_UNKNOWN
:
9373 error (_("Remote target does not support flash erase"));
9375 error (_("Error erasing flash with vFlashErase packet"));
9382 remote_target::remote_flash_write (ULONGEST address
,
9383 ULONGEST length
, ULONGEST
*xfered_len
,
9384 const gdb_byte
*data
)
9386 scoped_restore restore_timeout
9387 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9388 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
9393 remote_target::flash_done ()
9397 scoped_restore restore_timeout
9398 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9400 ret
= remote_send_printf ("vFlashDone");
9404 case PACKET_UNKNOWN
:
9405 error (_("Remote target does not support vFlashDone"));
9407 error (_("Error finishing flash operation"));
9414 /* Stuff for dealing with the packets which are part of this protocol.
9415 See comment at top of file for details. */
9417 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
9418 error to higher layers. Called when a serial error is detected.
9419 The exception message is STRING, followed by a colon and a blank,
9420 the system error message for errno at function entry and final dot
9421 for output compatibility with throw_perror_with_name. */
9424 unpush_and_perror (remote_target
*target
, const char *string
)
9426 int saved_errno
= errno
;
9428 remote_unpush_target (target
);
9429 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
9430 safe_strerror (saved_errno
));
9433 /* Read a single character from the remote end. The current quit
9434 handler is overridden to avoid quitting in the middle of packet
9435 sequence, as that would break communication with the remote server.
9436 See remote_serial_quit_handler for more detail. */
9439 remote_target::readchar (int timeout
)
9442 struct remote_state
*rs
= get_remote_state ();
9445 scoped_restore restore_quit_target
9446 = make_scoped_restore (&curr_quit_handler_target
, this);
9447 scoped_restore restore_quit
9448 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9450 rs
->got_ctrlc_during_io
= 0;
9452 ch
= serial_readchar (rs
->remote_desc
, timeout
);
9454 if (rs
->got_ctrlc_during_io
)
9461 switch ((enum serial_rc
) ch
)
9464 remote_unpush_target (this);
9465 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9468 unpush_and_perror (this, _("Remote communication error. "
9469 "Target disconnected."));
9471 case SERIAL_TIMEOUT
:
9477 /* Wrapper for serial_write that closes the target and throws if
9478 writing fails. The current quit handler is overridden to avoid
9479 quitting in the middle of packet sequence, as that would break
9480 communication with the remote server. See
9481 remote_serial_quit_handler for more detail. */
9484 remote_target::remote_serial_write (const char *str
, int len
)
9486 struct remote_state
*rs
= get_remote_state ();
9488 scoped_restore restore_quit_target
9489 = make_scoped_restore (&curr_quit_handler_target
, this);
9490 scoped_restore restore_quit
9491 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9493 rs
->got_ctrlc_during_io
= 0;
9495 if (serial_write (rs
->remote_desc
, str
, len
))
9497 unpush_and_perror (this, _("Remote communication error. "
9498 "Target disconnected."));
9501 if (rs
->got_ctrlc_during_io
)
9505 /* Return a string representing an escaped version of BUF, of len N.
9506 E.g. \n is converted to \\n, \t to \\t, etc. */
9509 escape_buffer (const char *buf
, int n
)
9513 stb
.putstrn (buf
, n
, '\\');
9514 return stb
.release ();
9518 remote_target::putpkt (const char *buf
)
9520 return putpkt_binary (buf
, strlen (buf
));
9523 /* Wrapper around remote_target::putpkt to avoid exporting
9527 putpkt (remote_target
*remote
, const char *buf
)
9529 return remote
->putpkt (buf
);
9532 /* Send a packet to the remote machine, with error checking. The data
9533 of the packet is in BUF. The string in BUF can be at most
9534 get_remote_packet_size () - 5 to account for the $, # and checksum,
9535 and for a possible /0 if we are debugging (remote_debug) and want
9536 to print the sent packet as a string. */
9539 remote_target::putpkt_binary (const char *buf
, int cnt
)
9541 struct remote_state
*rs
= get_remote_state ();
9543 unsigned char csum
= 0;
9544 gdb::def_vector
<char> data (cnt
+ 6);
9545 char *buf2
= data
.data ();
9551 /* Catch cases like trying to read memory or listing threads while
9552 we're waiting for a stop reply. The remote server wouldn't be
9553 ready to handle this request, so we'd hang and timeout. We don't
9554 have to worry about this in synchronous mode, because in that
9555 case it's not possible to issue a command while the target is
9556 running. This is not a problem in non-stop mode, because in that
9557 case, the stub is always ready to process serial input. */
9558 if (!target_is_non_stop_p ()
9559 && target_is_async_p ()
9560 && rs
->waiting_for_stop_reply
)
9562 error (_("Cannot execute this command while the target is running.\n"
9563 "Use the \"interrupt\" command to stop the target\n"
9564 "and then try again."));
9567 /* Copy the packet into buffer BUF2, encapsulating it
9568 and giving it a checksum. */
9573 for (i
= 0; i
< cnt
; i
++)
9579 *p
++ = tohex ((csum
>> 4) & 0xf);
9580 *p
++ = tohex (csum
& 0xf);
9582 /* Send it over and over until we get a positive ack. */
9590 int len
= (int) (p
- buf2
);
9593 if (remote_packet_max_chars
< 0)
9596 max_chars
= remote_packet_max_chars
;
9599 = escape_buffer (buf2
, std::min (len
, max_chars
));
9601 if (len
> max_chars
)
9602 remote_debug_printf_nofunc
9603 ("Sending packet: %s [%d bytes omitted]", str
.c_str (),
9606 remote_debug_printf_nofunc ("Sending packet: %s", str
.c_str ());
9608 remote_serial_write (buf2
, p
- buf2
);
9610 /* If this is a no acks version of the remote protocol, send the
9611 packet and move on. */
9615 /* Read until either a timeout occurs (-2) or '+' is read.
9616 Handle any notification that arrives in the mean time. */
9619 ch
= readchar (remote_timeout
);
9624 remote_debug_printf_nofunc ("Received Ack");
9627 remote_debug_printf_nofunc ("Received Nak");
9629 case SERIAL_TIMEOUT
:
9633 break; /* Retransmit buffer. */
9636 remote_debug_printf ("Packet instead of Ack, ignoring it");
9637 /* It's probably an old response sent because an ACK
9638 was lost. Gobble up the packet and ack it so it
9639 doesn't get retransmitted when we resend this
9642 remote_serial_write ("+", 1);
9643 continue; /* Now, go look for +. */
9650 /* If we got a notification, handle it, and go back to looking
9652 /* We've found the start of a notification. Now
9653 collect the data. */
9654 val
= read_frame (&rs
->buf
);
9657 remote_debug_printf_nofunc
9658 (" Notification received: %s",
9659 escape_buffer (rs
->buf
.data (), val
).c_str ());
9661 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9662 /* We're in sync now, rewait for the ack. */
9666 remote_debug_printf_nofunc ("Junk: %c%s", ch
& 0177,
9672 remote_debug_printf_nofunc ("Junk: %c%s", ch
& 0177,
9676 break; /* Here to retransmit. */
9680 /* This is wrong. If doing a long backtrace, the user should be
9681 able to get out next time we call QUIT, without anything as
9682 violent as interrupt_query. If we want to provide a way out of
9683 here without getting to the next QUIT, it should be based on
9684 hitting ^C twice as in remote_wait. */
9696 /* Come here after finding the start of a frame when we expected an
9697 ack. Do our best to discard the rest of this packet. */
9700 remote_target::skip_frame ()
9706 c
= readchar (remote_timeout
);
9709 case SERIAL_TIMEOUT
:
9710 /* Nothing we can do. */
9713 /* Discard the two bytes of checksum and stop. */
9714 c
= readchar (remote_timeout
);
9716 c
= readchar (remote_timeout
);
9719 case '*': /* Run length encoding. */
9720 /* Discard the repeat count. */
9721 c
= readchar (remote_timeout
);
9726 /* A regular character. */
9732 /* Come here after finding the start of the frame. Collect the rest
9733 into *BUF, verifying the checksum, length, and handling run-length
9734 compression. NUL terminate the buffer. If there is not enough room,
9737 Returns -1 on error, number of characters in buffer (ignoring the
9738 trailing NULL) on success. (could be extended to return one of the
9739 SERIAL status indications). */
9742 remote_target::read_frame (gdb::char_vector
*buf_p
)
9747 char *buf
= buf_p
->data ();
9748 struct remote_state
*rs
= get_remote_state ();
9755 c
= readchar (remote_timeout
);
9758 case SERIAL_TIMEOUT
:
9759 remote_debug_printf ("Timeout in mid-packet, retrying");
9763 remote_debug_printf ("Saw new packet start in middle of old one");
9764 return -1; /* Start a new packet, count retries. */
9768 unsigned char pktcsum
;
9774 check_0
= readchar (remote_timeout
);
9776 check_1
= readchar (remote_timeout
);
9778 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9780 remote_debug_printf ("Timeout in checksum, retrying");
9783 else if (check_0
< 0 || check_1
< 0)
9785 remote_debug_printf ("Communication error in checksum");
9789 /* Don't recompute the checksum; with no ack packets we
9790 don't have any way to indicate a packet retransmission
9795 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9796 if (csum
== pktcsum
)
9800 ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s",
9801 pktcsum
, csum
, escape_buffer (buf
, bc
).c_str ());
9803 /* Number of characters in buffer ignoring trailing
9807 case '*': /* Run length encoding. */
9812 c
= readchar (remote_timeout
);
9814 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9816 /* The character before ``*'' is repeated. */
9818 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9820 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9822 /* Make some more room in the buffer. */
9823 buf_p
->resize (buf_p
->size () + repeat
);
9824 buf
= buf_p
->data ();
9827 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9833 gdb_printf (_("Invalid run length encoding: %s\n"), buf
);
9837 if (bc
>= buf_p
->size () - 1)
9839 /* Make some more room in the buffer. */
9840 buf_p
->resize (buf_p
->size () * 2);
9841 buf
= buf_p
->data ();
9851 /* Set this to the maximum number of seconds to wait instead of waiting forever
9852 in target_wait(). If this timer times out, then it generates an error and
9853 the command is aborted. This replaces most of the need for timeouts in the
9854 GDB test suite, and makes it possible to distinguish between a hung target
9855 and one with slow communications. */
9857 static int watchdog
= 0;
9859 show_watchdog (struct ui_file
*file
, int from_tty
,
9860 struct cmd_list_element
*c
, const char *value
)
9862 gdb_printf (file
, _("Watchdog timer is %s.\n"), value
);
9865 /* Read a packet from the remote machine, with error checking, and
9866 store it in *BUF. Resize *BUF if necessary to hold the result. If
9867 FOREVER, wait forever rather than timing out; this is used (in
9868 synchronous mode) to wait for a target that is is executing user
9870 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9871 don't have to change all the calls to getpkt to deal with the
9872 return value, because at the moment I don't know what the right
9873 thing to do it for those. */
9876 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9878 getpkt_sane (buf
, forever
);
9882 /* Read a packet from the remote machine, with error checking, and
9883 store it in *BUF. Resize *BUF if necessary to hold the result. If
9884 FOREVER, wait forever rather than timing out; this is used (in
9885 synchronous mode) to wait for a target that is is executing user
9886 code to stop. If FOREVER == 0, this function is allowed to time
9887 out gracefully and return an indication of this to the caller.
9888 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9889 consider receiving a notification enough reason to return to the
9890 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9891 holds a notification or not (a regular packet). */
9894 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9895 int forever
, int expecting_notif
,
9898 struct remote_state
*rs
= get_remote_state ();
9904 strcpy (buf
->data (), "timeout");
9907 timeout
= watchdog
> 0 ? watchdog
: -1;
9908 else if (expecting_notif
)
9909 timeout
= 0; /* There should already be a char in the buffer. If
9912 timeout
= remote_timeout
;
9916 /* Process any number of notifications, and then return when
9920 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9922 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9924 /* This can loop forever if the remote side sends us
9925 characters continuously, but if it pauses, we'll get
9926 SERIAL_TIMEOUT from readchar because of timeout. Then
9927 we'll count that as a retry.
9929 Note that even when forever is set, we will only wait
9930 forever prior to the start of a packet. After that, we
9931 expect characters to arrive at a brisk pace. They should
9932 show up within remote_timeout intervals. */
9934 c
= readchar (timeout
);
9935 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9937 if (c
== SERIAL_TIMEOUT
)
9939 if (expecting_notif
)
9940 return -1; /* Don't complain, it's normal to not get
9941 anything in this case. */
9943 if (forever
) /* Watchdog went off? Kill the target. */
9945 remote_unpush_target (this);
9946 throw_error (TARGET_CLOSE_ERROR
,
9947 _("Watchdog timeout has expired. "
9948 "Target detached."));
9951 remote_debug_printf ("Timed out.");
9955 /* We've found the start of a packet or notification.
9956 Now collect the data. */
9957 val
= read_frame (buf
);
9962 remote_serial_write ("-", 1);
9965 if (tries
> MAX_TRIES
)
9967 /* We have tried hard enough, and just can't receive the
9968 packet/notification. Give up. */
9969 gdb_printf (_("Ignoring packet error, continuing...\n"));
9971 /* Skip the ack char if we're in no-ack mode. */
9972 if (!rs
->noack_mode
)
9973 remote_serial_write ("+", 1);
9977 /* If we got an ordinary packet, return that to our caller. */
9984 if (remote_packet_max_chars
< 0)
9987 max_chars
= remote_packet_max_chars
;
9990 = escape_buffer (buf
->data (),
9991 std::min (val
, max_chars
));
9993 if (val
> max_chars
)
9994 remote_debug_printf_nofunc
9995 ("Packet received: %s [%d bytes omitted]", str
.c_str (),
9998 remote_debug_printf_nofunc ("Packet received: %s",
10002 /* Skip the ack char if we're in no-ack mode. */
10003 if (!rs
->noack_mode
)
10004 remote_serial_write ("+", 1);
10005 if (is_notif
!= NULL
)
10010 /* If we got a notification, handle it, and go back to looking
10014 gdb_assert (c
== '%');
10016 remote_debug_printf_nofunc
10017 (" Notification received: %s",
10018 escape_buffer (buf
->data (), val
).c_str ());
10020 if (is_notif
!= NULL
)
10023 handle_notification (rs
->notif_state
, buf
->data ());
10025 /* Notifications require no acknowledgement. */
10027 if (expecting_notif
)
10034 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
10036 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
10040 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
10043 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
10046 /* Kill any new fork children of inferior INF that haven't been
10047 processed by follow_fork. */
10050 remote_target::kill_new_fork_children (inferior
*inf
)
10052 remote_state
*rs
= get_remote_state ();
10053 struct notif_client
*notif
= ¬if_client_stop
;
10055 /* Kill the fork child threads of any threads in inferior INF that are stopped
10056 at a fork event. */
10057 for (thread_info
*thread
: inf
->non_exited_threads ())
10059 const target_waitstatus
*ws
= thread_pending_fork_status (thread
);
10064 int child_pid
= ws
->child_ptid ().pid ();
10065 int res
= remote_vkill (child_pid
);
10068 error (_("Can't kill fork child process %d"), child_pid
);
10071 /* Check for any pending fork events (not reported or processed yet)
10072 in inferior INF and kill those fork child threads as well. */
10073 remote_notif_get_pending_events (notif
);
10074 for (auto &event
: rs
->stop_reply_queue
)
10076 if (event
->ptid
.pid () != inf
->pid
)
10079 if (!is_fork_status (event
->ws
.kind ()))
10082 int child_pid
= event
->ws
.child_ptid ().pid ();
10083 int res
= remote_vkill (child_pid
);
10086 error (_("Can't kill fork child process %d"), child_pid
);
10091 /* Target hook to kill the current inferior. */
10094 remote_target::kill ()
10097 inferior
*inf
= find_inferior_pid (this, inferior_ptid
.pid ());
10098 struct remote_state
*rs
= get_remote_state ();
10100 gdb_assert (inf
!= nullptr);
10102 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
10104 /* If we're stopped while forking and we haven't followed yet,
10105 kill the child task. We need to do this before killing the
10106 parent task because if this is a vfork then the parent will
10108 kill_new_fork_children (inf
);
10110 res
= remote_vkill (inf
->pid
);
10113 target_mourn_inferior (inferior_ptid
);
10118 /* If we are in 'target remote' mode and we are killing the only
10119 inferior, then we will tell gdbserver to exit and unpush the
10121 if (res
== -1 && !remote_multi_process_p (rs
)
10122 && number_of_live_inferiors (this) == 1)
10126 /* We've killed the remote end, we get to mourn it. If we are
10127 not in extended mode, mourning the inferior also unpushes
10128 remote_ops from the target stack, which closes the remote
10130 target_mourn_inferior (inferior_ptid
);
10135 error (_("Can't kill process"));
10138 /* Send a kill request to the target using the 'vKill' packet. */
10141 remote_target::remote_vkill (int pid
)
10143 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
10146 remote_state
*rs
= get_remote_state ();
10148 /* Tell the remote target to detach. */
10149 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
10151 getpkt (&rs
->buf
, 0);
10153 switch (packet_ok (rs
->buf
,
10154 &remote_protocol_packets
[PACKET_vKill
]))
10160 case PACKET_UNKNOWN
:
10163 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
10167 /* Send a kill request to the target using the 'k' packet. */
10170 remote_target::remote_kill_k ()
10172 /* Catch errors so the user can quit from gdb even when we
10173 aren't on speaking terms with the remote system. */
10178 catch (const gdb_exception_error
&ex
)
10180 if (ex
.error
== TARGET_CLOSE_ERROR
)
10182 /* If we got an (EOF) error that caused the target
10183 to go away, then we're done, that's what we wanted.
10184 "k" is susceptible to cause a premature EOF, given
10185 that the remote server isn't actually required to
10186 reply to "k", and it can happen that it doesn't
10187 even get to reply ACK to the "k". */
10191 /* Otherwise, something went wrong. We didn't actually kill
10192 the target. Just propagate the exception, and let the
10193 user or higher layers decide what to do. */
10199 remote_target::mourn_inferior ()
10201 struct remote_state
*rs
= get_remote_state ();
10203 /* We're no longer interested in notification events of an inferior
10204 that exited or was killed/detached. */
10205 discard_pending_stop_replies (current_inferior ());
10207 /* In 'target remote' mode with one inferior, we close the connection. */
10208 if (!rs
->extended
&& number_of_live_inferiors (this) <= 1)
10210 remote_unpush_target (this);
10214 /* In case we got here due to an error, but we're going to stay
10216 rs
->waiting_for_stop_reply
= 0;
10218 /* If the current general thread belonged to the process we just
10219 detached from or has exited, the remote side current general
10220 thread becomes undefined. Considering a case like this:
10222 - We just got here due to a detach.
10223 - The process that we're detaching from happens to immediately
10224 report a global breakpoint being hit in non-stop mode, in the
10225 same thread we had selected before.
10226 - GDB attaches to this process again.
10227 - This event happens to be the next event we handle.
10229 GDB would consider that the current general thread didn't need to
10230 be set on the stub side (with Hg), since for all it knew,
10231 GENERAL_THREAD hadn't changed.
10233 Notice that although in all-stop mode, the remote server always
10234 sets the current thread to the thread reporting the stop event,
10235 that doesn't happen in non-stop mode; in non-stop, the stub *must
10236 not* change the current thread when reporting a breakpoint hit,
10237 due to the decoupling of event reporting and event handling.
10239 To keep things simple, we always invalidate our notion of the
10241 record_currthread (rs
, minus_one_ptid
);
10243 /* Call common code to mark the inferior as not running. */
10244 generic_mourn_inferior ();
10248 extended_remote_target::supports_disable_randomization ()
10250 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
10254 remote_target::extended_remote_disable_randomization (int val
)
10256 struct remote_state
*rs
= get_remote_state ();
10259 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10260 "QDisableRandomization:%x", val
);
10262 reply
= remote_get_noisy_reply ();
10263 if (*reply
== '\0')
10264 error (_("Target does not support QDisableRandomization."));
10265 if (strcmp (reply
, "OK") != 0)
10266 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
10270 remote_target::extended_remote_run (const std::string
&args
)
10272 struct remote_state
*rs
= get_remote_state ();
10274 const char *remote_exec_file
= get_remote_exec_file ();
10276 /* If the user has disabled vRun support, or we have detected that
10277 support is not available, do not try it. */
10278 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
10281 strcpy (rs
->buf
.data (), "vRun;");
10282 len
= strlen (rs
->buf
.data ());
10284 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
10285 error (_("Remote file name too long for run packet"));
10286 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
10287 strlen (remote_exec_file
));
10289 if (!args
.empty ())
10293 gdb_argv
argv (args
.c_str ());
10294 for (i
= 0; argv
[i
] != NULL
; i
++)
10296 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
10297 error (_("Argument list too long for run packet"));
10298 rs
->buf
[len
++] = ';';
10299 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
10304 rs
->buf
[len
++] = '\0';
10307 getpkt (&rs
->buf
, 0);
10309 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
10312 /* We have a wait response. All is well. */
10314 case PACKET_UNKNOWN
:
10317 if (remote_exec_file
[0] == '\0')
10318 error (_("Running the default executable on the remote target failed; "
10319 "try \"set remote exec-file\"?"));
10321 error (_("Running \"%s\" on the remote target failed"),
10324 gdb_assert_not_reached ("bad switch");
10328 /* Helper function to send set/unset environment packets. ACTION is
10329 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
10330 or "QEnvironmentUnsetVariable". VALUE is the variable to be
10334 remote_target::send_environment_packet (const char *action
,
10335 const char *packet
,
10338 remote_state
*rs
= get_remote_state ();
10340 /* Convert the environment variable to an hex string, which
10341 is the best format to be transmitted over the wire. */
10342 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
10345 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10346 "%s:%s", packet
, encoded_value
.c_str ());
10349 getpkt (&rs
->buf
, 0);
10350 if (strcmp (rs
->buf
.data (), "OK") != 0)
10351 warning (_("Unable to %s environment variable '%s' on remote."),
10355 /* Helper function to handle the QEnvironment* packets. */
10358 remote_target::extended_remote_environment_support ()
10360 remote_state
*rs
= get_remote_state ();
10362 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
10364 putpkt ("QEnvironmentReset");
10365 getpkt (&rs
->buf
, 0);
10366 if (strcmp (rs
->buf
.data (), "OK") != 0)
10367 warning (_("Unable to reset environment on remote."));
10370 gdb_environ
*e
= ¤t_inferior ()->environment
;
10372 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
10373 for (const std::string
&el
: e
->user_set_env ())
10374 send_environment_packet ("set", "QEnvironmentHexEncoded",
10377 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
10378 for (const std::string
&el
: e
->user_unset_env ())
10379 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10382 /* Helper function to set the current working directory for the
10383 inferior in the remote target. */
10386 remote_target::extended_remote_set_inferior_cwd ()
10388 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10390 const std::string
&inferior_cwd
= current_inferior ()->cwd ();
10391 remote_state
*rs
= get_remote_state ();
10393 if (!inferior_cwd
.empty ())
10395 std::string hexpath
10396 = bin2hex ((const gdb_byte
*) inferior_cwd
.data (),
10397 inferior_cwd
.size ());
10399 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10400 "QSetWorkingDir:%s", hexpath
.c_str ());
10404 /* An empty inferior_cwd means that the user wants us to
10405 reset the remote server's inferior's cwd. */
10406 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10407 "QSetWorkingDir:");
10411 getpkt (&rs
->buf
, 0);
10412 if (packet_ok (rs
->buf
,
10413 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10416 Remote replied unexpectedly while setting the inferior's working\n\
10423 /* In the extended protocol we want to be able to do things like
10424 "run" and have them basically work as expected. So we need
10425 a special create_inferior function. We support changing the
10426 executable file and the command line arguments, but not the
10430 extended_remote_target::create_inferior (const char *exec_file
,
10431 const std::string
&args
,
10432 char **env
, int from_tty
)
10436 struct remote_state
*rs
= get_remote_state ();
10437 const char *remote_exec_file
= get_remote_exec_file ();
10439 /* If running asynchronously, register the target file descriptor
10440 with the event loop. */
10441 if (target_can_async_p ())
10444 /* Disable address space randomization if requested (and supported). */
10445 if (supports_disable_randomization ())
10446 extended_remote_disable_randomization (disable_randomization
);
10448 /* If startup-with-shell is on, we inform gdbserver to start the
10449 remote inferior using a shell. */
10450 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10452 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10453 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10455 getpkt (&rs
->buf
, 0);
10456 if (strcmp (rs
->buf
.data (), "OK") != 0)
10458 Remote replied unexpectedly while setting startup-with-shell: %s"),
10462 extended_remote_environment_support ();
10464 extended_remote_set_inferior_cwd ();
10466 /* Now restart the remote server. */
10467 run_worked
= extended_remote_run (args
) != -1;
10470 /* vRun was not supported. Fail if we need it to do what the
10472 if (remote_exec_file
[0])
10473 error (_("Remote target does not support \"set remote exec-file\""));
10474 if (!args
.empty ())
10475 error (_("Remote target does not support \"set args\" or run ARGS"));
10477 /* Fall back to "R". */
10478 extended_remote_restart ();
10481 /* vRun's success return is a stop reply. */
10482 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10483 add_current_inferior_and_thread (stop_reply
);
10485 /* Get updated offsets, if the stub uses qOffsets. */
10490 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10491 the list of conditions (in agent expression bytecode format), if any, the
10492 target needs to evaluate. The output is placed into the packet buffer
10493 started from BUF and ended at BUF_END. */
10496 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10497 struct bp_target_info
*bp_tgt
, char *buf
,
10500 if (bp_tgt
->conditions
.empty ())
10503 buf
+= strlen (buf
);
10504 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10507 /* Send conditions to the target. */
10508 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10510 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10511 buf
+= strlen (buf
);
10512 for (int i
= 0; i
< aexpr
->len
; ++i
)
10513 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10520 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10521 struct bp_target_info
*bp_tgt
, char *buf
)
10523 if (bp_tgt
->tcommands
.empty ())
10526 buf
+= strlen (buf
);
10528 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10529 buf
+= strlen (buf
);
10531 /* Concatenate all the agent expressions that are commands into the
10533 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10535 sprintf (buf
, "X%x,", aexpr
->len
);
10536 buf
+= strlen (buf
);
10537 for (int i
= 0; i
< aexpr
->len
; ++i
)
10538 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10543 /* Insert a breakpoint. On targets that have software breakpoint
10544 support, we ask the remote target to do the work; on targets
10545 which don't, we insert a traditional memory breakpoint. */
10548 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10549 struct bp_target_info
*bp_tgt
)
10551 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10552 If it succeeds, then set the support to PACKET_ENABLE. If it
10553 fails, and the user has explicitly requested the Z support then
10554 report an error, otherwise, mark it disabled and go on. */
10556 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10558 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10559 struct remote_state
*rs
;
10562 /* Make sure the remote is pointing at the right process, if
10564 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10565 set_general_process ();
10567 rs
= get_remote_state ();
10568 p
= rs
->buf
.data ();
10569 endbuf
= p
+ get_remote_packet_size ();
10574 addr
= (ULONGEST
) remote_address_masked (addr
);
10575 p
+= hexnumstr (p
, addr
);
10576 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10578 if (supports_evaluation_of_breakpoint_conditions ())
10579 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10581 if (can_run_breakpoint_commands ())
10582 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10585 getpkt (&rs
->buf
, 0);
10587 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10593 case PACKET_UNKNOWN
:
10598 /* If this breakpoint has target-side commands but this stub doesn't
10599 support Z0 packets, throw error. */
10600 if (!bp_tgt
->tcommands
.empty ())
10601 throw_error (NOT_SUPPORTED_ERROR
, _("\
10602 Target doesn't support breakpoints that have target side commands."));
10604 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10608 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10609 struct bp_target_info
*bp_tgt
,
10610 enum remove_bp_reason reason
)
10612 CORE_ADDR addr
= bp_tgt
->placed_address
;
10613 struct remote_state
*rs
= get_remote_state ();
10615 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10617 char *p
= rs
->buf
.data ();
10618 char *endbuf
= p
+ get_remote_packet_size ();
10620 /* Make sure the remote is pointing at the right process, if
10622 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10623 set_general_process ();
10629 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10630 p
+= hexnumstr (p
, addr
);
10631 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10634 getpkt (&rs
->buf
, 0);
10636 return (rs
->buf
[0] == 'E');
10639 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10642 static enum Z_packet_type
10643 watchpoint_to_Z_packet (int type
)
10648 return Z_PACKET_WRITE_WP
;
10651 return Z_PACKET_READ_WP
;
10654 return Z_PACKET_ACCESS_WP
;
10657 internal_error (__FILE__
, __LINE__
,
10658 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10663 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10664 enum target_hw_bp_type type
, struct expression
*cond
)
10666 struct remote_state
*rs
= get_remote_state ();
10667 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10669 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10671 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10674 /* Make sure the remote is pointing at the right process, if
10676 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10677 set_general_process ();
10679 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10680 p
= strchr (rs
->buf
.data (), '\0');
10681 addr
= remote_address_masked (addr
);
10682 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10683 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10686 getpkt (&rs
->buf
, 0);
10688 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10692 case PACKET_UNKNOWN
:
10697 internal_error (__FILE__
, __LINE__
,
10698 _("remote_insert_watchpoint: reached end of function"));
10702 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10703 CORE_ADDR start
, int length
)
10705 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10707 return diff
< length
;
10712 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10713 enum target_hw_bp_type type
, struct expression
*cond
)
10715 struct remote_state
*rs
= get_remote_state ();
10716 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10718 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10720 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10723 /* Make sure the remote is pointing at the right process, if
10725 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10726 set_general_process ();
10728 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10729 p
= strchr (rs
->buf
.data (), '\0');
10730 addr
= remote_address_masked (addr
);
10731 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10732 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10734 getpkt (&rs
->buf
, 0);
10736 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10739 case PACKET_UNKNOWN
:
10744 internal_error (__FILE__
, __LINE__
,
10745 _("remote_remove_watchpoint: reached end of function"));
10749 static int remote_hw_watchpoint_limit
= -1;
10750 static int remote_hw_watchpoint_length_limit
= -1;
10751 static int remote_hw_breakpoint_limit
= -1;
10754 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10756 if (remote_hw_watchpoint_length_limit
== 0)
10758 else if (remote_hw_watchpoint_length_limit
< 0)
10760 else if (len
<= remote_hw_watchpoint_length_limit
)
10767 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10769 if (type
== bp_hardware_breakpoint
)
10771 if (remote_hw_breakpoint_limit
== 0)
10773 else if (remote_hw_breakpoint_limit
< 0)
10775 else if (cnt
<= remote_hw_breakpoint_limit
)
10780 if (remote_hw_watchpoint_limit
== 0)
10782 else if (remote_hw_watchpoint_limit
< 0)
10786 else if (cnt
<= remote_hw_watchpoint_limit
)
10792 /* The to_stopped_by_sw_breakpoint method of target remote. */
10795 remote_target::stopped_by_sw_breakpoint ()
10797 struct thread_info
*thread
= inferior_thread ();
10799 return (thread
->priv
!= NULL
10800 && (get_remote_thread_info (thread
)->stop_reason
10801 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10804 /* The to_supports_stopped_by_sw_breakpoint method of target
10808 remote_target::supports_stopped_by_sw_breakpoint ()
10810 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10813 /* The to_stopped_by_hw_breakpoint method of target remote. */
10816 remote_target::stopped_by_hw_breakpoint ()
10818 struct thread_info
*thread
= inferior_thread ();
10820 return (thread
->priv
!= NULL
10821 && (get_remote_thread_info (thread
)->stop_reason
10822 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10825 /* The to_supports_stopped_by_hw_breakpoint method of target
10829 remote_target::supports_stopped_by_hw_breakpoint ()
10831 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10835 remote_target::stopped_by_watchpoint ()
10837 struct thread_info
*thread
= inferior_thread ();
10839 return (thread
->priv
!= NULL
10840 && (get_remote_thread_info (thread
)->stop_reason
10841 == TARGET_STOPPED_BY_WATCHPOINT
));
10845 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10847 struct thread_info
*thread
= inferior_thread ();
10849 if (thread
->priv
!= NULL
10850 && (get_remote_thread_info (thread
)->stop_reason
10851 == TARGET_STOPPED_BY_WATCHPOINT
))
10853 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10862 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10863 struct bp_target_info
*bp_tgt
)
10865 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10866 struct remote_state
*rs
;
10870 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10873 /* Make sure the remote is pointing at the right process, if
10875 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10876 set_general_process ();
10878 rs
= get_remote_state ();
10879 p
= rs
->buf
.data ();
10880 endbuf
= p
+ get_remote_packet_size ();
10886 addr
= remote_address_masked (addr
);
10887 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10888 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10890 if (supports_evaluation_of_breakpoint_conditions ())
10891 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10893 if (can_run_breakpoint_commands ())
10894 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10897 getpkt (&rs
->buf
, 0);
10899 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10902 if (rs
->buf
[1] == '.')
10904 message
= strchr (&rs
->buf
[2], '.');
10906 error (_("Remote failure reply: %s"), message
+ 1);
10909 case PACKET_UNKNOWN
:
10914 internal_error (__FILE__
, __LINE__
,
10915 _("remote_insert_hw_breakpoint: reached end of function"));
10920 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10921 struct bp_target_info
*bp_tgt
)
10924 struct remote_state
*rs
= get_remote_state ();
10925 char *p
= rs
->buf
.data ();
10926 char *endbuf
= p
+ get_remote_packet_size ();
10928 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10931 /* Make sure the remote is pointing at the right process, if
10933 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10934 set_general_process ();
10940 addr
= remote_address_masked (bp_tgt
->placed_address
);
10941 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10942 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10945 getpkt (&rs
->buf
, 0);
10947 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10950 case PACKET_UNKNOWN
:
10955 internal_error (__FILE__
, __LINE__
,
10956 _("remote_remove_hw_breakpoint: reached end of function"));
10959 /* Verify memory using the "qCRC:" request. */
10962 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10964 struct remote_state
*rs
= get_remote_state ();
10965 unsigned long host_crc
, target_crc
;
10968 /* It doesn't make sense to use qCRC if the remote target is
10969 connected but not running. */
10970 if (target_has_execution ()
10971 && packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10973 enum packet_result result
;
10975 /* Make sure the remote is pointing at the right process. */
10976 set_general_process ();
10978 /* FIXME: assumes lma can fit into long. */
10979 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10980 (long) lma
, (long) size
);
10983 /* Be clever; compute the host_crc before waiting for target
10985 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10987 getpkt (&rs
->buf
, 0);
10989 result
= packet_ok (rs
->buf
,
10990 &remote_protocol_packets
[PACKET_qCRC
]);
10991 if (result
== PACKET_ERROR
)
10993 else if (result
== PACKET_OK
)
10995 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10996 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10998 return (host_crc
== target_crc
);
11002 return simple_verify_memory (this, data
, lma
, size
);
11005 /* compare-sections command
11007 With no arguments, compares each loadable section in the exec bfd
11008 with the same memory range on the target, and reports mismatches.
11009 Useful for verifying the image on the target against the exec file. */
11012 compare_sections_command (const char *args
, int from_tty
)
11015 const char *sectname
;
11016 bfd_size_type size
;
11019 int mismatched
= 0;
11023 if (!current_program_space
->exec_bfd ())
11024 error (_("command cannot be used without an exec file"));
11026 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
11032 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
11034 if (!(s
->flags
& SEC_LOAD
))
11035 continue; /* Skip non-loadable section. */
11037 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
11038 continue; /* Skip writeable sections */
11040 size
= bfd_section_size (s
);
11042 continue; /* Skip zero-length section. */
11044 sectname
= bfd_section_name (s
);
11045 if (args
&& strcmp (args
, sectname
) != 0)
11046 continue; /* Not the section selected by user. */
11048 matched
= 1; /* Do this section. */
11051 gdb::byte_vector
sectdata (size
);
11052 bfd_get_section_contents (current_program_space
->exec_bfd (), s
,
11053 sectdata
.data (), 0, size
);
11055 res
= target_verify_memory (sectdata
.data (), lma
, size
);
11058 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
11059 paddress (target_gdbarch (), lma
),
11060 paddress (target_gdbarch (), lma
+ size
));
11062 gdb_printf ("Section %s, range %s -- %s: ", sectname
,
11063 paddress (target_gdbarch (), lma
),
11064 paddress (target_gdbarch (), lma
+ size
));
11066 gdb_printf ("matched.\n");
11069 gdb_printf ("MIS-MATCHED!\n");
11073 if (mismatched
> 0)
11074 warning (_("One or more sections of the target image does not match\n\
11075 the loaded file\n"));
11076 if (args
&& !matched
)
11077 gdb_printf (_("No loaded section named '%s'.\n"), args
);
11080 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
11081 into remote target. The number of bytes written to the remote
11082 target is returned, or -1 for error. */
11085 remote_target::remote_write_qxfer (const char *object_name
,
11086 const char *annex
, const gdb_byte
*writebuf
,
11087 ULONGEST offset
, LONGEST len
,
11088 ULONGEST
*xfered_len
,
11089 struct packet_config
*packet
)
11093 struct remote_state
*rs
= get_remote_state ();
11094 int max_size
= get_memory_write_packet_size ();
11096 if (packet_config_support (packet
) == PACKET_DISABLE
)
11097 return TARGET_XFER_E_IO
;
11099 /* Insert header. */
11100 i
= snprintf (rs
->buf
.data (), max_size
,
11101 "qXfer:%s:write:%s:%s:",
11102 object_name
, annex
? annex
: "",
11103 phex_nz (offset
, sizeof offset
));
11104 max_size
-= (i
+ 1);
11106 /* Escape as much data as fits into rs->buf. */
11107 buf_len
= remote_escape_output
11108 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
11110 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
11111 || getpkt_sane (&rs
->buf
, 0) < 0
11112 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11113 return TARGET_XFER_E_IO
;
11115 unpack_varlen_hex (rs
->buf
.data (), &n
);
11118 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11121 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
11122 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
11123 number of bytes read is returned, or 0 for EOF, or -1 for error.
11124 The number of bytes read may be less than LEN without indicating an
11125 EOF. PACKET is checked and updated to indicate whether the remote
11126 target supports this object. */
11129 remote_target::remote_read_qxfer (const char *object_name
,
11131 gdb_byte
*readbuf
, ULONGEST offset
,
11133 ULONGEST
*xfered_len
,
11134 struct packet_config
*packet
)
11136 struct remote_state
*rs
= get_remote_state ();
11137 LONGEST i
, n
, packet_len
;
11139 if (packet_config_support (packet
) == PACKET_DISABLE
)
11140 return TARGET_XFER_E_IO
;
11142 /* Check whether we've cached an end-of-object packet that matches
11144 if (rs
->finished_object
)
11146 if (strcmp (object_name
, rs
->finished_object
) == 0
11147 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
11148 && offset
== rs
->finished_offset
)
11149 return TARGET_XFER_EOF
;
11152 /* Otherwise, we're now reading something different. Discard
11154 xfree (rs
->finished_object
);
11155 xfree (rs
->finished_annex
);
11156 rs
->finished_object
= NULL
;
11157 rs
->finished_annex
= NULL
;
11160 /* Request only enough to fit in a single packet. The actual data
11161 may not, since we don't know how much of it will need to be escaped;
11162 the target is free to respond with slightly less data. We subtract
11163 five to account for the response type and the protocol frame. */
11164 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
11165 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
11166 "qXfer:%s:read:%s:%s,%s",
11167 object_name
, annex
? annex
: "",
11168 phex_nz (offset
, sizeof offset
),
11169 phex_nz (n
, sizeof n
));
11170 i
= putpkt (rs
->buf
);
11172 return TARGET_XFER_E_IO
;
11175 packet_len
= getpkt_sane (&rs
->buf
, 0);
11176 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11177 return TARGET_XFER_E_IO
;
11179 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
11180 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
11182 /* 'm' means there is (or at least might be) more data after this
11183 batch. That does not make sense unless there's at least one byte
11184 of data in this reply. */
11185 if (rs
->buf
[0] == 'm' && packet_len
== 1)
11186 error (_("Remote qXfer reply contained no data."));
11188 /* Got some data. */
11189 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
11190 packet_len
- 1, readbuf
, n
);
11192 /* 'l' is an EOF marker, possibly including a final block of data,
11193 or possibly empty. If we have the final block of a non-empty
11194 object, record this fact to bypass a subsequent partial read. */
11195 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
11197 rs
->finished_object
= xstrdup (object_name
);
11198 rs
->finished_annex
= xstrdup (annex
? annex
: "");
11199 rs
->finished_offset
= offset
+ i
;
11203 return TARGET_XFER_EOF
;
11207 return TARGET_XFER_OK
;
11211 enum target_xfer_status
11212 remote_target::xfer_partial (enum target_object object
,
11213 const char *annex
, gdb_byte
*readbuf
,
11214 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
11215 ULONGEST
*xfered_len
)
11217 struct remote_state
*rs
;
11221 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
11223 set_remote_traceframe ();
11224 set_general_thread (inferior_ptid
);
11226 rs
= get_remote_state ();
11228 /* Handle memory using the standard memory routines. */
11229 if (object
== TARGET_OBJECT_MEMORY
)
11231 /* If the remote target is connected but not running, we should
11232 pass this request down to a lower stratum (e.g. the executable
11234 if (!target_has_execution ())
11235 return TARGET_XFER_EOF
;
11237 if (writebuf
!= NULL
)
11238 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
11241 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
11245 /* Handle extra signal info using qxfer packets. */
11246 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
11249 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
11250 xfered_len
, &remote_protocol_packets
11251 [PACKET_qXfer_siginfo_read
]);
11253 return remote_write_qxfer ("siginfo", annex
,
11254 writebuf
, offset
, len
, xfered_len
,
11255 &remote_protocol_packets
11256 [PACKET_qXfer_siginfo_write
]);
11259 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
11262 return remote_read_qxfer ("statictrace", annex
,
11263 readbuf
, offset
, len
, xfered_len
,
11264 &remote_protocol_packets
11265 [PACKET_qXfer_statictrace_read
]);
11267 return TARGET_XFER_E_IO
;
11270 /* Only handle flash writes. */
11271 if (writebuf
!= NULL
)
11275 case TARGET_OBJECT_FLASH
:
11276 return remote_flash_write (offset
, len
, xfered_len
,
11280 return TARGET_XFER_E_IO
;
11284 /* Map pre-existing objects onto letters. DO NOT do this for new
11285 objects!!! Instead specify new query packets. */
11288 case TARGET_OBJECT_AVR
:
11292 case TARGET_OBJECT_AUXV
:
11293 gdb_assert (annex
== NULL
);
11294 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
11296 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
11298 case TARGET_OBJECT_AVAILABLE_FEATURES
:
11299 return remote_read_qxfer
11300 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
11301 &remote_protocol_packets
[PACKET_qXfer_features
]);
11303 case TARGET_OBJECT_LIBRARIES
:
11304 return remote_read_qxfer
11305 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
11306 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
11308 case TARGET_OBJECT_LIBRARIES_SVR4
:
11309 return remote_read_qxfer
11310 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
11311 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
11313 case TARGET_OBJECT_MEMORY_MAP
:
11314 gdb_assert (annex
== NULL
);
11315 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
11317 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
11319 case TARGET_OBJECT_OSDATA
:
11320 /* Should only get here if we're connected. */
11321 gdb_assert (rs
->remote_desc
);
11322 return remote_read_qxfer
11323 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
11324 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
11326 case TARGET_OBJECT_THREADS
:
11327 gdb_assert (annex
== NULL
);
11328 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
11330 &remote_protocol_packets
[PACKET_qXfer_threads
]);
11332 case TARGET_OBJECT_TRACEFRAME_INFO
:
11333 gdb_assert (annex
== NULL
);
11334 return remote_read_qxfer
11335 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
11336 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
11338 case TARGET_OBJECT_FDPIC
:
11339 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
11341 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
11343 case TARGET_OBJECT_OPENVMS_UIB
:
11344 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
11346 &remote_protocol_packets
[PACKET_qXfer_uib
]);
11348 case TARGET_OBJECT_BTRACE
:
11349 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
11351 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
11353 case TARGET_OBJECT_BTRACE_CONF
:
11354 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
11356 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
11358 case TARGET_OBJECT_EXEC_FILE
:
11359 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
11361 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
11364 return TARGET_XFER_E_IO
;
11367 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
11368 large enough let the caller deal with it. */
11369 if (len
< get_remote_packet_size ())
11370 return TARGET_XFER_E_IO
;
11371 len
= get_remote_packet_size ();
11373 /* Except for querying the minimum buffer size, target must be open. */
11374 if (!rs
->remote_desc
)
11375 error (_("remote query is only available after target open"));
11377 gdb_assert (annex
!= NULL
);
11378 gdb_assert (readbuf
!= NULL
);
11380 p2
= rs
->buf
.data ();
11382 *p2
++ = query_type
;
11384 /* We used one buffer char for the remote protocol q command and
11385 another for the query type. As the remote protocol encapsulation
11386 uses 4 chars plus one extra in case we are debugging
11387 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11390 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11392 /* Bad caller may have sent forbidden characters. */
11393 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11398 gdb_assert (annex
[i
] == '\0');
11400 i
= putpkt (rs
->buf
);
11402 return TARGET_XFER_E_IO
;
11404 getpkt (&rs
->buf
, 0);
11405 strcpy ((char *) readbuf
, rs
->buf
.data ());
11407 *xfered_len
= strlen ((char *) readbuf
);
11408 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11411 /* Implementation of to_get_memory_xfer_limit. */
11414 remote_target::get_memory_xfer_limit ()
11416 return get_memory_write_packet_size ();
11420 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11421 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11422 CORE_ADDR
*found_addrp
)
11424 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11425 struct remote_state
*rs
= get_remote_state ();
11426 int max_size
= get_memory_write_packet_size ();
11427 struct packet_config
*packet
=
11428 &remote_protocol_packets
[PACKET_qSearch_memory
];
11429 /* Number of packet bytes used to encode the pattern;
11430 this could be more than PATTERN_LEN due to escape characters. */
11431 int escaped_pattern_len
;
11432 /* Amount of pattern that was encodable in the packet. */
11433 int used_pattern_len
;
11436 ULONGEST found_addr
;
11438 auto read_memory
= [=] (CORE_ADDR addr
, gdb_byte
*result
, size_t len
)
11440 return (target_read (this, TARGET_OBJECT_MEMORY
, NULL
, result
, addr
, len
)
11444 /* Don't go to the target if we don't have to. This is done before
11445 checking packet_config_support to avoid the possibility that a
11446 success for this edge case means the facility works in
11448 if (pattern_len
> search_space_len
)
11450 if (pattern_len
== 0)
11452 *found_addrp
= start_addr
;
11456 /* If we already know the packet isn't supported, fall back to the simple
11457 way of searching memory. */
11459 if (packet_config_support (packet
) == PACKET_DISABLE
)
11461 /* Target doesn't provided special support, fall back and use the
11462 standard support (copy memory and do the search here). */
11463 return simple_search_memory (read_memory
, start_addr
, search_space_len
,
11464 pattern
, pattern_len
, found_addrp
);
11467 /* Make sure the remote is pointing at the right process. */
11468 set_general_process ();
11470 /* Insert header. */
11471 i
= snprintf (rs
->buf
.data (), max_size
,
11472 "qSearch:memory:%s;%s;",
11473 phex_nz (start_addr
, addr_size
),
11474 phex_nz (search_space_len
, sizeof (search_space_len
)));
11475 max_size
-= (i
+ 1);
11477 /* Escape as much data as fits into rs->buf. */
11478 escaped_pattern_len
=
11479 remote_escape_output (pattern
, pattern_len
, 1,
11480 (gdb_byte
*) rs
->buf
.data () + i
,
11481 &used_pattern_len
, max_size
);
11483 /* Bail if the pattern is too large. */
11484 if (used_pattern_len
!= pattern_len
)
11485 error (_("Pattern is too large to transmit to remote target."));
11487 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11488 || getpkt_sane (&rs
->buf
, 0) < 0
11489 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11491 /* The request may not have worked because the command is not
11492 supported. If so, fall back to the simple way. */
11493 if (packet_config_support (packet
) == PACKET_DISABLE
)
11495 return simple_search_memory (read_memory
, start_addr
, search_space_len
,
11496 pattern
, pattern_len
, found_addrp
);
11501 if (rs
->buf
[0] == '0')
11503 else if (rs
->buf
[0] == '1')
11506 if (rs
->buf
[1] != ',')
11507 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11508 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11509 *found_addrp
= found_addr
;
11512 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11518 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11520 struct remote_state
*rs
= get_remote_state ();
11521 char *p
= rs
->buf
.data ();
11523 if (!rs
->remote_desc
)
11524 error (_("remote rcmd is only available after target open"));
11526 /* Send a NULL command across as an empty command. */
11527 if (command
== NULL
)
11530 /* The query prefix. */
11531 strcpy (rs
->buf
.data (), "qRcmd,");
11532 p
= strchr (rs
->buf
.data (), '\0');
11534 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11535 > get_remote_packet_size ())
11536 error (_("\"monitor\" command ``%s'' is too long."), command
);
11538 /* Encode the actual command. */
11539 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11541 if (putpkt (rs
->buf
) < 0)
11542 error (_("Communication problem with target."));
11544 /* get/display the response */
11549 /* XXX - see also remote_get_noisy_reply(). */
11550 QUIT
; /* Allow user to bail out with ^C. */
11552 if (getpkt_sane (&rs
->buf
, 0) == -1)
11554 /* Timeout. Continue to (try to) read responses.
11555 This is better than stopping with an error, assuming the stub
11556 is still executing the (long) monitor command.
11557 If needed, the user can interrupt gdb using C-c, obtaining
11558 an effect similar to stop on timeout. */
11561 buf
= rs
->buf
.data ();
11562 if (buf
[0] == '\0')
11563 error (_("Target does not support this command."));
11564 if (buf
[0] == 'O' && buf
[1] != 'K')
11566 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11569 if (strcmp (buf
, "OK") == 0)
11571 if (strlen (buf
) == 3 && buf
[0] == 'E'
11572 && isxdigit (buf
[1]) && isxdigit (buf
[2]))
11574 error (_("Protocol error with Rcmd"));
11576 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11578 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11580 gdb_putc (c
, outbuf
);
11586 std::vector
<mem_region
>
11587 remote_target::memory_map ()
11589 std::vector
<mem_region
> result
;
11590 gdb::optional
<gdb::char_vector
> text
11591 = target_read_stralloc (current_inferior ()->top_target (),
11592 TARGET_OBJECT_MEMORY_MAP
, NULL
);
11595 result
= parse_memory_map (text
->data ());
11600 /* Set of callbacks used to implement the 'maint packet' command. */
11602 struct cli_packet_command_callbacks
: public send_remote_packet_callbacks
11604 /* Called before the packet is sent. BUF is the packet content before
11605 the protocol specific prefix, suffix, and escaping is added. */
11607 void sending (gdb::array_view
<const char> &buf
) override
11609 gdb_puts ("sending: ");
11610 print_packet (buf
);
11614 /* Called with BUF, the reply from the remote target. */
11616 void received (gdb::array_view
<const char> &buf
) override
11618 gdb_puts ("received: \"");
11619 print_packet (buf
);
11625 /* Print BUF o gdb_stdout. Any non-printable bytes in BUF are printed as
11626 '\x??' with '??' replaced by the hexadecimal value of the byte. */
11629 print_packet (gdb::array_view
<const char> &buf
)
11633 for (int i
= 0; i
< buf
.size (); ++i
)
11635 gdb_byte c
= buf
[i
];
11637 gdb_putc (c
, &stb
);
11639 gdb_printf (&stb
, "\\x%02x", (unsigned char) c
);
11642 gdb_puts (stb
.string ().c_str ());
11646 /* See remote.h. */
11649 send_remote_packet (gdb::array_view
<const char> &buf
,
11650 send_remote_packet_callbacks
*callbacks
)
11652 if (buf
.size () == 0 || buf
.data ()[0] == '\0')
11653 error (_("a remote packet must not be empty"));
11655 remote_target
*remote
= get_current_remote_target ();
11656 if (remote
== nullptr)
11657 error (_("packets can only be sent to a remote target"));
11659 callbacks
->sending (buf
);
11661 remote
->putpkt_binary (buf
.data (), buf
.size ());
11662 remote_state
*rs
= remote
->get_remote_state ();
11663 int bytes
= remote
->getpkt_sane (&rs
->buf
, 0);
11666 error (_("error while fetching packet from remote target"));
11668 gdb::array_view
<const char> view (&rs
->buf
[0], bytes
);
11669 callbacks
->received (view
);
11672 /* Entry point for the 'maint packet' command. */
11675 cli_packet_command (const char *args
, int from_tty
)
11677 cli_packet_command_callbacks cb
;
11678 gdb::array_view
<const char> view
11679 = gdb::make_array_view (args
, args
== nullptr ? 0 : strlen (args
));
11680 send_remote_packet (view
, &cb
);
11684 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11686 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11688 static void threadset_test_cmd (char *cmd
, int tty
);
11690 static void threadalive_test (char *cmd
, int tty
);
11692 static void threadlist_test_cmd (char *cmd
, int tty
);
11694 int get_and_display_threadinfo (threadref
*ref
);
11696 static void threadinfo_test_cmd (char *cmd
, int tty
);
11698 static int thread_display_step (threadref
*ref
, void *context
);
11700 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11702 static void init_remote_threadtests (void);
11704 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11707 threadset_test_cmd (const char *cmd
, int tty
)
11709 int sample_thread
= SAMPLE_THREAD
;
11711 gdb_printf (_("Remote threadset test\n"));
11712 set_general_thread (sample_thread
);
11717 threadalive_test (const char *cmd
, int tty
)
11719 int sample_thread
= SAMPLE_THREAD
;
11720 int pid
= inferior_ptid
.pid ();
11721 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11723 if (remote_thread_alive (ptid
))
11724 gdb_printf ("PASS: Thread alive test\n");
11726 gdb_printf ("FAIL: Thread alive test\n");
11729 void output_threadid (char *title
, threadref
*ref
);
11732 output_threadid (char *title
, threadref
*ref
)
11736 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11738 gdb_printf ("%s %s\n", title
, (&hexid
[0]));
11742 threadlist_test_cmd (const char *cmd
, int tty
)
11745 threadref nextthread
;
11746 int done
, result_count
;
11747 threadref threadlist
[3];
11749 gdb_printf ("Remote Threadlist test\n");
11750 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11751 &result_count
, &threadlist
[0]))
11752 gdb_printf ("FAIL: threadlist test\n");
11755 threadref
*scan
= threadlist
;
11756 threadref
*limit
= scan
+ result_count
;
11758 while (scan
< limit
)
11759 output_threadid (" thread ", scan
++);
11764 display_thread_info (struct gdb_ext_thread_info
*info
)
11766 output_threadid ("Threadid: ", &info
->threadid
);
11767 gdb_printf ("Name: %s\n ", info
->shortname
);
11768 gdb_printf ("State: %s\n", info
->display
);
11769 gdb_printf ("other: %s\n\n", info
->more_display
);
11773 get_and_display_threadinfo (threadref
*ref
)
11777 struct gdb_ext_thread_info threadinfo
;
11779 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11780 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11781 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11782 display_thread_info (&threadinfo
);
11787 threadinfo_test_cmd (const char *cmd
, int tty
)
11789 int athread
= SAMPLE_THREAD
;
11793 int_to_threadref (&thread
, athread
);
11794 gdb_printf ("Remote Threadinfo test\n");
11795 if (!get_and_display_threadinfo (&thread
))
11796 gdb_printf ("FAIL cannot get thread info\n");
11800 thread_display_step (threadref
*ref
, void *context
)
11802 /* output_threadid(" threadstep ",ref); *//* simple test */
11803 return get_and_display_threadinfo (ref
);
11807 threadlist_update_test_cmd (const char *cmd
, int tty
)
11809 gdb_printf ("Remote Threadlist update test\n");
11810 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11814 init_remote_threadtests (void)
11816 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11817 _("Fetch and print the remote list of "
11818 "thread identifiers, one pkt only."));
11819 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11820 _("Fetch and display info about one thread."));
11821 add_com ("tset", class_obscure
, threadset_test_cmd
,
11822 _("Test setting to a different thread."));
11823 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11824 _("Iterate through updating all remote thread info."));
11825 add_com ("talive", class_obscure
, threadalive_test
,
11826 _("Remote thread alive test."));
11831 /* Convert a thread ID to a string. */
11834 remote_target::pid_to_str (ptid_t ptid
)
11836 struct remote_state
*rs
= get_remote_state ();
11838 if (ptid
== null_ptid
)
11839 return normal_pid_to_str (ptid
);
11840 else if (ptid
.is_pid ())
11842 /* Printing an inferior target id. */
11844 /* When multi-process extensions are off, there's no way in the
11845 remote protocol to know the remote process id, if there's any
11846 at all. There's one exception --- when we're connected with
11847 target extended-remote, and we manually attached to a process
11848 with "attach PID". We don't record anywhere a flag that
11849 allows us to distinguish that case from the case of
11850 connecting with extended-remote and the stub already being
11851 attached to a process, and reporting yes to qAttached, hence
11852 no smart special casing here. */
11853 if (!remote_multi_process_p (rs
))
11854 return "Remote target";
11856 return normal_pid_to_str (ptid
);
11860 if (magic_null_ptid
== ptid
)
11861 return "Thread <main>";
11862 else if (remote_multi_process_p (rs
))
11863 if (ptid
.lwp () == 0)
11864 return normal_pid_to_str (ptid
);
11866 return string_printf ("Thread %d.%ld",
11867 ptid
.pid (), ptid
.lwp ());
11869 return string_printf ("Thread %ld", ptid
.lwp ());
11873 /* Get the address of the thread local variable in OBJFILE which is
11874 stored at OFFSET within the thread local storage for thread PTID. */
11877 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11880 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11882 struct remote_state
*rs
= get_remote_state ();
11883 char *p
= rs
->buf
.data ();
11884 char *endp
= p
+ get_remote_packet_size ();
11885 enum packet_result result
;
11887 strcpy (p
, "qGetTLSAddr:");
11889 p
= write_ptid (p
, endp
, ptid
);
11891 p
+= hexnumstr (p
, offset
);
11893 p
+= hexnumstr (p
, lm
);
11897 getpkt (&rs
->buf
, 0);
11898 result
= packet_ok (rs
->buf
,
11899 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11900 if (result
== PACKET_OK
)
11904 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11907 else if (result
== PACKET_UNKNOWN
)
11908 throw_error (TLS_GENERIC_ERROR
,
11909 _("Remote target doesn't support qGetTLSAddr packet"));
11911 throw_error (TLS_GENERIC_ERROR
,
11912 _("Remote target failed to process qGetTLSAddr request"));
11915 throw_error (TLS_GENERIC_ERROR
,
11916 _("TLS not supported or disabled on this target"));
11921 /* Provide thread local base, i.e. Thread Information Block address.
11922 Returns 1 if ptid is found and thread_local_base is non zero. */
11925 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11927 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11929 struct remote_state
*rs
= get_remote_state ();
11930 char *p
= rs
->buf
.data ();
11931 char *endp
= p
+ get_remote_packet_size ();
11932 enum packet_result result
;
11934 strcpy (p
, "qGetTIBAddr:");
11936 p
= write_ptid (p
, endp
, ptid
);
11940 getpkt (&rs
->buf
, 0);
11941 result
= packet_ok (rs
->buf
,
11942 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11943 if (result
== PACKET_OK
)
11946 unpack_varlen_hex (rs
->buf
.data (), &val
);
11948 *addr
= (CORE_ADDR
) val
;
11951 else if (result
== PACKET_UNKNOWN
)
11952 error (_("Remote target doesn't support qGetTIBAddr packet"));
11954 error (_("Remote target failed to process qGetTIBAddr request"));
11957 error (_("qGetTIBAddr not supported or disabled on this target"));
11962 /* Support for inferring a target description based on the current
11963 architecture and the size of a 'g' packet. While the 'g' packet
11964 can have any size (since optional registers can be left off the
11965 end), some sizes are easily recognizable given knowledge of the
11966 approximate architecture. */
11968 struct remote_g_packet_guess
11970 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11977 const struct target_desc
*tdesc
;
11980 struct remote_g_packet_data
: public allocate_on_obstack
11982 std::vector
<remote_g_packet_guess
> guesses
;
11985 static struct gdbarch_data
*remote_g_packet_data_handle
;
11988 remote_g_packet_data_init (struct obstack
*obstack
)
11990 return new (obstack
) remote_g_packet_data
;
11994 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11995 const struct target_desc
*tdesc
)
11997 struct remote_g_packet_data
*data
11998 = ((struct remote_g_packet_data
*)
11999 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
12001 gdb_assert (tdesc
!= NULL
);
12003 for (const remote_g_packet_guess
&guess
: data
->guesses
)
12004 if (guess
.bytes
== bytes
)
12005 internal_error (__FILE__
, __LINE__
,
12006 _("Duplicate g packet description added for size %d"),
12009 data
->guesses
.emplace_back (bytes
, tdesc
);
12012 /* Return true if remote_read_description would do anything on this target
12013 and architecture, false otherwise. */
12016 remote_read_description_p (struct target_ops
*target
)
12018 struct remote_g_packet_data
*data
12019 = ((struct remote_g_packet_data
*)
12020 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
12022 return !data
->guesses
.empty ();
12025 const struct target_desc
*
12026 remote_target::read_description ()
12028 struct remote_g_packet_data
*data
12029 = ((struct remote_g_packet_data
*)
12030 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
12032 /* Do not try this during initial connection, when we do not know
12033 whether there is a running but stopped thread. */
12034 if (!target_has_execution () || inferior_ptid
== null_ptid
)
12035 return beneath ()->read_description ();
12037 if (!data
->guesses
.empty ())
12039 int bytes
= send_g_packet ();
12041 for (const remote_g_packet_guess
&guess
: data
->guesses
)
12042 if (guess
.bytes
== bytes
)
12043 return guess
.tdesc
;
12045 /* We discard the g packet. A minor optimization would be to
12046 hold on to it, and fill the register cache once we have selected
12047 an architecture, but it's too tricky to do safely. */
12050 return beneath ()->read_description ();
12053 /* Remote file transfer support. This is host-initiated I/O, not
12054 target-initiated; for target-initiated, see remote-fileio.c. */
12056 /* If *LEFT is at least the length of STRING, copy STRING to
12057 *BUFFER, update *BUFFER to point to the new end of the buffer, and
12058 decrease *LEFT. Otherwise raise an error. */
12061 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
12063 int len
= strlen (string
);
12066 error (_("Packet too long for target."));
12068 memcpy (*buffer
, string
, len
);
12072 /* NUL-terminate the buffer as a convenience, if there is
12078 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
12079 *BUFFER, update *BUFFER to point to the new end of the buffer, and
12080 decrease *LEFT. Otherwise raise an error. */
12083 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
12086 if (2 * len
> *left
)
12087 error (_("Packet too long for target."));
12089 bin2hex (bytes
, *buffer
, len
);
12090 *buffer
+= 2 * len
;
12093 /* NUL-terminate the buffer as a convenience, if there is
12099 /* If *LEFT is large enough, convert VALUE to hex and add it to
12100 *BUFFER, update *BUFFER to point to the new end of the buffer, and
12101 decrease *LEFT. Otherwise raise an error. */
12104 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
12106 int len
= hexnumlen (value
);
12109 error (_("Packet too long for target."));
12111 hexnumstr (*buffer
, value
);
12115 /* NUL-terminate the buffer as a convenience, if there is
12121 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
12122 value, *REMOTE_ERRNO to the remote error number or zero if none
12123 was included, and *ATTACHMENT to point to the start of the annex
12124 if any. The length of the packet isn't needed here; there may
12125 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
12127 Return 0 if the packet could be parsed, -1 if it could not. If
12128 -1 is returned, the other variables may not be initialized. */
12131 remote_hostio_parse_result (const char *buffer
, int *retcode
,
12132 int *remote_errno
, const char **attachment
)
12137 *attachment
= NULL
;
12139 if (buffer
[0] != 'F')
12143 *retcode
= strtol (&buffer
[1], &p
, 16);
12144 if (errno
!= 0 || p
== &buffer
[1])
12147 /* Check for ",errno". */
12151 *remote_errno
= strtol (p
+ 1, &p2
, 16);
12152 if (errno
!= 0 || p
+ 1 == p2
)
12157 /* Check for ";attachment". If there is no attachment, the
12158 packet should end here. */
12161 *attachment
= p
+ 1;
12164 else if (*p
== '\0')
12170 /* Send a prepared I/O packet to the target and read its response.
12171 The prepared packet is in the global RS->BUF before this function
12172 is called, and the answer is there when we return.
12174 COMMAND_BYTES is the length of the request to send, which may include
12175 binary data. WHICH_PACKET is the packet configuration to check
12176 before attempting a packet. If an error occurs, *REMOTE_ERRNO
12177 is set to the error number and -1 is returned. Otherwise the value
12178 returned by the function is returned.
12180 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
12181 attachment is expected; an error will be reported if there's a
12182 mismatch. If one is found, *ATTACHMENT will be set to point into
12183 the packet buffer and *ATTACHMENT_LEN will be set to the
12184 attachment's length. */
12187 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
12188 int *remote_errno
, const char **attachment
,
12189 int *attachment_len
)
12191 struct remote_state
*rs
= get_remote_state ();
12192 int ret
, bytes_read
;
12193 const char *attachment_tmp
;
12195 if (packet_support (which_packet
) == PACKET_DISABLE
)
12197 *remote_errno
= FILEIO_ENOSYS
;
12201 putpkt_binary (rs
->buf
.data (), command_bytes
);
12202 bytes_read
= getpkt_sane (&rs
->buf
, 0);
12204 /* If it timed out, something is wrong. Don't try to parse the
12206 if (bytes_read
< 0)
12208 *remote_errno
= FILEIO_EINVAL
;
12212 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
12215 *remote_errno
= FILEIO_EINVAL
;
12217 case PACKET_UNKNOWN
:
12218 *remote_errno
= FILEIO_ENOSYS
;
12224 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
12227 *remote_errno
= FILEIO_EINVAL
;
12231 /* Make sure we saw an attachment if and only if we expected one. */
12232 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
12233 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
12235 *remote_errno
= FILEIO_EINVAL
;
12239 /* If an attachment was found, it must point into the packet buffer;
12240 work out how many bytes there were. */
12241 if (attachment_tmp
!= NULL
)
12243 *attachment
= attachment_tmp
;
12244 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
12250 /* See declaration.h. */
12253 readahead_cache::invalidate ()
12258 /* See declaration.h. */
12261 readahead_cache::invalidate_fd (int fd
)
12263 if (this->fd
== fd
)
12267 /* Set the filesystem remote_hostio functions that take FILENAME
12268 arguments will use. Return 0 on success, or -1 if an error
12269 occurs (and set *REMOTE_ERRNO). */
12272 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
12275 struct remote_state
*rs
= get_remote_state ();
12276 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
12277 char *p
= rs
->buf
.data ();
12278 int left
= get_remote_packet_size () - 1;
12282 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
12285 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
12288 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
12290 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
12291 remote_buffer_add_string (&p
, &left
, arg
);
12293 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
12294 remote_errno
, NULL
, NULL
);
12296 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
12300 rs
->fs_pid
= required_pid
;
12305 /* Implementation of to_fileio_open. */
12308 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
12309 int flags
, int mode
, int warn_if_slow
,
12312 struct remote_state
*rs
= get_remote_state ();
12313 char *p
= rs
->buf
.data ();
12314 int left
= get_remote_packet_size () - 1;
12318 static int warning_issued
= 0;
12320 gdb_printf (_("Reading %s from remote target...\n"),
12323 if (!warning_issued
)
12325 warning (_("File transfers from remote targets can be slow."
12326 " Use \"set sysroot\" to access files locally"
12328 warning_issued
= 1;
12332 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12335 remote_buffer_add_string (&p
, &left
, "vFile:open:");
12337 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12338 strlen (filename
));
12339 remote_buffer_add_string (&p
, &left
, ",");
12341 remote_buffer_add_int (&p
, &left
, flags
);
12342 remote_buffer_add_string (&p
, &left
, ",");
12344 remote_buffer_add_int (&p
, &left
, mode
);
12346 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
12347 remote_errno
, NULL
, NULL
);
12351 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
12352 int flags
, int mode
, int warn_if_slow
,
12355 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
12359 /* Implementation of to_fileio_pwrite. */
12362 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12363 ULONGEST offset
, int *remote_errno
)
12365 struct remote_state
*rs
= get_remote_state ();
12366 char *p
= rs
->buf
.data ();
12367 int left
= get_remote_packet_size ();
12370 rs
->readahead_cache
.invalidate_fd (fd
);
12372 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
12374 remote_buffer_add_int (&p
, &left
, fd
);
12375 remote_buffer_add_string (&p
, &left
, ",");
12377 remote_buffer_add_int (&p
, &left
, offset
);
12378 remote_buffer_add_string (&p
, &left
, ",");
12380 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
12381 (get_remote_packet_size ()
12382 - (p
- rs
->buf
.data ())));
12384 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
12385 remote_errno
, NULL
, NULL
);
12389 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12390 ULONGEST offset
, int *remote_errno
)
12392 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
12395 /* Helper for the implementation of to_fileio_pread. Read the file
12396 from the remote side with vFile:pread. */
12399 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
12400 ULONGEST offset
, int *remote_errno
)
12402 struct remote_state
*rs
= get_remote_state ();
12403 char *p
= rs
->buf
.data ();
12404 const char *attachment
;
12405 int left
= get_remote_packet_size ();
12406 int ret
, attachment_len
;
12409 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
12411 remote_buffer_add_int (&p
, &left
, fd
);
12412 remote_buffer_add_string (&p
, &left
, ",");
12414 remote_buffer_add_int (&p
, &left
, len
);
12415 remote_buffer_add_string (&p
, &left
, ",");
12417 remote_buffer_add_int (&p
, &left
, offset
);
12419 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
12420 remote_errno
, &attachment
,
12426 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12428 if (read_len
!= ret
)
12429 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
12434 /* See declaration.h. */
12437 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12441 && this->offset
<= offset
12442 && offset
< this->offset
+ this->bufsize
)
12444 ULONGEST max
= this->offset
+ this->bufsize
;
12446 if (offset
+ len
> max
)
12447 len
= max
- offset
;
12449 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12456 /* Implementation of to_fileio_pread. */
12459 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12460 ULONGEST offset
, int *remote_errno
)
12463 struct remote_state
*rs
= get_remote_state ();
12464 readahead_cache
*cache
= &rs
->readahead_cache
;
12466 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12469 cache
->hit_count
++;
12471 remote_debug_printf ("readahead cache hit %s",
12472 pulongest (cache
->hit_count
));
12476 cache
->miss_count
++;
12478 remote_debug_printf ("readahead cache miss %s",
12479 pulongest (cache
->miss_count
));
12482 cache
->offset
= offset
;
12483 cache
->bufsize
= get_remote_packet_size ();
12484 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12486 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12487 cache
->offset
, remote_errno
);
12490 cache
->invalidate_fd (fd
);
12494 cache
->bufsize
= ret
;
12495 return cache
->pread (fd
, read_buf
, len
, offset
);
12499 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12500 ULONGEST offset
, int *remote_errno
)
12502 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12505 /* Implementation of to_fileio_close. */
12508 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12510 struct remote_state
*rs
= get_remote_state ();
12511 char *p
= rs
->buf
.data ();
12512 int left
= get_remote_packet_size () - 1;
12514 rs
->readahead_cache
.invalidate_fd (fd
);
12516 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12518 remote_buffer_add_int (&p
, &left
, fd
);
12520 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12521 remote_errno
, NULL
, NULL
);
12525 remote_target::fileio_close (int fd
, int *remote_errno
)
12527 return remote_hostio_close (fd
, remote_errno
);
12530 /* Implementation of to_fileio_unlink. */
12533 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12536 struct remote_state
*rs
= get_remote_state ();
12537 char *p
= rs
->buf
.data ();
12538 int left
= get_remote_packet_size () - 1;
12540 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12543 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12545 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12546 strlen (filename
));
12548 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12549 remote_errno
, NULL
, NULL
);
12553 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12556 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12559 /* Implementation of to_fileio_readlink. */
12561 gdb::optional
<std::string
>
12562 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12565 struct remote_state
*rs
= get_remote_state ();
12566 char *p
= rs
->buf
.data ();
12567 const char *attachment
;
12568 int left
= get_remote_packet_size ();
12569 int len
, attachment_len
;
12572 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12575 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12577 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12578 strlen (filename
));
12580 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12581 remote_errno
, &attachment
,
12587 std::string
ret (len
, '\0');
12589 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12590 (gdb_byte
*) &ret
[0], len
);
12591 if (read_len
!= len
)
12592 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12597 /* Implementation of to_fileio_fstat. */
12600 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12602 struct remote_state
*rs
= get_remote_state ();
12603 char *p
= rs
->buf
.data ();
12604 int left
= get_remote_packet_size ();
12605 int attachment_len
, ret
;
12606 const char *attachment
;
12607 struct fio_stat fst
;
12610 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12612 remote_buffer_add_int (&p
, &left
, fd
);
12614 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12615 remote_errno
, &attachment
,
12619 if (*remote_errno
!= FILEIO_ENOSYS
)
12622 /* Strictly we should return -1, ENOSYS here, but when
12623 "set sysroot remote:" was implemented in August 2008
12624 BFD's need for a stat function was sidestepped with
12625 this hack. This was not remedied until March 2015
12626 so we retain the previous behavior to avoid breaking
12629 Note that the memset is a March 2015 addition; older
12630 GDBs set st_size *and nothing else* so the structure
12631 would have garbage in all other fields. This might
12632 break something but retaining the previous behavior
12633 here would be just too wrong. */
12635 memset (st
, 0, sizeof (struct stat
));
12636 st
->st_size
= INT_MAX
;
12640 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12641 (gdb_byte
*) &fst
, sizeof (fst
));
12643 if (read_len
!= ret
)
12644 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12646 if (read_len
!= sizeof (fst
))
12647 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12648 read_len
, (int) sizeof (fst
));
12650 remote_fileio_to_host_stat (&fst
, st
);
12655 /* Implementation of to_filesystem_is_local. */
12658 remote_target::filesystem_is_local ()
12660 /* Valgrind GDB presents itself as a remote target but works
12661 on the local filesystem: it does not implement remote get
12662 and users are not expected to set a sysroot. To handle
12663 this case we treat the remote filesystem as local if the
12664 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12665 does not support vFile:open. */
12666 if (gdb_sysroot
== TARGET_SYSROOT_PREFIX
)
12668 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12670 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12672 int fd
, remote_errno
;
12674 /* Try opening a file to probe support. The supplied
12675 filename is irrelevant, we only care about whether
12676 the stub recognizes the packet or not. */
12677 fd
= remote_hostio_open (NULL
, "just probing",
12678 FILEIO_O_RDONLY
, 0700, 0,
12682 remote_hostio_close (fd
, &remote_errno
);
12684 ps
= packet_support (PACKET_vFile_open
);
12687 if (ps
== PACKET_DISABLE
)
12689 static int warning_issued
= 0;
12691 if (!warning_issued
)
12693 warning (_("remote target does not support file"
12694 " transfer, attempting to access files"
12695 " from local filesystem."));
12696 warning_issued
= 1;
12707 remote_fileio_errno_to_host (int errnum
)
12713 case FILEIO_ENOENT
:
12721 case FILEIO_EACCES
:
12723 case FILEIO_EFAULT
:
12727 case FILEIO_EEXIST
:
12729 case FILEIO_ENODEV
:
12731 case FILEIO_ENOTDIR
:
12733 case FILEIO_EISDIR
:
12735 case FILEIO_EINVAL
:
12737 case FILEIO_ENFILE
:
12739 case FILEIO_EMFILE
:
12743 case FILEIO_ENOSPC
:
12745 case FILEIO_ESPIPE
:
12749 case FILEIO_ENOSYS
:
12751 case FILEIO_ENAMETOOLONG
:
12752 return ENAMETOOLONG
;
12758 remote_hostio_error (int errnum
)
12760 int host_error
= remote_fileio_errno_to_host (errnum
);
12762 if (host_error
== -1)
12763 error (_("Unknown remote I/O error %d"), errnum
);
12765 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12768 /* A RAII wrapper around a remote file descriptor. */
12770 class scoped_remote_fd
12773 scoped_remote_fd (remote_target
*remote
, int fd
)
12774 : m_remote (remote
), m_fd (fd
)
12778 ~scoped_remote_fd ()
12785 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12789 /* Swallow exception before it escapes the dtor. If
12790 something goes wrong, likely the connection is gone,
12791 and there's nothing else that can be done. */
12796 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12798 /* Release ownership of the file descriptor, and return it. */
12799 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12806 /* Return the owned file descriptor. */
12807 int get () const noexcept
12813 /* The remote target. */
12814 remote_target
*m_remote
;
12816 /* The owned remote I/O file descriptor. */
12821 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12823 remote_target
*remote
= get_current_remote_target ();
12825 if (remote
== nullptr)
12826 error (_("command can only be used with remote target"));
12828 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12832 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12835 int retcode
, remote_errno
, bytes
, io_size
;
12836 int bytes_in_buffer
;
12840 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12842 perror_with_name (local_file
);
12844 scoped_remote_fd fd
12845 (this, remote_hostio_open (NULL
,
12846 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12848 0700, 0, &remote_errno
));
12849 if (fd
.get () == -1)
12850 remote_hostio_error (remote_errno
);
12852 /* Send up to this many bytes at once. They won't all fit in the
12853 remote packet limit, so we'll transfer slightly fewer. */
12854 io_size
= get_remote_packet_size ();
12855 gdb::byte_vector
buffer (io_size
);
12857 bytes_in_buffer
= 0;
12860 while (bytes_in_buffer
|| !saw_eof
)
12864 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12865 io_size
- bytes_in_buffer
,
12869 if (ferror (file
.get ()))
12870 error (_("Error reading %s."), local_file
);
12873 /* EOF. Unless there is something still in the
12874 buffer from the last iteration, we are done. */
12876 if (bytes_in_buffer
== 0)
12884 bytes
+= bytes_in_buffer
;
12885 bytes_in_buffer
= 0;
12887 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12888 offset
, &remote_errno
);
12891 remote_hostio_error (remote_errno
);
12892 else if (retcode
== 0)
12893 error (_("Remote write of %d bytes returned 0!"), bytes
);
12894 else if (retcode
< bytes
)
12896 /* Short write. Save the rest of the read data for the next
12898 bytes_in_buffer
= bytes
- retcode
;
12899 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12905 if (remote_hostio_close (fd
.release (), &remote_errno
))
12906 remote_hostio_error (remote_errno
);
12909 gdb_printf (_("Successfully sent file \"%s\".\n"), local_file
);
12913 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12915 remote_target
*remote
= get_current_remote_target ();
12917 if (remote
== nullptr)
12918 error (_("command can only be used with remote target"));
12920 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12924 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12927 int remote_errno
, bytes
, io_size
;
12930 scoped_remote_fd fd
12931 (this, remote_hostio_open (NULL
,
12932 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12934 if (fd
.get () == -1)
12935 remote_hostio_error (remote_errno
);
12937 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12939 perror_with_name (local_file
);
12941 /* Send up to this many bytes at once. They won't all fit in the
12942 remote packet limit, so we'll transfer slightly fewer. */
12943 io_size
= get_remote_packet_size ();
12944 gdb::byte_vector
buffer (io_size
);
12949 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12952 /* Success, but no bytes, means end-of-file. */
12955 remote_hostio_error (remote_errno
);
12959 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12961 perror_with_name (local_file
);
12964 if (remote_hostio_close (fd
.release (), &remote_errno
))
12965 remote_hostio_error (remote_errno
);
12968 gdb_printf (_("Successfully fetched file \"%s\".\n"), remote_file
);
12972 remote_file_delete (const char *remote_file
, int from_tty
)
12974 remote_target
*remote
= get_current_remote_target ();
12976 if (remote
== nullptr)
12977 error (_("command can only be used with remote target"));
12979 remote
->remote_file_delete (remote_file
, from_tty
);
12983 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12985 int retcode
, remote_errno
;
12987 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12989 remote_hostio_error (remote_errno
);
12992 gdb_printf (_("Successfully deleted file \"%s\".\n"), remote_file
);
12996 remote_put_command (const char *args
, int from_tty
)
12999 error_no_arg (_("file to put"));
13001 gdb_argv
argv (args
);
13002 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
13003 error (_("Invalid parameters to remote put"));
13005 remote_file_put (argv
[0], argv
[1], from_tty
);
13009 remote_get_command (const char *args
, int from_tty
)
13012 error_no_arg (_("file to get"));
13014 gdb_argv
argv (args
);
13015 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
13016 error (_("Invalid parameters to remote get"));
13018 remote_file_get (argv
[0], argv
[1], from_tty
);
13022 remote_delete_command (const char *args
, int from_tty
)
13025 error_no_arg (_("file to delete"));
13027 gdb_argv
argv (args
);
13028 if (argv
[0] == NULL
|| argv
[1] != NULL
)
13029 error (_("Invalid parameters to remote delete"));
13031 remote_file_delete (argv
[0], from_tty
);
13035 remote_target::can_execute_reverse ()
13037 if (packet_support (PACKET_bs
) == PACKET_ENABLE
13038 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
13045 remote_target::supports_non_stop ()
13051 remote_target::supports_disable_randomization ()
13053 /* Only supported in extended mode. */
13058 remote_target::supports_multi_process ()
13060 struct remote_state
*rs
= get_remote_state ();
13062 return remote_multi_process_p (rs
);
13066 remote_supports_cond_tracepoints ()
13068 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
13072 remote_target::supports_evaluation_of_breakpoint_conditions ()
13074 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
13078 remote_supports_fast_tracepoints ()
13080 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
13084 remote_supports_static_tracepoints ()
13086 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
13090 remote_supports_install_in_trace ()
13092 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
13096 remote_target::supports_enable_disable_tracepoint ()
13098 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
13103 remote_target::supports_string_tracing ()
13105 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
13109 remote_target::can_run_breakpoint_commands ()
13111 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
13115 remote_target::trace_init ()
13117 struct remote_state
*rs
= get_remote_state ();
13120 remote_get_noisy_reply ();
13121 if (strcmp (rs
->buf
.data (), "OK") != 0)
13122 error (_("Target does not support this command."));
13125 /* Recursive routine to walk through command list including loops, and
13126 download packets for each command. */
13129 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
13130 struct command_line
*cmds
)
13132 struct remote_state
*rs
= get_remote_state ();
13133 struct command_line
*cmd
;
13135 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
13137 QUIT
; /* Allow user to bail out with ^C. */
13138 strcpy (rs
->buf
.data (), "QTDPsrc:");
13139 encode_source_string (num
, addr
, "cmd", cmd
->line
,
13140 rs
->buf
.data () + strlen (rs
->buf
.data ()),
13141 rs
->buf
.size () - strlen (rs
->buf
.data ()));
13143 remote_get_noisy_reply ();
13144 if (strcmp (rs
->buf
.data (), "OK"))
13145 warning (_("Target does not support source download."));
13147 if (cmd
->control_type
== while_control
13148 || cmd
->control_type
== while_stepping_control
)
13150 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
13152 QUIT
; /* Allow user to bail out with ^C. */
13153 strcpy (rs
->buf
.data (), "QTDPsrc:");
13154 encode_source_string (num
, addr
, "cmd", "end",
13155 rs
->buf
.data () + strlen (rs
->buf
.data ()),
13156 rs
->buf
.size () - strlen (rs
->buf
.data ()));
13158 remote_get_noisy_reply ();
13159 if (strcmp (rs
->buf
.data (), "OK"))
13160 warning (_("Target does not support source download."));
13166 remote_target::download_tracepoint (struct bp_location
*loc
)
13170 std::vector
<std::string
> tdp_actions
;
13171 std::vector
<std::string
> stepping_actions
;
13173 struct breakpoint
*b
= loc
->owner
;
13174 struct tracepoint
*t
= (struct tracepoint
*) b
;
13175 struct remote_state
*rs
= get_remote_state ();
13177 const char *err_msg
= _("Tracepoint packet too large for target.");
13180 /* We use a buffer other than rs->buf because we'll build strings
13181 across multiple statements, and other statements in between could
13183 gdb::char_vector
buf (get_remote_packet_size ());
13185 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
13187 tpaddr
= loc
->address
;
13188 strcpy (addrbuf
, phex (tpaddr
, sizeof (CORE_ADDR
)));
13189 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
13190 b
->number
, addrbuf
, /* address */
13191 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
13192 t
->step_count
, t
->pass_count
);
13194 if (ret
< 0 || ret
>= buf
.size ())
13195 error ("%s", err_msg
);
13197 /* Fast tracepoints are mostly handled by the target, but we can
13198 tell the target how big of an instruction block should be moved
13200 if (b
->type
== bp_fast_tracepoint
)
13202 /* Only test for support at download time; we may not know
13203 target capabilities at definition time. */
13204 if (remote_supports_fast_tracepoints ())
13206 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
13209 size_left
= buf
.size () - strlen (buf
.data ());
13210 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13212 gdb_insn_length (loc
->gdbarch
, tpaddr
));
13214 if (ret
< 0 || ret
>= size_left
)
13215 error ("%s", err_msg
);
13218 /* If it passed validation at definition but fails now,
13219 something is very wrong. */
13220 internal_error (__FILE__
, __LINE__
,
13221 _("Fast tracepoint not "
13222 "valid during download"));
13225 /* Fast tracepoints are functionally identical to regular
13226 tracepoints, so don't take lack of support as a reason to
13227 give up on the trace run. */
13228 warning (_("Target does not support fast tracepoints, "
13229 "downloading %d as regular tracepoint"), b
->number
);
13231 else if (b
->type
== bp_static_tracepoint
13232 || b
->type
== bp_static_marker_tracepoint
)
13234 /* Only test for support at download time; we may not know
13235 target capabilities at definition time. */
13236 if (remote_supports_static_tracepoints ())
13238 struct static_tracepoint_marker marker
;
13240 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
13242 size_left
= buf
.size () - strlen (buf
.data ());
13243 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13246 if (ret
< 0 || ret
>= size_left
)
13247 error ("%s", err_msg
);
13250 error (_("Static tracepoint not valid during download"));
13253 /* Fast tracepoints are functionally identical to regular
13254 tracepoints, so don't take lack of support as a reason
13255 to give up on the trace run. */
13256 error (_("Target does not support static tracepoints"));
13258 /* If the tracepoint has a conditional, make it into an agent
13259 expression and append to the definition. */
13262 /* Only test support at download time, we may not know target
13263 capabilities at definition time. */
13264 if (remote_supports_cond_tracepoints ())
13266 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
13269 size_left
= buf
.size () - strlen (buf
.data ());
13271 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13272 size_left
, ":X%x,", aexpr
->len
);
13274 if (ret
< 0 || ret
>= size_left
)
13275 error ("%s", err_msg
);
13277 size_left
= buf
.size () - strlen (buf
.data ());
13279 /* Two bytes to encode each aexpr byte, plus the terminating
13281 if (aexpr
->len
* 2 + 1 > size_left
)
13282 error ("%s", err_msg
);
13284 pkt
= buf
.data () + strlen (buf
.data ());
13286 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
13287 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
13291 warning (_("Target does not support conditional tracepoints, "
13292 "ignoring tp %d cond"), b
->number
);
13295 if (b
->commands
|| !default_collect
.empty ())
13297 size_left
= buf
.size () - strlen (buf
.data ());
13299 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13302 if (ret
< 0 || ret
>= size_left
)
13303 error ("%s", err_msg
);
13306 putpkt (buf
.data ());
13307 remote_get_noisy_reply ();
13308 if (strcmp (rs
->buf
.data (), "OK"))
13309 error (_("Target does not support tracepoints."));
13311 /* do_single_steps (t); */
13312 for (auto action_it
= tdp_actions
.begin ();
13313 action_it
!= tdp_actions
.end (); action_it
++)
13315 QUIT
; /* Allow user to bail out with ^C. */
13317 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
13318 || !stepping_actions
.empty ());
13320 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
13321 b
->number
, addrbuf
, /* address */
13322 action_it
->c_str (),
13323 has_more
? '-' : 0);
13325 if (ret
< 0 || ret
>= buf
.size ())
13326 error ("%s", err_msg
);
13328 putpkt (buf
.data ());
13329 remote_get_noisy_reply ();
13330 if (strcmp (rs
->buf
.data (), "OK"))
13331 error (_("Error on target while setting tracepoints."));
13334 for (auto action_it
= stepping_actions
.begin ();
13335 action_it
!= stepping_actions
.end (); action_it
++)
13337 QUIT
; /* Allow user to bail out with ^C. */
13339 bool is_first
= action_it
== stepping_actions
.begin ();
13340 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
13342 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
13343 b
->number
, addrbuf
, /* address */
13344 is_first
? "S" : "",
13345 action_it
->c_str (),
13346 has_more
? "-" : "");
13348 if (ret
< 0 || ret
>= buf
.size ())
13349 error ("%s", err_msg
);
13351 putpkt (buf
.data ());
13352 remote_get_noisy_reply ();
13353 if (strcmp (rs
->buf
.data (), "OK"))
13354 error (_("Error on target while setting tracepoints."));
13357 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
13359 if (b
->location
!= NULL
)
13361 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13363 if (ret
< 0 || ret
>= buf
.size ())
13364 error ("%s", err_msg
);
13366 encode_source_string (b
->number
, loc
->address
, "at",
13367 event_location_to_string (b
->location
.get ()),
13368 buf
.data () + strlen (buf
.data ()),
13369 buf
.size () - strlen (buf
.data ()));
13370 putpkt (buf
.data ());
13371 remote_get_noisy_reply ();
13372 if (strcmp (rs
->buf
.data (), "OK"))
13373 warning (_("Target does not support source download."));
13375 if (b
->cond_string
)
13377 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13379 if (ret
< 0 || ret
>= buf
.size ())
13380 error ("%s", err_msg
);
13382 encode_source_string (b
->number
, loc
->address
,
13383 "cond", b
->cond_string
.get (),
13384 buf
.data () + strlen (buf
.data ()),
13385 buf
.size () - strlen (buf
.data ()));
13386 putpkt (buf
.data ());
13387 remote_get_noisy_reply ();
13388 if (strcmp (rs
->buf
.data (), "OK"))
13389 warning (_("Target does not support source download."));
13391 remote_download_command_source (b
->number
, loc
->address
,
13392 breakpoint_commands (b
));
13397 remote_target::can_download_tracepoint ()
13399 struct remote_state
*rs
= get_remote_state ();
13400 struct trace_status
*ts
;
13403 /* Don't try to install tracepoints until we've relocated our
13404 symbols, and fetched and merged the target's tracepoint list with
13406 if (rs
->starting_up
)
13409 ts
= current_trace_status ();
13410 status
= get_trace_status (ts
);
13412 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
13415 /* If we are in a tracing experiment, but remote stub doesn't support
13416 installing tracepoint in trace, we have to return. */
13417 if (!remote_supports_install_in_trace ())
13425 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
13427 struct remote_state
*rs
= get_remote_state ();
13430 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13431 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13433 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13434 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13435 >= get_remote_packet_size ())
13436 error (_("Trace state variable name too long for tsv definition packet"));
13437 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13440 remote_get_noisy_reply ();
13441 if (rs
->buf
[0] == '\0')
13442 error (_("Target does not support this command."));
13443 if (strcmp (rs
->buf
.data (), "OK") != 0)
13444 error (_("Error on target while downloading trace state variable."));
13448 remote_target::enable_tracepoint (struct bp_location
*location
)
13450 struct remote_state
*rs
= get_remote_state ();
13452 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13453 location
->owner
->number
,
13454 phex (location
->address
, sizeof (CORE_ADDR
)));
13456 remote_get_noisy_reply ();
13457 if (rs
->buf
[0] == '\0')
13458 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13459 if (strcmp (rs
->buf
.data (), "OK") != 0)
13460 error (_("Error on target while enabling tracepoint."));
13464 remote_target::disable_tracepoint (struct bp_location
*location
)
13466 struct remote_state
*rs
= get_remote_state ();
13468 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13469 location
->owner
->number
,
13470 phex (location
->address
, sizeof (CORE_ADDR
)));
13472 remote_get_noisy_reply ();
13473 if (rs
->buf
[0] == '\0')
13474 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13475 if (strcmp (rs
->buf
.data (), "OK") != 0)
13476 error (_("Error on target while disabling tracepoint."));
13480 remote_target::trace_set_readonly_regions ()
13483 bfd_size_type size
;
13488 if (!current_program_space
->exec_bfd ())
13489 return; /* No information to give. */
13491 struct remote_state
*rs
= get_remote_state ();
13493 strcpy (rs
->buf
.data (), "QTro");
13494 offset
= strlen (rs
->buf
.data ());
13495 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
13497 char tmp1
[40], tmp2
[40];
13500 if ((s
->flags
& SEC_LOAD
) == 0 ||
13501 /* (s->flags & SEC_CODE) == 0 || */
13502 (s
->flags
& SEC_READONLY
) == 0)
13506 vma
= bfd_section_vma (s
);
13507 size
= bfd_section_size (s
);
13508 sprintf_vma (tmp1
, vma
);
13509 sprintf_vma (tmp2
, vma
+ size
);
13510 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13511 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13513 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13515 Too many sections for read-only sections definition packet."));
13518 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13520 offset
+= sec_length
;
13525 getpkt (&rs
->buf
, 0);
13530 remote_target::trace_start ()
13532 struct remote_state
*rs
= get_remote_state ();
13534 putpkt ("QTStart");
13535 remote_get_noisy_reply ();
13536 if (rs
->buf
[0] == '\0')
13537 error (_("Target does not support this command."));
13538 if (strcmp (rs
->buf
.data (), "OK") != 0)
13539 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13543 remote_target::get_trace_status (struct trace_status
*ts
)
13545 /* Initialize it just to avoid a GCC false warning. */
13547 enum packet_result result
;
13548 struct remote_state
*rs
= get_remote_state ();
13550 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13553 /* FIXME we need to get register block size some other way. */
13554 trace_regblock_size
13555 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13557 putpkt ("qTStatus");
13561 p
= remote_get_noisy_reply ();
13563 catch (const gdb_exception_error
&ex
)
13565 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13567 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13573 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13575 /* If the remote target doesn't do tracing, flag it. */
13576 if (result
== PACKET_UNKNOWN
)
13579 /* We're working with a live target. */
13580 ts
->filename
= NULL
;
13583 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13585 /* Function 'parse_trace_status' sets default value of each field of
13586 'ts' at first, so we don't have to do it here. */
13587 parse_trace_status (p
, ts
);
13589 return ts
->running
;
13593 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13594 struct uploaded_tp
*utp
)
13596 struct remote_state
*rs
= get_remote_state ();
13598 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13599 size_t size
= get_remote_packet_size ();
13604 tp
->traceframe_usage
= 0;
13605 for (bp_location
*loc
: tp
->locations ())
13607 /* If the tracepoint was never downloaded, don't go asking for
13609 if (tp
->number_on_target
== 0)
13611 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13612 phex_nz (loc
->address
, 0));
13614 reply
= remote_get_noisy_reply ();
13615 if (reply
&& *reply
)
13618 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13624 utp
->hit_count
= 0;
13625 utp
->traceframe_usage
= 0;
13626 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13627 phex_nz (utp
->addr
, 0));
13629 reply
= remote_get_noisy_reply ();
13630 if (reply
&& *reply
)
13633 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13639 remote_target::trace_stop ()
13641 struct remote_state
*rs
= get_remote_state ();
13644 remote_get_noisy_reply ();
13645 if (rs
->buf
[0] == '\0')
13646 error (_("Target does not support this command."));
13647 if (strcmp (rs
->buf
.data (), "OK") != 0)
13648 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13652 remote_target::trace_find (enum trace_find_type type
, int num
,
13653 CORE_ADDR addr1
, CORE_ADDR addr2
,
13656 struct remote_state
*rs
= get_remote_state ();
13657 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13659 int target_frameno
= -1, target_tracept
= -1;
13661 /* Lookups other than by absolute frame number depend on the current
13662 trace selected, so make sure it is correct on the remote end
13664 if (type
!= tfind_number
)
13665 set_remote_traceframe ();
13667 p
= rs
->buf
.data ();
13668 strcpy (p
, "QTFrame:");
13669 p
= strchr (p
, '\0');
13673 xsnprintf (p
, endbuf
- p
, "%x", num
);
13676 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13679 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13682 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13683 phex_nz (addr2
, 0));
13685 case tfind_outside
:
13686 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13687 phex_nz (addr2
, 0));
13690 error (_("Unknown trace find type %d"), type
);
13694 reply
= remote_get_noisy_reply ();
13695 if (*reply
== '\0')
13696 error (_("Target does not support this command."));
13698 while (reply
&& *reply
)
13703 target_frameno
= (int) strtol (p
, &reply
, 16);
13705 error (_("Unable to parse trace frame number"));
13706 /* Don't update our remote traceframe number cache on failure
13707 to select a remote traceframe. */
13708 if (target_frameno
== -1)
13713 target_tracept
= (int) strtol (p
, &reply
, 16);
13715 error (_("Unable to parse tracepoint number"));
13717 case 'O': /* "OK"? */
13718 if (reply
[1] == 'K' && reply
[2] == '\0')
13721 error (_("Bogus reply from target: %s"), reply
);
13724 error (_("Bogus reply from target: %s"), reply
);
13727 *tpp
= target_tracept
;
13729 rs
->remote_traceframe_number
= target_frameno
;
13730 return target_frameno
;
13734 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13736 struct remote_state
*rs
= get_remote_state ();
13740 set_remote_traceframe ();
13742 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13744 reply
= remote_get_noisy_reply ();
13745 if (reply
&& *reply
)
13749 unpack_varlen_hex (reply
+ 1, &uval
);
13750 *val
= (LONGEST
) uval
;
13758 remote_target::save_trace_data (const char *filename
)
13760 struct remote_state
*rs
= get_remote_state ();
13763 p
= rs
->buf
.data ();
13764 strcpy (p
, "QTSave:");
13766 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13767 >= get_remote_packet_size ())
13768 error (_("Remote file name too long for trace save packet"));
13769 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13772 reply
= remote_get_noisy_reply ();
13773 if (*reply
== '\0')
13774 error (_("Target does not support this command."));
13775 if (strcmp (reply
, "OK") != 0)
13776 error (_("Bogus reply from target: %s"), reply
);
13780 /* This is basically a memory transfer, but needs to be its own packet
13781 because we don't know how the target actually organizes its trace
13782 memory, plus we want to be able to ask for as much as possible, but
13783 not be unhappy if we don't get as much as we ask for. */
13786 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13788 struct remote_state
*rs
= get_remote_state ();
13793 p
= rs
->buf
.data ();
13794 strcpy (p
, "qTBuffer:");
13796 p
+= hexnumstr (p
, offset
);
13798 p
+= hexnumstr (p
, len
);
13802 reply
= remote_get_noisy_reply ();
13803 if (reply
&& *reply
)
13805 /* 'l' by itself means we're at the end of the buffer and
13806 there is nothing more to get. */
13810 /* Convert the reply into binary. Limit the number of bytes to
13811 convert according to our passed-in buffer size, rather than
13812 what was returned in the packet; if the target is
13813 unexpectedly generous and gives us a bigger reply than we
13814 asked for, we don't want to crash. */
13815 rslt
= hex2bin (reply
, buf
, len
);
13819 /* Something went wrong, flag as an error. */
13824 remote_target::set_disconnected_tracing (int val
)
13826 struct remote_state
*rs
= get_remote_state ();
13828 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13832 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13833 "QTDisconnected:%x", val
);
13835 reply
= remote_get_noisy_reply ();
13836 if (*reply
== '\0')
13837 error (_("Target does not support this command."));
13838 if (strcmp (reply
, "OK") != 0)
13839 error (_("Bogus reply from target: %s"), reply
);
13842 warning (_("Target does not support disconnected tracing."));
13846 remote_target::core_of_thread (ptid_t ptid
)
13848 thread_info
*info
= find_thread_ptid (this, ptid
);
13850 if (info
!= NULL
&& info
->priv
!= NULL
)
13851 return get_remote_thread_info (info
)->core
;
13857 remote_target::set_circular_trace_buffer (int val
)
13859 struct remote_state
*rs
= get_remote_state ();
13862 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13863 "QTBuffer:circular:%x", val
);
13865 reply
= remote_get_noisy_reply ();
13866 if (*reply
== '\0')
13867 error (_("Target does not support this command."));
13868 if (strcmp (reply
, "OK") != 0)
13869 error (_("Bogus reply from target: %s"), reply
);
13873 remote_target::traceframe_info ()
13875 gdb::optional
<gdb::char_vector
> text
13876 = target_read_stralloc (current_inferior ()->top_target (),
13877 TARGET_OBJECT_TRACEFRAME_INFO
,
13880 return parse_traceframe_info (text
->data ());
13885 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13886 instruction on which a fast tracepoint may be placed. Returns -1
13887 if the packet is not supported, and 0 if the minimum instruction
13888 length is unknown. */
13891 remote_target::get_min_fast_tracepoint_insn_len ()
13893 struct remote_state
*rs
= get_remote_state ();
13896 /* If we're not debugging a process yet, the IPA can't be
13898 if (!target_has_execution ())
13901 /* Make sure the remote is pointing at the right process. */
13902 set_general_process ();
13904 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13906 reply
= remote_get_noisy_reply ();
13907 if (*reply
== '\0')
13911 ULONGEST min_insn_len
;
13913 unpack_varlen_hex (reply
, &min_insn_len
);
13915 return (int) min_insn_len
;
13920 remote_target::set_trace_buffer_size (LONGEST val
)
13922 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13924 struct remote_state
*rs
= get_remote_state ();
13925 char *buf
= rs
->buf
.data ();
13926 char *endbuf
= buf
+ get_remote_packet_size ();
13927 enum packet_result result
;
13929 gdb_assert (val
>= 0 || val
== -1);
13930 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13931 /* Send -1 as literal "-1" to avoid host size dependency. */
13935 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13938 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13941 remote_get_noisy_reply ();
13942 result
= packet_ok (rs
->buf
,
13943 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13945 if (result
!= PACKET_OK
)
13946 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13951 remote_target::set_trace_notes (const char *user
, const char *notes
,
13952 const char *stop_notes
)
13954 struct remote_state
*rs
= get_remote_state ();
13956 char *buf
= rs
->buf
.data ();
13957 char *endbuf
= buf
+ get_remote_packet_size ();
13960 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13963 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13964 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13970 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13971 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13977 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13978 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13982 /* Ensure the buffer is terminated. */
13986 reply
= remote_get_noisy_reply ();
13987 if (*reply
== '\0')
13990 if (strcmp (reply
, "OK") != 0)
13991 error (_("Bogus reply from target: %s"), reply
);
13997 remote_target::use_agent (bool use
)
13999 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
14001 struct remote_state
*rs
= get_remote_state ();
14003 /* If the stub supports QAgent. */
14004 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
14006 getpkt (&rs
->buf
, 0);
14008 if (strcmp (rs
->buf
.data (), "OK") == 0)
14019 remote_target::can_use_agent ()
14021 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
14024 struct btrace_target_info
14026 /* The ptid of the traced thread. */
14029 /* The obtained branch trace configuration. */
14030 struct btrace_config conf
;
14033 /* Reset our idea of our target's btrace configuration. */
14036 remote_btrace_reset (remote_state
*rs
)
14038 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
14041 /* Synchronize the configuration with the target. */
14044 remote_target::btrace_sync_conf (const btrace_config
*conf
)
14046 struct packet_config
*packet
;
14047 struct remote_state
*rs
;
14048 char *buf
, *pos
, *endbuf
;
14050 rs
= get_remote_state ();
14051 buf
= rs
->buf
.data ();
14052 endbuf
= buf
+ get_remote_packet_size ();
14054 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
14055 if (packet_config_support (packet
) == PACKET_ENABLE
14056 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
14059 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
14063 getpkt (&rs
->buf
, 0);
14065 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
14067 if (buf
[0] == 'E' && buf
[1] == '.')
14068 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
14070 error (_("Failed to configure the BTS buffer size."));
14073 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
14076 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
14077 if (packet_config_support (packet
) == PACKET_ENABLE
14078 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
14081 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
14085 getpkt (&rs
->buf
, 0);
14087 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
14089 if (buf
[0] == 'E' && buf
[1] == '.')
14090 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
14092 error (_("Failed to configure the trace buffer size."));
14095 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
14099 /* Read TP's btrace configuration from the target and store it into CONF. */
14102 btrace_read_config (thread_info
*tp
, struct btrace_config
*conf
)
14104 /* target_read_stralloc relies on INFERIOR_PTID. */
14105 scoped_restore_current_thread restore_thread
;
14106 switch_to_thread (tp
);
14108 gdb::optional
<gdb::char_vector
> xml
14109 = target_read_stralloc (current_inferior ()->top_target (),
14110 TARGET_OBJECT_BTRACE_CONF
, "");
14112 parse_xml_btrace_conf (conf
, xml
->data ());
14115 /* Maybe reopen target btrace. */
14118 remote_target::remote_btrace_maybe_reopen ()
14120 struct remote_state
*rs
= get_remote_state ();
14121 int btrace_target_pushed
= 0;
14122 #if !defined (HAVE_LIBIPT)
14126 /* Don't bother walking the entirety of the remote thread list when
14127 we know the feature isn't supported by the remote. */
14128 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
14131 for (thread_info
*tp
: all_non_exited_threads (this))
14133 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
14134 btrace_read_config (tp
, &rs
->btrace_config
);
14136 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
14139 #if !defined (HAVE_LIBIPT)
14140 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
14145 warning (_("Target is recording using Intel Processor Trace "
14146 "but support was disabled at compile time."));
14151 #endif /* !defined (HAVE_LIBIPT) */
14153 /* Push target, once, but before anything else happens. This way our
14154 changes to the threads will be cleaned up by unpushing the target
14155 in case btrace_read_config () throws. */
14156 if (!btrace_target_pushed
)
14158 btrace_target_pushed
= 1;
14159 record_btrace_push_target ();
14160 gdb_printf (_("Target is recording using %s.\n"),
14161 btrace_format_string (rs
->btrace_config
.format
));
14164 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
14165 tp
->btrace
.target
->ptid
= tp
->ptid
;
14166 tp
->btrace
.target
->conf
= rs
->btrace_config
;
14170 /* Enable branch tracing. */
14172 struct btrace_target_info
*
14173 remote_target::enable_btrace (thread_info
*tp
,
14174 const struct btrace_config
*conf
)
14176 struct btrace_target_info
*tinfo
= NULL
;
14177 struct packet_config
*packet
= NULL
;
14178 struct remote_state
*rs
= get_remote_state ();
14179 char *buf
= rs
->buf
.data ();
14180 char *endbuf
= buf
+ get_remote_packet_size ();
14182 switch (conf
->format
)
14184 case BTRACE_FORMAT_BTS
:
14185 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
14188 case BTRACE_FORMAT_PT
:
14189 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
14193 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
14194 error (_("Target does not support branch tracing."));
14196 btrace_sync_conf (conf
);
14198 ptid_t ptid
= tp
->ptid
;
14199 set_general_thread (ptid
);
14201 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
14203 getpkt (&rs
->buf
, 0);
14205 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
14207 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
14208 error (_("Could not enable branch tracing for %s: %s"),
14209 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
14211 error (_("Could not enable branch tracing for %s."),
14212 target_pid_to_str (ptid
).c_str ());
14215 tinfo
= XCNEW (struct btrace_target_info
);
14216 tinfo
->ptid
= ptid
;
14218 /* If we fail to read the configuration, we lose some information, but the
14219 tracing itself is not impacted. */
14222 btrace_read_config (tp
, &tinfo
->conf
);
14224 catch (const gdb_exception_error
&err
)
14226 if (err
.message
!= NULL
)
14227 warning ("%s", err
.what ());
14233 /* Disable branch tracing. */
14236 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
14238 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
14239 struct remote_state
*rs
= get_remote_state ();
14240 char *buf
= rs
->buf
.data ();
14241 char *endbuf
= buf
+ get_remote_packet_size ();
14243 if (packet_config_support (packet
) != PACKET_ENABLE
)
14244 error (_("Target does not support branch tracing."));
14246 set_general_thread (tinfo
->ptid
);
14248 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
14250 getpkt (&rs
->buf
, 0);
14252 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
14254 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
14255 error (_("Could not disable branch tracing for %s: %s"),
14256 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
14258 error (_("Could not disable branch tracing for %s."),
14259 target_pid_to_str (tinfo
->ptid
).c_str ());
14265 /* Teardown branch tracing. */
14268 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
14270 /* We must not talk to the target during teardown. */
14274 /* Read the branch trace. */
14277 remote_target::read_btrace (struct btrace_data
*btrace
,
14278 struct btrace_target_info
*tinfo
,
14279 enum btrace_read_type type
)
14281 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
14284 if (packet_config_support (packet
) != PACKET_ENABLE
)
14285 error (_("Target does not support branch tracing."));
14287 #if !defined(HAVE_LIBEXPAT)
14288 error (_("Cannot process branch tracing result. XML parsing not supported."));
14293 case BTRACE_READ_ALL
:
14296 case BTRACE_READ_NEW
:
14299 case BTRACE_READ_DELTA
:
14303 internal_error (__FILE__
, __LINE__
,
14304 _("Bad branch tracing read type: %u."),
14305 (unsigned int) type
);
14308 gdb::optional
<gdb::char_vector
> xml
14309 = target_read_stralloc (current_inferior ()->top_target (),
14310 TARGET_OBJECT_BTRACE
, annex
);
14312 return BTRACE_ERR_UNKNOWN
;
14314 parse_xml_btrace (btrace
, xml
->data ());
14316 return BTRACE_ERR_NONE
;
14319 const struct btrace_config
*
14320 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
14322 return &tinfo
->conf
;
14326 remote_target::augmented_libraries_svr4_read ()
14328 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
14332 /* Implementation of to_load. */
14335 remote_target::load (const char *name
, int from_tty
)
14337 generic_load (name
, from_tty
);
14340 /* Accepts an integer PID; returns a string representing a file that
14341 can be opened on the remote side to get the symbols for the child
14342 process. Returns NULL if the operation is not supported. */
14345 remote_target::pid_to_exec_file (int pid
)
14347 static gdb::optional
<gdb::char_vector
> filename
;
14348 char *annex
= NULL
;
14350 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
14353 inferior
*inf
= find_inferior_pid (this, pid
);
14355 internal_error (__FILE__
, __LINE__
,
14356 _("not currently attached to process %d"), pid
);
14358 if (!inf
->fake_pid_p
)
14360 const int annex_size
= 9;
14362 annex
= (char *) alloca (annex_size
);
14363 xsnprintf (annex
, annex_size
, "%x", pid
);
14366 filename
= target_read_stralloc (current_inferior ()->top_target (),
14367 TARGET_OBJECT_EXEC_FILE
, annex
);
14369 return filename
? filename
->data () : nullptr;
14372 /* Implement the to_can_do_single_step target_ops method. */
14375 remote_target::can_do_single_step ()
14377 /* We can only tell whether target supports single step or not by
14378 supported s and S vCont actions if the stub supports vContSupported
14379 feature. If the stub doesn't support vContSupported feature,
14380 we have conservatively to think target doesn't supports single
14382 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
14384 struct remote_state
*rs
= get_remote_state ();
14386 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14387 remote_vcont_probe ();
14389 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
14395 /* Implementation of the to_execution_direction method for the remote
14398 enum exec_direction_kind
14399 remote_target::execution_direction ()
14401 struct remote_state
*rs
= get_remote_state ();
14403 return rs
->last_resume_exec_dir
;
14406 /* Return pointer to the thread_info struct which corresponds to
14407 THREAD_HANDLE (having length HANDLE_LEN). */
14410 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
14414 for (thread_info
*tp
: all_non_exited_threads (this))
14416 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14418 if (tp
->inf
== inf
&& priv
!= NULL
)
14420 if (handle_len
!= priv
->thread_handle
.size ())
14421 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14422 handle_len
, priv
->thread_handle
.size ());
14423 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14433 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
14435 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14436 return priv
->thread_handle
;
14440 remote_target::can_async_p ()
14442 /* This flag should be checked in the common target.c code. */
14443 gdb_assert (target_async_permitted
);
14445 /* We're async whenever the serial device can. */
14446 struct remote_state
*rs
= get_remote_state ();
14447 return serial_can_async_p (rs
->remote_desc
);
14451 remote_target::is_async_p ()
14453 /* We're async whenever the serial device is. */
14454 struct remote_state
*rs
= get_remote_state ();
14455 return serial_is_async_p (rs
->remote_desc
);
14458 /* Pass the SERIAL event on and up to the client. One day this code
14459 will be able to delay notifying the client of an event until the
14460 point where an entire packet has been received. */
14462 static serial_event_ftype remote_async_serial_handler
;
14465 remote_async_serial_handler (struct serial
*scb
, void *context
)
14467 /* Don't propogate error information up to the client. Instead let
14468 the client find out about the error by querying the target. */
14469 inferior_event_handler (INF_REG_EVENT
);
14473 remote_async_inferior_event_handler (gdb_client_data data
)
14475 inferior_event_handler (INF_REG_EVENT
);
14479 remote_target::async_wait_fd ()
14481 struct remote_state
*rs
= get_remote_state ();
14482 return rs
->remote_desc
->fd
;
14486 remote_target::async (int enable
)
14488 struct remote_state
*rs
= get_remote_state ();
14492 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14494 /* If there are pending events in the stop reply queue tell the
14495 event loop to process them. */
14496 if (!rs
->stop_reply_queue
.empty ())
14497 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14498 /* For simplicity, below we clear the pending events token
14499 without remembering whether it is marked, so here we always
14500 mark it. If there's actually no pending notification to
14501 process, this ends up being a no-op (other than a spurious
14502 event-loop wakeup). */
14503 if (target_is_non_stop_p ())
14504 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14508 serial_async (rs
->remote_desc
, NULL
, NULL
);
14509 /* If the core is disabling async, it doesn't want to be
14510 disturbed with target events. Clear all async event sources
14512 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14513 if (target_is_non_stop_p ())
14514 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14518 /* Implementation of the to_thread_events method. */
14521 remote_target::thread_events (int enable
)
14523 struct remote_state
*rs
= get_remote_state ();
14524 size_t size
= get_remote_packet_size ();
14526 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14529 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14531 getpkt (&rs
->buf
, 0);
14533 switch (packet_ok (rs
->buf
,
14534 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14537 if (strcmp (rs
->buf
.data (), "OK") != 0)
14538 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14541 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14543 case PACKET_UNKNOWN
:
14549 show_remote_cmd (const char *args
, int from_tty
)
14551 /* We can't just use cmd_show_list here, because we want to skip
14552 the redundant "show remote Z-packet" and the legacy aliases. */
14553 struct cmd_list_element
*list
= remote_show_cmdlist
;
14554 struct ui_out
*uiout
= current_uiout
;
14556 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14557 for (; list
!= NULL
; list
= list
->next
)
14558 if (strcmp (list
->name
, "Z-packet") == 0)
14560 else if (list
->type
== not_set_cmd
)
14561 /* Alias commands are exactly like the original, except they
14562 don't have the normal type. */
14566 ui_out_emit_tuple
option_emitter (uiout
, "option");
14568 uiout
->field_string ("name", list
->name
);
14569 uiout
->text (": ");
14570 if (list
->type
== show_cmd
)
14571 do_show_command (NULL
, from_tty
, list
);
14573 cmd_func (list
, NULL
, from_tty
);
14578 /* Function to be called whenever a new objfile (shlib) is detected. */
14580 remote_new_objfile (struct objfile
*objfile
)
14582 /* The objfile change happened in that program space. */
14583 program_space
*pspace
= current_program_space
;
14585 /* The affected program space is possibly shared by multiple inferiors.
14586 Consider sending a qSymbol packet for each of the inferiors using that
14588 for (inferior
*inf
: all_inferiors ())
14590 if (inf
->pspace
!= pspace
)
14593 /* Check whether the inferior's process target is a remote target. */
14594 remote_target
*remote
= as_remote_target (inf
->process_target ());
14595 if (remote
== nullptr)
14598 /* When we are attaching or handling a fork child and the shared library
14599 subsystem reads the list of loaded libraries, we receive new objfile
14600 events in between each found library. The libraries are read in an
14601 undefined order, so if we gave the remote side a chance to look up
14602 symbols between each objfile, we might give it an inconsistent picture
14603 of the inferior. It could appear that a library A appears loaded but
14604 a library B does not, even though library A requires library B. That
14605 would present a state that couldn't normally exist in the inferior.
14607 So, skip these events, we'll give the remote a chance to look up
14608 symbols once all the loaded libraries and their symbols are known to
14610 if (inf
->in_initial_library_scan
)
14613 if (!remote
->has_execution (inf
))
14616 /* Need to switch to a specific thread, because remote_check_symbols will
14617 set the general thread using INFERIOR_PTID.
14619 It's possible to have inferiors with no thread here, because we are
14620 called very early in the connection process, while the inferior is
14621 being set up, before threads are added. Just skip it, start_remote_1
14622 also calls remote_check_symbols when it's done setting things up. */
14623 thread_info
*thread
= any_thread_of_inferior (inf
);
14624 if (thread
!= nullptr)
14626 scoped_restore_current_thread restore_thread
;
14627 switch_to_thread (thread
);
14628 remote
->remote_check_symbols ();
14633 /* Pull all the tracepoints defined on the target and create local
14634 data structures representing them. We don't want to create real
14635 tracepoints yet, we don't want to mess up the user's existing
14639 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14641 struct remote_state
*rs
= get_remote_state ();
14644 /* Ask for a first packet of tracepoint definition. */
14646 getpkt (&rs
->buf
, 0);
14647 p
= rs
->buf
.data ();
14648 while (*p
&& *p
!= 'l')
14650 parse_tracepoint_definition (p
, utpp
);
14651 /* Ask for another packet of tracepoint definition. */
14653 getpkt (&rs
->buf
, 0);
14654 p
= rs
->buf
.data ();
14660 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14662 struct remote_state
*rs
= get_remote_state ();
14665 /* Ask for a first packet of variable definition. */
14667 getpkt (&rs
->buf
, 0);
14668 p
= rs
->buf
.data ();
14669 while (*p
&& *p
!= 'l')
14671 parse_tsv_definition (p
, utsvp
);
14672 /* Ask for another packet of variable definition. */
14674 getpkt (&rs
->buf
, 0);
14675 p
= rs
->buf
.data ();
14680 /* The "set/show range-stepping" show hook. */
14683 show_range_stepping (struct ui_file
*file
, int from_tty
,
14684 struct cmd_list_element
*c
,
14688 _("Debugger's willingness to use range stepping "
14689 "is %s.\n"), value
);
14692 /* Return true if the vCont;r action is supported by the remote
14696 remote_target::vcont_r_supported ()
14698 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14699 remote_vcont_probe ();
14701 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14702 && get_remote_state ()->supports_vCont
.r
);
14705 /* The "set/show range-stepping" set hook. */
14708 set_range_stepping (const char *ignore_args
, int from_tty
,
14709 struct cmd_list_element
*c
)
14711 /* When enabling, check whether range stepping is actually supported
14712 by the target, and warn if not. */
14713 if (use_range_stepping
)
14715 remote_target
*remote
= get_current_remote_target ();
14717 || !remote
->vcont_r_supported ())
14718 warning (_("Range stepping is not supported by the current target"));
14723 show_remote_debug (struct ui_file
*file
, int from_tty
,
14724 struct cmd_list_element
*c
, const char *value
)
14726 gdb_printf (file
, _("Debugging of remote protocol is %s.\n"),
14731 show_remote_timeout (struct ui_file
*file
, int from_tty
,
14732 struct cmd_list_element
*c
, const char *value
)
14735 _("Timeout limit to wait for target to respond is %s.\n"),
14739 /* Implement the "supports_memory_tagging" target_ops method. */
14742 remote_target::supports_memory_tagging ()
14744 return remote_memory_tagging_p ();
14747 /* Create the qMemTags packet given ADDRESS, LEN and TYPE. */
14750 create_fetch_memtags_request (gdb::char_vector
&packet
, CORE_ADDR address
,
14751 size_t len
, int type
)
14753 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
14755 std::string request
= string_printf ("qMemTags:%s,%s:%s",
14756 phex_nz (address
, addr_size
),
14757 phex_nz (len
, sizeof (len
)),
14758 phex_nz (type
, sizeof (type
)));
14760 strcpy (packet
.data (), request
.c_str ());
14763 /* Parse the qMemTags packet reply into TAGS.
14765 Return true if successful, false otherwise. */
14768 parse_fetch_memtags_reply (const gdb::char_vector
&reply
,
14769 gdb::byte_vector
&tags
)
14771 if (reply
.empty () || reply
[0] == 'E' || reply
[0] != 'm')
14774 /* Copy the tag data. */
14775 tags
= hex2bin (reply
.data () + 1);
14780 /* Create the QMemTags packet given ADDRESS, LEN, TYPE and TAGS. */
14783 create_store_memtags_request (gdb::char_vector
&packet
, CORE_ADDR address
,
14784 size_t len
, int type
,
14785 const gdb::byte_vector
&tags
)
14787 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
14789 /* Put together the main packet, address and length. */
14790 std::string request
= string_printf ("QMemTags:%s,%s:%s:",
14791 phex_nz (address
, addr_size
),
14792 phex_nz (len
, sizeof (len
)),
14793 phex_nz (type
, sizeof (type
)));
14794 request
+= bin2hex (tags
.data (), tags
.size ());
14796 /* Check if we have exceeded the maximum packet size. */
14797 if (packet
.size () < request
.length ())
14798 error (_("Contents too big for packet QMemTags."));
14800 strcpy (packet
.data (), request
.c_str ());
14803 /* Implement the "fetch_memtags" target_ops method. */
14806 remote_target::fetch_memtags (CORE_ADDR address
, size_t len
,
14807 gdb::byte_vector
&tags
, int type
)
14809 /* Make sure the qMemTags packet is supported. */
14810 if (!remote_memory_tagging_p ())
14811 gdb_assert_not_reached ("remote fetch_memtags called with packet disabled");
14813 struct remote_state
*rs
= get_remote_state ();
14815 create_fetch_memtags_request (rs
->buf
, address
, len
, type
);
14818 getpkt (&rs
->buf
, 0);
14820 return parse_fetch_memtags_reply (rs
->buf
, tags
);
14823 /* Implement the "store_memtags" target_ops method. */
14826 remote_target::store_memtags (CORE_ADDR address
, size_t len
,
14827 const gdb::byte_vector
&tags
, int type
)
14829 /* Make sure the QMemTags packet is supported. */
14830 if (!remote_memory_tagging_p ())
14831 gdb_assert_not_reached ("remote store_memtags called with packet disabled");
14833 struct remote_state
*rs
= get_remote_state ();
14835 create_store_memtags_request (rs
->buf
, address
, len
, type
, tags
);
14838 getpkt (&rs
->buf
, 0);
14840 /* Verify if the request was successful. */
14841 return packet_check_result (rs
->buf
.data ()) == PACKET_OK
;
14844 /* Return true if remote target T is non-stop. */
14847 remote_target_is_non_stop_p (remote_target
*t
)
14849 scoped_restore_current_thread restore_thread
;
14850 switch_to_target_no_thread (t
);
14852 return target_is_non_stop_p ();
14857 namespace selftests
{
14860 test_memory_tagging_functions ()
14862 remote_target remote
;
14864 struct packet_config
*config
14865 = &remote_protocol_packets
[PACKET_memory_tagging_feature
];
14867 scoped_restore restore_memtag_support_
14868 = make_scoped_restore (&config
->support
);
14870 /* Test memory tagging packet support. */
14871 config
->support
= PACKET_SUPPORT_UNKNOWN
;
14872 SELF_CHECK (remote
.supports_memory_tagging () == false);
14873 config
->support
= PACKET_DISABLE
;
14874 SELF_CHECK (remote
.supports_memory_tagging () == false);
14875 config
->support
= PACKET_ENABLE
;
14876 SELF_CHECK (remote
.supports_memory_tagging () == true);
14878 /* Setup testing. */
14879 gdb::char_vector packet
;
14880 gdb::byte_vector tags
, bv
;
14881 std::string expected
, reply
;
14882 packet
.resize (32000);
14884 /* Test creating a qMemTags request. */
14886 expected
= "qMemTags:0,0:0";
14887 create_fetch_memtags_request (packet
, 0x0, 0x0, 0);
14888 SELF_CHECK (strcmp (packet
.data (), expected
.c_str ()) == 0);
14890 expected
= "qMemTags:deadbeef,10:1";
14891 create_fetch_memtags_request (packet
, 0xdeadbeef, 16, 1);
14892 SELF_CHECK (strcmp (packet
.data (), expected
.c_str ()) == 0);
14894 /* Test parsing a qMemTags reply. */
14896 /* Error reply, tags vector unmodified. */
14898 strcpy (packet
.data (), reply
.c_str ());
14900 SELF_CHECK (parse_fetch_memtags_reply (packet
, tags
) == false);
14901 SELF_CHECK (tags
.size () == 0);
14903 /* Valid reply, tags vector updated. */
14907 for (int i
= 0; i
< 5; i
++)
14910 reply
= "m" + bin2hex (bv
.data (), bv
.size ());
14911 strcpy (packet
.data (), reply
.c_str ());
14913 SELF_CHECK (parse_fetch_memtags_reply (packet
, tags
) == true);
14914 SELF_CHECK (tags
.size () == 5);
14916 for (int i
= 0; i
< 5; i
++)
14917 SELF_CHECK (tags
[i
] == i
);
14919 /* Test creating a QMemTags request. */
14921 /* Empty tag data. */
14923 expected
= "QMemTags:0,0:0:";
14924 create_store_memtags_request (packet
, 0x0, 0x0, 0, tags
);
14925 SELF_CHECK (memcmp (packet
.data (), expected
.c_str (),
14926 expected
.length ()) == 0);
14928 /* Non-empty tag data. */
14930 for (int i
= 0; i
< 5; i
++)
14931 tags
.push_back (i
);
14932 expected
= "QMemTags:deadbeef,ff:1:0001020304";
14933 create_store_memtags_request (packet
, 0xdeadbeef, 255, 1, tags
);
14934 SELF_CHECK (memcmp (packet
.data (), expected
.c_str (),
14935 expected
.length ()) == 0);
14938 } // namespace selftests
14939 #endif /* GDB_SELF_TEST */
14941 void _initialize_remote ();
14943 _initialize_remote ()
14945 /* architecture specific data */
14946 remote_g_packet_data_handle
=
14947 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14949 add_target (remote_target_info
, remote_target::open
);
14950 add_target (extended_remote_target_info
, extended_remote_target::open
);
14952 /* Hook into new objfile notification. */
14953 gdb::observers::new_objfile
.attach (remote_new_objfile
, "remote");
14956 init_remote_threadtests ();
14959 /* set/show remote ... */
14961 add_basic_prefix_cmd ("remote", class_maintenance
, _("\
14962 Remote protocol specific variables.\n\
14963 Configure various remote-protocol specific variables such as\n\
14964 the packets being used."),
14965 &remote_set_cmdlist
,
14966 0 /* allow-unknown */, &setlist
);
14967 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14968 Remote protocol specific variables.\n\
14969 Configure various remote-protocol specific variables such as\n\
14970 the packets being used."),
14971 &remote_show_cmdlist
,
14972 0 /* allow-unknown */, &showlist
);
14974 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14975 Compare section data on target to the exec file.\n\
14976 Argument is a single section name (default: all loaded sections).\n\
14977 To compare only read-only loaded sections, specify the -r option."),
14980 add_cmd ("packet", class_maintenance
, cli_packet_command
, _("\
14981 Send an arbitrary packet to a remote target.\n\
14982 maintenance packet TEXT\n\
14983 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14984 this command sends the string TEXT to the inferior, and displays the\n\
14985 response packet. GDB supplies the initial `$' character, and the\n\
14986 terminating `#' character and checksum."),
14989 set_show_commands remotebreak_cmds
14990 = add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14991 Set whether to send break if interrupted."), _("\
14992 Show whether to send break if interrupted."), _("\
14993 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14994 set_remotebreak
, show_remotebreak
,
14995 &setlist
, &showlist
);
14996 deprecate_cmd (remotebreak_cmds
.set
, "set remote interrupt-sequence");
14997 deprecate_cmd (remotebreak_cmds
.show
, "show remote interrupt-sequence");
14999 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
15000 interrupt_sequence_modes
, &interrupt_sequence_mode
,
15002 Set interrupt sequence to remote target."), _("\
15003 Show interrupt sequence to remote target."), _("\
15004 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
15005 NULL
, show_interrupt_sequence
,
15006 &remote_set_cmdlist
,
15007 &remote_show_cmdlist
);
15009 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
15010 &interrupt_on_connect
, _("\
15011 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
15012 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
15013 If set, interrupt sequence is sent to remote target."),
15015 &remote_set_cmdlist
, &remote_show_cmdlist
);
15017 /* Install commands for configuring memory read/write packets. */
15019 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
15020 Set the maximum number of bytes per memory write packet (deprecated)."),
15022 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
15023 Show the maximum number of bytes per memory write packet (deprecated)."),
15025 add_cmd ("memory-write-packet-size", no_class
,
15026 set_memory_write_packet_size
, _("\
15027 Set the maximum number of bytes per memory-write packet.\n\
15028 Specify the number of bytes in a packet or 0 (zero) for the\n\
15029 default packet size. The actual limit is further reduced\n\
15030 dependent on the target. Specify ``fixed'' to disable the\n\
15031 further restriction and ``limit'' to enable that restriction."),
15032 &remote_set_cmdlist
);
15033 add_cmd ("memory-read-packet-size", no_class
,
15034 set_memory_read_packet_size
, _("\
15035 Set the maximum number of bytes per memory-read packet.\n\
15036 Specify the number of bytes in a packet or 0 (zero) for the\n\
15037 default packet size. The actual limit is further reduced\n\
15038 dependent on the target. Specify ``fixed'' to disable the\n\
15039 further restriction and ``limit'' to enable that restriction."),
15040 &remote_set_cmdlist
);
15041 add_cmd ("memory-write-packet-size", no_class
,
15042 show_memory_write_packet_size
,
15043 _("Show the maximum number of bytes per memory-write packet."),
15044 &remote_show_cmdlist
);
15045 add_cmd ("memory-read-packet-size", no_class
,
15046 show_memory_read_packet_size
,
15047 _("Show the maximum number of bytes per memory-read packet."),
15048 &remote_show_cmdlist
);
15050 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
15051 &remote_hw_watchpoint_limit
, _("\
15052 Set the maximum number of target hardware watchpoints."), _("\
15053 Show the maximum number of target hardware watchpoints."), _("\
15054 Specify \"unlimited\" for unlimited hardware watchpoints."),
15055 NULL
, show_hardware_watchpoint_limit
,
15056 &remote_set_cmdlist
,
15057 &remote_show_cmdlist
);
15058 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
15060 &remote_hw_watchpoint_length_limit
, _("\
15061 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
15062 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
15063 Specify \"unlimited\" to allow watchpoints of unlimited size."),
15064 NULL
, show_hardware_watchpoint_length_limit
,
15065 &remote_set_cmdlist
, &remote_show_cmdlist
);
15066 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
15067 &remote_hw_breakpoint_limit
, _("\
15068 Set the maximum number of target hardware breakpoints."), _("\
15069 Show the maximum number of target hardware breakpoints."), _("\
15070 Specify \"unlimited\" for unlimited hardware breakpoints."),
15071 NULL
, show_hardware_breakpoint_limit
,
15072 &remote_set_cmdlist
, &remote_show_cmdlist
);
15074 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
15075 &remote_address_size
, _("\
15076 Set the maximum size of the address (in bits) in a memory packet."), _("\
15077 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
15079 NULL
, /* FIXME: i18n: */
15080 &setlist
, &showlist
);
15082 init_all_packet_configs ();
15084 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
15085 "X", "binary-download", 1);
15087 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
15088 "vCont", "verbose-resume", 0);
15090 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
15091 "QPassSignals", "pass-signals", 0);
15093 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
15094 "QCatchSyscalls", "catch-syscalls", 0);
15096 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
15097 "QProgramSignals", "program-signals", 0);
15099 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
15100 "QSetWorkingDir", "set-working-dir", 0);
15102 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
15103 "QStartupWithShell", "startup-with-shell", 0);
15105 add_packet_config_cmd (&remote_protocol_packets
15106 [PACKET_QEnvironmentHexEncoded
],
15107 "QEnvironmentHexEncoded", "environment-hex-encoded",
15110 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
15111 "QEnvironmentReset", "environment-reset",
15114 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
15115 "QEnvironmentUnset", "environment-unset",
15118 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
15119 "qSymbol", "symbol-lookup", 0);
15121 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
15122 "P", "set-register", 1);
15124 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
15125 "p", "fetch-register", 1);
15127 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
15128 "Z0", "software-breakpoint", 0);
15130 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
15131 "Z1", "hardware-breakpoint", 0);
15133 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
15134 "Z2", "write-watchpoint", 0);
15136 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
15137 "Z3", "read-watchpoint", 0);
15139 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
15140 "Z4", "access-watchpoint", 0);
15142 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
15143 "qXfer:auxv:read", "read-aux-vector", 0);
15145 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
15146 "qXfer:exec-file:read", "pid-to-exec-file", 0);
15148 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
15149 "qXfer:features:read", "target-features", 0);
15151 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
15152 "qXfer:libraries:read", "library-info", 0);
15154 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
15155 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
15157 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
15158 "qXfer:memory-map:read", "memory-map", 0);
15160 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
15161 "qXfer:osdata:read", "osdata", 0);
15163 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
15164 "qXfer:threads:read", "threads", 0);
15166 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
15167 "qXfer:siginfo:read", "read-siginfo-object", 0);
15169 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
15170 "qXfer:siginfo:write", "write-siginfo-object", 0);
15172 add_packet_config_cmd
15173 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
15174 "qXfer:traceframe-info:read", "traceframe-info", 0);
15176 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
15177 "qXfer:uib:read", "unwind-info-block", 0);
15179 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
15180 "qGetTLSAddr", "get-thread-local-storage-address",
15183 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
15184 "qGetTIBAddr", "get-thread-information-block-address",
15187 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
15188 "bc", "reverse-continue", 0);
15190 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
15191 "bs", "reverse-step", 0);
15193 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
15194 "qSupported", "supported-packets", 0);
15196 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
15197 "qSearch:memory", "search-memory", 0);
15199 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
15200 "qTStatus", "trace-status", 0);
15202 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
15203 "vFile:setfs", "hostio-setfs", 0);
15205 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
15206 "vFile:open", "hostio-open", 0);
15208 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
15209 "vFile:pread", "hostio-pread", 0);
15211 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
15212 "vFile:pwrite", "hostio-pwrite", 0);
15214 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
15215 "vFile:close", "hostio-close", 0);
15217 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
15218 "vFile:unlink", "hostio-unlink", 0);
15220 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
15221 "vFile:readlink", "hostio-readlink", 0);
15223 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
15224 "vFile:fstat", "hostio-fstat", 0);
15226 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
15227 "vAttach", "attach", 0);
15229 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
15232 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
15233 "QStartNoAckMode", "noack", 0);
15235 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
15236 "vKill", "kill", 0);
15238 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
15239 "qAttached", "query-attached", 0);
15241 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
15242 "ConditionalTracepoints",
15243 "conditional-tracepoints", 0);
15245 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
15246 "ConditionalBreakpoints",
15247 "conditional-breakpoints", 0);
15249 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
15250 "BreakpointCommands",
15251 "breakpoint-commands", 0);
15253 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
15254 "FastTracepoints", "fast-tracepoints", 0);
15256 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
15257 "TracepointSource", "TracepointSource", 0);
15259 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
15260 "QAllow", "allow", 0);
15262 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
15263 "StaticTracepoints", "static-tracepoints", 0);
15265 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
15266 "InstallInTrace", "install-in-trace", 0);
15268 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
15269 "qXfer:statictrace:read", "read-sdata-object", 0);
15271 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
15272 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
15274 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
15275 "QDisableRandomization", "disable-randomization", 0);
15277 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
15278 "QAgent", "agent", 0);
15280 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
15281 "QTBuffer:size", "trace-buffer-size", 0);
15283 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
15284 "Qbtrace:off", "disable-btrace", 0);
15286 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
15287 "Qbtrace:bts", "enable-btrace-bts", 0);
15289 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
15290 "Qbtrace:pt", "enable-btrace-pt", 0);
15292 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
15293 "qXfer:btrace", "read-btrace", 0);
15295 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
15296 "qXfer:btrace-conf", "read-btrace-conf", 0);
15298 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
15299 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
15301 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
15302 "multiprocess-feature", "multiprocess-feature", 0);
15304 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
15305 "swbreak-feature", "swbreak-feature", 0);
15307 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
15308 "hwbreak-feature", "hwbreak-feature", 0);
15310 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
15311 "fork-event-feature", "fork-event-feature", 0);
15313 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
15314 "vfork-event-feature", "vfork-event-feature", 0);
15316 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
15317 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
15319 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
15320 "vContSupported", "verbose-resume-supported", 0);
15322 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
15323 "exec-event-feature", "exec-event-feature", 0);
15325 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
15326 "vCtrlC", "ctrl-c", 0);
15328 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
15329 "QThreadEvents", "thread-events", 0);
15331 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
15332 "N stop reply", "no-resumed-stop-reply", 0);
15334 add_packet_config_cmd (&remote_protocol_packets
[PACKET_memory_tagging_feature
],
15335 "memory-tagging-feature", "memory-tagging-feature", 0);
15337 /* Assert that we've registered "set remote foo-packet" commands
15338 for all packet configs. */
15342 for (i
= 0; i
< PACKET_MAX
; i
++)
15344 /* Ideally all configs would have a command associated. Some
15345 still don't though. */
15350 case PACKET_QNonStop
:
15351 case PACKET_EnableDisableTracepoints_feature
:
15352 case PACKET_tracenz_feature
:
15353 case PACKET_DisconnectedTracing_feature
:
15354 case PACKET_augmented_libraries_svr4_read_feature
:
15356 /* Additions to this list need to be well justified:
15357 pre-existing packets are OK; new packets are not. */
15365 /* This catches both forgetting to add a config command, and
15366 forgetting to remove a packet from the exception list. */
15367 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
15371 /* Keep the old ``set remote Z-packet ...'' working. Each individual
15372 Z sub-packet has its own set and show commands, but users may
15373 have sets to this variable in their .gdbinit files (or in their
15375 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
15376 &remote_Z_packet_detect
, _("\
15377 Set use of remote protocol `Z' packets."), _("\
15378 Show use of remote protocol `Z' packets."), _("\
15379 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
15381 set_remote_protocol_Z_packet_cmd
,
15382 show_remote_protocol_Z_packet_cmd
,
15383 /* FIXME: i18n: Use of remote protocol
15384 `Z' packets is %s. */
15385 &remote_set_cmdlist
, &remote_show_cmdlist
);
15387 add_basic_prefix_cmd ("remote", class_files
, _("\
15388 Manipulate files on the remote system.\n\
15389 Transfer files to and from the remote target system."),
15391 0 /* allow-unknown */, &cmdlist
);
15393 add_cmd ("put", class_files
, remote_put_command
,
15394 _("Copy a local file to the remote system."),
15397 add_cmd ("get", class_files
, remote_get_command
,
15398 _("Copy a remote file to the local system."),
15401 add_cmd ("delete", class_files
, remote_delete_command
,
15402 _("Delete a remote file."),
15405 add_setshow_string_noescape_cmd ("exec-file", class_files
,
15406 &remote_exec_file_var
, _("\
15407 Set the remote pathname for \"run\"."), _("\
15408 Show the remote pathname for \"run\"."), NULL
,
15409 set_remote_exec_file
,
15410 show_remote_exec_file
,
15411 &remote_set_cmdlist
,
15412 &remote_show_cmdlist
);
15414 add_setshow_boolean_cmd ("range-stepping", class_run
,
15415 &use_range_stepping
, _("\
15416 Enable or disable range stepping."), _("\
15417 Show whether target-assisted range stepping is enabled."), _("\
15418 If on, and the target supports it, when stepping a source line, GDB\n\
15419 tells the target to step the corresponding range of addresses itself instead\n\
15420 of issuing multiple single-steps. This speeds up source level\n\
15421 stepping. If off, GDB always issues single-steps, even if range\n\
15422 stepping is supported by the target. The default is on."),
15423 set_range_stepping
,
15424 show_range_stepping
,
15428 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
15429 Set watchdog timer."), _("\
15430 Show watchdog timer."), _("\
15431 When non-zero, this timeout is used instead of waiting forever for a target\n\
15432 to finish a low-level step or continue operation. If the specified amount\n\
15433 of time passes without a response from the target, an error occurs."),
15436 &setlist
, &showlist
);
15438 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
15439 &remote_packet_max_chars
, _("\
15440 Set the maximum number of characters to display for each remote packet."), _("\
15441 Show the maximum number of characters to display for each remote packet."), _("\
15442 Specify \"unlimited\" to display all the characters."),
15443 NULL
, show_remote_packet_max_chars
,
15444 &setdebuglist
, &showdebuglist
);
15446 add_setshow_boolean_cmd ("remote", no_class
, &remote_debug
,
15447 _("Set debugging of remote protocol."),
15448 _("Show debugging of remote protocol."),
15450 When enabled, each packet sent or received with the remote target\n\
15454 &setdebuglist
, &showdebuglist
);
15456 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
15457 &remote_timeout
, _("\
15458 Set timeout limit to wait for target to respond."), _("\
15459 Show timeout limit to wait for target to respond."), _("\
15460 This value is used to set the time limit for gdb to wait for a response\n\
15461 from the target."),
15463 show_remote_timeout
,
15464 &setlist
, &showlist
);
15466 /* Eventually initialize fileio. See fileio.c */
15467 initialize_remote_fileio (&remote_set_cmdlist
, &remote_show_cmdlist
);
15470 selftests::register_test ("remote_memory_tagging",
15471 selftests::test_memory_tagging_functions
);