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 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
;
1022 is_remote_target (process_stratum_target
*target
)
1024 remote_target
*rt
= dynamic_cast<remote_target
*> (target
);
1025 return rt
!= nullptr;
1028 /* Per-program-space data key. */
1029 static const struct program_space_key
<char, gdb::xfree_deleter
<char>>
1032 /* The variable registered as the control variable used by the
1033 remote exec-file commands. While the remote exec-file setting is
1034 per-program-space, the set/show machinery uses this as the
1035 location of the remote exec-file value. */
1036 static std::string remote_exec_file_var
;
1038 /* The size to align memory write packets, when practical. The protocol
1039 does not guarantee any alignment, and gdb will generate short
1040 writes and unaligned writes, but even as a best-effort attempt this
1041 can improve bulk transfers. For instance, if a write is misaligned
1042 relative to the target's data bus, the stub may need to make an extra
1043 round trip fetching data from the target. This doesn't make a
1044 huge difference, but it's easy to do, so we try to be helpful.
1046 The alignment chosen is arbitrary; usually data bus width is
1047 important here, not the possibly larger cache line size. */
1048 enum { REMOTE_ALIGN_WRITES
= 16 };
1050 /* Prototypes for local functions. */
1052 static int hexnumlen (ULONGEST num
);
1054 static int stubhex (int ch
);
1056 static int hexnumstr (char *, ULONGEST
);
1058 static int hexnumnstr (char *, ULONGEST
, int);
1060 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
1062 static int stub_unpack_int (const char *buff
, int fieldlength
);
1064 struct packet_config
;
1066 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
1068 struct cmd_list_element
*c
,
1071 static ptid_t
read_ptid (const char *buf
, const char **obuf
);
1073 static void remote_async_inferior_event_handler (gdb_client_data
);
1075 static bool remote_read_description_p (struct target_ops
*target
);
1077 static void remote_console_output (const char *msg
);
1079 static void remote_btrace_reset (remote_state
*rs
);
1081 static void remote_unpush_and_throw (remote_target
*target
);
1085 static struct cmd_list_element
*remote_cmdlist
;
1087 /* For "set remote" and "show remote". */
1089 static struct cmd_list_element
*remote_set_cmdlist
;
1090 static struct cmd_list_element
*remote_show_cmdlist
;
1092 /* Controls whether GDB is willing to use range stepping. */
1094 static bool use_range_stepping
= true;
1096 /* From the remote target's point of view, each thread is in one of these three
1098 enum class resume_state
1100 /* Not resumed - we haven't been asked to resume this thread. */
1103 /* We have been asked to resume this thread, but haven't sent a vCont action
1104 for it yet. We'll need to consider it next time commit_resume is
1106 RESUMED_PENDING_VCONT
,
1108 /* We have been asked to resume this thread, and we have sent a vCont action
1113 /* Information about a thread's pending vCont-resume. Used when a thread is in
1114 the remote_resume_state::RESUMED_PENDING_VCONT state. remote_target::resume
1115 stores this information which is then picked up by
1116 remote_target::commit_resume to know which is the proper action for this
1117 thread to include in the vCont packet. */
1118 struct resumed_pending_vcont_info
1120 /* True if the last resume call for this thread was a step request, false
1121 if a continue request. */
1124 /* The signal specified in the last resume call for this thread. */
1128 /* Private data that we'll store in (struct thread_info)->priv. */
1129 struct remote_thread_info
: public private_thread_info
1135 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1136 sequence of bytes. */
1137 gdb::byte_vector thread_handle
;
1139 /* Whether the target stopped for a breakpoint/watchpoint. */
1140 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1142 /* This is set to the data address of the access causing the target
1143 to stop for a watchpoint. */
1144 CORE_ADDR watch_data_address
= 0;
1146 /* Get the thread's resume state. */
1147 enum resume_state
get_resume_state () const
1149 return m_resume_state
;
1152 /* Put the thread in the NOT_RESUMED state. */
1153 void set_not_resumed ()
1155 m_resume_state
= resume_state::NOT_RESUMED
;
1158 /* Put the thread in the RESUMED_PENDING_VCONT state. */
1159 void set_resumed_pending_vcont (bool step
, gdb_signal sig
)
1161 m_resume_state
= resume_state::RESUMED_PENDING_VCONT
;
1162 m_resumed_pending_vcont_info
.step
= step
;
1163 m_resumed_pending_vcont_info
.sig
= sig
;
1166 /* Get the information this thread's pending vCont-resumption.
1168 Must only be called if the thread is in the RESUMED_PENDING_VCONT resume
1170 const struct resumed_pending_vcont_info
&resumed_pending_vcont_info () const
1172 gdb_assert (m_resume_state
== resume_state::RESUMED_PENDING_VCONT
);
1174 return m_resumed_pending_vcont_info
;
1177 /* Put the thread in the VCONT_RESUMED state. */
1180 m_resume_state
= resume_state::RESUMED
;
1184 /* Resume state for this thread. This is used to implement vCont action
1185 coalescing (only when the target operates in non-stop mode).
1187 remote_target::resume moves the thread to the RESUMED_PENDING_VCONT state,
1188 which notes that this thread must be considered in the next commit_resume
1191 remote_target::commit_resume sends a vCont packet with actions for the
1192 threads in the RESUMED_PENDING_VCONT state and moves them to the
1193 VCONT_RESUMED state.
1195 When reporting a stop to the core for a thread, that thread is moved back
1196 to the NOT_RESUMED state. */
1197 enum resume_state m_resume_state
= resume_state::NOT_RESUMED
;
1199 /* Extra info used if the thread is in the RESUMED_PENDING_VCONT state. */
1200 struct resumed_pending_vcont_info m_resumed_pending_vcont_info
;
1203 remote_state::remote_state ()
1208 remote_state::~remote_state ()
1210 xfree (this->last_pass_packet
);
1211 xfree (this->last_program_signals_packet
);
1212 xfree (this->finished_object
);
1213 xfree (this->finished_annex
);
1216 /* Utility: generate error from an incoming stub packet. */
1218 trace_error (char *buf
)
1221 return; /* not an error msg */
1224 case '1': /* malformed packet error */
1225 if (*++buf
== '0') /* general case: */
1226 error (_("remote.c: error in outgoing packet."));
1228 error (_("remote.c: error in outgoing packet at field #%ld."),
1229 strtol (buf
, NULL
, 16));
1231 error (_("Target returns error code '%s'."), buf
);
1235 /* Utility: wait for reply from stub, while accepting "O" packets. */
1238 remote_target::remote_get_noisy_reply ()
1240 struct remote_state
*rs
= get_remote_state ();
1242 do /* Loop on reply from remote stub. */
1246 QUIT
; /* Allow user to bail out with ^C. */
1247 getpkt (&rs
->buf
, 0);
1248 buf
= rs
->buf
.data ();
1251 else if (startswith (buf
, "qRelocInsn:"))
1254 CORE_ADDR from
, to
, org_to
;
1256 int adjusted_size
= 0;
1259 p
= buf
+ strlen ("qRelocInsn:");
1260 pp
= unpack_varlen_hex (p
, &ul
);
1262 error (_("invalid qRelocInsn packet: %s"), buf
);
1266 unpack_varlen_hex (p
, &ul
);
1273 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1276 catch (const gdb_exception
&ex
)
1278 if (ex
.error
== MEMORY_ERROR
)
1280 /* Propagate memory errors silently back to the
1281 target. The stub may have limited the range of
1282 addresses we can write to, for example. */
1286 /* Something unexpectedly bad happened. Be verbose
1287 so we can tell what, and propagate the error back
1288 to the stub, so it doesn't get stuck waiting for
1290 exception_fprintf (gdb_stderr
, ex
,
1291 _("warning: relocating instruction: "));
1298 adjusted_size
= to
- org_to
;
1300 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1304 else if (buf
[0] == 'O' && buf
[1] != 'K')
1305 remote_console_output (buf
+ 1); /* 'O' message from stub */
1307 return buf
; /* Here's the actual reply. */
1312 struct remote_arch_state
*
1313 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1315 remote_arch_state
*rsa
;
1317 auto it
= this->m_arch_states
.find (gdbarch
);
1318 if (it
== this->m_arch_states
.end ())
1320 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1321 std::forward_as_tuple (gdbarch
),
1322 std::forward_as_tuple (gdbarch
));
1323 rsa
= &p
.first
->second
;
1325 /* Make sure that the packet buffer is plenty big enough for
1326 this architecture. */
1327 if (this->buf
.size () < rsa
->remote_packet_size
)
1328 this->buf
.resize (2 * rsa
->remote_packet_size
);
1336 /* Fetch the global remote target state. */
1339 remote_target::get_remote_state ()
1341 /* Make sure that the remote architecture state has been
1342 initialized, because doing so might reallocate rs->buf. Any
1343 function which calls getpkt also needs to be mindful of changes
1344 to rs->buf, but this call limits the number of places which run
1346 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1348 return &m_remote_state
;
1351 /* Fetch the remote exec-file from the current program space. */
1354 get_remote_exec_file (void)
1356 char *remote_exec_file
;
1358 remote_exec_file
= remote_pspace_data
.get (current_program_space
);
1359 if (remote_exec_file
== NULL
)
1362 return remote_exec_file
;
1365 /* Set the remote exec file for PSPACE. */
1368 set_pspace_remote_exec_file (struct program_space
*pspace
,
1369 const char *remote_exec_file
)
1371 char *old_file
= remote_pspace_data
.get (pspace
);
1374 remote_pspace_data
.set (pspace
, xstrdup (remote_exec_file
));
1377 /* The "set/show remote exec-file" set command hook. */
1380 set_remote_exec_file (const char *ignored
, int from_tty
,
1381 struct cmd_list_element
*c
)
1383 set_pspace_remote_exec_file (current_program_space
,
1384 remote_exec_file_var
.c_str ());
1387 /* The "set/show remote exec-file" show command hook. */
1390 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1391 struct cmd_list_element
*cmd
, const char *value
)
1393 fprintf_filtered (file
, "%s\n", get_remote_exec_file ());
1397 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1399 int regnum
, num_remote_regs
, offset
;
1400 struct packet_reg
**remote_regs
;
1402 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1404 struct packet_reg
*r
= ®s
[regnum
];
1406 if (register_size (gdbarch
, regnum
) == 0)
1407 /* Do not try to fetch zero-sized (placeholder) registers. */
1410 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1415 /* Define the g/G packet format as the contents of each register
1416 with a remote protocol number, in order of ascending protocol
1419 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1420 for (num_remote_regs
= 0, regnum
= 0;
1421 regnum
< gdbarch_num_regs (gdbarch
);
1423 if (regs
[regnum
].pnum
!= -1)
1424 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1426 std::sort (remote_regs
, remote_regs
+ num_remote_regs
,
1427 [] (const packet_reg
*a
, const packet_reg
*b
)
1428 { return a
->pnum
< b
->pnum
; });
1430 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1432 remote_regs
[regnum
]->in_g_packet
= 1;
1433 remote_regs
[regnum
]->offset
= offset
;
1434 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1440 /* Given the architecture described by GDBARCH, return the remote
1441 protocol register's number and the register's offset in the g/G
1442 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1443 If the target does not have a mapping for REGNUM, return false,
1444 otherwise, return true. */
1447 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1448 int *pnum
, int *poffset
)
1450 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1452 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1454 map_regcache_remote_table (gdbarch
, regs
.data ());
1456 *pnum
= regs
[regnum
].pnum
;
1457 *poffset
= regs
[regnum
].offset
;
1462 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1464 /* Use the architecture to build a regnum<->pnum table, which will be
1465 1:1 unless a feature set specifies otherwise. */
1466 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1468 /* Record the maximum possible size of the g packet - it may turn out
1470 this->sizeof_g_packet
1471 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1473 /* Default maximum number of characters in a packet body. Many
1474 remote stubs have a hardwired buffer size of 400 bytes
1475 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1476 as the maximum packet-size to ensure that the packet and an extra
1477 NUL character can always fit in the buffer. This stops GDB
1478 trashing stubs that try to squeeze an extra NUL into what is
1479 already a full buffer (As of 1999-12-04 that was most stubs). */
1480 this->remote_packet_size
= 400 - 1;
1482 /* This one is filled in when a ``g'' packet is received. */
1483 this->actual_register_packet_size
= 0;
1485 /* Should rsa->sizeof_g_packet needs more space than the
1486 default, adjust the size accordingly. Remember that each byte is
1487 encoded as two characters. 32 is the overhead for the packet
1488 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1489 (``$NN:G...#NN'') is a better guess, the below has been padded a
1491 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1492 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1495 /* Get a pointer to the current remote target. If not connected to a
1496 remote target, return NULL. */
1498 static remote_target
*
1499 get_current_remote_target ()
1501 target_ops
*proc_target
= current_inferior ()->process_target ();
1502 return dynamic_cast<remote_target
*> (proc_target
);
1505 /* Return the current allowed size of a remote packet. This is
1506 inferred from the current architecture, and should be used to
1507 limit the length of outgoing packets. */
1509 remote_target::get_remote_packet_size ()
1511 struct remote_state
*rs
= get_remote_state ();
1512 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1514 if (rs
->explicit_packet_size
)
1515 return rs
->explicit_packet_size
;
1517 return rsa
->remote_packet_size
;
1520 static struct packet_reg
*
1521 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1524 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1528 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1530 gdb_assert (r
->regnum
== regnum
);
1535 static struct packet_reg
*
1536 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1541 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1543 struct packet_reg
*r
= &rsa
->regs
[i
];
1545 if (r
->pnum
== pnum
)
1551 /* Allow the user to specify what sequence to send to the remote
1552 when he requests a program interruption: Although ^C is usually
1553 what remote systems expect (this is the default, here), it is
1554 sometimes preferable to send a break. On other systems such
1555 as the Linux kernel, a break followed by g, which is Magic SysRq g
1556 is required in order to interrupt the execution. */
1557 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1558 const char interrupt_sequence_break
[] = "BREAK";
1559 const char interrupt_sequence_break_g
[] = "BREAK-g";
1560 static const char *const interrupt_sequence_modes
[] =
1562 interrupt_sequence_control_c
,
1563 interrupt_sequence_break
,
1564 interrupt_sequence_break_g
,
1567 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1570 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1571 struct cmd_list_element
*c
,
1574 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1575 fprintf_filtered (file
,
1576 _("Send the ASCII ETX character (Ctrl-c) "
1577 "to the remote target to interrupt the "
1578 "execution of the program.\n"));
1579 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1580 fprintf_filtered (file
,
1581 _("send a break signal to the remote target "
1582 "to interrupt the execution of the program.\n"));
1583 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1584 fprintf_filtered (file
,
1585 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1586 "the remote target to interrupt the execution "
1587 "of Linux kernel.\n"));
1589 internal_error (__FILE__
, __LINE__
,
1590 _("Invalid value for interrupt_sequence_mode: %s."),
1591 interrupt_sequence_mode
);
1594 /* This boolean variable specifies whether interrupt_sequence is sent
1595 to the remote target when gdb connects to it.
1596 This is mostly needed when you debug the Linux kernel: The Linux kernel
1597 expects BREAK g which is Magic SysRq g for connecting gdb. */
1598 static bool interrupt_on_connect
= false;
1600 /* This variable is used to implement the "set/show remotebreak" commands.
1601 Since these commands are now deprecated in favor of "set/show remote
1602 interrupt-sequence", it no longer has any effect on the code. */
1603 static bool remote_break
;
1606 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1609 interrupt_sequence_mode
= interrupt_sequence_break
;
1611 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1615 show_remotebreak (struct ui_file
*file
, int from_tty
,
1616 struct cmd_list_element
*c
,
1621 /* This variable sets the number of bits in an address that are to be
1622 sent in a memory ("M" or "m") packet. Normally, after stripping
1623 leading zeros, the entire address would be sent. This variable
1624 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1625 initial implementation of remote.c restricted the address sent in
1626 memory packets to ``host::sizeof long'' bytes - (typically 32
1627 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1628 address was never sent. Since fixing this bug may cause a break in
1629 some remote targets this variable is principally provided to
1630 facilitate backward compatibility. */
1632 static unsigned int remote_address_size
;
1635 /* User configurable variables for the number of characters in a
1636 memory read/write packet. MIN (rsa->remote_packet_size,
1637 rsa->sizeof_g_packet) is the default. Some targets need smaller
1638 values (fifo overruns, et.al.) and some users need larger values
1639 (speed up transfers). The variables ``preferred_*'' (the user
1640 request), ``current_*'' (what was actually set) and ``forced_*''
1641 (Positive - a soft limit, negative - a hard limit). */
1643 struct memory_packet_config
1650 /* The default max memory-write-packet-size, when the setting is
1651 "fixed". The 16k is historical. (It came from older GDB's using
1652 alloca for buffers and the knowledge (folklore?) that some hosts
1653 don't cope very well with large alloca calls.) */
1654 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1656 /* The minimum remote packet size for memory transfers. Ensures we
1657 can write at least one byte. */
1658 #define MIN_MEMORY_PACKET_SIZE 20
1660 /* Get the memory packet size, assuming it is fixed. */
1663 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1665 gdb_assert (config
->fixed_p
);
1667 if (config
->size
<= 0)
1668 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1670 return config
->size
;
1673 /* Compute the current size of a read/write packet. Since this makes
1674 use of ``actual_register_packet_size'' the computation is dynamic. */
1677 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1679 struct remote_state
*rs
= get_remote_state ();
1680 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1683 if (config
->fixed_p
)
1684 what_they_get
= get_fixed_memory_packet_size (config
);
1687 what_they_get
= get_remote_packet_size ();
1688 /* Limit the packet to the size specified by the user. */
1689 if (config
->size
> 0
1690 && what_they_get
> config
->size
)
1691 what_they_get
= config
->size
;
1693 /* Limit it to the size of the targets ``g'' response unless we have
1694 permission from the stub to use a larger packet size. */
1695 if (rs
->explicit_packet_size
== 0
1696 && rsa
->actual_register_packet_size
> 0
1697 && what_they_get
> rsa
->actual_register_packet_size
)
1698 what_they_get
= rsa
->actual_register_packet_size
;
1700 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1701 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1703 /* Make sure there is room in the global buffer for this packet
1704 (including its trailing NUL byte). */
1705 if (rs
->buf
.size () < what_they_get
+ 1)
1706 rs
->buf
.resize (2 * what_they_get
);
1708 return what_they_get
;
1711 /* Update the size of a read/write packet. If they user wants
1712 something really big then do a sanity check. */
1715 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1717 int fixed_p
= config
->fixed_p
;
1718 long size
= config
->size
;
1721 error (_("Argument required (integer, `fixed' or `limited')."));
1722 else if (strcmp (args
, "hard") == 0
1723 || strcmp (args
, "fixed") == 0)
1725 else if (strcmp (args
, "soft") == 0
1726 || strcmp (args
, "limit") == 0)
1732 size
= strtoul (args
, &end
, 0);
1734 error (_("Invalid %s (bad syntax)."), config
->name
);
1736 /* Instead of explicitly capping the size of a packet to or
1737 disallowing it, the user is allowed to set the size to
1738 something arbitrarily large. */
1742 if (fixed_p
&& !config
->fixed_p
)
1744 /* So that the query shows the correct value. */
1745 long query_size
= (size
<= 0
1746 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1749 if (! query (_("The target may not be able to correctly handle a %s\n"
1750 "of %ld bytes. Change the packet size? "),
1751 config
->name
, query_size
))
1752 error (_("Packet size not changed."));
1754 /* Update the config. */
1755 config
->fixed_p
= fixed_p
;
1756 config
->size
= size
;
1760 show_memory_packet_size (struct memory_packet_config
*config
)
1762 if (config
->size
== 0)
1763 printf_filtered (_("The %s is 0 (default). "), config
->name
);
1765 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1766 if (config
->fixed_p
)
1767 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1768 get_fixed_memory_packet_size (config
));
1771 remote_target
*remote
= get_current_remote_target ();
1774 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1775 remote
->get_memory_packet_size (config
));
1777 puts_filtered ("The actual limit will be further reduced "
1778 "dependent on the target.\n");
1782 /* FIXME: needs to be per-remote-target. */
1783 static struct memory_packet_config memory_write_packet_config
=
1785 "memory-write-packet-size",
1789 set_memory_write_packet_size (const char *args
, int from_tty
)
1791 set_memory_packet_size (args
, &memory_write_packet_config
);
1795 show_memory_write_packet_size (const char *args
, int from_tty
)
1797 show_memory_packet_size (&memory_write_packet_config
);
1800 /* Show the number of hardware watchpoints that can be used. */
1803 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1804 struct cmd_list_element
*c
,
1807 fprintf_filtered (file
, _("The maximum number of target hardware "
1808 "watchpoints is %s.\n"), value
);
1811 /* Show the length limit (in bytes) for hardware watchpoints. */
1814 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1815 struct cmd_list_element
*c
,
1818 fprintf_filtered (file
, _("The maximum length (in bytes) of a target "
1819 "hardware watchpoint is %s.\n"), value
);
1822 /* Show the number of hardware breakpoints that can be used. */
1825 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1826 struct cmd_list_element
*c
,
1829 fprintf_filtered (file
, _("The maximum number of target hardware "
1830 "breakpoints is %s.\n"), value
);
1833 /* Controls the maximum number of characters to display in the debug output
1834 for each remote packet. The remaining characters are omitted. */
1836 static int remote_packet_max_chars
= 512;
1838 /* Show the maximum number of characters to display for each remote packet
1839 when remote debugging is enabled. */
1842 show_remote_packet_max_chars (struct ui_file
*file
, int from_tty
,
1843 struct cmd_list_element
*c
,
1846 fprintf_filtered (file
, _("Number of remote packet characters to "
1847 "display is %s.\n"), value
);
1851 remote_target::get_memory_write_packet_size ()
1853 return get_memory_packet_size (&memory_write_packet_config
);
1856 /* FIXME: needs to be per-remote-target. */
1857 static struct memory_packet_config memory_read_packet_config
=
1859 "memory-read-packet-size",
1863 set_memory_read_packet_size (const char *args
, int from_tty
)
1865 set_memory_packet_size (args
, &memory_read_packet_config
);
1869 show_memory_read_packet_size (const char *args
, int from_tty
)
1871 show_memory_packet_size (&memory_read_packet_config
);
1875 remote_target::get_memory_read_packet_size ()
1877 long size
= get_memory_packet_size (&memory_read_packet_config
);
1879 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1880 extra buffer size argument before the memory read size can be
1881 increased beyond this. */
1882 if (size
> get_remote_packet_size ())
1883 size
= get_remote_packet_size ();
1889 struct packet_config
1894 /* If auto, GDB auto-detects support for this packet or feature,
1895 either through qSupported, or by trying the packet and looking
1896 at the response. If true, GDB assumes the target supports this
1897 packet. If false, the packet is disabled. Configs that don't
1898 have an associated command always have this set to auto. */
1899 enum auto_boolean detect
;
1901 /* The "show remote foo-packet" command created for this packet. */
1902 cmd_list_element
*show_cmd
;
1904 /* Does the target support this packet? */
1905 enum packet_support support
;
1908 static enum packet_support
packet_config_support (struct packet_config
*config
);
1909 static enum packet_support
packet_support (int packet
);
1912 show_packet_config_cmd (ui_file
*file
, struct packet_config
*config
)
1914 const char *support
= "internal-error";
1916 switch (packet_config_support (config
))
1919 support
= "enabled";
1921 case PACKET_DISABLE
:
1922 support
= "disabled";
1924 case PACKET_SUPPORT_UNKNOWN
:
1925 support
= "unknown";
1928 switch (config
->detect
)
1930 case AUTO_BOOLEAN_AUTO
:
1931 fprintf_filtered (file
,
1932 _("Support for the `%s' packet "
1933 "is auto-detected, currently %s.\n"),
1934 config
->name
, support
);
1936 case AUTO_BOOLEAN_TRUE
:
1937 case AUTO_BOOLEAN_FALSE
:
1938 fprintf_filtered (file
,
1939 _("Support for the `%s' packet is currently %s.\n"),
1940 config
->name
, support
);
1946 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1947 const char *title
, int legacy
)
1949 config
->name
= name
;
1950 config
->title
= title
;
1951 gdb::unique_xmalloc_ptr
<char> set_doc
1952 = xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1954 gdb::unique_xmalloc_ptr
<char> show_doc
1955 = xstrprintf ("Show current use of remote protocol `%s' (%s) packet.",
1957 /* set/show TITLE-packet {auto,on,off} */
1958 gdb::unique_xmalloc_ptr
<char> cmd_name
= xstrprintf ("%s-packet", title
);
1959 set_show_commands cmds
1960 = add_setshow_auto_boolean_cmd (cmd_name
.release (), class_obscure
,
1961 &config
->detect
, set_doc
.get (),
1962 show_doc
.get (), NULL
, /* help_doc */
1964 show_remote_protocol_packet_cmd
,
1965 &remote_set_cmdlist
, &remote_show_cmdlist
);
1966 config
->show_cmd
= cmds
.show
;
1968 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1971 /* It's not clear who should take ownership of this string, so, for
1972 now, make it static, and give copies to each of the add_alias_cmd
1974 static gdb::unique_xmalloc_ptr
<char> legacy_name
1975 = xstrprintf ("%s-packet", name
);
1976 add_alias_cmd (legacy_name
.get (), cmds
.set
, class_obscure
, 0,
1977 &remote_set_cmdlist
);
1978 add_alias_cmd (legacy_name
.get (), cmds
.show
, class_obscure
, 0,
1979 &remote_show_cmdlist
);
1983 static enum packet_result
1984 packet_check_result (const char *buf
)
1988 /* The stub recognized the packet request. Check that the
1989 operation succeeded. */
1991 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1993 /* "Enn" - definitely an error. */
1994 return PACKET_ERROR
;
1996 /* Always treat "E." as an error. This will be used for
1997 more verbose error messages, such as E.memtypes. */
1998 if (buf
[0] == 'E' && buf
[1] == '.')
1999 return PACKET_ERROR
;
2001 /* The packet may or may not be OK. Just assume it is. */
2005 /* The stub does not support the packet. */
2006 return PACKET_UNKNOWN
;
2009 static enum packet_result
2010 packet_check_result (const gdb::char_vector
&buf
)
2012 return packet_check_result (buf
.data ());
2015 static enum packet_result
2016 packet_ok (const char *buf
, struct packet_config
*config
)
2018 enum packet_result result
;
2020 if (config
->detect
!= AUTO_BOOLEAN_TRUE
2021 && config
->support
== PACKET_DISABLE
)
2022 internal_error (__FILE__
, __LINE__
,
2023 _("packet_ok: attempt to use a disabled packet"));
2025 result
= packet_check_result (buf
);
2030 /* The stub recognized the packet request. */
2031 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
2033 remote_debug_printf ("Packet %s (%s) is supported",
2034 config
->name
, config
->title
);
2035 config
->support
= PACKET_ENABLE
;
2038 case PACKET_UNKNOWN
:
2039 /* The stub does not support the packet. */
2040 if (config
->detect
== AUTO_BOOLEAN_AUTO
2041 && config
->support
== PACKET_ENABLE
)
2043 /* If the stub previously indicated that the packet was
2044 supported then there is a protocol error. */
2045 error (_("Protocol error: %s (%s) conflicting enabled responses."),
2046 config
->name
, config
->title
);
2048 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
2050 /* The user set it wrong. */
2051 error (_("Enabled packet %s (%s) not recognized by stub"),
2052 config
->name
, config
->title
);
2055 remote_debug_printf ("Packet %s (%s) is NOT supported",
2056 config
->name
, config
->title
);
2057 config
->support
= PACKET_DISABLE
;
2064 static enum packet_result
2065 packet_ok (const gdb::char_vector
&buf
, struct packet_config
*config
)
2067 return packet_ok (buf
.data (), config
);
2084 PACKET_vFile_pwrite
,
2086 PACKET_vFile_unlink
,
2087 PACKET_vFile_readlink
,
2090 PACKET_qXfer_features
,
2091 PACKET_qXfer_exec_file
,
2092 PACKET_qXfer_libraries
,
2093 PACKET_qXfer_libraries_svr4
,
2094 PACKET_qXfer_memory_map
,
2095 PACKET_qXfer_osdata
,
2096 PACKET_qXfer_threads
,
2097 PACKET_qXfer_statictrace_read
,
2098 PACKET_qXfer_traceframe_info
,
2104 PACKET_QPassSignals
,
2105 PACKET_QCatchSyscalls
,
2106 PACKET_QProgramSignals
,
2107 PACKET_QSetWorkingDir
,
2108 PACKET_QStartupWithShell
,
2109 PACKET_QEnvironmentHexEncoded
,
2110 PACKET_QEnvironmentReset
,
2111 PACKET_QEnvironmentUnset
,
2113 PACKET_qSearch_memory
,
2116 PACKET_QStartNoAckMode
,
2118 PACKET_qXfer_siginfo_read
,
2119 PACKET_qXfer_siginfo_write
,
2122 /* Support for conditional tracepoints. */
2123 PACKET_ConditionalTracepoints
,
2125 /* Support for target-side breakpoint conditions. */
2126 PACKET_ConditionalBreakpoints
,
2128 /* Support for target-side breakpoint commands. */
2129 PACKET_BreakpointCommands
,
2131 /* Support for fast tracepoints. */
2132 PACKET_FastTracepoints
,
2134 /* Support for static tracepoints. */
2135 PACKET_StaticTracepoints
,
2137 /* Support for installing tracepoints while a trace experiment is
2139 PACKET_InstallInTrace
,
2143 PACKET_TracepointSource
,
2146 PACKET_QDisableRandomization
,
2148 PACKET_QTBuffer_size
,
2152 PACKET_qXfer_btrace
,
2154 /* Support for the QNonStop packet. */
2157 /* Support for the QThreadEvents packet. */
2158 PACKET_QThreadEvents
,
2160 /* Support for multi-process extensions. */
2161 PACKET_multiprocess_feature
,
2163 /* Support for enabling and disabling tracepoints while a trace
2164 experiment is running. */
2165 PACKET_EnableDisableTracepoints_feature
,
2167 /* Support for collecting strings using the tracenz bytecode. */
2168 PACKET_tracenz_feature
,
2170 /* Support for continuing to run a trace experiment while GDB is
2172 PACKET_DisconnectedTracing_feature
,
2174 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2175 PACKET_augmented_libraries_svr4_read_feature
,
2177 /* Support for the qXfer:btrace-conf:read packet. */
2178 PACKET_qXfer_btrace_conf
,
2180 /* Support for the Qbtrace-conf:bts:size packet. */
2181 PACKET_Qbtrace_conf_bts_size
,
2183 /* Support for swbreak+ feature. */
2184 PACKET_swbreak_feature
,
2186 /* Support for hwbreak+ feature. */
2187 PACKET_hwbreak_feature
,
2189 /* Support for fork events. */
2190 PACKET_fork_event_feature
,
2192 /* Support for vfork events. */
2193 PACKET_vfork_event_feature
,
2195 /* Support for the Qbtrace-conf:pt:size packet. */
2196 PACKET_Qbtrace_conf_pt_size
,
2198 /* Support for exec events. */
2199 PACKET_exec_event_feature
,
2201 /* Support for query supported vCont actions. */
2202 PACKET_vContSupported
,
2204 /* Support remote CTRL-C. */
2207 /* Support TARGET_WAITKIND_NO_RESUMED. */
2210 /* Support for memory tagging, allocation tag fetch/store
2211 packets and the tag violation stop replies. */
2212 PACKET_memory_tagging_feature
,
2217 /* FIXME: needs to be per-remote-target. Ignoring this for now,
2218 assuming all remote targets are the same server (thus all support
2219 the same packets). */
2220 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
2222 /* Returns the packet's corresponding "set remote foo-packet" command
2223 state. See struct packet_config for more details. */
2225 static enum auto_boolean
2226 packet_set_cmd_state (int packet
)
2228 return remote_protocol_packets
[packet
].detect
;
2231 /* Returns whether a given packet or feature is supported. This takes
2232 into account the state of the corresponding "set remote foo-packet"
2233 command, which may be used to bypass auto-detection. */
2235 static enum packet_support
2236 packet_config_support (struct packet_config
*config
)
2238 switch (config
->detect
)
2240 case AUTO_BOOLEAN_TRUE
:
2241 return PACKET_ENABLE
;
2242 case AUTO_BOOLEAN_FALSE
:
2243 return PACKET_DISABLE
;
2244 case AUTO_BOOLEAN_AUTO
:
2245 return config
->support
;
2247 gdb_assert_not_reached ("bad switch");
2251 /* Same as packet_config_support, but takes the packet's enum value as
2254 static enum packet_support
2255 packet_support (int packet
)
2257 struct packet_config
*config
= &remote_protocol_packets
[packet
];
2259 return packet_config_support (config
);
2263 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
2264 struct cmd_list_element
*c
,
2267 struct packet_config
*packet
;
2268 gdb_assert (c
->var
.has_value ());
2270 for (packet
= remote_protocol_packets
;
2271 packet
< &remote_protocol_packets
[PACKET_MAX
];
2274 if (c
== packet
->show_cmd
)
2276 show_packet_config_cmd (file
, packet
);
2280 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
2284 /* Should we try one of the 'Z' requests? */
2288 Z_PACKET_SOFTWARE_BP
,
2289 Z_PACKET_HARDWARE_BP
,
2296 /* For compatibility with older distributions. Provide a ``set remote
2297 Z-packet ...'' command that updates all the Z packet types. */
2299 static enum auto_boolean remote_Z_packet_detect
;
2302 set_remote_protocol_Z_packet_cmd (const char *args
, int from_tty
,
2303 struct cmd_list_element
*c
)
2307 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2308 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
2312 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
2313 struct cmd_list_element
*c
,
2318 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2320 show_packet_config_cmd (file
, &remote_protocol_packets
[PACKET_Z0
+ i
]);
2324 /* Returns true if the multi-process extensions are in effect. */
2327 remote_multi_process_p (struct remote_state
*rs
)
2329 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
2332 /* Returns true if fork events are supported. */
2335 remote_fork_event_p (struct remote_state
*rs
)
2337 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
2340 /* Returns true if vfork events are supported. */
2343 remote_vfork_event_p (struct remote_state
*rs
)
2345 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
2348 /* Returns true if exec events are supported. */
2351 remote_exec_event_p (struct remote_state
*rs
)
2353 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
2356 /* Returns true if memory tagging is supported, false otherwise. */
2359 remote_memory_tagging_p ()
2361 return packet_support (PACKET_memory_tagging_feature
) == PACKET_ENABLE
;
2364 /* Insert fork catchpoint target routine. If fork events are enabled
2365 then return success, nothing more to do. */
2368 remote_target::insert_fork_catchpoint (int pid
)
2370 struct remote_state
*rs
= get_remote_state ();
2372 return !remote_fork_event_p (rs
);
2375 /* Remove fork catchpoint target routine. Nothing to do, just
2379 remote_target::remove_fork_catchpoint (int pid
)
2384 /* Insert vfork catchpoint target routine. If vfork events are enabled
2385 then return success, nothing more to do. */
2388 remote_target::insert_vfork_catchpoint (int pid
)
2390 struct remote_state
*rs
= get_remote_state ();
2392 return !remote_vfork_event_p (rs
);
2395 /* Remove vfork catchpoint target routine. Nothing to do, just
2399 remote_target::remove_vfork_catchpoint (int pid
)
2404 /* Insert exec catchpoint target routine. If exec events are
2405 enabled, just return success. */
2408 remote_target::insert_exec_catchpoint (int pid
)
2410 struct remote_state
*rs
= get_remote_state ();
2412 return !remote_exec_event_p (rs
);
2415 /* Remove exec catchpoint target routine. Nothing to do, just
2419 remote_target::remove_exec_catchpoint (int pid
)
2426 /* Take advantage of the fact that the TID field is not used, to tag
2427 special ptids with it set to != 0. */
2428 static const ptid_t
magic_null_ptid (42000, -1, 1);
2429 static const ptid_t
not_sent_ptid (42000, -2, 1);
2430 static const ptid_t
any_thread_ptid (42000, 0, 1);
2432 /* Find out if the stub attached to PID (and hence GDB should offer to
2433 detach instead of killing it when bailing out). */
2436 remote_target::remote_query_attached (int pid
)
2438 struct remote_state
*rs
= get_remote_state ();
2439 size_t size
= get_remote_packet_size ();
2441 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
2444 if (remote_multi_process_p (rs
))
2445 xsnprintf (rs
->buf
.data (), size
, "qAttached:%x", pid
);
2447 xsnprintf (rs
->buf
.data (), size
, "qAttached");
2450 getpkt (&rs
->buf
, 0);
2452 switch (packet_ok (rs
->buf
,
2453 &remote_protocol_packets
[PACKET_qAttached
]))
2456 if (strcmp (rs
->buf
.data (), "1") == 0)
2460 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
2462 case PACKET_UNKNOWN
:
2469 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2470 has been invented by GDB, instead of reported by the target. Since
2471 we can be connected to a remote system before before knowing about
2472 any inferior, mark the target with execution when we find the first
2473 inferior. If ATTACHED is 1, then we had just attached to this
2474 inferior. If it is 0, then we just created this inferior. If it
2475 is -1, then try querying the remote stub to find out if it had
2476 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2477 attempt to open this inferior's executable as the main executable
2478 if no main executable is open already. */
2481 remote_target::remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
2484 struct inferior
*inf
;
2486 /* Check whether this process we're learning about is to be
2487 considered attached, or if is to be considered to have been
2488 spawned by the stub. */
2490 attached
= remote_query_attached (pid
);
2492 if (gdbarch_has_global_solist (target_gdbarch ()))
2494 /* If the target shares code across all inferiors, then every
2495 attach adds a new inferior. */
2496 inf
= add_inferior (pid
);
2498 /* ... and every inferior is bound to the same program space.
2499 However, each inferior may still have its own address
2501 inf
->aspace
= maybe_new_address_space ();
2502 inf
->pspace
= current_program_space
;
2506 /* In the traditional debugging scenario, there's a 1-1 match
2507 between program/address spaces. We simply bind the inferior
2508 to the program space's address space. */
2509 inf
= current_inferior ();
2511 /* However, if the current inferior is already bound to a
2512 process, find some other empty inferior. */
2516 for (inferior
*it
: all_inferiors ())
2525 /* Since all inferiors were already bound to a process, add
2527 inf
= add_inferior_with_spaces ();
2529 switch_to_inferior_no_thread (inf
);
2530 inf
->push_target (this);
2531 inferior_appeared (inf
, pid
);
2534 inf
->attach_flag
= attached
;
2535 inf
->fake_pid_p
= fake_pid_p
;
2537 /* If no main executable is currently open then attempt to
2538 open the file that was executed to create this inferior. */
2539 if (try_open_exec
&& get_exec_file (0) == NULL
)
2540 exec_file_locate_attach (pid
, 0, 1);
2542 /* Check for exec file mismatch, and let the user solve it. */
2543 validate_exec_file (1);
2548 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2549 static remote_thread_info
*get_remote_thread_info (remote_target
*target
,
2552 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2553 according to EXECUTING and RUNNING respectively. If SILENT_P (or the
2554 remote_state::starting_up flag) is true then the new thread is added
2555 silently, otherwise the new thread will be announced to the user. */
2558 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
,
2561 struct remote_state
*rs
= get_remote_state ();
2562 struct thread_info
*thread
;
2564 /* GDB historically didn't pull threads in the initial connection
2565 setup. If the remote target doesn't even have a concept of
2566 threads (e.g., a bare-metal target), even if internally we
2567 consider that a single-threaded target, mentioning a new thread
2568 might be confusing to the user. Be silent then, preserving the
2569 age old behavior. */
2570 if (rs
->starting_up
|| silent_p
)
2571 thread
= add_thread_silent (this, ptid
);
2573 thread
= add_thread (this, ptid
);
2575 /* We start by assuming threads are resumed. That state then gets updated
2576 when we process a matching stop reply. */
2577 get_remote_thread_info (thread
)->set_resumed ();
2579 set_executing (this, ptid
, executing
);
2580 set_running (this, ptid
, running
);
2585 /* Come here when we learn about a thread id from the remote target.
2586 It may be the first time we hear about such thread, so take the
2587 opportunity to add it to GDB's thread list. In case this is the
2588 first time we're noticing its corresponding inferior, add it to
2589 GDB's inferior list as well. EXECUTING indicates whether the
2590 thread is (internally) executing or stopped. */
2593 remote_target::remote_notice_new_inferior (ptid_t currthread
, bool executing
)
2595 /* In non-stop mode, we assume new found threads are (externally)
2596 running until proven otherwise with a stop reply. In all-stop,
2597 we can only get here if all threads are stopped. */
2598 bool running
= target_is_non_stop_p ();
2600 /* If this is a new thread, add it to GDB's thread list.
2601 If we leave it up to WFI to do this, bad things will happen. */
2603 thread_info
*tp
= find_thread_ptid (this, currthread
);
2604 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2606 /* We're seeing an event on a thread id we knew had exited.
2607 This has to be a new thread reusing the old id. Add it. */
2608 remote_add_thread (currthread
, running
, executing
, false);
2612 if (!in_thread_list (this, currthread
))
2614 struct inferior
*inf
= NULL
;
2615 int pid
= currthread
.pid ();
2617 if (inferior_ptid
.is_pid ()
2618 && pid
== inferior_ptid
.pid ())
2620 /* inferior_ptid has no thread member yet. This can happen
2621 with the vAttach -> remote_wait,"TAAthread:" path if the
2622 stub doesn't support qC. This is the first stop reported
2623 after an attach, so this is the main thread. Update the
2624 ptid in the thread list. */
2625 if (in_thread_list (this, ptid_t (pid
)))
2626 thread_change_ptid (this, inferior_ptid
, currthread
);
2630 = remote_add_thread (currthread
, running
, executing
, false);
2631 switch_to_thread (thr
);
2636 if (magic_null_ptid
== inferior_ptid
)
2638 /* inferior_ptid is not set yet. This can happen with the
2639 vRun -> remote_wait,"TAAthread:" path if the stub
2640 doesn't support qC. This is the first stop reported
2641 after an attach, so this is the main thread. Update the
2642 ptid in the thread list. */
2643 thread_change_ptid (this, inferior_ptid
, currthread
);
2647 /* When connecting to a target remote, or to a target
2648 extended-remote which already was debugging an inferior, we
2649 may not know about it yet. Add it before adding its child
2650 thread, so notifications are emitted in a sensible order. */
2651 if (find_inferior_pid (this, currthread
.pid ()) == NULL
)
2653 struct remote_state
*rs
= get_remote_state ();
2654 bool fake_pid_p
= !remote_multi_process_p (rs
);
2656 inf
= remote_add_inferior (fake_pid_p
,
2657 currthread
.pid (), -1, 1);
2660 /* This is really a new thread. Add it. */
2661 thread_info
*new_thr
2662 = remote_add_thread (currthread
, running
, executing
, false);
2664 /* If we found a new inferior, let the common code do whatever
2665 it needs to with it (e.g., read shared libraries, insert
2666 breakpoints), unless we're just setting up an all-stop
2670 struct remote_state
*rs
= get_remote_state ();
2672 if (!rs
->starting_up
)
2673 notice_new_inferior (new_thr
, executing
, 0);
2678 /* Return THREAD's private thread data, creating it if necessary. */
2680 static remote_thread_info
*
2681 get_remote_thread_info (thread_info
*thread
)
2683 gdb_assert (thread
!= NULL
);
2685 if (thread
->priv
== NULL
)
2686 thread
->priv
.reset (new remote_thread_info
);
2688 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2691 /* Return PTID's private thread data, creating it if necessary. */
2693 static remote_thread_info
*
2694 get_remote_thread_info (remote_target
*target
, ptid_t ptid
)
2696 thread_info
*thr
= find_thread_ptid (target
, ptid
);
2697 return get_remote_thread_info (thr
);
2700 /* Call this function as a result of
2701 1) A halt indication (T packet) containing a thread id
2702 2) A direct query of currthread
2703 3) Successful execution of set thread */
2706 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2708 rs
->general_thread
= currthread
;
2711 /* If 'QPassSignals' is supported, tell the remote stub what signals
2712 it can simply pass through to the inferior without reporting. */
2715 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2717 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2719 char *pass_packet
, *p
;
2721 struct remote_state
*rs
= get_remote_state ();
2723 gdb_assert (pass_signals
.size () < 256);
2724 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2726 if (pass_signals
[i
])
2729 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2730 strcpy (pass_packet
, "QPassSignals:");
2731 p
= pass_packet
+ strlen (pass_packet
);
2732 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2734 if (pass_signals
[i
])
2737 *p
++ = tohex (i
>> 4);
2738 *p
++ = tohex (i
& 15);
2747 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2749 putpkt (pass_packet
);
2750 getpkt (&rs
->buf
, 0);
2751 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2752 xfree (rs
->last_pass_packet
);
2753 rs
->last_pass_packet
= pass_packet
;
2756 xfree (pass_packet
);
2760 /* If 'QCatchSyscalls' is supported, tell the remote stub
2761 to report syscalls to GDB. */
2764 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2765 gdb::array_view
<const int> syscall_counts
)
2767 const char *catch_packet
;
2768 enum packet_result result
;
2771 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2773 /* Not supported. */
2777 if (needed
&& any_count
== 0)
2779 /* Count how many syscalls are to be caught. */
2780 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2782 if (syscall_counts
[i
] != 0)
2787 remote_debug_printf ("pid %d needed %d any_count %d n_sysno %d",
2788 pid
, needed
, any_count
, n_sysno
);
2790 std::string built_packet
;
2793 /* Prepare a packet with the sysno list, assuming max 8+1
2794 characters for a sysno. If the resulting packet size is too
2795 big, fallback on the non-selective packet. */
2796 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2797 built_packet
.reserve (maxpktsz
);
2798 built_packet
= "QCatchSyscalls:1";
2801 /* Add in each syscall to be caught. */
2802 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2804 if (syscall_counts
[i
] != 0)
2805 string_appendf (built_packet
, ";%zx", i
);
2808 if (built_packet
.size () > get_remote_packet_size ())
2810 /* catch_packet too big. Fallback to less efficient
2811 non selective mode, with GDB doing the filtering. */
2812 catch_packet
= "QCatchSyscalls:1";
2815 catch_packet
= built_packet
.c_str ();
2818 catch_packet
= "QCatchSyscalls:0";
2820 struct remote_state
*rs
= get_remote_state ();
2822 putpkt (catch_packet
);
2823 getpkt (&rs
->buf
, 0);
2824 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2825 if (result
== PACKET_OK
)
2831 /* If 'QProgramSignals' is supported, tell the remote stub what
2832 signals it should pass through to the inferior when detaching. */
2835 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2837 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2841 struct remote_state
*rs
= get_remote_state ();
2843 gdb_assert (signals
.size () < 256);
2844 for (size_t i
= 0; i
< signals
.size (); i
++)
2849 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2850 strcpy (packet
, "QProgramSignals:");
2851 p
= packet
+ strlen (packet
);
2852 for (size_t i
= 0; i
< signals
.size (); i
++)
2854 if (signal_pass_state (i
))
2857 *p
++ = tohex (i
>> 4);
2858 *p
++ = tohex (i
& 15);
2867 if (!rs
->last_program_signals_packet
2868 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2871 getpkt (&rs
->buf
, 0);
2872 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2873 xfree (rs
->last_program_signals_packet
);
2874 rs
->last_program_signals_packet
= packet
;
2881 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2882 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2883 thread. If GEN is set, set the general thread, if not, then set
2884 the step/continue thread. */
2886 remote_target::set_thread (ptid_t ptid
, int gen
)
2888 struct remote_state
*rs
= get_remote_state ();
2889 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2890 char *buf
= rs
->buf
.data ();
2891 char *endbuf
= buf
+ get_remote_packet_size ();
2897 *buf
++ = gen
? 'g' : 'c';
2898 if (ptid
== magic_null_ptid
)
2899 xsnprintf (buf
, endbuf
- buf
, "0");
2900 else if (ptid
== any_thread_ptid
)
2901 xsnprintf (buf
, endbuf
- buf
, "0");
2902 else if (ptid
== minus_one_ptid
)
2903 xsnprintf (buf
, endbuf
- buf
, "-1");
2905 write_ptid (buf
, endbuf
, ptid
);
2907 getpkt (&rs
->buf
, 0);
2909 rs
->general_thread
= ptid
;
2911 rs
->continue_thread
= ptid
;
2915 remote_target::set_general_thread (ptid_t ptid
)
2917 set_thread (ptid
, 1);
2921 remote_target::set_continue_thread (ptid_t ptid
)
2923 set_thread (ptid
, 0);
2926 /* Change the remote current process. Which thread within the process
2927 ends up selected isn't important, as long as it is the same process
2928 as what INFERIOR_PTID points to.
2930 This comes from that fact that there is no explicit notion of
2931 "selected process" in the protocol. The selected process for
2932 general operations is the process the selected general thread
2936 remote_target::set_general_process ()
2938 struct remote_state
*rs
= get_remote_state ();
2940 /* If the remote can't handle multiple processes, don't bother. */
2941 if (!remote_multi_process_p (rs
))
2944 /* We only need to change the remote current thread if it's pointing
2945 at some other process. */
2946 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2947 set_general_thread (inferior_ptid
);
2951 /* Return nonzero if this is the main thread that we made up ourselves
2952 to model non-threaded targets as single-threaded. */
2955 remote_thread_always_alive (ptid_t ptid
)
2957 if (ptid
== magic_null_ptid
)
2958 /* The main thread is always alive. */
2961 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2962 /* The main thread is always alive. This can happen after a
2963 vAttach, if the remote side doesn't support
2970 /* Return nonzero if the thread PTID is still alive on the remote
2974 remote_target::thread_alive (ptid_t ptid
)
2976 struct remote_state
*rs
= get_remote_state ();
2979 /* Check if this is a thread that we made up ourselves to model
2980 non-threaded targets as single-threaded. */
2981 if (remote_thread_always_alive (ptid
))
2984 p
= rs
->buf
.data ();
2985 endp
= p
+ get_remote_packet_size ();
2988 write_ptid (p
, endp
, ptid
);
2991 getpkt (&rs
->buf
, 0);
2992 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2995 /* Return a pointer to a thread name if we know it and NULL otherwise.
2996 The thread_info object owns the memory for the name. */
2999 remote_target::thread_name (struct thread_info
*info
)
3001 if (info
->priv
!= NULL
)
3003 const std::string
&name
= get_remote_thread_info (info
)->name
;
3004 return !name
.empty () ? name
.c_str () : NULL
;
3010 /* About these extended threadlist and threadinfo packets. They are
3011 variable length packets but, the fields within them are often fixed
3012 length. They are redundant enough to send over UDP as is the
3013 remote protocol in general. There is a matching unit test module
3016 /* WARNING: This threadref data structure comes from the remote O.S.,
3017 libstub protocol encoding, and remote.c. It is not particularly
3020 /* Right now, the internal structure is int. We want it to be bigger.
3021 Plan to fix this. */
3023 typedef int gdb_threadref
; /* Internal GDB thread reference. */
3025 /* gdb_ext_thread_info is an internal GDB data structure which is
3026 equivalent to the reply of the remote threadinfo packet. */
3028 struct gdb_ext_thread_info
3030 threadref threadid
; /* External form of thread reference. */
3031 int active
; /* Has state interesting to GDB?
3033 char display
[256]; /* Brief state display, name,
3034 blocked/suspended. */
3035 char shortname
[32]; /* To be used to name threads. */
3036 char more_display
[256]; /* Long info, statistics, queue depth,
3040 /* The volume of remote transfers can be limited by submitting
3041 a mask containing bits specifying the desired information.
3042 Use a union of these values as the 'selection' parameter to
3043 get_thread_info. FIXME: Make these TAG names more thread specific. */
3045 #define TAG_THREADID 1
3046 #define TAG_EXISTS 2
3047 #define TAG_DISPLAY 4
3048 #define TAG_THREADNAME 8
3049 #define TAG_MOREDISPLAY 16
3051 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
3053 static const char *unpack_nibble (const char *buf
, int *val
);
3055 static const char *unpack_byte (const char *buf
, int *value
);
3057 static char *pack_int (char *buf
, int value
);
3059 static const char *unpack_int (const char *buf
, int *value
);
3061 static const char *unpack_string (const char *src
, char *dest
, int length
);
3063 static char *pack_threadid (char *pkt
, threadref
*id
);
3065 static const char *unpack_threadid (const char *inbuf
, threadref
*id
);
3067 void int_to_threadref (threadref
*id
, int value
);
3069 static int threadref_to_int (threadref
*ref
);
3071 static void copy_threadref (threadref
*dest
, threadref
*src
);
3073 static int threadmatch (threadref
*dest
, threadref
*src
);
3075 static char *pack_threadinfo_request (char *pkt
, int mode
,
3078 static char *pack_threadlist_request (char *pkt
, int startflag
,
3080 threadref
*nextthread
);
3082 static int remote_newthread_step (threadref
*ref
, void *context
);
3085 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
3086 buffer we're allowed to write to. Returns
3087 BUF+CHARACTERS_WRITTEN. */
3090 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
3093 struct remote_state
*rs
= get_remote_state ();
3095 if (remote_multi_process_p (rs
))
3099 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
3101 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
3105 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
3107 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
3112 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
3113 last parsed char. Returns null_ptid if no thread id is found, and
3114 throws an error if the thread id has an invalid format. */
3117 read_ptid (const char *buf
, const char **obuf
)
3119 const char *p
= buf
;
3121 ULONGEST pid
= 0, tid
= 0;
3125 /* Multi-process ptid. */
3126 pp
= unpack_varlen_hex (p
+ 1, &pid
);
3128 error (_("invalid remote ptid: %s"), p
);
3131 pp
= unpack_varlen_hex (p
+ 1, &tid
);
3134 return ptid_t (pid
, tid
);
3137 /* No multi-process. Just a tid. */
3138 pp
= unpack_varlen_hex (p
, &tid
);
3140 /* Return null_ptid when no thread id is found. */
3148 /* Since the stub is not sending a process id, then default to
3149 what's in inferior_ptid, unless it's null at this point. If so,
3150 then since there's no way to know the pid of the reported
3151 threads, use the magic number. */
3152 if (inferior_ptid
== null_ptid
)
3153 pid
= magic_null_ptid
.pid ();
3155 pid
= inferior_ptid
.pid ();
3159 return ptid_t (pid
, tid
);
3165 if (ch
>= 'a' && ch
<= 'f')
3166 return ch
- 'a' + 10;
3167 if (ch
>= '0' && ch
<= '9')
3169 if (ch
>= 'A' && ch
<= 'F')
3170 return ch
- 'A' + 10;
3175 stub_unpack_int (const char *buff
, int fieldlength
)
3182 nibble
= stubhex (*buff
++);
3186 retval
= retval
<< 4;
3192 unpack_nibble (const char *buf
, int *val
)
3194 *val
= fromhex (*buf
++);
3199 unpack_byte (const char *buf
, int *value
)
3201 *value
= stub_unpack_int (buf
, 2);
3206 pack_int (char *buf
, int value
)
3208 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3209 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3210 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3211 buf
= pack_hex_byte (buf
, (value
& 0xff));
3216 unpack_int (const char *buf
, int *value
)
3218 *value
= stub_unpack_int (buf
, 8);
3222 #if 0 /* Currently unused, uncomment when needed. */
3223 static char *pack_string (char *pkt
, char *string
);
3226 pack_string (char *pkt
, char *string
)
3231 len
= strlen (string
);
3233 len
= 200; /* Bigger than most GDB packets, junk??? */
3234 pkt
= pack_hex_byte (pkt
, len
);
3238 if ((ch
== '\0') || (ch
== '#'))
3239 ch
= '*'; /* Protect encapsulation. */
3244 #endif /* 0 (unused) */
3247 unpack_string (const char *src
, char *dest
, int length
)
3256 pack_threadid (char *pkt
, threadref
*id
)
3259 unsigned char *altid
;
3261 altid
= (unsigned char *) id
;
3262 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3264 pkt
= pack_hex_byte (pkt
, *altid
++);
3270 unpack_threadid (const char *inbuf
, threadref
*id
)
3273 const char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3276 altref
= (char *) id
;
3278 while (inbuf
< limit
)
3280 x
= stubhex (*inbuf
++);
3281 y
= stubhex (*inbuf
++);
3282 *altref
++ = (x
<< 4) | y
;
3287 /* Externally, threadrefs are 64 bits but internally, they are still
3288 ints. This is due to a mismatch of specifications. We would like
3289 to use 64bit thread references internally. This is an adapter
3293 int_to_threadref (threadref
*id
, int value
)
3295 unsigned char *scan
;
3297 scan
= (unsigned char *) id
;
3303 *scan
++ = (value
>> 24) & 0xff;
3304 *scan
++ = (value
>> 16) & 0xff;
3305 *scan
++ = (value
>> 8) & 0xff;
3306 *scan
++ = (value
& 0xff);
3310 threadref_to_int (threadref
*ref
)
3313 unsigned char *scan
;
3319 value
= (value
<< 8) | ((*scan
++) & 0xff);
3324 copy_threadref (threadref
*dest
, threadref
*src
)
3327 unsigned char *csrc
, *cdest
;
3329 csrc
= (unsigned char *) src
;
3330 cdest
= (unsigned char *) dest
;
3337 threadmatch (threadref
*dest
, threadref
*src
)
3339 /* Things are broken right now, so just assume we got a match. */
3341 unsigned char *srcp
, *destp
;
3343 srcp
= (char *) src
;
3344 destp
= (char *) dest
;
3348 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3355 threadid:1, # always request threadid
3362 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3365 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3367 *pkt
++ = 'q'; /* Info Query */
3368 *pkt
++ = 'P'; /* process or thread info */
3369 pkt
= pack_int (pkt
, mode
); /* mode */
3370 pkt
= pack_threadid (pkt
, id
); /* threadid */
3371 *pkt
= '\0'; /* terminate */
3375 /* These values tag the fields in a thread info response packet. */
3376 /* Tagging the fields allows us to request specific fields and to
3377 add more fields as time goes by. */
3379 #define TAG_THREADID 1 /* Echo the thread identifier. */
3380 #define TAG_EXISTS 2 /* Is this process defined enough to
3381 fetch registers and its stack? */
3382 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3383 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3384 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3388 remote_target::remote_unpack_thread_info_response (const char *pkt
,
3389 threadref
*expectedref
,
3390 gdb_ext_thread_info
*info
)
3392 struct remote_state
*rs
= get_remote_state ();
3396 const char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3399 /* info->threadid = 0; FIXME: implement zero_threadref. */
3401 info
->display
[0] = '\0';
3402 info
->shortname
[0] = '\0';
3403 info
->more_display
[0] = '\0';
3405 /* Assume the characters indicating the packet type have been
3407 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3408 pkt
= unpack_threadid (pkt
, &ref
);
3411 warning (_("Incomplete response to threadinfo request."));
3412 if (!threadmatch (&ref
, expectedref
))
3413 { /* This is an answer to a different request. */
3414 warning (_("ERROR RMT Thread info mismatch."));
3417 copy_threadref (&info
->threadid
, &ref
);
3419 /* Loop on tagged fields , try to bail if something goes wrong. */
3421 /* Packets are terminated with nulls. */
3422 while ((pkt
< limit
) && mask
&& *pkt
)
3424 pkt
= unpack_int (pkt
, &tag
); /* tag */
3425 pkt
= unpack_byte (pkt
, &length
); /* length */
3426 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3428 warning (_("ERROR RMT: threadinfo tag mismatch."));
3432 if (tag
== TAG_THREADID
)
3436 warning (_("ERROR RMT: length of threadid is not 16."));
3440 pkt
= unpack_threadid (pkt
, &ref
);
3441 mask
= mask
& ~TAG_THREADID
;
3444 if (tag
== TAG_EXISTS
)
3446 info
->active
= stub_unpack_int (pkt
, length
);
3448 mask
= mask
& ~(TAG_EXISTS
);
3451 warning (_("ERROR RMT: 'exists' length too long."));
3457 if (tag
== TAG_THREADNAME
)
3459 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3460 mask
= mask
& ~TAG_THREADNAME
;
3463 if (tag
== TAG_DISPLAY
)
3465 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3466 mask
= mask
& ~TAG_DISPLAY
;
3469 if (tag
== TAG_MOREDISPLAY
)
3471 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3472 mask
= mask
& ~TAG_MOREDISPLAY
;
3475 warning (_("ERROR RMT: unknown thread info tag."));
3476 break; /* Not a tag we know about. */
3482 remote_target::remote_get_threadinfo (threadref
*threadid
,
3484 gdb_ext_thread_info
*info
)
3486 struct remote_state
*rs
= get_remote_state ();
3489 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3491 getpkt (&rs
->buf
, 0);
3493 if (rs
->buf
[0] == '\0')
3496 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3501 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3504 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3505 threadref
*nextthread
)
3507 *pkt
++ = 'q'; /* info query packet */
3508 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3509 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3510 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3511 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3516 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3519 remote_target::parse_threadlist_response (const char *pkt
, int result_limit
,
3520 threadref
*original_echo
,
3521 threadref
*resultlist
,
3524 struct remote_state
*rs
= get_remote_state ();
3525 int count
, resultcount
, done
;
3528 /* Assume the 'q' and 'M chars have been stripped. */
3529 const char *limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3530 /* done parse past here */
3531 pkt
= unpack_byte (pkt
, &count
); /* count field */
3532 pkt
= unpack_nibble (pkt
, &done
);
3533 /* The first threadid is the argument threadid. */
3534 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3535 while ((count
-- > 0) && (pkt
< limit
))
3537 pkt
= unpack_threadid (pkt
, resultlist
++);
3538 if (resultcount
++ >= result_limit
)
3546 /* Fetch the next batch of threads from the remote. Returns -1 if the
3547 qL packet is not supported, 0 on error and 1 on success. */
3550 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3551 int result_limit
, int *done
, int *result_count
,
3552 threadref
*threadlist
)
3554 struct remote_state
*rs
= get_remote_state ();
3557 /* Truncate result limit to be smaller than the packet size. */
3558 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3559 >= get_remote_packet_size ())
3560 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3562 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3565 getpkt (&rs
->buf
, 0);
3566 if (rs
->buf
[0] == '\0')
3568 /* Packet not supported. */
3573 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3574 &rs
->echo_nextthread
, threadlist
, done
);
3576 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3578 /* FIXME: This is a good reason to drop the packet. */
3579 /* Possibly, there is a duplicate response. */
3581 retransmit immediatly - race conditions
3582 retransmit after timeout - yes
3584 wait for packet, then exit
3586 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3587 return 0; /* I choose simply exiting. */
3589 if (*result_count
<= 0)
3593 warning (_("RMT ERROR : failed to get remote thread list."));
3596 return result
; /* break; */
3598 if (*result_count
> result_limit
)
3601 warning (_("RMT ERROR: threadlist response longer than requested."));
3607 /* Fetch the list of remote threads, with the qL packet, and call
3608 STEPFUNCTION for each thread found. Stops iterating and returns 1
3609 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3610 STEPFUNCTION returns false. If the packet is not supported,
3614 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3615 void *context
, int looplimit
)
3617 struct remote_state
*rs
= get_remote_state ();
3618 int done
, i
, result_count
;
3626 if (loopcount
++ > looplimit
)
3629 warning (_("Remote fetch threadlist -infinite loop-."));
3632 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3633 MAXTHREADLISTRESULTS
,
3634 &done
, &result_count
,
3635 rs
->resultthreadlist
);
3638 /* Clear for later iterations. */
3640 /* Setup to resume next batch of thread references, set nextthread. */
3641 if (result_count
>= 1)
3642 copy_threadref (&rs
->nextthread
,
3643 &rs
->resultthreadlist
[result_count
- 1]);
3645 while (result_count
--)
3647 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3657 /* A thread found on the remote target. */
3661 explicit thread_item (ptid_t ptid_
)
3665 thread_item (thread_item
&&other
) = default;
3666 thread_item
&operator= (thread_item
&&other
) = default;
3668 DISABLE_COPY_AND_ASSIGN (thread_item
);
3670 /* The thread's PTID. */
3673 /* The thread's extra info. */
3676 /* The thread's name. */
3679 /* The core the thread was running on. -1 if not known. */
3682 /* The thread handle associated with the thread. */
3683 gdb::byte_vector thread_handle
;
3686 /* Context passed around to the various methods listing remote
3687 threads. As new threads are found, they're added to the ITEMS
3690 struct threads_listing_context
3692 /* Return true if this object contains an entry for a thread with ptid
3695 bool contains_thread (ptid_t ptid
) const
3697 auto match_ptid
= [&] (const thread_item
&item
)
3699 return item
.ptid
== ptid
;
3702 auto it
= std::find_if (this->items
.begin (),
3706 return it
!= this->items
.end ();
3709 /* Remove the thread with ptid PTID. */
3711 void remove_thread (ptid_t ptid
)
3713 auto match_ptid
= [&] (const thread_item
&item
)
3715 return item
.ptid
== ptid
;
3718 auto it
= std::remove_if (this->items
.begin (),
3722 if (it
!= this->items
.end ())
3723 this->items
.erase (it
);
3726 /* The threads found on the remote target. */
3727 std::vector
<thread_item
> items
;
3731 remote_newthread_step (threadref
*ref
, void *data
)
3733 struct threads_listing_context
*context
3734 = (struct threads_listing_context
*) data
;
3735 int pid
= inferior_ptid
.pid ();
3736 int lwp
= threadref_to_int (ref
);
3737 ptid_t
ptid (pid
, lwp
);
3739 context
->items
.emplace_back (ptid
);
3741 return 1; /* continue iterator */
3744 #define CRAZY_MAX_THREADS 1000
3747 remote_target::remote_current_thread (ptid_t oldpid
)
3749 struct remote_state
*rs
= get_remote_state ();
3752 getpkt (&rs
->buf
, 0);
3753 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3758 result
= read_ptid (&rs
->buf
[2], &obuf
);
3760 remote_debug_printf ("warning: garbage in qC reply");
3768 /* List remote threads using the deprecated qL packet. */
3771 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3773 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3774 CRAZY_MAX_THREADS
) >= 0)
3780 #if defined(HAVE_LIBEXPAT)
3783 start_thread (struct gdb_xml_parser
*parser
,
3784 const struct gdb_xml_element
*element
,
3786 std::vector
<gdb_xml_value
> &attributes
)
3788 struct threads_listing_context
*data
3789 = (struct threads_listing_context
*) user_data
;
3790 struct gdb_xml_value
*attr
;
3792 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3793 ptid_t ptid
= read_ptid (id
, NULL
);
3795 data
->items
.emplace_back (ptid
);
3796 thread_item
&item
= data
->items
.back ();
3798 attr
= xml_find_attribute (attributes
, "core");
3800 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3802 attr
= xml_find_attribute (attributes
, "name");
3804 item
.name
= (const char *) attr
->value
.get ();
3806 attr
= xml_find_attribute (attributes
, "handle");
3808 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3812 end_thread (struct gdb_xml_parser
*parser
,
3813 const struct gdb_xml_element
*element
,
3814 void *user_data
, const char *body_text
)
3816 struct threads_listing_context
*data
3817 = (struct threads_listing_context
*) user_data
;
3819 if (body_text
!= NULL
&& *body_text
!= '\0')
3820 data
->items
.back ().extra
= body_text
;
3823 const struct gdb_xml_attribute thread_attributes
[] = {
3824 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3825 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3826 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3827 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3828 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3831 const struct gdb_xml_element thread_children
[] = {
3832 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3835 const struct gdb_xml_element threads_children
[] = {
3836 { "thread", thread_attributes
, thread_children
,
3837 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3838 start_thread
, end_thread
},
3839 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3842 const struct gdb_xml_element threads_elements
[] = {
3843 { "threads", NULL
, threads_children
,
3844 GDB_XML_EF_NONE
, NULL
, NULL
},
3845 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3850 /* List remote threads using qXfer:threads:read. */
3853 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3855 #if defined(HAVE_LIBEXPAT)
3856 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3858 gdb::optional
<gdb::char_vector
> xml
3859 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3861 if (xml
&& (*xml
)[0] != '\0')
3863 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3864 threads_elements
, xml
->data (), context
);
3874 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3877 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3879 struct remote_state
*rs
= get_remote_state ();
3881 if (rs
->use_threadinfo_query
)
3885 putpkt ("qfThreadInfo");
3886 getpkt (&rs
->buf
, 0);
3887 bufp
= rs
->buf
.data ();
3888 if (bufp
[0] != '\0') /* q packet recognized */
3890 while (*bufp
++ == 'm') /* reply contains one or more TID */
3894 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3895 context
->items
.emplace_back (ptid
);
3897 while (*bufp
++ == ','); /* comma-separated list */
3898 putpkt ("qsThreadInfo");
3899 getpkt (&rs
->buf
, 0);
3900 bufp
= rs
->buf
.data ();
3906 /* Packet not recognized. */
3907 rs
->use_threadinfo_query
= 0;
3914 /* Return true if INF only has one non-exited thread. */
3917 has_single_non_exited_thread (inferior
*inf
)
3920 for (thread_info
*tp ATTRIBUTE_UNUSED
: inf
->non_exited_threads ())
3926 /* Implement the to_update_thread_list function for the remote
3930 remote_target::update_thread_list ()
3932 struct threads_listing_context context
;
3935 /* We have a few different mechanisms to fetch the thread list. Try
3936 them all, starting with the most preferred one first, falling
3937 back to older methods. */
3938 if (remote_get_threads_with_qxfer (&context
)
3939 || remote_get_threads_with_qthreadinfo (&context
)
3940 || remote_get_threads_with_ql (&context
))
3944 if (context
.items
.empty ()
3945 && remote_thread_always_alive (inferior_ptid
))
3947 /* Some targets don't really support threads, but still
3948 reply an (empty) thread list in response to the thread
3949 listing packets, instead of replying "packet not
3950 supported". Exit early so we don't delete the main
3955 /* CONTEXT now holds the current thread list on the remote
3956 target end. Delete GDB-side threads no longer found on the
3958 for (thread_info
*tp
: all_threads_safe ())
3960 if (tp
->inf
->process_target () != this)
3963 if (!context
.contains_thread (tp
->ptid
))
3965 /* Do not remove the thread if it is the last thread in
3966 the inferior. This situation happens when we have a
3967 pending exit process status to process. Otherwise we
3968 may end up with a seemingly live inferior (i.e. pid
3969 != 0) that has no threads. */
3970 if (has_single_non_exited_thread (tp
->inf
))
3978 /* Remove any unreported fork child threads from CONTEXT so
3979 that we don't interfere with follow fork, which is where
3980 creation of such threads is handled. */
3981 remove_new_fork_children (&context
);
3983 /* And now add threads we don't know about yet to our list. */
3984 for (thread_item
&item
: context
.items
)
3986 if (item
.ptid
!= null_ptid
)
3988 /* In non-stop mode, we assume new found threads are
3989 executing until proven otherwise with a stop reply.
3990 In all-stop, we can only get here if all threads are
3992 bool executing
= target_is_non_stop_p ();
3994 remote_notice_new_inferior (item
.ptid
, executing
);
3996 thread_info
*tp
= find_thread_ptid (this, item
.ptid
);
3997 remote_thread_info
*info
= get_remote_thread_info (tp
);
3998 info
->core
= item
.core
;
3999 info
->extra
= std::move (item
.extra
);
4000 info
->name
= std::move (item
.name
);
4001 info
->thread_handle
= std::move (item
.thread_handle
);
4008 /* If no thread listing method is supported, then query whether
4009 each known thread is alive, one by one, with the T packet.
4010 If the target doesn't support threads at all, then this is a
4011 no-op. See remote_thread_alive. */
4017 * Collect a descriptive string about the given thread.
4018 * The target may say anything it wants to about the thread
4019 * (typically info about its blocked / runnable state, name, etc.).
4020 * This string will appear in the info threads display.
4022 * Optional: targets are not required to implement this function.
4026 remote_target::extra_thread_info (thread_info
*tp
)
4028 struct remote_state
*rs
= get_remote_state ();
4031 struct gdb_ext_thread_info threadinfo
;
4033 if (rs
->remote_desc
== 0) /* paranoia */
4034 internal_error (__FILE__
, __LINE__
,
4035 _("remote_threads_extra_info"));
4037 if (tp
->ptid
== magic_null_ptid
4038 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
4039 /* This is the main thread which was added by GDB. The remote
4040 server doesn't know about it. */
4043 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
4045 /* If already have cached info, use it. */
4046 if (!extra
.empty ())
4047 return extra
.c_str ();
4049 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
4051 /* If we're using qXfer:threads:read, then the extra info is
4052 included in the XML. So if we didn't have anything cached,
4053 it's because there's really no extra info. */
4057 if (rs
->use_threadextra_query
)
4059 char *b
= rs
->buf
.data ();
4060 char *endb
= b
+ get_remote_packet_size ();
4062 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
4064 write_ptid (b
, endb
, tp
->ptid
);
4067 getpkt (&rs
->buf
, 0);
4068 if (rs
->buf
[0] != 0)
4070 extra
.resize (strlen (rs
->buf
.data ()) / 2);
4071 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
4072 return extra
.c_str ();
4076 /* If the above query fails, fall back to the old method. */
4077 rs
->use_threadextra_query
= 0;
4078 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
4079 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
4080 int_to_threadref (&id
, tp
->ptid
.lwp ());
4081 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
4082 if (threadinfo
.active
)
4084 if (*threadinfo
.shortname
)
4085 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
4086 if (*threadinfo
.display
)
4088 if (!extra
.empty ())
4090 string_appendf (extra
, " State: %s", threadinfo
.display
);
4092 if (*threadinfo
.more_display
)
4094 if (!extra
.empty ())
4096 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
4098 return extra
.c_str ();
4105 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
4106 struct static_tracepoint_marker
*marker
)
4108 struct remote_state
*rs
= get_remote_state ();
4109 char *p
= rs
->buf
.data ();
4111 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
4113 p
+= hexnumstr (p
, addr
);
4115 getpkt (&rs
->buf
, 0);
4116 p
= rs
->buf
.data ();
4119 error (_("Remote failure reply: %s"), p
);
4123 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
4130 std::vector
<static_tracepoint_marker
>
4131 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
4133 struct remote_state
*rs
= get_remote_state ();
4134 std::vector
<static_tracepoint_marker
> markers
;
4136 static_tracepoint_marker marker
;
4138 /* Ask for a first packet of static tracepoint marker
4141 getpkt (&rs
->buf
, 0);
4142 p
= rs
->buf
.data ();
4144 error (_("Remote failure reply: %s"), p
);
4150 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
4152 if (strid
== NULL
|| marker
.str_id
== strid
)
4153 markers
.push_back (std::move (marker
));
4155 while (*p
++ == ','); /* comma-separated list */
4156 /* Ask for another packet of static tracepoint definition. */
4158 getpkt (&rs
->buf
, 0);
4159 p
= rs
->buf
.data ();
4166 /* Implement the to_get_ada_task_ptid function for the remote targets. */
4169 remote_target::get_ada_task_ptid (long lwp
, ULONGEST thread
)
4171 return ptid_t (inferior_ptid
.pid (), lwp
);
4175 /* Restart the remote side; this is an extended protocol operation. */
4178 remote_target::extended_remote_restart ()
4180 struct remote_state
*rs
= get_remote_state ();
4182 /* Send the restart command; for reasons I don't understand the
4183 remote side really expects a number after the "R". */
4184 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
4187 remote_fileio_reset ();
4190 /* Clean up connection to a remote debugger. */
4193 remote_target::close ()
4195 /* Make sure we leave stdin registered in the event loop. */
4198 trace_reset_local_state ();
4203 remote_target::~remote_target ()
4205 struct remote_state
*rs
= get_remote_state ();
4207 /* Check for NULL because we may get here with a partially
4208 constructed target/connection. */
4209 if (rs
->remote_desc
== nullptr)
4212 serial_close (rs
->remote_desc
);
4214 /* We are destroying the remote target, so we should discard
4215 everything of this target. */
4216 discard_pending_stop_replies_in_queue ();
4218 if (rs
->remote_async_inferior_event_token
)
4219 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4221 delete rs
->notif_state
;
4224 /* Query the remote side for the text, data and bss offsets. */
4227 remote_target::get_offsets ()
4229 struct remote_state
*rs
= get_remote_state ();
4232 int lose
, num_segments
= 0, do_sections
, do_segments
;
4233 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4235 if (current_program_space
->symfile_object_file
== NULL
)
4238 putpkt ("qOffsets");
4239 getpkt (&rs
->buf
, 0);
4240 buf
= rs
->buf
.data ();
4242 if (buf
[0] == '\000')
4243 return; /* Return silently. Stub doesn't support
4247 warning (_("Remote failure reply: %s"), buf
);
4251 /* Pick up each field in turn. This used to be done with scanf, but
4252 scanf will make trouble if CORE_ADDR size doesn't match
4253 conversion directives correctly. The following code will work
4254 with any size of CORE_ADDR. */
4255 text_addr
= data_addr
= bss_addr
= 0;
4259 if (startswith (ptr
, "Text="))
4262 /* Don't use strtol, could lose on big values. */
4263 while (*ptr
&& *ptr
!= ';')
4264 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4266 if (startswith (ptr
, ";Data="))
4269 while (*ptr
&& *ptr
!= ';')
4270 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4275 if (!lose
&& startswith (ptr
, ";Bss="))
4278 while (*ptr
&& *ptr
!= ';')
4279 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4281 if (bss_addr
!= data_addr
)
4282 warning (_("Target reported unsupported offsets: %s"), buf
);
4287 else if (startswith (ptr
, "TextSeg="))
4290 /* Don't use strtol, could lose on big values. */
4291 while (*ptr
&& *ptr
!= ';')
4292 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4295 if (startswith (ptr
, ";DataSeg="))
4298 while (*ptr
&& *ptr
!= ';')
4299 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4307 error (_("Malformed response to offset query, %s"), buf
);
4308 else if (*ptr
!= '\0')
4309 warning (_("Target reported unsupported offsets: %s"), buf
);
4311 objfile
*objf
= current_program_space
->symfile_object_file
;
4312 section_offsets offs
= objf
->section_offsets
;
4314 symfile_segment_data_up data
= get_symfile_segment_data (objf
->obfd
);
4315 do_segments
= (data
!= NULL
);
4316 do_sections
= num_segments
== 0;
4318 if (num_segments
> 0)
4320 segments
[0] = text_addr
;
4321 segments
[1] = data_addr
;
4323 /* If we have two segments, we can still try to relocate everything
4324 by assuming that the .text and .data offsets apply to the whole
4325 text and data segments. Convert the offsets given in the packet
4326 to base addresses for symfile_map_offsets_to_segments. */
4327 else if (data
!= nullptr && data
->segments
.size () == 2)
4329 segments
[0] = data
->segments
[0].base
+ text_addr
;
4330 segments
[1] = data
->segments
[1].base
+ data_addr
;
4333 /* If the object file has only one segment, assume that it is text
4334 rather than data; main programs with no writable data are rare,
4335 but programs with no code are useless. Of course the code might
4336 have ended up in the data segment... to detect that we would need
4337 the permissions here. */
4338 else if (data
&& data
->segments
.size () == 1)
4340 segments
[0] = data
->segments
[0].base
+ text_addr
;
4343 /* There's no way to relocate by segment. */
4349 int ret
= symfile_map_offsets_to_segments (objf
->obfd
,
4351 num_segments
, segments
);
4353 if (ret
== 0 && !do_sections
)
4354 error (_("Can not handle qOffsets TextSeg "
4355 "response with this symbol file"));
4363 offs
[SECT_OFF_TEXT (objf
)] = text_addr
;
4365 /* This is a temporary kludge to force data and bss to use the
4366 same offsets because that's what nlmconv does now. The real
4367 solution requires changes to the stub and remote.c that I
4368 don't have time to do right now. */
4370 offs
[SECT_OFF_DATA (objf
)] = data_addr
;
4371 offs
[SECT_OFF_BSS (objf
)] = data_addr
;
4374 objfile_relocate (objf
, offs
);
4377 /* Send interrupt_sequence to remote target. */
4380 remote_target::send_interrupt_sequence ()
4382 struct remote_state
*rs
= get_remote_state ();
4384 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4385 remote_serial_write ("\x03", 1);
4386 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4387 serial_send_break (rs
->remote_desc
);
4388 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4390 serial_send_break (rs
->remote_desc
);
4391 remote_serial_write ("g", 1);
4394 internal_error (__FILE__
, __LINE__
,
4395 _("Invalid value for interrupt_sequence_mode: %s."),
4396 interrupt_sequence_mode
);
4400 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4401 and extract the PTID. Returns NULL_PTID if not found. */
4404 stop_reply_extract_thread (const char *stop_reply
)
4406 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4410 /* Txx r:val ; r:val (...) */
4413 /* Look for "register" named "thread". */
4418 p1
= strchr (p
, ':');
4422 if (strncmp (p
, "thread", p1
- p
) == 0)
4423 return read_ptid (++p1
, &p
);
4425 p1
= strchr (p
, ';');
4437 /* Determine the remote side's current thread. If we have a stop
4438 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4439 "thread" register we can extract the current thread from. If not,
4440 ask the remote which is the current thread with qC. The former
4441 method avoids a roundtrip. */
4444 remote_target::get_current_thread (const char *wait_status
)
4446 ptid_t ptid
= null_ptid
;
4448 /* Note we don't use remote_parse_stop_reply as that makes use of
4449 the target architecture, which we haven't yet fully determined at
4451 if (wait_status
!= NULL
)
4452 ptid
= stop_reply_extract_thread (wait_status
);
4453 if (ptid
== null_ptid
)
4454 ptid
= remote_current_thread (inferior_ptid
);
4459 /* Query the remote target for which is the current thread/process,
4460 add it to our tables, and update INFERIOR_PTID. The caller is
4461 responsible for setting the state such that the remote end is ready
4462 to return the current thread.
4464 This function is called after handling the '?' or 'vRun' packets,
4465 whose response is a stop reply from which we can also try
4466 extracting the thread. If the target doesn't support the explicit
4467 qC query, we infer the current thread from that stop reply, passed
4468 in in WAIT_STATUS, which may be NULL.
4470 The function returns pointer to the main thread of the inferior. */
4473 remote_target::add_current_inferior_and_thread (const char *wait_status
)
4475 struct remote_state
*rs
= get_remote_state ();
4476 bool fake_pid_p
= false;
4478 switch_to_no_thread ();
4480 /* Now, if we have thread information, update the current thread's
4482 ptid_t curr_ptid
= get_current_thread (wait_status
);
4484 if (curr_ptid
!= null_ptid
)
4486 if (!remote_multi_process_p (rs
))
4491 /* Without this, some commands which require an active target
4492 (such as kill) won't work. This variable serves (at least)
4493 double duty as both the pid of the target process (if it has
4494 such), and as a flag indicating that a target is active. */
4495 curr_ptid
= magic_null_ptid
;
4499 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4501 /* Add the main thread and switch to it. Don't try reading
4502 registers yet, since we haven't fetched the target description
4504 thread_info
*tp
= add_thread_silent (this, curr_ptid
);
4505 switch_to_thread_no_regs (tp
);
4510 /* Print info about a thread that was found already stopped on
4514 remote_target::print_one_stopped_thread (thread_info
*thread
)
4516 target_waitstatus ws
;
4518 /* If there is a pending waitstatus, use it. If there isn't it's because
4519 the thread's stop was reported with TARGET_WAITKIND_STOPPED / GDB_SIGNAL_0
4520 and process_initial_stop_replies decided it wasn't interesting to save
4521 and report to the core. */
4522 if (thread
->has_pending_waitstatus ())
4524 ws
= thread
->pending_waitstatus ();
4525 thread
->clear_pending_waitstatus ();
4529 ws
.set_stopped (GDB_SIGNAL_0
);
4532 switch_to_thread (thread
);
4533 thread
->set_stop_pc (get_frame_pc (get_current_frame ()));
4534 set_current_sal_from_frame (get_current_frame ());
4536 /* For "info program". */
4537 set_last_target_status (this, thread
->ptid
, ws
);
4539 if (ws
.kind () == TARGET_WAITKIND_STOPPED
)
4541 enum gdb_signal sig
= ws
.sig ();
4543 if (signal_print_state (sig
))
4544 gdb::observers::signal_received
.notify (sig
);
4546 gdb::observers::normal_stop
.notify (NULL
, 1);
4549 /* Process all initial stop replies the remote side sent in response
4550 to the ? packet. These indicate threads that were already stopped
4551 on initial connection. We mark these threads as stopped and print
4552 their current frame before giving the user the prompt. */
4555 remote_target::process_initial_stop_replies (int from_tty
)
4557 int pending_stop_replies
= stop_reply_queue_length ();
4558 struct thread_info
*selected
= NULL
;
4559 struct thread_info
*lowest_stopped
= NULL
;
4560 struct thread_info
*first
= NULL
;
4562 /* This is only used when the target is non-stop. */
4563 gdb_assert (target_is_non_stop_p ());
4565 /* Consume the initial pending events. */
4566 while (pending_stop_replies
-- > 0)
4568 ptid_t waiton_ptid
= minus_one_ptid
;
4570 struct target_waitstatus ws
;
4571 int ignore_event
= 0;
4573 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4575 print_target_wait_results (waiton_ptid
, event_ptid
, ws
);
4579 case TARGET_WAITKIND_IGNORE
:
4580 case TARGET_WAITKIND_NO_RESUMED
:
4581 case TARGET_WAITKIND_SIGNALLED
:
4582 case TARGET_WAITKIND_EXITED
:
4583 /* We shouldn't see these, but if we do, just ignore. */
4584 remote_debug_printf ("event ignored");
4595 thread_info
*evthread
= find_thread_ptid (this, event_ptid
);
4597 if (ws
.kind () == TARGET_WAITKIND_STOPPED
)
4599 enum gdb_signal sig
= ws
.sig ();
4601 /* Stubs traditionally report SIGTRAP as initial signal,
4602 instead of signal 0. Suppress it. */
4603 if (sig
== GDB_SIGNAL_TRAP
)
4605 evthread
->set_stop_signal (sig
);
4606 ws
.set_stopped (sig
);
4609 if (ws
.kind () != TARGET_WAITKIND_STOPPED
4610 || ws
.sig () != GDB_SIGNAL_0
)
4611 evthread
->set_pending_waitstatus (ws
);
4613 set_executing (this, event_ptid
, false);
4614 set_running (this, event_ptid
, false);
4615 get_remote_thread_info (evthread
)->set_not_resumed ();
4618 /* "Notice" the new inferiors before anything related to
4619 registers/memory. */
4620 for (inferior
*inf
: all_non_exited_inferiors (this))
4622 inf
->needs_setup
= 1;
4626 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4627 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4632 /* If all-stop on top of non-stop, pause all threads. Note this
4633 records the threads' stop pc, so must be done after "noticing"
4638 /* At this point, the remote target is not async. It needs to be for
4639 the poll in stop_all_threads to consider events from it, so enable
4641 gdb_assert (!this->is_async_p ());
4642 SCOPE_EXIT
{ target_async (0); };
4644 stop_all_threads ();
4647 /* If all threads of an inferior were already stopped, we
4648 haven't setup the inferior yet. */
4649 for (inferior
*inf
: all_non_exited_inferiors (this))
4651 if (inf
->needs_setup
)
4653 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4654 switch_to_thread_no_regs (thread
);
4660 /* Now go over all threads that are stopped, and print their current
4661 frame. If all-stop, then if there's a signalled thread, pick
4663 for (thread_info
*thread
: all_non_exited_threads (this))
4669 thread
->set_running (false);
4670 else if (thread
->state
!= THREAD_STOPPED
)
4673 if (selected
== nullptr && thread
->has_pending_waitstatus ())
4676 if (lowest_stopped
== NULL
4677 || thread
->inf
->num
< lowest_stopped
->inf
->num
4678 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4679 lowest_stopped
= thread
;
4682 print_one_stopped_thread (thread
);
4685 /* In all-stop, we only print the status of one thread, and leave
4686 others with their status pending. */
4689 thread_info
*thread
= selected
;
4691 thread
= lowest_stopped
;
4695 print_one_stopped_thread (thread
);
4699 /* Mark a remote_target as marking (by setting the starting_up flag within
4700 its remote_state) for the lifetime of this object. The reference count
4701 on the remote target is temporarily incremented, to prevent the target
4702 being deleted under our feet. */
4704 struct scoped_mark_target_starting
4706 /* Constructor, TARGET is the target to be marked as starting, its
4707 reference count will be incremented. */
4708 scoped_mark_target_starting (remote_target
*target
)
4709 : m_remote_target (target
)
4711 m_remote_target
->incref ();
4712 remote_state
*rs
= m_remote_target
->get_remote_state ();
4713 rs
->starting_up
= true;
4716 /* Destructor, mark the target being worked on as no longer starting, and
4717 decrement the reference count. */
4718 ~scoped_mark_target_starting ()
4720 remote_state
*rs
= m_remote_target
->get_remote_state ();
4721 rs
->starting_up
= false;
4722 decref_target (m_remote_target
);
4727 /* The target on which we are operating. */
4728 remote_target
*m_remote_target
;
4731 /* Helper for remote_target::start_remote, start the remote connection and
4732 sync state. Return true if everything goes OK, otherwise, return false.
4733 This function exists so that the scoped_restore created within it will
4734 expire before we return to remote_target::start_remote. */
4737 remote_target::start_remote_1 (int from_tty
, int extended_p
)
4739 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
4741 struct remote_state
*rs
= get_remote_state ();
4742 struct packet_config
*noack_config
;
4744 /* Signal other parts that we're going through the initial setup,
4745 and so things may not be stable yet. E.g., we don't try to
4746 install tracepoints until we've relocated symbols. Also, a
4747 Ctrl-C before we're connected and synced up can't interrupt the
4748 target. Instead, it offers to drop the (potentially wedged)
4750 scoped_mark_target_starting
target_is_starting (this);
4754 if (interrupt_on_connect
)
4755 send_interrupt_sequence ();
4757 /* Ack any packet which the remote side has already sent. */
4758 remote_serial_write ("+", 1);
4760 /* The first packet we send to the target is the optional "supported
4761 packets" request. If the target can answer this, it will tell us
4762 which later probes to skip. */
4763 remote_query_supported ();
4765 /* If the stub wants to get a QAllow, compose one and send it. */
4766 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4769 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4770 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4771 as a reply to known packet. For packet "vFile:setfs:" it is an
4772 invalid reply and GDB would return error in
4773 remote_hostio_set_filesystem, making remote files access impossible.
4774 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4775 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4777 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4779 putpkt (v_mustreplyempty
);
4780 getpkt (&rs
->buf
, 0);
4781 if (strcmp (rs
->buf
.data (), "OK") == 0)
4782 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4783 else if (strcmp (rs
->buf
.data (), "") != 0)
4784 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4788 /* Next, we possibly activate noack mode.
4790 If the QStartNoAckMode packet configuration is set to AUTO,
4791 enable noack mode if the stub reported a wish for it with
4794 If set to TRUE, then enable noack mode even if the stub didn't
4795 report it in qSupported. If the stub doesn't reply OK, the
4796 session ends with an error.
4798 If FALSE, then don't activate noack mode, regardless of what the
4799 stub claimed should be the default with qSupported. */
4801 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4802 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4804 putpkt ("QStartNoAckMode");
4805 getpkt (&rs
->buf
, 0);
4806 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4812 /* Tell the remote that we are using the extended protocol. */
4814 getpkt (&rs
->buf
, 0);
4817 /* Let the target know which signals it is allowed to pass down to
4819 update_signals_program_target ();
4821 /* Next, if the target can specify a description, read it. We do
4822 this before anything involving memory or registers. */
4823 target_find_description ();
4825 /* Next, now that we know something about the target, update the
4826 address spaces in the program spaces. */
4827 update_address_spaces ();
4829 /* On OSs where the list of libraries is global to all
4830 processes, we fetch them early. */
4831 if (gdbarch_has_global_solist (target_gdbarch ()))
4832 solib_add (NULL
, from_tty
, auto_solib_add
);
4834 if (target_is_non_stop_p ())
4836 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4837 error (_("Non-stop mode requested, but remote "
4838 "does not support non-stop"));
4840 putpkt ("QNonStop:1");
4841 getpkt (&rs
->buf
, 0);
4843 if (strcmp (rs
->buf
.data (), "OK") != 0)
4844 error (_("Remote refused setting non-stop mode with: %s"),
4847 /* Find about threads and processes the stub is already
4848 controlling. We default to adding them in the running state.
4849 The '?' query below will then tell us about which threads are
4851 this->update_thread_list ();
4853 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4855 /* Don't assume that the stub can operate in all-stop mode.
4856 Request it explicitly. */
4857 putpkt ("QNonStop:0");
4858 getpkt (&rs
->buf
, 0);
4860 if (strcmp (rs
->buf
.data (), "OK") != 0)
4861 error (_("Remote refused setting all-stop mode with: %s"),
4865 /* Upload TSVs regardless of whether the target is running or not. The
4866 remote stub, such as GDBserver, may have some predefined or builtin
4867 TSVs, even if the target is not running. */
4868 if (get_trace_status (current_trace_status ()) != -1)
4870 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4872 upload_trace_state_variables (&uploaded_tsvs
);
4873 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4876 /* Check whether the target is running now. */
4878 getpkt (&rs
->buf
, 0);
4880 if (!target_is_non_stop_p ())
4882 char *wait_status
= NULL
;
4884 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4887 error (_("The target is not running (try extended-remote?)"));
4892 /* Save the reply for later. */
4893 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4894 strcpy (wait_status
, rs
->buf
.data ());
4897 /* Fetch thread list. */
4898 target_update_thread_list ();
4900 /* Let the stub know that we want it to return the thread. */
4901 set_continue_thread (minus_one_ptid
);
4903 if (thread_count (this) == 0)
4905 /* Target has no concept of threads at all. GDB treats
4906 non-threaded target as single-threaded; add a main
4908 thread_info
*tp
= add_current_inferior_and_thread (wait_status
);
4909 get_remote_thread_info (tp
)->set_resumed ();
4913 /* We have thread information; select the thread the target
4914 says should be current. If we're reconnecting to a
4915 multi-threaded program, this will ideally be the thread
4916 that last reported an event before GDB disconnected. */
4917 ptid_t curr_thread
= get_current_thread (wait_status
);
4918 if (curr_thread
== null_ptid
)
4920 /* Odd... The target was able to list threads, but not
4921 tell us which thread was current (no "thread"
4922 register in T stop reply?). Just pick the first
4923 thread in the thread list then. */
4925 remote_debug_printf ("warning: couldn't determine remote "
4926 "current thread; picking first in list.");
4928 for (thread_info
*tp
: all_non_exited_threads (this,
4931 switch_to_thread (tp
);
4936 switch_to_thread (find_thread_ptid (this, curr_thread
));
4939 /* init_wait_for_inferior should be called before get_offsets in order
4940 to manage `inserted' flag in bp loc in a correct state.
4941 breakpoint_init_inferior, called from init_wait_for_inferior, set
4942 `inserted' flag to 0, while before breakpoint_re_set, called from
4943 start_remote, set `inserted' flag to 1. In the initialization of
4944 inferior, breakpoint_init_inferior should be called first, and then
4945 breakpoint_re_set can be called. If this order is broken, state of
4946 `inserted' flag is wrong, and cause some problems on breakpoint
4948 init_wait_for_inferior ();
4950 get_offsets (); /* Get text, data & bss offsets. */
4952 /* If we could not find a description using qXfer, and we know
4953 how to do it some other way, try again. This is not
4954 supported for non-stop; it could be, but it is tricky if
4955 there are no stopped threads when we connect. */
4956 if (remote_read_description_p (this)
4957 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4959 target_clear_description ();
4960 target_find_description ();
4963 /* Use the previously fetched status. */
4964 gdb_assert (wait_status
!= NULL
);
4965 struct notif_event
*reply
4966 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
4967 push_stop_reply ((struct stop_reply
*) reply
);
4969 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4973 /* Clear WFI global state. Do this before finding about new
4974 threads and inferiors, and setting the current inferior.
4975 Otherwise we would clear the proceed status of the current
4976 inferior when we want its stop_soon state to be preserved
4977 (see notice_new_inferior). */
4978 init_wait_for_inferior ();
4980 /* In non-stop, we will either get an "OK", meaning that there
4981 are no stopped threads at this time; or, a regular stop
4982 reply. In the latter case, there may be more than one thread
4983 stopped --- we pull them all out using the vStopped
4985 if (strcmp (rs
->buf
.data (), "OK") != 0)
4987 struct notif_client
*notif
= ¬if_client_stop
;
4989 /* remote_notif_get_pending_replies acks this one, and gets
4991 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4992 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4993 remote_notif_get_pending_events (notif
);
4996 if (thread_count (this) == 0)
4999 error (_("The target is not running (try extended-remote?)"));
5003 /* Report all signals during attach/startup. */
5006 /* If there are already stopped threads, mark them stopped and
5007 report their stops before giving the prompt to the user. */
5008 process_initial_stop_replies (from_tty
);
5010 if (target_can_async_p ())
5014 /* If we connected to a live target, do some additional setup. */
5015 if (target_has_execution ())
5017 /* No use without a symbol-file. */
5018 if (current_program_space
->symfile_object_file
)
5019 remote_check_symbols ();
5022 /* Possibly the target has been engaged in a trace run started
5023 previously; find out where things are at. */
5024 if (get_trace_status (current_trace_status ()) != -1)
5026 struct uploaded_tp
*uploaded_tps
= NULL
;
5028 if (current_trace_status ()->running
)
5029 printf_filtered (_("Trace is already running on the target.\n"));
5031 upload_tracepoints (&uploaded_tps
);
5033 merge_uploaded_tracepoints (&uploaded_tps
);
5036 /* Possibly the target has been engaged in a btrace record started
5037 previously; find out where things are at. */
5038 remote_btrace_maybe_reopen ();
5043 /* Start the remote connection and sync state. */
5046 remote_target::start_remote (int from_tty
, int extended_p
)
5048 if (start_remote_1 (from_tty
, extended_p
)
5049 && breakpoints_should_be_inserted_now ())
5050 insert_breakpoints ();
5054 remote_target::connection_string ()
5056 remote_state
*rs
= get_remote_state ();
5058 if (rs
->remote_desc
->name
!= NULL
)
5059 return rs
->remote_desc
->name
;
5064 /* Open a connection to a remote debugger.
5065 NAME is the filename used for communication. */
5068 remote_target::open (const char *name
, int from_tty
)
5070 open_1 (name
, from_tty
, 0);
5073 /* Open a connection to a remote debugger using the extended
5074 remote gdb protocol. NAME is the filename used for communication. */
5077 extended_remote_target::open (const char *name
, int from_tty
)
5079 open_1 (name
, from_tty
, 1 /*extended_p */);
5082 /* Reset all packets back to "unknown support". Called when opening a
5083 new connection to a remote target. */
5086 reset_all_packet_configs_support (void)
5090 for (i
= 0; i
< PACKET_MAX
; i
++)
5091 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
5094 /* Initialize all packet configs. */
5097 init_all_packet_configs (void)
5101 for (i
= 0; i
< PACKET_MAX
; i
++)
5103 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
5104 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
5108 /* Symbol look-up. */
5111 remote_target::remote_check_symbols ()
5116 /* The remote side has no concept of inferiors that aren't running
5117 yet, it only knows about running processes. If we're connected
5118 but our current inferior is not running, we should not invite the
5119 remote target to request symbol lookups related to its
5120 (unrelated) current process. */
5121 if (!target_has_execution ())
5124 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
5127 /* Make sure the remote is pointing at the right process. Note
5128 there's no way to select "no process". */
5129 set_general_process ();
5131 /* Allocate a message buffer. We can't reuse the input buffer in RS,
5132 because we need both at the same time. */
5133 gdb::char_vector
msg (get_remote_packet_size ());
5134 gdb::char_vector
reply (get_remote_packet_size ());
5136 /* Invite target to request symbol lookups. */
5138 putpkt ("qSymbol::");
5140 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
5142 while (startswith (reply
.data (), "qSymbol:"))
5144 struct bound_minimal_symbol sym
;
5147 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
5150 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
5151 if (sym
.minsym
== NULL
)
5152 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
5156 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
5157 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
5159 /* If this is a function address, return the start of code
5160 instead of any data function descriptor. */
5161 sym_addr
= gdbarch_convert_from_func_ptr_addr
5162 (target_gdbarch (), sym_addr
, current_inferior ()->top_target ());
5164 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
5165 phex_nz (sym_addr
, addr_size
), &reply
[8]);
5168 putpkt (msg
.data ());
5173 static struct serial
*
5174 remote_serial_open (const char *name
)
5176 static int udp_warning
= 0;
5178 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
5179 of in ser-tcp.c, because it is the remote protocol assuming that the
5180 serial connection is reliable and not the serial connection promising
5182 if (!udp_warning
&& startswith (name
, "udp:"))
5184 warning (_("The remote protocol may be unreliable over UDP.\n"
5185 "Some events may be lost, rendering further debugging "
5190 return serial_open (name
);
5193 /* Inform the target of our permission settings. The permission flags
5194 work without this, but if the target knows the settings, it can do
5195 a couple things. First, it can add its own check, to catch cases
5196 that somehow manage to get by the permissions checks in target
5197 methods. Second, if the target is wired to disallow particular
5198 settings (for instance, a system in the field that is not set up to
5199 be able to stop at a breakpoint), it can object to any unavailable
5203 remote_target::set_permissions ()
5205 struct remote_state
*rs
= get_remote_state ();
5207 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
5208 "WriteReg:%x;WriteMem:%x;"
5209 "InsertBreak:%x;InsertTrace:%x;"
5210 "InsertFastTrace:%x;Stop:%x",
5211 may_write_registers
, may_write_memory
,
5212 may_insert_breakpoints
, may_insert_tracepoints
,
5213 may_insert_fast_tracepoints
, may_stop
);
5215 getpkt (&rs
->buf
, 0);
5217 /* If the target didn't like the packet, warn the user. Do not try
5218 to undo the user's settings, that would just be maddening. */
5219 if (strcmp (rs
->buf
.data (), "OK") != 0)
5220 warning (_("Remote refused setting permissions with: %s"),
5224 /* This type describes each known response to the qSupported
5226 struct protocol_feature
5228 /* The name of this protocol feature. */
5231 /* The default for this protocol feature. */
5232 enum packet_support default_support
;
5234 /* The function to call when this feature is reported, or after
5235 qSupported processing if the feature is not supported.
5236 The first argument points to this structure. The second
5237 argument indicates whether the packet requested support be
5238 enabled, disabled, or probed (or the default, if this function
5239 is being called at the end of processing and this feature was
5240 not reported). The third argument may be NULL; if not NULL, it
5241 is a NUL-terminated string taken from the packet following
5242 this feature's name and an equals sign. */
5243 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5244 enum packet_support
, const char *);
5246 /* The corresponding packet for this feature. Only used if
5247 FUNC is remote_supported_packet. */
5252 remote_supported_packet (remote_target
*remote
,
5253 const struct protocol_feature
*feature
,
5254 enum packet_support support
,
5255 const char *argument
)
5259 warning (_("Remote qSupported response supplied an unexpected value for"
5260 " \"%s\"."), feature
->name
);
5264 remote_protocol_packets
[feature
->packet
].support
= support
;
5268 remote_target::remote_packet_size (const protocol_feature
*feature
,
5269 enum packet_support support
, const char *value
)
5271 struct remote_state
*rs
= get_remote_state ();
5276 if (support
!= PACKET_ENABLE
)
5279 if (value
== NULL
|| *value
== '\0')
5281 warning (_("Remote target reported \"%s\" without a size."),
5287 packet_size
= strtol (value
, &value_end
, 16);
5288 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5290 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5291 feature
->name
, value
);
5295 /* Record the new maximum packet size. */
5296 rs
->explicit_packet_size
= packet_size
;
5300 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5301 enum packet_support support
, const char *value
)
5303 remote
->remote_packet_size (feature
, support
, value
);
5306 static const struct protocol_feature remote_protocol_features
[] = {
5307 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5308 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5309 PACKET_qXfer_auxv
},
5310 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5311 PACKET_qXfer_exec_file
},
5312 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5313 PACKET_qXfer_features
},
5314 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5315 PACKET_qXfer_libraries
},
5316 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5317 PACKET_qXfer_libraries_svr4
},
5318 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5319 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5320 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5321 PACKET_qXfer_memory_map
},
5322 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5323 PACKET_qXfer_osdata
},
5324 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5325 PACKET_qXfer_threads
},
5326 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5327 PACKET_qXfer_traceframe_info
},
5328 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5329 PACKET_QPassSignals
},
5330 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5331 PACKET_QCatchSyscalls
},
5332 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5333 PACKET_QProgramSignals
},
5334 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5335 PACKET_QSetWorkingDir
},
5336 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5337 PACKET_QStartupWithShell
},
5338 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5339 PACKET_QEnvironmentHexEncoded
},
5340 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5341 PACKET_QEnvironmentReset
},
5342 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5343 PACKET_QEnvironmentUnset
},
5344 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5345 PACKET_QStartNoAckMode
},
5346 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5347 PACKET_multiprocess_feature
},
5348 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5349 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5350 PACKET_qXfer_siginfo_read
},
5351 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5352 PACKET_qXfer_siginfo_write
},
5353 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5354 PACKET_ConditionalTracepoints
},
5355 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5356 PACKET_ConditionalBreakpoints
},
5357 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5358 PACKET_BreakpointCommands
},
5359 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5360 PACKET_FastTracepoints
},
5361 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5362 PACKET_StaticTracepoints
},
5363 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5364 PACKET_InstallInTrace
},
5365 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5366 PACKET_DisconnectedTracing_feature
},
5367 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5369 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5371 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5372 PACKET_TracepointSource
},
5373 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5375 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5376 PACKET_EnableDisableTracepoints_feature
},
5377 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5378 PACKET_qXfer_fdpic
},
5379 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5381 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5382 PACKET_QDisableRandomization
},
5383 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5384 { "QTBuffer:size", PACKET_DISABLE
,
5385 remote_supported_packet
, PACKET_QTBuffer_size
},
5386 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5387 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5388 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5389 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5390 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5391 PACKET_qXfer_btrace
},
5392 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5393 PACKET_qXfer_btrace_conf
},
5394 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5395 PACKET_Qbtrace_conf_bts_size
},
5396 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5397 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5398 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5399 PACKET_fork_event_feature
},
5400 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5401 PACKET_vfork_event_feature
},
5402 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5403 PACKET_exec_event_feature
},
5404 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5405 PACKET_Qbtrace_conf_pt_size
},
5406 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5407 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5408 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5409 { "memory-tagging", PACKET_DISABLE
, remote_supported_packet
,
5410 PACKET_memory_tagging_feature
},
5413 static char *remote_support_xml
;
5415 /* Register string appended to "xmlRegisters=" in qSupported query. */
5418 register_remote_support_xml (const char *xml
)
5420 #if defined(HAVE_LIBEXPAT)
5421 if (remote_support_xml
== NULL
)
5422 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5425 char *copy
= xstrdup (remote_support_xml
+ 13);
5427 char *p
= strtok_r (copy
, ",", &saveptr
);
5431 if (strcmp (p
, xml
) == 0)
5438 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5441 remote_support_xml
= reconcat (remote_support_xml
,
5442 remote_support_xml
, ",", xml
,
5449 remote_query_supported_append (std::string
*msg
, const char *append
)
5453 msg
->append (append
);
5457 remote_target::remote_query_supported ()
5459 struct remote_state
*rs
= get_remote_state ();
5462 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5464 /* The packet support flags are handled differently for this packet
5465 than for most others. We treat an error, a disabled packet, and
5466 an empty response identically: any features which must be reported
5467 to be used will be automatically disabled. An empty buffer
5468 accomplishes this, since that is also the representation for a list
5469 containing no features. */
5472 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5476 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5477 remote_query_supported_append (&q
, "multiprocess+");
5479 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5480 remote_query_supported_append (&q
, "swbreak+");
5481 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5482 remote_query_supported_append (&q
, "hwbreak+");
5484 remote_query_supported_append (&q
, "qRelocInsn+");
5486 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5487 != AUTO_BOOLEAN_FALSE
)
5488 remote_query_supported_append (&q
, "fork-events+");
5489 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5490 != AUTO_BOOLEAN_FALSE
)
5491 remote_query_supported_append (&q
, "vfork-events+");
5492 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5493 != AUTO_BOOLEAN_FALSE
)
5494 remote_query_supported_append (&q
, "exec-events+");
5496 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5497 remote_query_supported_append (&q
, "vContSupported+");
5499 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5500 remote_query_supported_append (&q
, "QThreadEvents+");
5502 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5503 remote_query_supported_append (&q
, "no-resumed+");
5505 if (packet_set_cmd_state (PACKET_memory_tagging_feature
)
5506 != AUTO_BOOLEAN_FALSE
)
5507 remote_query_supported_append (&q
, "memory-tagging+");
5509 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5510 the qSupported:xmlRegisters=i386 handling. */
5511 if (remote_support_xml
!= NULL
5512 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5513 remote_query_supported_append (&q
, remote_support_xml
);
5515 q
= "qSupported:" + q
;
5516 putpkt (q
.c_str ());
5518 getpkt (&rs
->buf
, 0);
5520 /* If an error occured, warn, but do not return - just reset the
5521 buffer to empty and go on to disable features. */
5522 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5525 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5530 memset (seen
, 0, sizeof (seen
));
5532 next
= rs
->buf
.data ();
5535 enum packet_support is_supported
;
5536 char *p
, *end
, *name_end
, *value
;
5538 /* First separate out this item from the rest of the packet. If
5539 there's another item after this, we overwrite the separator
5540 (terminated strings are much easier to work with). */
5542 end
= strchr (p
, ';');
5545 end
= p
+ strlen (p
);
5555 warning (_("empty item in \"qSupported\" response"));
5560 name_end
= strchr (p
, '=');
5563 /* This is a name=value entry. */
5564 is_supported
= PACKET_ENABLE
;
5565 value
= name_end
+ 1;
5574 is_supported
= PACKET_ENABLE
;
5578 is_supported
= PACKET_DISABLE
;
5582 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5586 warning (_("unrecognized item \"%s\" "
5587 "in \"qSupported\" response"), p
);
5593 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5594 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5596 const struct protocol_feature
*feature
;
5599 feature
= &remote_protocol_features
[i
];
5600 feature
->func (this, feature
, is_supported
, value
);
5605 /* If we increased the packet size, make sure to increase the global
5606 buffer size also. We delay this until after parsing the entire
5607 qSupported packet, because this is the same buffer we were
5609 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5610 rs
->buf
.resize (rs
->explicit_packet_size
);
5612 /* Handle the defaults for unmentioned features. */
5613 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5616 const struct protocol_feature
*feature
;
5618 feature
= &remote_protocol_features
[i
];
5619 feature
->func (this, feature
, feature
->default_support
, NULL
);
5623 /* Serial QUIT handler for the remote serial descriptor.
5625 Defers handling a Ctrl-C until we're done with the current
5626 command/response packet sequence, unless:
5628 - We're setting up the connection. Don't send a remote interrupt
5629 request, as we're not fully synced yet. Quit immediately
5632 - The target has been resumed in the foreground
5633 (target_terminal::is_ours is false) with a synchronous resume
5634 packet, and we're blocked waiting for the stop reply, thus a
5635 Ctrl-C should be immediately sent to the target.
5637 - We get a second Ctrl-C while still within the same serial read or
5638 write. In that case the serial is seemingly wedged --- offer to
5641 - We see a second Ctrl-C without target response, after having
5642 previously interrupted the target. In that case the target/stub
5643 is probably wedged --- offer to quit/disconnect.
5647 remote_target::remote_serial_quit_handler ()
5649 struct remote_state
*rs
= get_remote_state ();
5651 if (check_quit_flag ())
5653 /* If we're starting up, we're not fully synced yet. Quit
5655 if (rs
->starting_up
)
5657 else if (rs
->got_ctrlc_during_io
)
5659 if (query (_("The target is not responding to GDB commands.\n"
5660 "Stop debugging it? ")))
5661 remote_unpush_and_throw (this);
5663 /* If ^C has already been sent once, offer to disconnect. */
5664 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5666 /* All-stop protocol, and blocked waiting for stop reply. Send
5667 an interrupt request. */
5668 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5669 target_interrupt ();
5671 rs
->got_ctrlc_during_io
= 1;
5675 /* The remote_target that is current while the quit handler is
5676 overridden with remote_serial_quit_handler. */
5677 static remote_target
*curr_quit_handler_target
;
5680 remote_serial_quit_handler ()
5682 curr_quit_handler_target
->remote_serial_quit_handler ();
5685 /* Remove the remote target from the target stack of each inferior
5686 that is using it. Upper targets depend on it so remove them
5690 remote_unpush_target (remote_target
*target
)
5692 /* We have to unpush the target from all inferiors, even those that
5694 scoped_restore_current_inferior restore_current_inferior
;
5696 for (inferior
*inf
: all_inferiors (target
))
5698 switch_to_inferior_no_thread (inf
);
5699 pop_all_targets_at_and_above (process_stratum
);
5700 generic_mourn_inferior ();
5703 /* Don't rely on target_close doing this when the target is popped
5704 from the last remote inferior above, because something may be
5705 holding a reference to the target higher up on the stack, meaning
5706 target_close won't be called yet. We lost the connection to the
5707 target, so clear these now, otherwise we may later throw
5708 TARGET_CLOSE_ERROR while trying to tell the remote target to
5710 fileio_handles_invalidate_target (target
);
5714 remote_unpush_and_throw (remote_target
*target
)
5716 remote_unpush_target (target
);
5717 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5721 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5723 remote_target
*curr_remote
= get_current_remote_target ();
5726 error (_("To open a remote debug connection, you need to specify what\n"
5727 "serial device is attached to the remote system\n"
5728 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5730 /* If we're connected to a running target, target_preopen will kill it.
5731 Ask this question first, before target_preopen has a chance to kill
5733 if (curr_remote
!= NULL
&& !target_has_execution ())
5736 && !query (_("Already connected to a remote target. Disconnect? ")))
5737 error (_("Still connected."));
5740 /* Here the possibly existing remote target gets unpushed. */
5741 target_preopen (from_tty
);
5743 remote_fileio_reset ();
5744 reopen_exec_file ();
5745 reread_symbols (from_tty
);
5747 remote_target
*remote
5748 = (extended_p
? new extended_remote_target () : new remote_target ());
5749 target_ops_up
target_holder (remote
);
5751 remote_state
*rs
= remote
->get_remote_state ();
5753 /* See FIXME above. */
5754 if (!target_async_permitted
)
5755 rs
->wait_forever_enabled_p
= 1;
5757 rs
->remote_desc
= remote_serial_open (name
);
5758 if (!rs
->remote_desc
)
5759 perror_with_name (name
);
5761 if (baud_rate
!= -1)
5763 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5765 /* The requested speed could not be set. Error out to
5766 top level after closing remote_desc. Take care to
5767 set remote_desc to NULL to avoid closing remote_desc
5769 serial_close (rs
->remote_desc
);
5770 rs
->remote_desc
= NULL
;
5771 perror_with_name (name
);
5775 serial_setparity (rs
->remote_desc
, serial_parity
);
5776 serial_raw (rs
->remote_desc
);
5778 /* If there is something sitting in the buffer we might take it as a
5779 response to a command, which would be bad. */
5780 serial_flush_input (rs
->remote_desc
);
5784 puts_filtered ("Remote debugging using ");
5785 puts_filtered (name
);
5786 puts_filtered ("\n");
5789 /* Switch to using the remote target now. */
5790 current_inferior ()->push_target (std::move (target_holder
));
5792 /* Register extra event sources in the event loop. */
5793 rs
->remote_async_inferior_event_token
5794 = create_async_event_handler (remote_async_inferior_event_handler
, nullptr,
5796 rs
->notif_state
= remote_notif_state_allocate (remote
);
5798 /* Reset the target state; these things will be queried either by
5799 remote_query_supported or as they are needed. */
5800 reset_all_packet_configs_support ();
5801 rs
->explicit_packet_size
= 0;
5803 rs
->extended
= extended_p
;
5804 rs
->waiting_for_stop_reply
= 0;
5805 rs
->ctrlc_pending_p
= 0;
5806 rs
->got_ctrlc_during_io
= 0;
5808 rs
->general_thread
= not_sent_ptid
;
5809 rs
->continue_thread
= not_sent_ptid
;
5810 rs
->remote_traceframe_number
= -1;
5812 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5814 /* Probe for ability to use "ThreadInfo" query, as required. */
5815 rs
->use_threadinfo_query
= 1;
5816 rs
->use_threadextra_query
= 1;
5818 rs
->readahead_cache
.invalidate ();
5820 if (target_async_permitted
)
5822 /* FIXME: cagney/1999-09-23: During the initial connection it is
5823 assumed that the target is already ready and able to respond to
5824 requests. Unfortunately remote_start_remote() eventually calls
5825 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5826 around this. Eventually a mechanism that allows
5827 wait_for_inferior() to expect/get timeouts will be
5829 rs
->wait_forever_enabled_p
= 0;
5832 /* First delete any symbols previously loaded from shared libraries. */
5833 no_shared_libraries (NULL
, 0);
5835 /* Start the remote connection. If error() or QUIT, discard this
5836 target (we'd otherwise be in an inconsistent state) and then
5837 propogate the error on up the exception chain. This ensures that
5838 the caller doesn't stumble along blindly assuming that the
5839 function succeeded. The CLI doesn't have this problem but other
5840 UI's, such as MI do.
5842 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5843 this function should return an error indication letting the
5844 caller restore the previous state. Unfortunately the command
5845 ``target remote'' is directly wired to this function making that
5846 impossible. On a positive note, the CLI side of this problem has
5847 been fixed - the function set_cmd_context() makes it possible for
5848 all the ``target ....'' commands to share a common callback
5849 function. See cli-dump.c. */
5854 remote
->start_remote (from_tty
, extended_p
);
5856 catch (const gdb_exception
&ex
)
5858 /* Pop the partially set up target - unless something else did
5859 already before throwing the exception. */
5860 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5861 remote_unpush_target (remote
);
5866 remote_btrace_reset (rs
);
5868 if (target_async_permitted
)
5869 rs
->wait_forever_enabled_p
= 1;
5872 /* Determine if WS represents a fork status. */
5875 is_fork_status (target_waitkind kind
)
5877 return (kind
== TARGET_WAITKIND_FORKED
5878 || kind
== TARGET_WAITKIND_VFORKED
);
5881 /* Return THREAD's pending status if it is a pending fork parent, else
5884 static const target_waitstatus
*
5885 thread_pending_fork_status (struct thread_info
*thread
)
5887 const target_waitstatus
&ws
5888 = (thread
->has_pending_waitstatus ()
5889 ? thread
->pending_waitstatus ()
5890 : thread
->pending_follow
);
5892 if (!is_fork_status (ws
.kind ()))
5898 /* Detach the specified process. */
5901 remote_target::remote_detach_pid (int pid
)
5903 struct remote_state
*rs
= get_remote_state ();
5905 /* This should not be necessary, but the handling for D;PID in
5906 GDBserver versions prior to 8.2 incorrectly assumes that the
5907 selected process points to the same process we're detaching,
5908 leading to misbehavior (and possibly GDBserver crashing) when it
5909 does not. Since it's easy and cheap, work around it by forcing
5910 GDBserver to select GDB's current process. */
5911 set_general_process ();
5913 if (remote_multi_process_p (rs
))
5914 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5916 strcpy (rs
->buf
.data (), "D");
5919 getpkt (&rs
->buf
, 0);
5921 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5923 else if (rs
->buf
[0] == '\0')
5924 error (_("Remote doesn't know how to detach"));
5926 error (_("Can't detach process."));
5929 /* This detaches a program to which we previously attached, using
5930 inferior_ptid to identify the process. After this is done, GDB
5931 can be used to debug some other program. We better not have left
5932 any breakpoints in the target program or it'll die when it hits
5936 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5938 int pid
= inferior_ptid
.pid ();
5939 struct remote_state
*rs
= get_remote_state ();
5942 if (!target_has_execution ())
5943 error (_("No process to detach from."));
5945 target_announce_detach (from_tty
);
5947 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
5949 /* If we're in breakpoints-always-inserted mode, or the inferior
5950 is running, we have to remove breakpoints before detaching.
5951 We don't do this in common code instead because not all
5952 targets support removing breakpoints while the target is
5953 running. The remote target / gdbserver does, though. */
5954 remove_breakpoints_inf (current_inferior ());
5957 /* Tell the remote target to detach. */
5958 remote_detach_pid (pid
);
5960 /* Exit only if this is the only active inferior. */
5961 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors (this) == 1)
5962 puts_filtered (_("Ending remote debugging.\n"));
5964 /* See if any thread of the inferior we are detaching has a pending fork
5965 status. In that case, we must detach from the child resulting from
5967 for (thread_info
*thread
: inf
->non_exited_threads ())
5969 const target_waitstatus
*ws
= thread_pending_fork_status (thread
);
5974 remote_detach_pid (ws
->child_ptid ().pid ());
5977 /* Check also for any pending fork events in the stop reply queue. */
5978 remote_notif_get_pending_events (¬if_client_stop
);
5979 for (stop_reply_up
&reply
: rs
->stop_reply_queue
)
5981 if (reply
->ptid
.pid () != pid
)
5984 if (!is_fork_status (reply
->ws
.kind ()))
5987 remote_detach_pid (reply
->ws
.child_ptid ().pid ());
5990 thread_info
*tp
= find_thread_ptid (this, inferior_ptid
);
5992 /* Check to see if we are detaching a fork parent. Note that if we
5993 are detaching a fork child, tp == NULL. */
5994 is_fork_parent
= (tp
!= NULL
5995 && tp
->pending_follow
.kind () == TARGET_WAITKIND_FORKED
);
5997 /* If doing detach-on-fork, we don't mourn, because that will delete
5998 breakpoints that should be available for the followed inferior. */
5999 if (!is_fork_parent
)
6001 /* Save the pid as a string before mourning, since that will
6002 unpush the remote target, and we need the string after. */
6003 std::string infpid
= target_pid_to_str (ptid_t (pid
));
6005 target_mourn_inferior (inferior_ptid
);
6006 if (print_inferior_events
)
6007 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
6008 inf
->num
, infpid
.c_str ());
6012 switch_to_no_thread ();
6013 detach_inferior (current_inferior ());
6018 remote_target::detach (inferior
*inf
, int from_tty
)
6020 remote_detach_1 (inf
, from_tty
);
6024 extended_remote_target::detach (inferior
*inf
, int from_tty
)
6026 remote_detach_1 (inf
, from_tty
);
6029 /* Target follow-fork function for remote targets. On entry, and
6030 at return, the current inferior is the fork parent.
6032 Note that although this is currently only used for extended-remote,
6033 it is named remote_follow_fork in anticipation of using it for the
6034 remote target as well. */
6037 remote_target::follow_fork (inferior
*child_inf
, ptid_t child_ptid
,
6038 target_waitkind fork_kind
, bool follow_child
,
6041 process_stratum_target::follow_fork (child_inf
, child_ptid
,
6042 fork_kind
, follow_child
, detach_fork
);
6044 struct remote_state
*rs
= get_remote_state ();
6046 if ((fork_kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
6047 || (fork_kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
6049 /* When following the parent and detaching the child, we detach
6050 the child here. For the case of following the child and
6051 detaching the parent, the detach is done in the target-
6052 independent follow fork code in infrun.c. We can't use
6053 target_detach when detaching an unfollowed child because
6054 the client side doesn't know anything about the child. */
6055 if (detach_fork
&& !follow_child
)
6057 /* Detach the fork child. */
6058 remote_detach_pid (child_ptid
.pid ());
6063 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
6064 in the program space of the new inferior. */
6067 remote_target::follow_exec (inferior
*follow_inf
, ptid_t ptid
,
6068 const char *execd_pathname
)
6070 process_stratum_target::follow_exec (follow_inf
, ptid
, execd_pathname
);
6072 /* We know that this is a target file name, so if it has the "target:"
6073 prefix we strip it off before saving it in the program space. */
6074 if (is_target_filename (execd_pathname
))
6075 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
6077 set_pspace_remote_exec_file (follow_inf
->pspace
, execd_pathname
);
6080 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
6083 remote_target::disconnect (const char *args
, int from_tty
)
6086 error (_("Argument given to \"disconnect\" when remotely debugging."));
6088 /* Make sure we unpush even the extended remote targets. Calling
6089 target_mourn_inferior won't unpush, and
6090 remote_target::mourn_inferior won't unpush if there is more than
6091 one inferior left. */
6092 remote_unpush_target (this);
6095 puts_filtered ("Ending remote debugging.\n");
6098 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
6099 be chatty about it. */
6102 extended_remote_target::attach (const char *args
, int from_tty
)
6104 struct remote_state
*rs
= get_remote_state ();
6106 char *wait_status
= NULL
;
6108 pid
= parse_pid_to_attach (args
);
6110 /* Remote PID can be freely equal to getpid, do not check it here the same
6111 way as in other targets. */
6113 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
6114 error (_("This target does not support attaching to a process"));
6116 target_announce_attach (from_tty
, pid
);
6118 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
6120 getpkt (&rs
->buf
, 0);
6122 switch (packet_ok (rs
->buf
,
6123 &remote_protocol_packets
[PACKET_vAttach
]))
6126 if (!target_is_non_stop_p ())
6128 /* Save the reply for later. */
6129 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
6130 strcpy (wait_status
, rs
->buf
.data ());
6132 else if (strcmp (rs
->buf
.data (), "OK") != 0)
6133 error (_("Attaching to %s failed with: %s"),
6134 target_pid_to_str (ptid_t (pid
)).c_str (),
6137 case PACKET_UNKNOWN
:
6138 error (_("This target does not support attaching to a process"));
6140 error (_("Attaching to %s failed"),
6141 target_pid_to_str (ptid_t (pid
)).c_str ());
6144 switch_to_inferior_no_thread (remote_add_inferior (false, pid
, 1, 0));
6146 inferior_ptid
= ptid_t (pid
);
6148 if (target_is_non_stop_p ())
6150 /* Get list of threads. */
6151 update_thread_list ();
6153 thread_info
*thread
= first_thread_of_inferior (current_inferior ());
6154 if (thread
!= nullptr)
6155 switch_to_thread (thread
);
6157 /* Invalidate our notion of the remote current thread. */
6158 record_currthread (rs
, minus_one_ptid
);
6162 /* Now, if we have thread information, update the main thread's
6164 ptid_t curr_ptid
= remote_current_thread (ptid_t (pid
));
6166 /* Add the main thread to the thread list. We add the thread
6167 silently in this case (the final true parameter). */
6168 thread_info
*thr
= remote_add_thread (curr_ptid
, true, true, true);
6170 switch_to_thread (thr
);
6173 /* Next, if the target can specify a description, read it. We do
6174 this before anything involving memory or registers. */
6175 target_find_description ();
6177 if (!target_is_non_stop_p ())
6179 /* Use the previously fetched status. */
6180 gdb_assert (wait_status
!= NULL
);
6182 struct notif_event
*reply
6183 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
6185 push_stop_reply ((struct stop_reply
*) reply
);
6189 gdb_assert (wait_status
== NULL
);
6191 gdb_assert (target_can_async_p ());
6195 /* Implementation of the to_post_attach method. */
6198 extended_remote_target::post_attach (int pid
)
6200 /* Get text, data & bss offsets. */
6203 /* In certain cases GDB might not have had the chance to start
6204 symbol lookup up until now. This could happen if the debugged
6205 binary is not using shared libraries, the vsyscall page is not
6206 present (on Linux) and the binary itself hadn't changed since the
6207 debugging process was started. */
6208 if (current_program_space
->symfile_object_file
!= NULL
)
6209 remote_check_symbols();
6213 /* Check for the availability of vCont. This function should also check
6217 remote_target::remote_vcont_probe ()
6219 remote_state
*rs
= get_remote_state ();
6222 strcpy (rs
->buf
.data (), "vCont?");
6224 getpkt (&rs
->buf
, 0);
6225 buf
= rs
->buf
.data ();
6227 /* Make sure that the features we assume are supported. */
6228 if (startswith (buf
, "vCont"))
6231 int support_c
, support_C
;
6233 rs
->supports_vCont
.s
= 0;
6234 rs
->supports_vCont
.S
= 0;
6237 rs
->supports_vCont
.t
= 0;
6238 rs
->supports_vCont
.r
= 0;
6239 while (p
&& *p
== ';')
6242 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6243 rs
->supports_vCont
.s
= 1;
6244 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6245 rs
->supports_vCont
.S
= 1;
6246 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6248 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6250 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6251 rs
->supports_vCont
.t
= 1;
6252 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6253 rs
->supports_vCont
.r
= 1;
6255 p
= strchr (p
, ';');
6258 /* If c, and C are not all supported, we can't use vCont. Clearing
6259 BUF will make packet_ok disable the packet. */
6260 if (!support_c
|| !support_C
)
6264 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
6265 rs
->supports_vCont_probed
= true;
6268 /* Helper function for building "vCont" resumptions. Write a
6269 resumption to P. ENDP points to one-passed-the-end of the buffer
6270 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
6271 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
6272 resumed thread should be single-stepped and/or signalled. If PTID
6273 equals minus_one_ptid, then all threads are resumed; if PTID
6274 represents a process, then all threads of the process are resumed;
6275 the thread to be stepped and/or signalled is given in the global
6279 remote_target::append_resumption (char *p
, char *endp
,
6280 ptid_t ptid
, int step
, gdb_signal siggnal
)
6282 struct remote_state
*rs
= get_remote_state ();
6284 if (step
&& siggnal
!= GDB_SIGNAL_0
)
6285 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
6287 /* GDB is willing to range step. */
6288 && use_range_stepping
6289 /* Target supports range stepping. */
6290 && rs
->supports_vCont
.r
6291 /* We don't currently support range stepping multiple
6292 threads with a wildcard (though the protocol allows it,
6293 so stubs shouldn't make an active effort to forbid
6295 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6297 struct thread_info
*tp
;
6299 if (ptid
== minus_one_ptid
)
6301 /* If we don't know about the target thread's tid, then
6302 we're resuming magic_null_ptid (see caller). */
6303 tp
= find_thread_ptid (this, magic_null_ptid
);
6306 tp
= find_thread_ptid (this, ptid
);
6307 gdb_assert (tp
!= NULL
);
6309 if (tp
->control
.may_range_step
)
6311 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6313 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6314 phex_nz (tp
->control
.step_range_start
,
6316 phex_nz (tp
->control
.step_range_end
,
6320 p
+= xsnprintf (p
, endp
- p
, ";s");
6323 p
+= xsnprintf (p
, endp
- p
, ";s");
6324 else if (siggnal
!= GDB_SIGNAL_0
)
6325 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6327 p
+= xsnprintf (p
, endp
- p
, ";c");
6329 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6333 /* All (-1) threads of process. */
6334 nptid
= ptid_t (ptid
.pid (), -1);
6336 p
+= xsnprintf (p
, endp
- p
, ":");
6337 p
= write_ptid (p
, endp
, nptid
);
6339 else if (ptid
!= minus_one_ptid
)
6341 p
+= xsnprintf (p
, endp
- p
, ":");
6342 p
= write_ptid (p
, endp
, ptid
);
6348 /* Clear the thread's private info on resume. */
6351 resume_clear_thread_private_info (struct thread_info
*thread
)
6353 if (thread
->priv
!= NULL
)
6355 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6357 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6358 priv
->watch_data_address
= 0;
6362 /* Append a vCont continue-with-signal action for threads that have a
6363 non-zero stop signal. */
6366 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6369 for (thread_info
*thread
: all_non_exited_threads (this, ptid
))
6370 if (inferior_ptid
!= thread
->ptid
6371 && thread
->stop_signal () != GDB_SIGNAL_0
)
6373 p
= append_resumption (p
, endp
, thread
->ptid
,
6374 0, thread
->stop_signal ());
6375 thread
->set_stop_signal (GDB_SIGNAL_0
);
6376 resume_clear_thread_private_info (thread
);
6382 /* Set the target running, using the packets that use Hc
6386 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6389 struct remote_state
*rs
= get_remote_state ();
6392 rs
->last_sent_signal
= siggnal
;
6393 rs
->last_sent_step
= step
;
6395 /* The c/s/C/S resume packets use Hc, so set the continue
6397 if (ptid
== minus_one_ptid
)
6398 set_continue_thread (any_thread_ptid
);
6400 set_continue_thread (ptid
);
6402 for (thread_info
*thread
: all_non_exited_threads (this))
6403 resume_clear_thread_private_info (thread
);
6405 buf
= rs
->buf
.data ();
6406 if (::execution_direction
== EXEC_REVERSE
)
6408 /* We don't pass signals to the target in reverse exec mode. */
6409 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6410 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6413 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6414 error (_("Remote reverse-step not supported."));
6415 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6416 error (_("Remote reverse-continue not supported."));
6418 strcpy (buf
, step
? "bs" : "bc");
6420 else if (siggnal
!= GDB_SIGNAL_0
)
6422 buf
[0] = step
? 'S' : 'C';
6423 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6424 buf
[2] = tohex (((int) siggnal
) & 0xf);
6428 strcpy (buf
, step
? "s" : "c");
6433 /* Resume the remote inferior by using a "vCont" packet. The thread
6434 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6435 resumed thread should be single-stepped and/or signalled. If PTID
6436 equals minus_one_ptid, then all threads are resumed; the thread to
6437 be stepped and/or signalled is given in the global INFERIOR_PTID.
6438 This function returns non-zero iff it resumes the inferior.
6440 This function issues a strict subset of all possible vCont commands
6444 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6445 enum gdb_signal siggnal
)
6447 struct remote_state
*rs
= get_remote_state ();
6451 /* No reverse execution actions defined for vCont. */
6452 if (::execution_direction
== EXEC_REVERSE
)
6455 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6456 remote_vcont_probe ();
6458 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6461 p
= rs
->buf
.data ();
6462 endp
= p
+ get_remote_packet_size ();
6464 /* If we could generate a wider range of packets, we'd have to worry
6465 about overflowing BUF. Should there be a generic
6466 "multi-part-packet" packet? */
6468 p
+= xsnprintf (p
, endp
- p
, "vCont");
6470 if (ptid
== magic_null_ptid
)
6472 /* MAGIC_NULL_PTID means that we don't have any active threads,
6473 so we don't have any TID numbers the inferior will
6474 understand. Make sure to only send forms that do not specify
6476 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6478 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6480 /* Resume all threads (of all processes, or of a single
6481 process), with preference for INFERIOR_PTID. This assumes
6482 inferior_ptid belongs to the set of all threads we are about
6484 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6486 /* Step inferior_ptid, with or without signal. */
6487 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6490 /* Also pass down any pending signaled resumption for other
6491 threads not the current. */
6492 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6494 /* And continue others without a signal. */
6495 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6499 /* Scheduler locking; resume only PTID. */
6500 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6503 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6506 if (target_is_non_stop_p ())
6508 /* In non-stop, the stub replies to vCont with "OK". The stop
6509 reply will be reported asynchronously by means of a `%Stop'
6511 getpkt (&rs
->buf
, 0);
6512 if (strcmp (rs
->buf
.data (), "OK") != 0)
6513 error (_("Unexpected vCont reply in non-stop mode: %s"),
6520 /* Tell the remote machine to resume. */
6523 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6525 struct remote_state
*rs
= get_remote_state ();
6527 /* When connected in non-stop mode, the core resumes threads
6528 individually. Resuming remote threads directly in target_resume
6529 would thus result in sending one packet per thread. Instead, to
6530 minimize roundtrip latency, here we just store the resume
6531 request (put the thread in RESUMED_PENDING_VCONT state); the actual remote
6532 resumption will be done in remote_target::commit_resume, where we'll be
6533 able to do vCont action coalescing. */
6534 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6536 remote_thread_info
*remote_thr
;
6538 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6539 remote_thr
= get_remote_thread_info (this, inferior_ptid
);
6541 remote_thr
= get_remote_thread_info (this, ptid
);
6543 /* We don't expect the core to ask to resume an already resumed (from
6544 its point of view) thread. */
6545 gdb_assert (remote_thr
->get_resume_state () == resume_state::NOT_RESUMED
);
6547 remote_thr
->set_resumed_pending_vcont (step
, siggnal
);
6551 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6552 (explained in remote-notif.c:handle_notification) so
6553 remote_notif_process is not called. We need find a place where
6554 it is safe to start a 'vNotif' sequence. It is good to do it
6555 before resuming inferior, because inferior was stopped and no RSP
6556 traffic at that moment. */
6557 if (!target_is_non_stop_p ())
6558 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6560 rs
->last_resume_exec_dir
= ::execution_direction
;
6562 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6563 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6564 remote_resume_with_hc (ptid
, step
, siggnal
);
6566 /* Update resumed state tracked by the remote target. */
6567 for (thread_info
*tp
: all_non_exited_threads (this, ptid
))
6568 get_remote_thread_info (tp
)->set_resumed ();
6570 /* We've just told the target to resume. The remote server will
6571 wait for the inferior to stop, and then send a stop reply. In
6572 the mean time, we can't start another command/query ourselves
6573 because the stub wouldn't be ready to process it. This applies
6574 only to the base all-stop protocol, however. In non-stop (which
6575 only supports vCont), the stub replies with an "OK", and is
6576 immediate able to process further serial input. */
6577 if (!target_is_non_stop_p ())
6578 rs
->waiting_for_stop_reply
= 1;
6581 /* Private per-inferior info for target remote processes. */
6583 struct remote_inferior
: public private_inferior
6585 /* Whether we can send a wildcard vCont for this process. */
6586 bool may_wildcard_vcont
= true;
6589 /* Get the remote private inferior data associated to INF. */
6591 static remote_inferior
*
6592 get_remote_inferior (inferior
*inf
)
6594 if (inf
->priv
== NULL
)
6595 inf
->priv
.reset (new remote_inferior
);
6597 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6600 /* Class used to track the construction of a vCont packet in the
6601 outgoing packet buffer. This is used to send multiple vCont
6602 packets if we have more actions than would fit a single packet. */
6607 explicit vcont_builder (remote_target
*remote
)
6614 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6619 /* The remote target. */
6620 remote_target
*m_remote
;
6622 /* Pointer to the first action. P points here if no action has been
6624 char *m_first_action
;
6626 /* Where the next action will be appended. */
6629 /* The end of the buffer. Must never write past this. */
6633 /* Prepare the outgoing buffer for a new vCont packet. */
6636 vcont_builder::restart ()
6638 struct remote_state
*rs
= m_remote
->get_remote_state ();
6640 m_p
= rs
->buf
.data ();
6641 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6642 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6643 m_first_action
= m_p
;
6646 /* If the vCont packet being built has any action, send it to the
6650 vcont_builder::flush ()
6652 struct remote_state
*rs
;
6654 if (m_p
== m_first_action
)
6657 rs
= m_remote
->get_remote_state ();
6658 m_remote
->putpkt (rs
->buf
);
6659 m_remote
->getpkt (&rs
->buf
, 0);
6660 if (strcmp (rs
->buf
.data (), "OK") != 0)
6661 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6664 /* The largest action is range-stepping, with its two addresses. This
6665 is more than sufficient. If a new, bigger action is created, it'll
6666 quickly trigger a failed assertion in append_resumption (and we'll
6668 #define MAX_ACTION_SIZE 200
6670 /* Append a new vCont action in the outgoing packet being built. If
6671 the action doesn't fit the packet along with previous actions, push
6672 what we've got so far to the remote end and start over a new vCont
6673 packet (with the new action). */
6676 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6678 char buf
[MAX_ACTION_SIZE
+ 1];
6680 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6681 ptid
, step
, siggnal
);
6683 /* Check whether this new action would fit in the vCont packet along
6684 with previous actions. If not, send what we've got so far and
6685 start a new vCont packet. */
6686 size_t rsize
= endp
- buf
;
6687 if (rsize
> m_endp
- m_p
)
6692 /* Should now fit. */
6693 gdb_assert (rsize
<= m_endp
- m_p
);
6696 memcpy (m_p
, buf
, rsize
);
6701 /* to_commit_resume implementation. */
6704 remote_target::commit_resumed ()
6706 /* If connected in all-stop mode, we'd send the remote resume
6707 request directly from remote_resume. Likewise if
6708 reverse-debugging, as there are no defined vCont actions for
6709 reverse execution. */
6710 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6713 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6714 instead of resuming all threads of each process individually.
6715 However, if any thread of a process must remain halted, we can't
6716 send wildcard resumes and must send one action per thread.
6718 Care must be taken to not resume threads/processes the server
6719 side already told us are stopped, but the core doesn't know about
6720 yet, because the events are still in the vStopped notification
6723 #1 => vCont s:p1.1;c
6725 #3 <= %Stopped T05 p1.1
6730 #8 (infrun handles the stop for p1.1 and continues stepping)
6731 #9 => vCont s:p1.1;c
6733 The last vCont above would resume thread p1.2 by mistake, because
6734 the server has no idea that the event for p1.2 had not been
6737 The server side must similarly ignore resume actions for the
6738 thread that has a pending %Stopped notification (and any other
6739 threads with events pending), until GDB acks the notification
6740 with vStopped. Otherwise, e.g., the following case is
6743 #1 => g (or any other packet)
6745 #3 <= %Stopped T05 p1.2
6746 #4 => vCont s:p1.1;c
6749 Above, the server must not resume thread p1.2. GDB can't know
6750 that p1.2 stopped until it acks the %Stopped notification, and
6751 since from GDB's perspective all threads should be running, it
6754 Finally, special care must also be given to handling fork/vfork
6755 events. A (v)fork event actually tells us that two processes
6756 stopped -- the parent and the child. Until we follow the fork,
6757 we must not resume the child. Therefore, if we have a pending
6758 fork follow, we must not send a global wildcard resume action
6759 (vCont;c). We can still send process-wide wildcards though. */
6761 /* Start by assuming a global wildcard (vCont;c) is possible. */
6762 bool may_global_wildcard_vcont
= true;
6764 /* And assume every process is individually wildcard-able too. */
6765 for (inferior
*inf
: all_non_exited_inferiors (this))
6767 remote_inferior
*priv
= get_remote_inferior (inf
);
6769 priv
->may_wildcard_vcont
= true;
6772 /* Check for any pending events (not reported or processed yet) and
6773 disable process and global wildcard resumes appropriately. */
6774 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6776 bool any_pending_vcont_resume
= false;
6778 for (thread_info
*tp
: all_non_exited_threads (this))
6780 remote_thread_info
*priv
= get_remote_thread_info (tp
);
6782 /* If a thread of a process is not meant to be resumed, then we
6783 can't wildcard that process. */
6784 if (priv
->get_resume_state () == resume_state::NOT_RESUMED
)
6786 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6788 /* And if we can't wildcard a process, we can't wildcard
6789 everything either. */
6790 may_global_wildcard_vcont
= false;
6794 if (priv
->get_resume_state () == resume_state::RESUMED_PENDING_VCONT
)
6795 any_pending_vcont_resume
= true;
6797 /* If a thread is the parent of an unfollowed fork, then we
6798 can't do a global wildcard, as that would resume the fork
6800 if (thread_pending_fork_status (tp
) != nullptr)
6801 may_global_wildcard_vcont
= false;
6804 /* We didn't have any resumed thread pending a vCont resume, so nothing to
6806 if (!any_pending_vcont_resume
)
6809 /* Now let's build the vCont packet(s). Actions must be appended
6810 from narrower to wider scopes (thread -> process -> global). If
6811 we end up with too many actions for a single packet vcont_builder
6812 flushes the current vCont packet to the remote side and starts a
6814 struct vcont_builder
vcont_builder (this);
6816 /* Threads first. */
6817 for (thread_info
*tp
: all_non_exited_threads (this))
6819 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6821 /* If the thread was previously vCont-resumed, no need to send a specific
6822 action for it. If we didn't receive a resume request for it, don't
6823 send an action for it either. */
6824 if (remote_thr
->get_resume_state () != resume_state::RESUMED_PENDING_VCONT
)
6827 gdb_assert (!thread_is_in_step_over_chain (tp
));
6829 /* We should never be commit-resuming a thread that has a stop reply.
6830 Otherwise, we would end up reporting a stop event for a thread while
6831 it is running on the remote target. */
6832 remote_state
*rs
= get_remote_state ();
6833 for (const auto &stop_reply
: rs
->stop_reply_queue
)
6834 gdb_assert (stop_reply
->ptid
!= tp
->ptid
);
6836 const resumed_pending_vcont_info
&info
6837 = remote_thr
->resumed_pending_vcont_info ();
6839 /* Check if we need to send a specific action for this thread. If not,
6840 it will be included in a wildcard resume instead. */
6841 if (info
.step
|| info
.sig
!= GDB_SIGNAL_0
6842 || !get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6843 vcont_builder
.push_action (tp
->ptid
, info
.step
, info
.sig
);
6845 remote_thr
->set_resumed ();
6848 /* Now check whether we can send any process-wide wildcard. This is
6849 to avoid sending a global wildcard in the case nothing is
6850 supposed to be resumed. */
6851 bool any_process_wildcard
= false;
6853 for (inferior
*inf
: all_non_exited_inferiors (this))
6855 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6857 any_process_wildcard
= true;
6862 if (any_process_wildcard
)
6864 /* If all processes are wildcard-able, then send a single "c"
6865 action, otherwise, send an "all (-1) threads of process"
6866 continue action for each running process, if any. */
6867 if (may_global_wildcard_vcont
)
6869 vcont_builder
.push_action (minus_one_ptid
,
6870 false, GDB_SIGNAL_0
);
6874 for (inferior
*inf
: all_non_exited_inferiors (this))
6876 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6878 vcont_builder
.push_action (ptid_t (inf
->pid
),
6879 false, GDB_SIGNAL_0
);
6885 vcont_builder
.flush ();
6888 /* Implementation of target_has_pending_events. */
6891 remote_target::has_pending_events ()
6893 if (target_can_async_p ())
6895 remote_state
*rs
= get_remote_state ();
6897 if (async_event_handler_marked (rs
->remote_async_inferior_event_token
))
6900 /* Note that BUFCNT can be negative, indicating sticky
6902 if (rs
->remote_desc
->bufcnt
!= 0)
6910 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6911 thread, all threads of a remote process, or all threads of all
6915 remote_target::remote_stop_ns (ptid_t ptid
)
6917 struct remote_state
*rs
= get_remote_state ();
6918 char *p
= rs
->buf
.data ();
6919 char *endp
= p
+ get_remote_packet_size ();
6921 /* If any thread that needs to stop was resumed but pending a vCont
6922 resume, generate a phony stop_reply. However, first check
6923 whether the thread wasn't resumed with a signal. Generating a
6924 phony stop in that case would result in losing the signal. */
6925 bool needs_commit
= false;
6926 for (thread_info
*tp
: all_non_exited_threads (this, ptid
))
6928 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6930 if (remote_thr
->get_resume_state ()
6931 == resume_state::RESUMED_PENDING_VCONT
)
6933 const resumed_pending_vcont_info
&info
6934 = remote_thr
->resumed_pending_vcont_info ();
6935 if (info
.sig
!= GDB_SIGNAL_0
)
6937 /* This signal must be forwarded to the inferior. We
6938 could commit-resume just this thread, but its simpler
6939 to just commit-resume everything. */
6940 needs_commit
= true;
6949 for (thread_info
*tp
: all_non_exited_threads (this, ptid
))
6951 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6953 if (remote_thr
->get_resume_state ()
6954 == resume_state::RESUMED_PENDING_VCONT
)
6956 remote_debug_printf ("Enqueueing phony stop reply for thread pending "
6957 "vCont-resume (%d, %ld, %s)", tp
->ptid
.pid(),
6959 pulongest (tp
->ptid
.tid ()));
6961 /* Check that the thread wasn't resumed with a signal.
6962 Generating a phony stop would result in losing the
6964 const resumed_pending_vcont_info
&info
6965 = remote_thr
->resumed_pending_vcont_info ();
6966 gdb_assert (info
.sig
== GDB_SIGNAL_0
);
6968 stop_reply
*sr
= new stop_reply ();
6969 sr
->ptid
= tp
->ptid
;
6971 sr
->ws
.set_stopped (GDB_SIGNAL_0
);
6972 sr
->arch
= tp
->inf
->gdbarch
;
6973 sr
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6974 sr
->watch_data_address
= 0;
6976 this->push_stop_reply (sr
);
6978 /* Pretend that this thread was actually resumed on the
6979 remote target, then stopped. If we leave it in the
6980 RESUMED_PENDING_VCONT state and the commit_resumed
6981 method is called while the stop reply is still in the
6982 queue, we'll end up reporting a stop event to the core
6983 for that thread while it is running on the remote
6984 target... that would be bad. */
6985 remote_thr
->set_resumed ();
6989 /* FIXME: This supports_vCont_probed check is a workaround until
6990 packet_support is per-connection. */
6991 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
6992 || !rs
->supports_vCont_probed
)
6993 remote_vcont_probe ();
6995 if (!rs
->supports_vCont
.t
)
6996 error (_("Remote server does not support stopping threads"));
6998 if (ptid
== minus_one_ptid
6999 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
7000 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
7005 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
7008 /* All (-1) threads of process. */
7009 nptid
= ptid_t (ptid
.pid (), -1);
7012 /* Small optimization: if we already have a stop reply for
7013 this thread, no use in telling the stub we want this
7015 if (peek_stop_reply (ptid
))
7021 write_ptid (p
, endp
, nptid
);
7024 /* In non-stop, we get an immediate OK reply. The stop reply will
7025 come in asynchronously by notification. */
7027 getpkt (&rs
->buf
, 0);
7028 if (strcmp (rs
->buf
.data (), "OK") != 0)
7029 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
7033 /* All-stop version of target_interrupt. Sends a break or a ^C to
7034 interrupt the remote target. It is undefined which thread of which
7035 process reports the interrupt. */
7038 remote_target::remote_interrupt_as ()
7040 struct remote_state
*rs
= get_remote_state ();
7042 rs
->ctrlc_pending_p
= 1;
7044 /* If the inferior is stopped already, but the core didn't know
7045 about it yet, just ignore the request. The pending stop events
7046 will be collected in remote_wait. */
7047 if (stop_reply_queue_length () > 0)
7050 /* Send interrupt_sequence to remote target. */
7051 send_interrupt_sequence ();
7054 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
7055 the remote target. It is undefined which thread of which process
7056 reports the interrupt. Throws an error if the packet is not
7057 supported by the server. */
7060 remote_target::remote_interrupt_ns ()
7062 struct remote_state
*rs
= get_remote_state ();
7063 char *p
= rs
->buf
.data ();
7064 char *endp
= p
+ get_remote_packet_size ();
7066 xsnprintf (p
, endp
- p
, "vCtrlC");
7068 /* In non-stop, we get an immediate OK reply. The stop reply will
7069 come in asynchronously by notification. */
7071 getpkt (&rs
->buf
, 0);
7073 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
7077 case PACKET_UNKNOWN
:
7078 error (_("No support for interrupting the remote target."));
7080 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
7084 /* Implement the to_stop function for the remote targets. */
7087 remote_target::stop (ptid_t ptid
)
7089 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
7091 if (target_is_non_stop_p ())
7092 remote_stop_ns (ptid
);
7095 /* We don't currently have a way to transparently pause the
7096 remote target in all-stop mode. Interrupt it instead. */
7097 remote_interrupt_as ();
7101 /* Implement the to_interrupt function for the remote targets. */
7104 remote_target::interrupt ()
7106 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
7108 if (target_is_non_stop_p ())
7109 remote_interrupt_ns ();
7111 remote_interrupt_as ();
7114 /* Implement the to_pass_ctrlc function for the remote targets. */
7117 remote_target::pass_ctrlc ()
7119 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
7121 struct remote_state
*rs
= get_remote_state ();
7123 /* If we're starting up, we're not fully synced yet. Quit
7125 if (rs
->starting_up
)
7127 /* If ^C has already been sent once, offer to disconnect. */
7128 else if (rs
->ctrlc_pending_p
)
7131 target_interrupt ();
7134 /* Ask the user what to do when an interrupt is received. */
7137 remote_target::interrupt_query ()
7139 struct remote_state
*rs
= get_remote_state ();
7141 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
7143 if (query (_("The target is not responding to interrupt requests.\n"
7144 "Stop debugging it? ")))
7146 remote_unpush_target (this);
7147 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
7152 if (query (_("Interrupted while waiting for the program.\n"
7153 "Give up waiting? ")))
7158 /* Enable/disable target terminal ownership. Most targets can use
7159 terminal groups to control terminal ownership. Remote targets are
7160 different in that explicit transfer of ownership to/from GDB/target
7164 remote_target::terminal_inferior ()
7166 /* NOTE: At this point we could also register our selves as the
7167 recipient of all input. Any characters typed could then be
7168 passed on down to the target. */
7172 remote_target::terminal_ours ()
7177 remote_console_output (const char *msg
)
7181 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
7184 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
7188 gdb_stdtarg
->puts (tb
);
7190 gdb_stdtarg
->flush ();
7193 /* Return the length of the stop reply queue. */
7196 remote_target::stop_reply_queue_length ()
7198 remote_state
*rs
= get_remote_state ();
7199 return rs
->stop_reply_queue
.size ();
7203 remote_notif_stop_parse (remote_target
*remote
,
7204 struct notif_client
*self
, const char *buf
,
7205 struct notif_event
*event
)
7207 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
7211 remote_notif_stop_ack (remote_target
*remote
,
7212 struct notif_client
*self
, const char *buf
,
7213 struct notif_event
*event
)
7215 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
7218 putpkt (remote
, self
->ack_command
);
7220 /* Kind can be TARGET_WAITKIND_IGNORE if we have meanwhile discarded
7221 the notification. It was left in the queue because we need to
7222 acknowledge it and pull the rest of the notifications out. */
7223 if (stop_reply
->ws
.kind () != TARGET_WAITKIND_IGNORE
)
7224 remote
->push_stop_reply (stop_reply
);
7228 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
7229 struct notif_client
*self
)
7231 /* We can't get pending events in remote_notif_process for
7232 notification stop, and we have to do this in remote_wait_ns
7233 instead. If we fetch all queued events from stub, remote stub
7234 may exit and we have no chance to process them back in
7236 remote_state
*rs
= remote
->get_remote_state ();
7237 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7241 stop_reply::~stop_reply ()
7243 for (cached_reg_t
®
: regcache
)
7247 static notif_event_up
7248 remote_notif_stop_alloc_reply ()
7250 return notif_event_up (new struct stop_reply ());
7253 /* A client of notification Stop. */
7255 struct notif_client notif_client_stop
=
7259 remote_notif_stop_parse
,
7260 remote_notif_stop_ack
,
7261 remote_notif_stop_can_get_pending_events
,
7262 remote_notif_stop_alloc_reply
,
7266 /* If CONTEXT contains any fork child threads that have not been
7267 reported yet, remove them from the CONTEXT list. If such a
7268 thread exists it is because we are stopped at a fork catchpoint
7269 and have not yet called follow_fork, which will set up the
7270 host-side data structures for the new process. */
7273 remote_target::remove_new_fork_children (threads_listing_context
*context
)
7275 struct notif_client
*notif
= ¬if_client_stop
;
7277 /* For any threads stopped at a fork event, remove the corresponding
7278 fork child threads from the CONTEXT list. */
7279 for (thread_info
*thread
: all_non_exited_threads (this))
7281 const target_waitstatus
*ws
= thread_pending_fork_status (thread
);
7286 context
->remove_thread (ws
->child_ptid ());
7289 /* Check for any pending fork events (not reported or processed yet)
7290 in process PID and remove those fork child threads from the
7291 CONTEXT list as well. */
7292 remote_notif_get_pending_events (notif
);
7293 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7294 if (event
->ws
.kind () == TARGET_WAITKIND_FORKED
7295 || event
->ws
.kind () == TARGET_WAITKIND_VFORKED
7296 || event
->ws
.kind () == TARGET_WAITKIND_THREAD_EXITED
)
7297 context
->remove_thread (event
->ws
.child_ptid ());
7300 /* Check whether any event pending in the vStopped queue would prevent a
7301 global or process wildcard vCont action. Set *may_global_wildcard to
7302 false if we can't do a global wildcard (vCont;c), and clear the event
7303 inferior's may_wildcard_vcont flag if we can't do a process-wide
7304 wildcard resume (vCont;c:pPID.-1). */
7307 remote_target::check_pending_events_prevent_wildcard_vcont
7308 (bool *may_global_wildcard
)
7310 struct notif_client
*notif
= ¬if_client_stop
;
7312 remote_notif_get_pending_events (notif
);
7313 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7315 if (event
->ws
.kind () == TARGET_WAITKIND_NO_RESUMED
7316 || event
->ws
.kind () == TARGET_WAITKIND_NO_HISTORY
)
7319 if (event
->ws
.kind () == TARGET_WAITKIND_FORKED
7320 || event
->ws
.kind () == TARGET_WAITKIND_VFORKED
)
7321 *may_global_wildcard
= false;
7323 /* This may be the first time we heard about this process.
7324 Regardless, we must not do a global wildcard resume, otherwise
7325 we'd resume this process too. */
7326 *may_global_wildcard
= false;
7327 if (event
->ptid
!= null_ptid
)
7329 inferior
*inf
= find_inferior_ptid (this, event
->ptid
);
7331 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7336 /* Discard all pending stop replies of inferior INF. */
7339 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7341 struct stop_reply
*reply
;
7342 struct remote_state
*rs
= get_remote_state ();
7343 struct remote_notif_state
*rns
= rs
->notif_state
;
7345 /* This function can be notified when an inferior exists. When the
7346 target is not remote, the notification state is NULL. */
7347 if (rs
->remote_desc
== NULL
)
7350 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7352 /* Discard the in-flight notification. */
7353 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7355 /* Leave the notification pending, since the server expects that
7356 we acknowledge it with vStopped. But clear its contents, so
7357 that later on when we acknowledge it, we also discard it. */
7359 ("discarding in-flight notification: ptid: %s, ws: %s\n",
7360 reply
->ptid
.to_string().c_str(),
7361 reply
->ws
.to_string ().c_str ());
7362 reply
->ws
.set_ignore ();
7365 /* Discard the stop replies we have already pulled with
7367 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7368 rs
->stop_reply_queue
.end (),
7369 [=] (const stop_reply_up
&event
)
7371 return event
->ptid
.pid () == inf
->pid
;
7373 for (auto it
= iter
; it
!= rs
->stop_reply_queue
.end (); ++it
)
7375 ("discarding queued stop reply: ptid: %s, ws: %s\n",
7376 reply
->ptid
.to_string().c_str(),
7377 reply
->ws
.to_string ().c_str ());
7378 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7381 /* Discard the stop replies for RS in stop_reply_queue. */
7384 remote_target::discard_pending_stop_replies_in_queue ()
7386 remote_state
*rs
= get_remote_state ();
7388 /* Discard the stop replies we have already pulled with
7390 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7391 rs
->stop_reply_queue
.end (),
7392 [=] (const stop_reply_up
&event
)
7394 return event
->rs
== rs
;
7396 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7399 /* Remove the first reply in 'stop_reply_queue' which matches
7403 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7405 remote_state
*rs
= get_remote_state ();
7407 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7408 rs
->stop_reply_queue
.end (),
7409 [=] (const stop_reply_up
&event
)
7411 return event
->ptid
.matches (ptid
);
7413 struct stop_reply
*result
;
7414 if (iter
== rs
->stop_reply_queue
.end ())
7418 result
= iter
->release ();
7419 rs
->stop_reply_queue
.erase (iter
);
7423 fprintf_unfiltered (gdb_stdlog
,
7424 "notif: discard queued event: 'Stop' in %s\n",
7425 ptid
.to_string ().c_str ());
7430 /* Look for a queued stop reply belonging to PTID. If one is found,
7431 remove it from the queue, and return it. Returns NULL if none is
7432 found. If there are still queued events left to process, tell the
7433 event loop to get back to target_wait soon. */
7436 remote_target::queued_stop_reply (ptid_t ptid
)
7438 remote_state
*rs
= get_remote_state ();
7439 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7441 if (!rs
->stop_reply_queue
.empty () && target_can_async_p ())
7443 /* There's still at least an event left. */
7444 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7450 /* Push a fully parsed stop reply in the stop reply queue. Since we
7451 know that we now have at least one queued event left to pass to the
7452 core side, tell the event loop to get back to target_wait soon. */
7455 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7457 remote_state
*rs
= get_remote_state ();
7458 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7461 fprintf_unfiltered (gdb_stdlog
,
7462 "notif: push 'Stop' %s to queue %d\n",
7463 new_event
->ptid
.to_string ().c_str (),
7464 int (rs
->stop_reply_queue
.size ()));
7466 /* Mark the pending event queue only if async mode is currently enabled.
7467 If async mode is not currently enabled, then, if it later becomes
7468 enabled, and there are events in this queue, we will mark the event
7469 token at that point, see remote_target::async. */
7470 if (target_is_async_p ())
7471 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7474 /* Returns true if we have a stop reply for PTID. */
7477 remote_target::peek_stop_reply (ptid_t ptid
)
7479 remote_state
*rs
= get_remote_state ();
7480 for (auto &event
: rs
->stop_reply_queue
)
7481 if (ptid
== event
->ptid
7482 && event
->ws
.kind () == TARGET_WAITKIND_STOPPED
)
7487 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7488 starting with P and ending with PEND matches PREFIX. */
7491 strprefix (const char *p
, const char *pend
, const char *prefix
)
7493 for ( ; p
< pend
; p
++, prefix
++)
7496 return *prefix
== '\0';
7499 /* Parse the stop reply in BUF. Either the function succeeds, and the
7500 result is stored in EVENT, or throws an error. */
7503 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7505 remote_arch_state
*rsa
= NULL
;
7510 event
->ptid
= null_ptid
;
7511 event
->rs
= get_remote_state ();
7512 event
->ws
.set_ignore ();
7513 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7514 event
->regcache
.clear ();
7519 case 'T': /* Status with PC, SP, FP, ... */
7520 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7521 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7523 n... = register number
7524 r... = register contents
7527 p
= &buf
[3]; /* after Txx */
7533 p1
= strchr (p
, ':');
7535 error (_("Malformed packet(a) (missing colon): %s\n\
7539 error (_("Malformed packet(a) (missing register number): %s\n\
7543 /* Some "registers" are actually extended stop information.
7544 Note if you're adding a new entry here: GDB 7.9 and
7545 earlier assume that all register "numbers" that start
7546 with an hex digit are real register numbers. Make sure
7547 the server only sends such a packet if it knows the
7548 client understands it. */
7550 if (strprefix (p
, p1
, "thread"))
7551 event
->ptid
= read_ptid (++p1
, &p
);
7552 else if (strprefix (p
, p1
, "syscall_entry"))
7556 p
= unpack_varlen_hex (++p1
, &sysno
);
7557 event
->ws
.set_syscall_entry ((int) sysno
);
7559 else if (strprefix (p
, p1
, "syscall_return"))
7563 p
= unpack_varlen_hex (++p1
, &sysno
);
7564 event
->ws
.set_syscall_return ((int) sysno
);
7566 else if (strprefix (p
, p1
, "watch")
7567 || strprefix (p
, p1
, "rwatch")
7568 || strprefix (p
, p1
, "awatch"))
7570 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7571 p
= unpack_varlen_hex (++p1
, &addr
);
7572 event
->watch_data_address
= (CORE_ADDR
) addr
;
7574 else if (strprefix (p
, p1
, "swbreak"))
7576 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7578 /* Make sure the stub doesn't forget to indicate support
7580 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7581 error (_("Unexpected swbreak stop reason"));
7583 /* The value part is documented as "must be empty",
7584 though we ignore it, in case we ever decide to make
7585 use of it in a backward compatible way. */
7586 p
= strchrnul (p1
+ 1, ';');
7588 else if (strprefix (p
, p1
, "hwbreak"))
7590 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7592 /* Make sure the stub doesn't forget to indicate support
7594 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7595 error (_("Unexpected hwbreak stop reason"));
7598 p
= strchrnul (p1
+ 1, ';');
7600 else if (strprefix (p
, p1
, "library"))
7602 event
->ws
.set_loaded ();
7603 p
= strchrnul (p1
+ 1, ';');
7605 else if (strprefix (p
, p1
, "replaylog"))
7607 event
->ws
.set_no_history ();
7608 /* p1 will indicate "begin" or "end", but it makes
7609 no difference for now, so ignore it. */
7610 p
= strchrnul (p1
+ 1, ';');
7612 else if (strprefix (p
, p1
, "core"))
7616 p
= unpack_varlen_hex (++p1
, &c
);
7619 else if (strprefix (p
, p1
, "fork"))
7620 event
->ws
.set_forked (read_ptid (++p1
, &p
));
7621 else if (strprefix (p
, p1
, "vfork"))
7622 event
->ws
.set_vforked (read_ptid (++p1
, &p
));
7623 else if (strprefix (p
, p1
, "vforkdone"))
7625 event
->ws
.set_vfork_done ();
7626 p
= strchrnul (p1
+ 1, ';');
7628 else if (strprefix (p
, p1
, "exec"))
7633 /* Determine the length of the execd pathname. */
7634 p
= unpack_varlen_hex (++p1
, &ignored
);
7635 pathlen
= (p
- p1
) / 2;
7637 /* Save the pathname for event reporting and for
7638 the next run command. */
7639 gdb::unique_xmalloc_ptr
<char> pathname
7640 ((char *) xmalloc (pathlen
+ 1));
7641 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7642 pathname
.get ()[pathlen
] = '\0';
7644 /* This is freed during event handling. */
7645 event
->ws
.set_execd (std::move (pathname
));
7647 /* Skip the registers included in this packet, since
7648 they may be for an architecture different from the
7649 one used by the original program. */
7652 else if (strprefix (p
, p1
, "create"))
7654 event
->ws
.set_thread_created ();
7655 p
= strchrnul (p1
+ 1, ';');
7664 p
= strchrnul (p1
+ 1, ';');
7669 /* Maybe a real ``P'' register number. */
7670 p_temp
= unpack_varlen_hex (p
, &pnum
);
7671 /* If the first invalid character is the colon, we got a
7672 register number. Otherwise, it's an unknown stop
7676 /* If we haven't parsed the event's thread yet, find
7677 it now, in order to find the architecture of the
7678 reported expedited registers. */
7679 if (event
->ptid
== null_ptid
)
7681 /* If there is no thread-id information then leave
7682 the event->ptid as null_ptid. Later in
7683 process_stop_reply we will pick a suitable
7685 const char *thr
= strstr (p1
+ 1, ";thread:");
7687 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7694 = (event
->ptid
== null_ptid
7696 : find_inferior_ptid (this, event
->ptid
));
7697 /* If this is the first time we learn anything
7698 about this process, skip the registers
7699 included in this packet, since we don't yet
7700 know which architecture to use to parse them.
7701 We'll determine the architecture later when
7702 we process the stop reply and retrieve the
7703 target description, via
7704 remote_notice_new_inferior ->
7705 post_create_inferior. */
7708 p
= strchrnul (p1
+ 1, ';');
7713 event
->arch
= inf
->gdbarch
;
7714 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7718 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7719 cached_reg_t cached_reg
;
7722 error (_("Remote sent bad register number %s: %s\n\
7724 hex_string (pnum
), p
, buf
);
7726 cached_reg
.num
= reg
->regnum
;
7727 cached_reg
.data
= (gdb_byte
*)
7728 xmalloc (register_size (event
->arch
, reg
->regnum
));
7731 fieldsize
= hex2bin (p
, cached_reg
.data
,
7732 register_size (event
->arch
, reg
->regnum
));
7734 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7735 warning (_("Remote reply is too short: %s"), buf
);
7737 event
->regcache
.push_back (cached_reg
);
7741 /* Not a number. Silently skip unknown optional
7743 p
= strchrnul (p1
+ 1, ';');
7748 error (_("Remote register badly formatted: %s\nhere: %s"),
7753 if (event
->ws
.kind () != TARGET_WAITKIND_IGNORE
)
7757 case 'S': /* Old style status, just signal only. */
7761 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7762 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7763 event
->ws
.set_stopped ((enum gdb_signal
) sig
);
7765 event
->ws
.set_stopped (GDB_SIGNAL_UNKNOWN
);
7768 case 'w': /* Thread exited. */
7772 p
= unpack_varlen_hex (&buf
[1], &value
);
7773 event
->ws
.set_thread_exited (value
);
7775 error (_("stop reply packet badly formatted: %s"), buf
);
7776 event
->ptid
= read_ptid (++p
, NULL
);
7779 case 'W': /* Target exited. */
7784 /* GDB used to accept only 2 hex chars here. Stubs should
7785 only send more if they detect GDB supports multi-process
7787 p
= unpack_varlen_hex (&buf
[1], &value
);
7791 /* The remote process exited. */
7792 event
->ws
.set_exited (value
);
7796 /* The remote process exited with a signal. */
7797 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7798 event
->ws
.set_signalled ((enum gdb_signal
) value
);
7800 event
->ws
.set_signalled (GDB_SIGNAL_UNKNOWN
);
7803 /* If no process is specified, return null_ptid, and let the
7804 caller figure out the right process to use. */
7814 else if (startswith (p
, "process:"))
7818 p
+= sizeof ("process:") - 1;
7819 unpack_varlen_hex (p
, &upid
);
7823 error (_("unknown stop reply packet: %s"), buf
);
7826 error (_("unknown stop reply packet: %s"), buf
);
7827 event
->ptid
= ptid_t (pid
);
7831 event
->ws
.set_no_resumed ();
7832 event
->ptid
= minus_one_ptid
;
7837 /* When the stub wants to tell GDB about a new notification reply, it
7838 sends a notification (%Stop, for example). Those can come it at
7839 any time, hence, we have to make sure that any pending
7840 putpkt/getpkt sequence we're making is finished, before querying
7841 the stub for more events with the corresponding ack command
7842 (vStopped, for example). E.g., if we started a vStopped sequence
7843 immediately upon receiving the notification, something like this
7851 1.6) <-- (registers reply to step #1.3)
7853 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7856 To solve this, whenever we parse a %Stop notification successfully,
7857 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7858 doing whatever we were doing:
7864 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7865 2.5) <-- (registers reply to step #2.3)
7867 Eventually after step #2.5, we return to the event loop, which
7868 notices there's an event on the
7869 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7870 associated callback --- the function below. At this point, we're
7871 always safe to start a vStopped sequence. :
7874 2.7) <-- T05 thread:2
7880 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7882 struct remote_state
*rs
= get_remote_state ();
7884 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7887 fprintf_unfiltered (gdb_stdlog
,
7888 "notif: process: '%s' ack pending event\n",
7892 nc
->ack (this, nc
, rs
->buf
.data (),
7893 rs
->notif_state
->pending_event
[nc
->id
]);
7894 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7898 getpkt (&rs
->buf
, 0);
7899 if (strcmp (rs
->buf
.data (), "OK") == 0)
7902 remote_notif_ack (this, nc
, rs
->buf
.data ());
7908 fprintf_unfiltered (gdb_stdlog
,
7909 "notif: process: '%s' no pending reply\n",
7914 /* Wrapper around remote_target::remote_notif_get_pending_events to
7915 avoid having to export the whole remote_target class. */
7918 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7920 remote
->remote_notif_get_pending_events (nc
);
7923 /* Called from process_stop_reply when the stop packet we are responding
7924 to didn't include a process-id or thread-id. STATUS is the stop event
7925 we are responding to.
7927 It is the task of this function to select a suitable thread (or process)
7928 and return its ptid, this is the thread (or process) we will assume the
7929 stop event came from.
7931 In some cases there isn't really any choice about which thread (or
7932 process) is selected, a basic remote with a single process containing a
7933 single thread might choose not to send any process-id or thread-id in
7934 its stop packets, this function will select and return the one and only
7937 However, if a target supports multiple threads (or processes) and still
7938 doesn't include a thread-id (or process-id) in its stop packet then
7939 first, this is a badly behaving target, and second, we're going to have
7940 to select a thread (or process) at random and use that. This function
7941 will print a warning to the user if it detects that there is the
7942 possibility that GDB is guessing which thread (or process) to
7945 Note that this is called before GDB fetches the updated thread list from the
7946 target. So it's possible for the stop reply to be ambiguous and for GDB to
7947 not realize it. For example, if there's initially one thread, the target
7948 spawns a second thread, and then sends a stop reply without an id that
7949 concerns the first thread. GDB will assume the stop reply is about the
7950 first thread - the only thread it knows about - without printing a warning.
7951 Anyway, if the remote meant for the stop reply to be about the second thread,
7952 then it would be really broken, because GDB doesn't know about that thread
7956 remote_target::select_thread_for_ambiguous_stop_reply
7957 (const target_waitstatus
&status
)
7959 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
7961 /* Some stop events apply to all threads in an inferior, while others
7962 only apply to a single thread. */
7963 bool process_wide_stop
7964 = (status
.kind () == TARGET_WAITKIND_EXITED
7965 || status
.kind () == TARGET_WAITKIND_SIGNALLED
);
7967 remote_debug_printf ("process_wide_stop = %d", process_wide_stop
);
7969 thread_info
*first_resumed_thread
= nullptr;
7970 bool ambiguous
= false;
7972 /* Consider all non-exited threads of the target, find the first resumed
7974 for (thread_info
*thr
: all_non_exited_threads (this))
7976 remote_thread_info
*remote_thr
= get_remote_thread_info (thr
);
7978 if (remote_thr
->get_resume_state () != resume_state::RESUMED
)
7981 if (first_resumed_thread
== nullptr)
7982 first_resumed_thread
= thr
;
7983 else if (!process_wide_stop
7984 || first_resumed_thread
->ptid
.pid () != thr
->ptid
.pid ())
7988 gdb_assert (first_resumed_thread
!= nullptr);
7990 remote_debug_printf ("first resumed thread is %s",
7991 pid_to_str (first_resumed_thread
->ptid
).c_str ());
7992 remote_debug_printf ("is this guess ambiguous? = %d", ambiguous
);
7994 /* Warn if the remote target is sending ambiguous stop replies. */
7997 static bool warned
= false;
8001 /* If you are seeing this warning then the remote target has
8002 stopped without specifying a thread-id, but the target
8003 does have multiple threads (or inferiors), and so GDB is
8004 having to guess which thread stopped.
8006 Examples of what might cause this are the target sending
8007 and 'S' stop packet, or a 'T' stop packet and not
8008 including a thread-id.
8010 Additionally, the target might send a 'W' or 'X packet
8011 without including a process-id, when the target has
8012 multiple running inferiors. */
8013 if (process_wide_stop
)
8014 warning (_("multi-inferior target stopped without "
8015 "sending a process-id, using first "
8016 "non-exited inferior"));
8018 warning (_("multi-threaded target stopped without "
8019 "sending a thread-id, using first "
8020 "non-exited thread"));
8025 /* If this is a stop for all threads then don't use a particular threads
8026 ptid, instead create a new ptid where only the pid field is set. */
8027 if (process_wide_stop
)
8028 return ptid_t (first_resumed_thread
->ptid
.pid ());
8030 return first_resumed_thread
->ptid
;
8033 /* Called when it is decided that STOP_REPLY holds the info of the
8034 event that is to be returned to the core. This function always
8035 destroys STOP_REPLY. */
8038 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
8039 struct target_waitstatus
*status
)
8041 *status
= stop_reply
->ws
;
8042 ptid_t ptid
= stop_reply
->ptid
;
8044 /* If no thread/process was reported by the stub then select a suitable
8046 if (ptid
== null_ptid
)
8047 ptid
= select_thread_for_ambiguous_stop_reply (*status
);
8048 gdb_assert (ptid
!= null_ptid
);
8050 if (status
->kind () != TARGET_WAITKIND_EXITED
8051 && status
->kind () != TARGET_WAITKIND_SIGNALLED
8052 && status
->kind () != TARGET_WAITKIND_NO_RESUMED
)
8054 /* Expedited registers. */
8055 if (!stop_reply
->regcache
.empty ())
8057 struct regcache
*regcache
8058 = get_thread_arch_regcache (this, ptid
, stop_reply
->arch
);
8060 for (cached_reg_t
®
: stop_reply
->regcache
)
8062 regcache
->raw_supply (reg
.num
, reg
.data
);
8066 stop_reply
->regcache
.clear ();
8069 remote_notice_new_inferior (ptid
, false);
8070 remote_thread_info
*remote_thr
= get_remote_thread_info (this, ptid
);
8071 remote_thr
->core
= stop_reply
->core
;
8072 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
8073 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
8075 if (target_is_non_stop_p ())
8077 /* If the target works in non-stop mode, a stop-reply indicates that
8078 only this thread stopped. */
8079 remote_thr
->set_not_resumed ();
8083 /* If the target works in all-stop mode, a stop-reply indicates that
8084 all the target's threads stopped. */
8085 for (thread_info
*tp
: all_non_exited_threads (this))
8086 get_remote_thread_info (tp
)->set_not_resumed ();
8094 /* The non-stop mode version of target_wait. */
8097 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
8098 target_wait_flags options
)
8100 struct remote_state
*rs
= get_remote_state ();
8101 struct stop_reply
*stop_reply
;
8105 /* If in non-stop mode, get out of getpkt even if a
8106 notification is received. */
8108 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
8111 if (ret
!= -1 && !is_notif
)
8114 case 'E': /* Error of some sort. */
8115 /* We're out of sync with the target now. Did it continue
8116 or not? We can't tell which thread it was in non-stop,
8117 so just ignore this. */
8118 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
8120 case 'O': /* Console output. */
8121 remote_console_output (&rs
->buf
[1]);
8124 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
8128 /* Acknowledge a pending stop reply that may have arrived in the
8130 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
8131 remote_notif_get_pending_events (¬if_client_stop
);
8133 /* If indeed we noticed a stop reply, we're done. */
8134 stop_reply
= queued_stop_reply (ptid
);
8135 if (stop_reply
!= NULL
)
8136 return process_stop_reply (stop_reply
, status
);
8138 /* Still no event. If we're just polling for an event, then
8139 return to the event loop. */
8140 if (options
& TARGET_WNOHANG
)
8142 status
->set_ignore ();
8143 return minus_one_ptid
;
8146 /* Otherwise do a blocking wait. */
8147 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
8151 /* Return the first resumed thread. */
8154 first_remote_resumed_thread (remote_target
*target
)
8156 for (thread_info
*tp
: all_non_exited_threads (target
, minus_one_ptid
))
8162 /* Wait until the remote machine stops, then return, storing status in
8163 STATUS just as `wait' would. */
8166 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
,
8167 target_wait_flags options
)
8169 struct remote_state
*rs
= get_remote_state ();
8170 ptid_t event_ptid
= null_ptid
;
8172 struct stop_reply
*stop_reply
;
8176 status
->set_ignore ();
8178 stop_reply
= queued_stop_reply (ptid
);
8179 if (stop_reply
!= NULL
)
8181 /* None of the paths that push a stop reply onto the queue should
8182 have set the waiting_for_stop_reply flag. */
8183 gdb_assert (!rs
->waiting_for_stop_reply
);
8184 event_ptid
= process_stop_reply (stop_reply
, status
);
8188 int forever
= ((options
& TARGET_WNOHANG
) == 0
8189 && rs
->wait_forever_enabled_p
);
8191 if (!rs
->waiting_for_stop_reply
)
8193 status
->set_no_resumed ();
8194 return minus_one_ptid
;
8197 /* FIXME: cagney/1999-09-27: If we're in async mode we should
8198 _never_ wait for ever -> test on target_is_async_p().
8199 However, before we do that we need to ensure that the caller
8200 knows how to take the target into/out of async mode. */
8202 int ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
8204 /* GDB gets a notification. Return to core as this event is
8206 if (ret
!= -1 && is_notif
)
8207 return minus_one_ptid
;
8209 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
8210 return minus_one_ptid
;
8212 buf
= rs
->buf
.data ();
8214 /* Assume that the target has acknowledged Ctrl-C unless we receive
8215 an 'F' or 'O' packet. */
8216 if (buf
[0] != 'F' && buf
[0] != 'O')
8217 rs
->ctrlc_pending_p
= 0;
8221 case 'E': /* Error of some sort. */
8222 /* We're out of sync with the target now. Did it continue or
8223 not? Not is more likely, so report a stop. */
8224 rs
->waiting_for_stop_reply
= 0;
8226 warning (_("Remote failure reply: %s"), buf
);
8227 status
->set_stopped (GDB_SIGNAL_0
);
8229 case 'F': /* File-I/O request. */
8230 /* GDB may access the inferior memory while handling the File-I/O
8231 request, but we don't want GDB accessing memory while waiting
8232 for a stop reply. See the comments in putpkt_binary. Set
8233 waiting_for_stop_reply to 0 temporarily. */
8234 rs
->waiting_for_stop_reply
= 0;
8235 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
8236 rs
->ctrlc_pending_p
= 0;
8237 /* GDB handled the File-I/O request, and the target is running
8238 again. Keep waiting for events. */
8239 rs
->waiting_for_stop_reply
= 1;
8241 case 'N': case 'T': case 'S': case 'X': case 'W':
8243 /* There is a stop reply to handle. */
8244 rs
->waiting_for_stop_reply
= 0;
8247 = (struct stop_reply
*) remote_notif_parse (this,
8251 event_ptid
= process_stop_reply (stop_reply
, status
);
8254 case 'O': /* Console output. */
8255 remote_console_output (buf
+ 1);
8258 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
8260 /* Zero length reply means that we tried 'S' or 'C' and the
8261 remote system doesn't support it. */
8262 target_terminal::ours_for_output ();
8264 ("Can't send signals to this remote system. %s not sent.\n",
8265 gdb_signal_to_name (rs
->last_sent_signal
));
8266 rs
->last_sent_signal
= GDB_SIGNAL_0
;
8267 target_terminal::inferior ();
8269 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
8275 warning (_("Invalid remote reply: %s"), buf
);
8280 if (status
->kind () == TARGET_WAITKIND_NO_RESUMED
)
8281 return minus_one_ptid
;
8282 else if (status
->kind () == TARGET_WAITKIND_IGNORE
)
8284 /* Nothing interesting happened. If we're doing a non-blocking
8285 poll, we're done. Otherwise, go back to waiting. */
8286 if (options
& TARGET_WNOHANG
)
8287 return minus_one_ptid
;
8291 else if (status
->kind () != TARGET_WAITKIND_EXITED
8292 && status
->kind () != TARGET_WAITKIND_SIGNALLED
)
8294 if (event_ptid
!= null_ptid
)
8295 record_currthread (rs
, event_ptid
);
8297 event_ptid
= first_remote_resumed_thread (this);
8301 /* A process exit. Invalidate our notion of current thread. */
8302 record_currthread (rs
, minus_one_ptid
);
8303 /* It's possible that the packet did not include a pid. */
8304 if (event_ptid
== null_ptid
)
8305 event_ptid
= first_remote_resumed_thread (this);
8306 /* EVENT_PTID could still be NULL_PTID. Double-check. */
8307 if (event_ptid
== null_ptid
)
8308 event_ptid
= magic_null_ptid
;
8314 /* Wait until the remote machine stops, then return, storing status in
8315 STATUS just as `wait' would. */
8318 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
8319 target_wait_flags options
)
8321 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
8323 remote_state
*rs
= get_remote_state ();
8325 /* Start by clearing the flag that asks for our wait method to be called,
8326 we'll mark it again at the end if needed. If the target is not in
8327 async mode then the async token should not be marked. */
8328 if (target_is_async_p ())
8329 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
8331 gdb_assert (!async_event_handler_marked
8332 (rs
->remote_async_inferior_event_token
));
8336 if (target_is_non_stop_p ())
8337 event_ptid
= wait_ns (ptid
, status
, options
);
8339 event_ptid
= wait_as (ptid
, status
, options
);
8341 if (target_is_async_p ())
8343 /* If there are events left in the queue, or unacknowledged
8344 notifications, then tell the event loop to call us again. */
8345 if (!rs
->stop_reply_queue
.empty ()
8346 || rs
->notif_state
->pending_event
[notif_client_stop
.id
] != nullptr)
8347 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
8353 /* Fetch a single register using a 'p' packet. */
8356 remote_target::fetch_register_using_p (struct regcache
*regcache
,
8359 struct gdbarch
*gdbarch
= regcache
->arch ();
8360 struct remote_state
*rs
= get_remote_state ();
8362 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8365 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
8368 if (reg
->pnum
== -1)
8371 p
= rs
->buf
.data ();
8373 p
+= hexnumstr (p
, reg
->pnum
);
8376 getpkt (&rs
->buf
, 0);
8378 buf
= rs
->buf
.data ();
8380 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
8384 case PACKET_UNKNOWN
:
8387 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
8388 gdbarch_register_name (regcache
->arch (),
8393 /* If this register is unfetchable, tell the regcache. */
8396 regcache
->raw_supply (reg
->regnum
, NULL
);
8400 /* Otherwise, parse and supply the value. */
8406 error (_("fetch_register_using_p: early buf termination"));
8408 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8411 regcache
->raw_supply (reg
->regnum
, regp
);
8415 /* Fetch the registers included in the target's 'g' packet. */
8418 remote_target::send_g_packet ()
8420 struct remote_state
*rs
= get_remote_state ();
8423 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
8425 getpkt (&rs
->buf
, 0);
8426 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8427 error (_("Could not read registers; remote failure reply '%s'"),
8430 /* We can get out of synch in various cases. If the first character
8431 in the buffer is not a hex character, assume that has happened
8432 and try to fetch another packet to read. */
8433 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
8434 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
8435 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
8436 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
8438 remote_debug_printf ("Bad register packet; fetching a new packet");
8439 getpkt (&rs
->buf
, 0);
8442 buf_len
= strlen (rs
->buf
.data ());
8444 /* Sanity check the received packet. */
8445 if (buf_len
% 2 != 0)
8446 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
8452 remote_target::process_g_packet (struct regcache
*regcache
)
8454 struct gdbarch
*gdbarch
= regcache
->arch ();
8455 struct remote_state
*rs
= get_remote_state ();
8456 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8461 buf_len
= strlen (rs
->buf
.data ());
8463 /* Further sanity checks, with knowledge of the architecture. */
8464 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
8465 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8467 rsa
->sizeof_g_packet
, buf_len
/ 2,
8470 /* Save the size of the packet sent to us by the target. It is used
8471 as a heuristic when determining the max size of packets that the
8472 target can safely receive. */
8473 if (rsa
->actual_register_packet_size
== 0)
8474 rsa
->actual_register_packet_size
= buf_len
;
8476 /* If this is smaller than we guessed the 'g' packet would be,
8477 update our records. A 'g' reply that doesn't include a register's
8478 value implies either that the register is not available, or that
8479 the 'p' packet must be used. */
8480 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8482 long sizeof_g_packet
= buf_len
/ 2;
8484 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8486 long offset
= rsa
->regs
[i
].offset
;
8487 long reg_size
= register_size (gdbarch
, i
);
8489 if (rsa
->regs
[i
].pnum
== -1)
8492 if (offset
>= sizeof_g_packet
)
8493 rsa
->regs
[i
].in_g_packet
= 0;
8494 else if (offset
+ reg_size
> sizeof_g_packet
)
8495 error (_("Truncated register %d in remote 'g' packet"), i
);
8497 rsa
->regs
[i
].in_g_packet
= 1;
8500 /* Looks valid enough, we can assume this is the correct length
8501 for a 'g' packet. It's important not to adjust
8502 rsa->sizeof_g_packet if we have truncated registers otherwise
8503 this "if" won't be run the next time the method is called
8504 with a packet of the same size and one of the internal errors
8505 below will trigger instead. */
8506 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8509 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8511 /* Unimplemented registers read as all bits zero. */
8512 memset (regs
, 0, rsa
->sizeof_g_packet
);
8514 /* Reply describes registers byte by byte, each byte encoded as two
8515 hex characters. Suck them all up, then supply them to the
8516 register cacheing/storage mechanism. */
8518 p
= rs
->buf
.data ();
8519 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8521 if (p
[0] == 0 || p
[1] == 0)
8522 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8523 internal_error (__FILE__
, __LINE__
,
8524 _("unexpected end of 'g' packet reply"));
8526 if (p
[0] == 'x' && p
[1] == 'x')
8527 regs
[i
] = 0; /* 'x' */
8529 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8533 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8535 struct packet_reg
*r
= &rsa
->regs
[i
];
8536 long reg_size
= register_size (gdbarch
, i
);
8540 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8541 /* This shouldn't happen - we adjusted in_g_packet above. */
8542 internal_error (__FILE__
, __LINE__
,
8543 _("unexpected end of 'g' packet reply"));
8544 else if (rs
->buf
[r
->offset
* 2] == 'x')
8546 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8547 /* The register isn't available, mark it as such (at
8548 the same time setting the value to zero). */
8549 regcache
->raw_supply (r
->regnum
, NULL
);
8552 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8558 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8561 process_g_packet (regcache
);
8564 /* Make the remote selected traceframe match GDB's selected
8568 remote_target::set_remote_traceframe ()
8571 struct remote_state
*rs
= get_remote_state ();
8573 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8576 /* Avoid recursion, remote_trace_find calls us again. */
8577 rs
->remote_traceframe_number
= get_traceframe_number ();
8579 newnum
= target_trace_find (tfind_number
,
8580 get_traceframe_number (), 0, 0, NULL
);
8582 /* Should not happen. If it does, all bets are off. */
8583 if (newnum
!= get_traceframe_number ())
8584 warning (_("could not set remote traceframe"));
8588 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8590 struct gdbarch
*gdbarch
= regcache
->arch ();
8591 struct remote_state
*rs
= get_remote_state ();
8592 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8595 set_remote_traceframe ();
8596 set_general_thread (regcache
->ptid ());
8600 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8602 gdb_assert (reg
!= NULL
);
8604 /* If this register might be in the 'g' packet, try that first -
8605 we are likely to read more than one register. If this is the
8606 first 'g' packet, we might be overly optimistic about its
8607 contents, so fall back to 'p'. */
8608 if (reg
->in_g_packet
)
8610 fetch_registers_using_g (regcache
);
8611 if (reg
->in_g_packet
)
8615 if (fetch_register_using_p (regcache
, reg
))
8618 /* This register is not available. */
8619 regcache
->raw_supply (reg
->regnum
, NULL
);
8624 fetch_registers_using_g (regcache
);
8626 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8627 if (!rsa
->regs
[i
].in_g_packet
)
8628 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8630 /* This register is not available. */
8631 regcache
->raw_supply (i
, NULL
);
8635 /* Prepare to store registers. Since we may send them all (using a
8636 'G' request), we have to read out the ones we don't want to change
8640 remote_target::prepare_to_store (struct regcache
*regcache
)
8642 struct remote_state
*rs
= get_remote_state ();
8643 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8646 /* Make sure the entire registers array is valid. */
8647 switch (packet_support (PACKET_P
))
8649 case PACKET_DISABLE
:
8650 case PACKET_SUPPORT_UNKNOWN
:
8651 /* Make sure all the necessary registers are cached. */
8652 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8653 if (rsa
->regs
[i
].in_g_packet
)
8654 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8661 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8662 packet was not recognized. */
8665 remote_target::store_register_using_P (const struct regcache
*regcache
,
8668 struct gdbarch
*gdbarch
= regcache
->arch ();
8669 struct remote_state
*rs
= get_remote_state ();
8670 /* Try storing a single register. */
8671 char *buf
= rs
->buf
.data ();
8672 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8675 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8678 if (reg
->pnum
== -1)
8681 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8682 p
= buf
+ strlen (buf
);
8683 regcache
->raw_collect (reg
->regnum
, regp
);
8684 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8686 getpkt (&rs
->buf
, 0);
8688 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8693 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8694 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8695 case PACKET_UNKNOWN
:
8698 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8702 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8703 contents of the register cache buffer. FIXME: ignores errors. */
8706 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8708 struct remote_state
*rs
= get_remote_state ();
8709 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8713 /* Extract all the registers in the regcache copying them into a
8718 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8719 memset (regs
, 0, rsa
->sizeof_g_packet
);
8720 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8722 struct packet_reg
*r
= &rsa
->regs
[i
];
8725 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8729 /* Command describes registers byte by byte,
8730 each byte encoded as two hex characters. */
8731 p
= rs
->buf
.data ();
8733 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8735 getpkt (&rs
->buf
, 0);
8736 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8737 error (_("Could not write registers; remote failure reply '%s'"),
8741 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8742 of the register cache buffer. FIXME: ignores errors. */
8745 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8747 struct gdbarch
*gdbarch
= regcache
->arch ();
8748 struct remote_state
*rs
= get_remote_state ();
8749 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8752 set_remote_traceframe ();
8753 set_general_thread (regcache
->ptid ());
8757 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8759 gdb_assert (reg
!= NULL
);
8761 /* Always prefer to store registers using the 'P' packet if
8762 possible; we often change only a small number of registers.
8763 Sometimes we change a larger number; we'd need help from a
8764 higher layer to know to use 'G'. */
8765 if (store_register_using_P (regcache
, reg
))
8768 /* For now, don't complain if we have no way to write the
8769 register. GDB loses track of unavailable registers too
8770 easily. Some day, this may be an error. We don't have
8771 any way to read the register, either... */
8772 if (!reg
->in_g_packet
)
8775 store_registers_using_G (regcache
);
8779 store_registers_using_G (regcache
);
8781 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8782 if (!rsa
->regs
[i
].in_g_packet
)
8783 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8784 /* See above for why we do not issue an error here. */
8789 /* Return the number of hex digits in num. */
8792 hexnumlen (ULONGEST num
)
8796 for (i
= 0; num
!= 0; i
++)
8799 return std::max (i
, 1);
8802 /* Set BUF to the minimum number of hex digits representing NUM. */
8805 hexnumstr (char *buf
, ULONGEST num
)
8807 int len
= hexnumlen (num
);
8809 return hexnumnstr (buf
, num
, len
);
8813 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8816 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8822 for (i
= width
- 1; i
>= 0; i
--)
8824 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8831 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8834 remote_address_masked (CORE_ADDR addr
)
8836 unsigned int address_size
= remote_address_size
;
8838 /* If "remoteaddresssize" was not set, default to target address size. */
8840 address_size
= gdbarch_addr_bit (target_gdbarch ());
8842 if (address_size
> 0
8843 && address_size
< (sizeof (ULONGEST
) * 8))
8845 /* Only create a mask when that mask can safely be constructed
8846 in a ULONGEST variable. */
8849 mask
= (mask
<< address_size
) - 1;
8855 /* Determine whether the remote target supports binary downloading.
8856 This is accomplished by sending a no-op memory write of zero length
8857 to the target at the specified address. It does not suffice to send
8858 the whole packet, since many stubs strip the eighth bit and
8859 subsequently compute a wrong checksum, which causes real havoc with
8862 NOTE: This can still lose if the serial line is not eight-bit
8863 clean. In cases like this, the user should clear "remote
8867 remote_target::check_binary_download (CORE_ADDR addr
)
8869 struct remote_state
*rs
= get_remote_state ();
8871 switch (packet_support (PACKET_X
))
8873 case PACKET_DISABLE
:
8877 case PACKET_SUPPORT_UNKNOWN
:
8881 p
= rs
->buf
.data ();
8883 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8885 p
+= hexnumstr (p
, (ULONGEST
) 0);
8889 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8890 getpkt (&rs
->buf
, 0);
8892 if (rs
->buf
[0] == '\0')
8894 remote_debug_printf ("binary downloading NOT supported by target");
8895 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8899 remote_debug_printf ("binary downloading supported by target");
8900 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8907 /* Helper function to resize the payload in order to try to get a good
8908 alignment. We try to write an amount of data such that the next write will
8909 start on an address aligned on REMOTE_ALIGN_WRITES. */
8912 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8914 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8917 /* Write memory data directly to the remote machine.
8918 This does not inform the data cache; the data cache uses this.
8919 HEADER is the starting part of the packet.
8920 MEMADDR is the address in the remote memory space.
8921 MYADDR is the address of the buffer in our space.
8922 LEN_UNITS is the number of addressable units to write.
8923 UNIT_SIZE is the length in bytes of an addressable unit.
8924 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8925 should send data as binary ('X'), or hex-encoded ('M').
8927 The function creates packet of the form
8928 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8930 where encoding of <DATA> is terminated by PACKET_FORMAT.
8932 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8935 Return the transferred status, error or OK (an
8936 'enum target_xfer_status' value). Save the number of addressable units
8937 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8939 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8940 exchange between gdb and the stub could look like (?? in place of the
8946 -> $M1000,3:eeeeffffeeee#??
8950 <- eeeeffffeeeedddd */
8953 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8954 const gdb_byte
*myaddr
,
8957 ULONGEST
*xfered_len_units
,
8958 char packet_format
, int use_length
)
8960 struct remote_state
*rs
= get_remote_state ();
8966 int payload_capacity_bytes
;
8967 int payload_length_bytes
;
8969 if (packet_format
!= 'X' && packet_format
!= 'M')
8970 internal_error (__FILE__
, __LINE__
,
8971 _("remote_write_bytes_aux: bad packet format"));
8974 return TARGET_XFER_EOF
;
8976 payload_capacity_bytes
= get_memory_write_packet_size ();
8978 /* The packet buffer will be large enough for the payload;
8979 get_memory_packet_size ensures this. */
8982 /* Compute the size of the actual payload by subtracting out the
8983 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8985 payload_capacity_bytes
-= strlen ("$,:#NN");
8987 /* The comma won't be used. */
8988 payload_capacity_bytes
+= 1;
8989 payload_capacity_bytes
-= strlen (header
);
8990 payload_capacity_bytes
-= hexnumlen (memaddr
);
8992 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8994 strcat (rs
->buf
.data (), header
);
8995 p
= rs
->buf
.data () + strlen (header
);
8997 /* Compute a best guess of the number of bytes actually transfered. */
8998 if (packet_format
== 'X')
9000 /* Best guess at number of bytes that will fit. */
9001 todo_units
= std::min (len_units
,
9002 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
9004 payload_capacity_bytes
-= hexnumlen (todo_units
);
9005 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
9009 /* Number of bytes that will fit. */
9011 = std::min (len_units
,
9012 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
9014 payload_capacity_bytes
-= hexnumlen (todo_units
);
9015 todo_units
= std::min (todo_units
,
9016 (payload_capacity_bytes
/ unit_size
) / 2);
9019 if (todo_units
<= 0)
9020 internal_error (__FILE__
, __LINE__
,
9021 _("minimum packet size too small to write data"));
9023 /* If we already need another packet, then try to align the end
9024 of this packet to a useful boundary. */
9025 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
9026 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
9028 /* Append "<memaddr>". */
9029 memaddr
= remote_address_masked (memaddr
);
9030 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
9037 /* Append the length and retain its location and size. It may need to be
9038 adjusted once the packet body has been created. */
9040 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
9048 /* Append the packet body. */
9049 if (packet_format
== 'X')
9051 /* Binary mode. Send target system values byte by byte, in
9052 increasing byte addresses. Only escape certain critical
9054 payload_length_bytes
=
9055 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
9056 &units_written
, payload_capacity_bytes
);
9058 /* If not all TODO units fit, then we'll need another packet. Make
9059 a second try to keep the end of the packet aligned. Don't do
9060 this if the packet is tiny. */
9061 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
9065 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
9067 if (new_todo_units
!= units_written
)
9068 payload_length_bytes
=
9069 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
9070 (gdb_byte
*) p
, &units_written
,
9071 payload_capacity_bytes
);
9074 p
+= payload_length_bytes
;
9075 if (use_length
&& units_written
< todo_units
)
9077 /* Escape chars have filled up the buffer prematurely,
9078 and we have actually sent fewer units than planned.
9079 Fix-up the length field of the packet. Use the same
9080 number of characters as before. */
9081 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
9083 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
9088 /* Normal mode: Send target system values byte by byte, in
9089 increasing byte addresses. Each byte is encoded as a two hex
9091 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
9092 units_written
= todo_units
;
9095 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
9096 getpkt (&rs
->buf
, 0);
9098 if (rs
->buf
[0] == 'E')
9099 return TARGET_XFER_E_IO
;
9101 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
9102 send fewer units than we'd planned. */
9103 *xfered_len_units
= (ULONGEST
) units_written
;
9104 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
9107 /* Write memory data directly to the remote machine.
9108 This does not inform the data cache; the data cache uses this.
9109 MEMADDR is the address in the remote memory space.
9110 MYADDR is the address of the buffer in our space.
9111 LEN is the number of bytes.
9113 Return the transferred status, error or OK (an
9114 'enum target_xfer_status' value). Save the number of bytes
9115 transferred in *XFERED_LEN. Only transfer a single packet. */
9118 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
9119 ULONGEST len
, int unit_size
,
9120 ULONGEST
*xfered_len
)
9122 const char *packet_format
= NULL
;
9124 /* Check whether the target supports binary download. */
9125 check_binary_download (memaddr
);
9127 switch (packet_support (PACKET_X
))
9130 packet_format
= "X";
9132 case PACKET_DISABLE
:
9133 packet_format
= "M";
9135 case PACKET_SUPPORT_UNKNOWN
:
9136 internal_error (__FILE__
, __LINE__
,
9137 _("remote_write_bytes: bad internal state"));
9139 internal_error (__FILE__
, __LINE__
, _("bad switch"));
9142 return remote_write_bytes_aux (packet_format
,
9143 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
9144 packet_format
[0], 1);
9147 /* Read memory data directly from the remote machine.
9148 This does not use the data cache; the data cache uses this.
9149 MEMADDR is the address in the remote memory space.
9150 MYADDR is the address of the buffer in our space.
9151 LEN_UNITS is the number of addressable memory units to read..
9152 UNIT_SIZE is the length in bytes of an addressable unit.
9154 Return the transferred status, error or OK (an
9155 'enum target_xfer_status' value). Save the number of bytes
9156 transferred in *XFERED_LEN_UNITS.
9158 See the comment of remote_write_bytes_aux for an example of
9159 memory read/write exchange between gdb and the stub. */
9162 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
9164 int unit_size
, ULONGEST
*xfered_len_units
)
9166 struct remote_state
*rs
= get_remote_state ();
9167 int buf_size_bytes
; /* Max size of packet output buffer. */
9172 buf_size_bytes
= get_memory_read_packet_size ();
9173 /* The packet buffer will be large enough for the payload;
9174 get_memory_packet_size ensures this. */
9176 /* Number of units that will fit. */
9177 todo_units
= std::min (len_units
,
9178 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
9180 /* Construct "m"<memaddr>","<len>". */
9181 memaddr
= remote_address_masked (memaddr
);
9182 p
= rs
->buf
.data ();
9184 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
9186 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
9189 getpkt (&rs
->buf
, 0);
9190 if (rs
->buf
[0] == 'E'
9191 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
9192 && rs
->buf
[3] == '\0')
9193 return TARGET_XFER_E_IO
;
9194 /* Reply describes memory byte by byte, each byte encoded as two hex
9196 p
= rs
->buf
.data ();
9197 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
9198 /* Return what we have. Let higher layers handle partial reads. */
9199 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
9200 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
9203 /* Using the set of read-only target sections of remote, read live
9206 For interface/parameters/return description see target.h,
9210 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
9214 ULONGEST
*xfered_len
)
9216 const struct target_section
*secp
;
9218 secp
= target_section_by_addr (this, memaddr
);
9220 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
9222 ULONGEST memend
= memaddr
+ len
;
9224 const target_section_table
*table
= target_get_section_table (this);
9225 for (const target_section
&p
: *table
)
9227 if (memaddr
>= p
.addr
)
9229 if (memend
<= p
.endaddr
)
9231 /* Entire transfer is within this section. */
9232 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
9235 else if (memaddr
>= p
.endaddr
)
9237 /* This section ends before the transfer starts. */
9242 /* This section overlaps the transfer. Just do half. */
9243 len
= p
.endaddr
- memaddr
;
9244 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
9251 return TARGET_XFER_EOF
;
9254 /* Similar to remote_read_bytes_1, but it reads from the remote stub
9255 first if the requested memory is unavailable in traceframe.
9256 Otherwise, fall back to remote_read_bytes_1. */
9259 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
9260 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
9261 ULONGEST
*xfered_len
)
9264 return TARGET_XFER_EOF
;
9266 if (get_traceframe_number () != -1)
9268 std::vector
<mem_range
> available
;
9270 /* If we fail to get the set of available memory, then the
9271 target does not support querying traceframe info, and so we
9272 attempt reading from the traceframe anyway (assuming the
9273 target implements the old QTro packet then). */
9274 if (traceframe_available_memory (&available
, memaddr
, len
))
9276 if (available
.empty () || available
[0].start
!= memaddr
)
9278 enum target_xfer_status res
;
9280 /* Don't read into the traceframe's available
9282 if (!available
.empty ())
9284 LONGEST oldlen
= len
;
9286 len
= available
[0].start
- memaddr
;
9287 gdb_assert (len
<= oldlen
);
9290 /* This goes through the topmost target again. */
9291 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
9292 len
, unit_size
, xfered_len
);
9293 if (res
== TARGET_XFER_OK
)
9294 return TARGET_XFER_OK
;
9297 /* No use trying further, we know some memory starting
9298 at MEMADDR isn't available. */
9300 return (*xfered_len
!= 0) ?
9301 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
9305 /* Don't try to read more than how much is available, in
9306 case the target implements the deprecated QTro packet to
9307 cater for older GDBs (the target's knowledge of read-only
9308 sections may be outdated by now). */
9309 len
= available
[0].length
;
9313 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
9318 /* Sends a packet with content determined by the printf format string
9319 FORMAT and the remaining arguments, then gets the reply. Returns
9320 whether the packet was a success, a failure, or unknown. */
9323 remote_target::remote_send_printf (const char *format
, ...)
9325 struct remote_state
*rs
= get_remote_state ();
9326 int max_size
= get_remote_packet_size ();
9329 va_start (ap
, format
);
9332 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
9336 if (size
>= max_size
)
9337 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
9339 if (putpkt (rs
->buf
) < 0)
9340 error (_("Communication problem with target."));
9343 getpkt (&rs
->buf
, 0);
9345 return packet_check_result (rs
->buf
);
9348 /* Flash writing can take quite some time. We'll set
9349 effectively infinite timeout for flash operations.
9350 In future, we'll need to decide on a better approach. */
9351 static const int remote_flash_timeout
= 1000;
9354 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
9356 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
9357 enum packet_result ret
;
9358 scoped_restore restore_timeout
9359 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9361 ret
= remote_send_printf ("vFlashErase:%s,%s",
9362 phex (address
, addr_size
),
9366 case PACKET_UNKNOWN
:
9367 error (_("Remote target does not support flash erase"));
9369 error (_("Error erasing flash with vFlashErase packet"));
9376 remote_target::remote_flash_write (ULONGEST address
,
9377 ULONGEST length
, ULONGEST
*xfered_len
,
9378 const gdb_byte
*data
)
9380 scoped_restore restore_timeout
9381 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9382 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
9387 remote_target::flash_done ()
9391 scoped_restore restore_timeout
9392 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9394 ret
= remote_send_printf ("vFlashDone");
9398 case PACKET_UNKNOWN
:
9399 error (_("Remote target does not support vFlashDone"));
9401 error (_("Error finishing flash operation"));
9408 /* Stuff for dealing with the packets which are part of this protocol.
9409 See comment at top of file for details. */
9411 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
9412 error to higher layers. Called when a serial error is detected.
9413 The exception message is STRING, followed by a colon and a blank,
9414 the system error message for errno at function entry and final dot
9415 for output compatibility with throw_perror_with_name. */
9418 unpush_and_perror (remote_target
*target
, const char *string
)
9420 int saved_errno
= errno
;
9422 remote_unpush_target (target
);
9423 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
9424 safe_strerror (saved_errno
));
9427 /* Read a single character from the remote end. The current quit
9428 handler is overridden to avoid quitting in the middle of packet
9429 sequence, as that would break communication with the remote server.
9430 See remote_serial_quit_handler for more detail. */
9433 remote_target::readchar (int timeout
)
9436 struct remote_state
*rs
= get_remote_state ();
9439 scoped_restore restore_quit_target
9440 = make_scoped_restore (&curr_quit_handler_target
, this);
9441 scoped_restore restore_quit
9442 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9444 rs
->got_ctrlc_during_io
= 0;
9446 ch
= serial_readchar (rs
->remote_desc
, timeout
);
9448 if (rs
->got_ctrlc_during_io
)
9455 switch ((enum serial_rc
) ch
)
9458 remote_unpush_target (this);
9459 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9462 unpush_and_perror (this, _("Remote communication error. "
9463 "Target disconnected."));
9465 case SERIAL_TIMEOUT
:
9471 /* Wrapper for serial_write that closes the target and throws if
9472 writing fails. The current quit handler is overridden to avoid
9473 quitting in the middle of packet sequence, as that would break
9474 communication with the remote server. See
9475 remote_serial_quit_handler for more detail. */
9478 remote_target::remote_serial_write (const char *str
, int len
)
9480 struct remote_state
*rs
= get_remote_state ();
9482 scoped_restore restore_quit_target
9483 = make_scoped_restore (&curr_quit_handler_target
, this);
9484 scoped_restore restore_quit
9485 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9487 rs
->got_ctrlc_during_io
= 0;
9489 if (serial_write (rs
->remote_desc
, str
, len
))
9491 unpush_and_perror (this, _("Remote communication error. "
9492 "Target disconnected."));
9495 if (rs
->got_ctrlc_during_io
)
9499 /* Return a string representing an escaped version of BUF, of len N.
9500 E.g. \n is converted to \\n, \t to \\t, etc. */
9503 escape_buffer (const char *buf
, int n
)
9507 stb
.putstrn (buf
, n
, '\\');
9508 return stb
.release ();
9512 remote_target::putpkt (const char *buf
)
9514 return putpkt_binary (buf
, strlen (buf
));
9517 /* Wrapper around remote_target::putpkt to avoid exporting
9521 putpkt (remote_target
*remote
, const char *buf
)
9523 return remote
->putpkt (buf
);
9526 /* Send a packet to the remote machine, with error checking. The data
9527 of the packet is in BUF. The string in BUF can be at most
9528 get_remote_packet_size () - 5 to account for the $, # and checksum,
9529 and for a possible /0 if we are debugging (remote_debug) and want
9530 to print the sent packet as a string. */
9533 remote_target::putpkt_binary (const char *buf
, int cnt
)
9535 struct remote_state
*rs
= get_remote_state ();
9537 unsigned char csum
= 0;
9538 gdb::def_vector
<char> data (cnt
+ 6);
9539 char *buf2
= data
.data ();
9545 /* Catch cases like trying to read memory or listing threads while
9546 we're waiting for a stop reply. The remote server wouldn't be
9547 ready to handle this request, so we'd hang and timeout. We don't
9548 have to worry about this in synchronous mode, because in that
9549 case it's not possible to issue a command while the target is
9550 running. This is not a problem in non-stop mode, because in that
9551 case, the stub is always ready to process serial input. */
9552 if (!target_is_non_stop_p ()
9553 && target_is_async_p ()
9554 && rs
->waiting_for_stop_reply
)
9556 error (_("Cannot execute this command while the target is running.\n"
9557 "Use the \"interrupt\" command to stop the target\n"
9558 "and then try again."));
9561 /* Copy the packet into buffer BUF2, encapsulating it
9562 and giving it a checksum. */
9567 for (i
= 0; i
< cnt
; i
++)
9573 *p
++ = tohex ((csum
>> 4) & 0xf);
9574 *p
++ = tohex (csum
& 0xf);
9576 /* Send it over and over until we get a positive ack. */
9584 int len
= (int) (p
- buf2
);
9587 if (remote_packet_max_chars
< 0)
9590 max_chars
= remote_packet_max_chars
;
9593 = escape_buffer (buf2
, std::min (len
, max_chars
));
9595 if (len
> max_chars
)
9596 remote_debug_printf_nofunc
9597 ("Sending packet: %s [%d bytes omitted]", str
.c_str (),
9600 remote_debug_printf_nofunc ("Sending packet: %s", str
.c_str ());
9602 remote_serial_write (buf2
, p
- buf2
);
9604 /* If this is a no acks version of the remote protocol, send the
9605 packet and move on. */
9609 /* Read until either a timeout occurs (-2) or '+' is read.
9610 Handle any notification that arrives in the mean time. */
9613 ch
= readchar (remote_timeout
);
9618 remote_debug_printf_nofunc ("Received Ack");
9621 remote_debug_printf_nofunc ("Received Nak");
9623 case SERIAL_TIMEOUT
:
9627 break; /* Retransmit buffer. */
9630 remote_debug_printf ("Packet instead of Ack, ignoring it");
9631 /* It's probably an old response sent because an ACK
9632 was lost. Gobble up the packet and ack it so it
9633 doesn't get retransmitted when we resend this
9636 remote_serial_write ("+", 1);
9637 continue; /* Now, go look for +. */
9644 /* If we got a notification, handle it, and go back to looking
9646 /* We've found the start of a notification. Now
9647 collect the data. */
9648 val
= read_frame (&rs
->buf
);
9651 remote_debug_printf_nofunc
9652 (" Notification received: %s",
9653 escape_buffer (rs
->buf
.data (), val
).c_str ());
9655 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9656 /* We're in sync now, rewait for the ack. */
9660 remote_debug_printf_nofunc ("Junk: %c%s", ch
& 0177,
9666 remote_debug_printf_nofunc ("Junk: %c%s", ch
& 0177,
9670 break; /* Here to retransmit. */
9674 /* This is wrong. If doing a long backtrace, the user should be
9675 able to get out next time we call QUIT, without anything as
9676 violent as interrupt_query. If we want to provide a way out of
9677 here without getting to the next QUIT, it should be based on
9678 hitting ^C twice as in remote_wait. */
9690 /* Come here after finding the start of a frame when we expected an
9691 ack. Do our best to discard the rest of this packet. */
9694 remote_target::skip_frame ()
9700 c
= readchar (remote_timeout
);
9703 case SERIAL_TIMEOUT
:
9704 /* Nothing we can do. */
9707 /* Discard the two bytes of checksum and stop. */
9708 c
= readchar (remote_timeout
);
9710 c
= readchar (remote_timeout
);
9713 case '*': /* Run length encoding. */
9714 /* Discard the repeat count. */
9715 c
= readchar (remote_timeout
);
9720 /* A regular character. */
9726 /* Come here after finding the start of the frame. Collect the rest
9727 into *BUF, verifying the checksum, length, and handling run-length
9728 compression. NUL terminate the buffer. If there is not enough room,
9731 Returns -1 on error, number of characters in buffer (ignoring the
9732 trailing NULL) on success. (could be extended to return one of the
9733 SERIAL status indications). */
9736 remote_target::read_frame (gdb::char_vector
*buf_p
)
9741 char *buf
= buf_p
->data ();
9742 struct remote_state
*rs
= get_remote_state ();
9749 c
= readchar (remote_timeout
);
9752 case SERIAL_TIMEOUT
:
9753 remote_debug_printf ("Timeout in mid-packet, retrying");
9757 remote_debug_printf ("Saw new packet start in middle of old one");
9758 return -1; /* Start a new packet, count retries. */
9762 unsigned char pktcsum
;
9768 check_0
= readchar (remote_timeout
);
9770 check_1
= readchar (remote_timeout
);
9772 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9774 remote_debug_printf ("Timeout in checksum, retrying");
9777 else if (check_0
< 0 || check_1
< 0)
9779 remote_debug_printf ("Communication error in checksum");
9783 /* Don't recompute the checksum; with no ack packets we
9784 don't have any way to indicate a packet retransmission
9789 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9790 if (csum
== pktcsum
)
9794 ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s",
9795 pktcsum
, csum
, escape_buffer (buf
, bc
).c_str ());
9797 /* Number of characters in buffer ignoring trailing
9801 case '*': /* Run length encoding. */
9806 c
= readchar (remote_timeout
);
9808 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9810 /* The character before ``*'' is repeated. */
9812 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9814 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9816 /* Make some more room in the buffer. */
9817 buf_p
->resize (buf_p
->size () + repeat
);
9818 buf
= buf_p
->data ();
9821 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9827 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9831 if (bc
>= buf_p
->size () - 1)
9833 /* Make some more room in the buffer. */
9834 buf_p
->resize (buf_p
->size () * 2);
9835 buf
= buf_p
->data ();
9845 /* Set this to the maximum number of seconds to wait instead of waiting forever
9846 in target_wait(). If this timer times out, then it generates an error and
9847 the command is aborted. This replaces most of the need for timeouts in the
9848 GDB test suite, and makes it possible to distinguish between a hung target
9849 and one with slow communications. */
9851 static int watchdog
= 0;
9853 show_watchdog (struct ui_file
*file
, int from_tty
,
9854 struct cmd_list_element
*c
, const char *value
)
9856 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9859 /* Read a packet from the remote machine, with error checking, and
9860 store it in *BUF. Resize *BUF if necessary to hold the result. If
9861 FOREVER, wait forever rather than timing out; this is used (in
9862 synchronous mode) to wait for a target that is is executing user
9864 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9865 don't have to change all the calls to getpkt to deal with the
9866 return value, because at the moment I don't know what the right
9867 thing to do it for those. */
9870 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9872 getpkt_sane (buf
, forever
);
9876 /* Read a packet from the remote machine, with error checking, and
9877 store it in *BUF. Resize *BUF if necessary to hold the result. If
9878 FOREVER, wait forever rather than timing out; this is used (in
9879 synchronous mode) to wait for a target that is is executing user
9880 code to stop. If FOREVER == 0, this function is allowed to time
9881 out gracefully and return an indication of this to the caller.
9882 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9883 consider receiving a notification enough reason to return to the
9884 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9885 holds a notification or not (a regular packet). */
9888 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9889 int forever
, int expecting_notif
,
9892 struct remote_state
*rs
= get_remote_state ();
9898 strcpy (buf
->data (), "timeout");
9901 timeout
= watchdog
> 0 ? watchdog
: -1;
9902 else if (expecting_notif
)
9903 timeout
= 0; /* There should already be a char in the buffer. If
9906 timeout
= remote_timeout
;
9910 /* Process any number of notifications, and then return when
9914 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9916 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9918 /* This can loop forever if the remote side sends us
9919 characters continuously, but if it pauses, we'll get
9920 SERIAL_TIMEOUT from readchar because of timeout. Then
9921 we'll count that as a retry.
9923 Note that even when forever is set, we will only wait
9924 forever prior to the start of a packet. After that, we
9925 expect characters to arrive at a brisk pace. They should
9926 show up within remote_timeout intervals. */
9928 c
= readchar (timeout
);
9929 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9931 if (c
== SERIAL_TIMEOUT
)
9933 if (expecting_notif
)
9934 return -1; /* Don't complain, it's normal to not get
9935 anything in this case. */
9937 if (forever
) /* Watchdog went off? Kill the target. */
9939 remote_unpush_target (this);
9940 throw_error (TARGET_CLOSE_ERROR
,
9941 _("Watchdog timeout has expired. "
9942 "Target detached."));
9945 remote_debug_printf ("Timed out.");
9949 /* We've found the start of a packet or notification.
9950 Now collect the data. */
9951 val
= read_frame (buf
);
9956 remote_serial_write ("-", 1);
9959 if (tries
> MAX_TRIES
)
9961 /* We have tried hard enough, and just can't receive the
9962 packet/notification. Give up. */
9963 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9965 /* Skip the ack char if we're in no-ack mode. */
9966 if (!rs
->noack_mode
)
9967 remote_serial_write ("+", 1);
9971 /* If we got an ordinary packet, return that to our caller. */
9978 if (remote_packet_max_chars
< 0)
9981 max_chars
= remote_packet_max_chars
;
9984 = escape_buffer (buf
->data (),
9985 std::min (val
, max_chars
));
9987 if (val
> max_chars
)
9988 remote_debug_printf_nofunc
9989 ("Packet received: %s [%d bytes omitted]", str
.c_str (),
9992 remote_debug_printf_nofunc ("Packet received: %s",
9996 /* Skip the ack char if we're in no-ack mode. */
9997 if (!rs
->noack_mode
)
9998 remote_serial_write ("+", 1);
9999 if (is_notif
!= NULL
)
10004 /* If we got a notification, handle it, and go back to looking
10008 gdb_assert (c
== '%');
10010 remote_debug_printf_nofunc
10011 (" Notification received: %s",
10012 escape_buffer (buf
->data (), val
).c_str ());
10014 if (is_notif
!= NULL
)
10017 handle_notification (rs
->notif_state
, buf
->data ());
10019 /* Notifications require no acknowledgement. */
10021 if (expecting_notif
)
10028 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
10030 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
10034 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
10037 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
10040 /* Kill any new fork children of inferior INF that haven't been
10041 processed by follow_fork. */
10044 remote_target::kill_new_fork_children (inferior
*inf
)
10046 remote_state
*rs
= get_remote_state ();
10047 struct notif_client
*notif
= ¬if_client_stop
;
10049 /* Kill the fork child threads of any threads in inferior INF that are stopped
10050 at a fork event. */
10051 for (thread_info
*thread
: inf
->non_exited_threads ())
10053 const target_waitstatus
*ws
= thread_pending_fork_status (thread
);
10058 int child_pid
= ws
->child_ptid ().pid ();
10059 int res
= remote_vkill (child_pid
);
10062 error (_("Can't kill fork child process %d"), child_pid
);
10065 /* Check for any pending fork events (not reported or processed yet)
10066 in inferior INF and kill those fork child threads as well. */
10067 remote_notif_get_pending_events (notif
);
10068 for (auto &event
: rs
->stop_reply_queue
)
10070 if (event
->ptid
.pid () != inf
->pid
)
10073 if (!is_fork_status (event
->ws
.kind ()))
10076 int child_pid
= event
->ws
.child_ptid ().pid ();
10077 int res
= remote_vkill (child_pid
);
10080 error (_("Can't kill fork child process %d"), child_pid
);
10085 /* Target hook to kill the current inferior. */
10088 remote_target::kill ()
10091 inferior
*inf
= find_inferior_pid (this, inferior_ptid
.pid ());
10092 struct remote_state
*rs
= get_remote_state ();
10094 gdb_assert (inf
!= nullptr);
10096 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
10098 /* If we're stopped while forking and we haven't followed yet,
10099 kill the child task. We need to do this before killing the
10100 parent task because if this is a vfork then the parent will
10102 kill_new_fork_children (inf
);
10104 res
= remote_vkill (inf
->pid
);
10107 target_mourn_inferior (inferior_ptid
);
10112 /* If we are in 'target remote' mode and we are killing the only
10113 inferior, then we will tell gdbserver to exit and unpush the
10115 if (res
== -1 && !remote_multi_process_p (rs
)
10116 && number_of_live_inferiors (this) == 1)
10120 /* We've killed the remote end, we get to mourn it. If we are
10121 not in extended mode, mourning the inferior also unpushes
10122 remote_ops from the target stack, which closes the remote
10124 target_mourn_inferior (inferior_ptid
);
10129 error (_("Can't kill process"));
10132 /* Send a kill request to the target using the 'vKill' packet. */
10135 remote_target::remote_vkill (int pid
)
10137 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
10140 remote_state
*rs
= get_remote_state ();
10142 /* Tell the remote target to detach. */
10143 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
10145 getpkt (&rs
->buf
, 0);
10147 switch (packet_ok (rs
->buf
,
10148 &remote_protocol_packets
[PACKET_vKill
]))
10154 case PACKET_UNKNOWN
:
10157 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
10161 /* Send a kill request to the target using the 'k' packet. */
10164 remote_target::remote_kill_k ()
10166 /* Catch errors so the user can quit from gdb even when we
10167 aren't on speaking terms with the remote system. */
10172 catch (const gdb_exception_error
&ex
)
10174 if (ex
.error
== TARGET_CLOSE_ERROR
)
10176 /* If we got an (EOF) error that caused the target
10177 to go away, then we're done, that's what we wanted.
10178 "k" is susceptible to cause a premature EOF, given
10179 that the remote server isn't actually required to
10180 reply to "k", and it can happen that it doesn't
10181 even get to reply ACK to the "k". */
10185 /* Otherwise, something went wrong. We didn't actually kill
10186 the target. Just propagate the exception, and let the
10187 user or higher layers decide what to do. */
10193 remote_target::mourn_inferior ()
10195 struct remote_state
*rs
= get_remote_state ();
10197 /* We're no longer interested in notification events of an inferior
10198 that exited or was killed/detached. */
10199 discard_pending_stop_replies (current_inferior ());
10201 /* In 'target remote' mode with one inferior, we close the connection. */
10202 if (!rs
->extended
&& number_of_live_inferiors (this) <= 1)
10204 remote_unpush_target (this);
10208 /* In case we got here due to an error, but we're going to stay
10210 rs
->waiting_for_stop_reply
= 0;
10212 /* If the current general thread belonged to the process we just
10213 detached from or has exited, the remote side current general
10214 thread becomes undefined. Considering a case like this:
10216 - We just got here due to a detach.
10217 - The process that we're detaching from happens to immediately
10218 report a global breakpoint being hit in non-stop mode, in the
10219 same thread we had selected before.
10220 - GDB attaches to this process again.
10221 - This event happens to be the next event we handle.
10223 GDB would consider that the current general thread didn't need to
10224 be set on the stub side (with Hg), since for all it knew,
10225 GENERAL_THREAD hadn't changed.
10227 Notice that although in all-stop mode, the remote server always
10228 sets the current thread to the thread reporting the stop event,
10229 that doesn't happen in non-stop mode; in non-stop, the stub *must
10230 not* change the current thread when reporting a breakpoint hit,
10231 due to the decoupling of event reporting and event handling.
10233 To keep things simple, we always invalidate our notion of the
10235 record_currthread (rs
, minus_one_ptid
);
10237 /* Call common code to mark the inferior as not running. */
10238 generic_mourn_inferior ();
10242 extended_remote_target::supports_disable_randomization ()
10244 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
10248 remote_target::extended_remote_disable_randomization (int val
)
10250 struct remote_state
*rs
= get_remote_state ();
10253 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10254 "QDisableRandomization:%x", val
);
10256 reply
= remote_get_noisy_reply ();
10257 if (*reply
== '\0')
10258 error (_("Target does not support QDisableRandomization."));
10259 if (strcmp (reply
, "OK") != 0)
10260 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
10264 remote_target::extended_remote_run (const std::string
&args
)
10266 struct remote_state
*rs
= get_remote_state ();
10268 const char *remote_exec_file
= get_remote_exec_file ();
10270 /* If the user has disabled vRun support, or we have detected that
10271 support is not available, do not try it. */
10272 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
10275 strcpy (rs
->buf
.data (), "vRun;");
10276 len
= strlen (rs
->buf
.data ());
10278 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
10279 error (_("Remote file name too long for run packet"));
10280 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
10281 strlen (remote_exec_file
));
10283 if (!args
.empty ())
10287 gdb_argv
argv (args
.c_str ());
10288 for (i
= 0; argv
[i
] != NULL
; i
++)
10290 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
10291 error (_("Argument list too long for run packet"));
10292 rs
->buf
[len
++] = ';';
10293 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
10298 rs
->buf
[len
++] = '\0';
10301 getpkt (&rs
->buf
, 0);
10303 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
10306 /* We have a wait response. All is well. */
10308 case PACKET_UNKNOWN
:
10311 if (remote_exec_file
[0] == '\0')
10312 error (_("Running the default executable on the remote target failed; "
10313 "try \"set remote exec-file\"?"));
10315 error (_("Running \"%s\" on the remote target failed"),
10318 gdb_assert_not_reached ("bad switch");
10322 /* Helper function to send set/unset environment packets. ACTION is
10323 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
10324 or "QEnvironmentUnsetVariable". VALUE is the variable to be
10328 remote_target::send_environment_packet (const char *action
,
10329 const char *packet
,
10332 remote_state
*rs
= get_remote_state ();
10334 /* Convert the environment variable to an hex string, which
10335 is the best format to be transmitted over the wire. */
10336 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
10339 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10340 "%s:%s", packet
, encoded_value
.c_str ());
10343 getpkt (&rs
->buf
, 0);
10344 if (strcmp (rs
->buf
.data (), "OK") != 0)
10345 warning (_("Unable to %s environment variable '%s' on remote."),
10349 /* Helper function to handle the QEnvironment* packets. */
10352 remote_target::extended_remote_environment_support ()
10354 remote_state
*rs
= get_remote_state ();
10356 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
10358 putpkt ("QEnvironmentReset");
10359 getpkt (&rs
->buf
, 0);
10360 if (strcmp (rs
->buf
.data (), "OK") != 0)
10361 warning (_("Unable to reset environment on remote."));
10364 gdb_environ
*e
= ¤t_inferior ()->environment
;
10366 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
10367 for (const std::string
&el
: e
->user_set_env ())
10368 send_environment_packet ("set", "QEnvironmentHexEncoded",
10371 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
10372 for (const std::string
&el
: e
->user_unset_env ())
10373 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10376 /* Helper function to set the current working directory for the
10377 inferior in the remote target. */
10380 remote_target::extended_remote_set_inferior_cwd ()
10382 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10384 const std::string
&inferior_cwd
= current_inferior ()->cwd ();
10385 remote_state
*rs
= get_remote_state ();
10387 if (!inferior_cwd
.empty ())
10389 std::string hexpath
10390 = bin2hex ((const gdb_byte
*) inferior_cwd
.data (),
10391 inferior_cwd
.size ());
10393 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10394 "QSetWorkingDir:%s", hexpath
.c_str ());
10398 /* An empty inferior_cwd means that the user wants us to
10399 reset the remote server's inferior's cwd. */
10400 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10401 "QSetWorkingDir:");
10405 getpkt (&rs
->buf
, 0);
10406 if (packet_ok (rs
->buf
,
10407 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10410 Remote replied unexpectedly while setting the inferior's working\n\
10417 /* In the extended protocol we want to be able to do things like
10418 "run" and have them basically work as expected. So we need
10419 a special create_inferior function. We support changing the
10420 executable file and the command line arguments, but not the
10424 extended_remote_target::create_inferior (const char *exec_file
,
10425 const std::string
&args
,
10426 char **env
, int from_tty
)
10430 struct remote_state
*rs
= get_remote_state ();
10431 const char *remote_exec_file
= get_remote_exec_file ();
10433 /* If running asynchronously, register the target file descriptor
10434 with the event loop. */
10435 if (target_can_async_p ())
10438 /* Disable address space randomization if requested (and supported). */
10439 if (supports_disable_randomization ())
10440 extended_remote_disable_randomization (disable_randomization
);
10442 /* If startup-with-shell is on, we inform gdbserver to start the
10443 remote inferior using a shell. */
10444 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10446 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10447 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10449 getpkt (&rs
->buf
, 0);
10450 if (strcmp (rs
->buf
.data (), "OK") != 0)
10452 Remote replied unexpectedly while setting startup-with-shell: %s"),
10456 extended_remote_environment_support ();
10458 extended_remote_set_inferior_cwd ();
10460 /* Now restart the remote server. */
10461 run_worked
= extended_remote_run (args
) != -1;
10464 /* vRun was not supported. Fail if we need it to do what the
10466 if (remote_exec_file
[0])
10467 error (_("Remote target does not support \"set remote exec-file\""));
10468 if (!args
.empty ())
10469 error (_("Remote target does not support \"set args\" or run ARGS"));
10471 /* Fall back to "R". */
10472 extended_remote_restart ();
10475 /* vRun's success return is a stop reply. */
10476 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10477 add_current_inferior_and_thread (stop_reply
);
10479 /* Get updated offsets, if the stub uses qOffsets. */
10484 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10485 the list of conditions (in agent expression bytecode format), if any, the
10486 target needs to evaluate. The output is placed into the packet buffer
10487 started from BUF and ended at BUF_END. */
10490 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10491 struct bp_target_info
*bp_tgt
, char *buf
,
10494 if (bp_tgt
->conditions
.empty ())
10497 buf
+= strlen (buf
);
10498 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10501 /* Send conditions to the target. */
10502 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10504 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10505 buf
+= strlen (buf
);
10506 for (int i
= 0; i
< aexpr
->len
; ++i
)
10507 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10514 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10515 struct bp_target_info
*bp_tgt
, char *buf
)
10517 if (bp_tgt
->tcommands
.empty ())
10520 buf
+= strlen (buf
);
10522 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10523 buf
+= strlen (buf
);
10525 /* Concatenate all the agent expressions that are commands into the
10527 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10529 sprintf (buf
, "X%x,", aexpr
->len
);
10530 buf
+= strlen (buf
);
10531 for (int i
= 0; i
< aexpr
->len
; ++i
)
10532 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10537 /* Insert a breakpoint. On targets that have software breakpoint
10538 support, we ask the remote target to do the work; on targets
10539 which don't, we insert a traditional memory breakpoint. */
10542 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10543 struct bp_target_info
*bp_tgt
)
10545 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10546 If it succeeds, then set the support to PACKET_ENABLE. If it
10547 fails, and the user has explicitly requested the Z support then
10548 report an error, otherwise, mark it disabled and go on. */
10550 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10552 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10553 struct remote_state
*rs
;
10556 /* Make sure the remote is pointing at the right process, if
10558 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10559 set_general_process ();
10561 rs
= get_remote_state ();
10562 p
= rs
->buf
.data ();
10563 endbuf
= p
+ get_remote_packet_size ();
10568 addr
= (ULONGEST
) remote_address_masked (addr
);
10569 p
+= hexnumstr (p
, addr
);
10570 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10572 if (supports_evaluation_of_breakpoint_conditions ())
10573 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10575 if (can_run_breakpoint_commands ())
10576 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10579 getpkt (&rs
->buf
, 0);
10581 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10587 case PACKET_UNKNOWN
:
10592 /* If this breakpoint has target-side commands but this stub doesn't
10593 support Z0 packets, throw error. */
10594 if (!bp_tgt
->tcommands
.empty ())
10595 throw_error (NOT_SUPPORTED_ERROR
, _("\
10596 Target doesn't support breakpoints that have target side commands."));
10598 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10602 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10603 struct bp_target_info
*bp_tgt
,
10604 enum remove_bp_reason reason
)
10606 CORE_ADDR addr
= bp_tgt
->placed_address
;
10607 struct remote_state
*rs
= get_remote_state ();
10609 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10611 char *p
= rs
->buf
.data ();
10612 char *endbuf
= p
+ get_remote_packet_size ();
10614 /* Make sure the remote is pointing at the right process, if
10616 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10617 set_general_process ();
10623 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10624 p
+= hexnumstr (p
, addr
);
10625 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10628 getpkt (&rs
->buf
, 0);
10630 return (rs
->buf
[0] == 'E');
10633 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10636 static enum Z_packet_type
10637 watchpoint_to_Z_packet (int type
)
10642 return Z_PACKET_WRITE_WP
;
10645 return Z_PACKET_READ_WP
;
10648 return Z_PACKET_ACCESS_WP
;
10651 internal_error (__FILE__
, __LINE__
,
10652 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10657 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10658 enum target_hw_bp_type type
, struct expression
*cond
)
10660 struct remote_state
*rs
= get_remote_state ();
10661 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10663 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10665 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10668 /* Make sure the remote is pointing at the right process, if
10670 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10671 set_general_process ();
10673 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10674 p
= strchr (rs
->buf
.data (), '\0');
10675 addr
= remote_address_masked (addr
);
10676 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10677 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10680 getpkt (&rs
->buf
, 0);
10682 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10686 case PACKET_UNKNOWN
:
10691 internal_error (__FILE__
, __LINE__
,
10692 _("remote_insert_watchpoint: reached end of function"));
10696 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10697 CORE_ADDR start
, int length
)
10699 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10701 return diff
< length
;
10706 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10707 enum target_hw_bp_type type
, struct expression
*cond
)
10709 struct remote_state
*rs
= get_remote_state ();
10710 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10712 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10714 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10717 /* Make sure the remote is pointing at the right process, if
10719 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10720 set_general_process ();
10722 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10723 p
= strchr (rs
->buf
.data (), '\0');
10724 addr
= remote_address_masked (addr
);
10725 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10726 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10728 getpkt (&rs
->buf
, 0);
10730 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10733 case PACKET_UNKNOWN
:
10738 internal_error (__FILE__
, __LINE__
,
10739 _("remote_remove_watchpoint: reached end of function"));
10743 static int remote_hw_watchpoint_limit
= -1;
10744 static int remote_hw_watchpoint_length_limit
= -1;
10745 static int remote_hw_breakpoint_limit
= -1;
10748 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10750 if (remote_hw_watchpoint_length_limit
== 0)
10752 else if (remote_hw_watchpoint_length_limit
< 0)
10754 else if (len
<= remote_hw_watchpoint_length_limit
)
10761 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10763 if (type
== bp_hardware_breakpoint
)
10765 if (remote_hw_breakpoint_limit
== 0)
10767 else if (remote_hw_breakpoint_limit
< 0)
10769 else if (cnt
<= remote_hw_breakpoint_limit
)
10774 if (remote_hw_watchpoint_limit
== 0)
10776 else if (remote_hw_watchpoint_limit
< 0)
10780 else if (cnt
<= remote_hw_watchpoint_limit
)
10786 /* The to_stopped_by_sw_breakpoint method of target remote. */
10789 remote_target::stopped_by_sw_breakpoint ()
10791 struct thread_info
*thread
= inferior_thread ();
10793 return (thread
->priv
!= NULL
10794 && (get_remote_thread_info (thread
)->stop_reason
10795 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10798 /* The to_supports_stopped_by_sw_breakpoint method of target
10802 remote_target::supports_stopped_by_sw_breakpoint ()
10804 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10807 /* The to_stopped_by_hw_breakpoint method of target remote. */
10810 remote_target::stopped_by_hw_breakpoint ()
10812 struct thread_info
*thread
= inferior_thread ();
10814 return (thread
->priv
!= NULL
10815 && (get_remote_thread_info (thread
)->stop_reason
10816 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10819 /* The to_supports_stopped_by_hw_breakpoint method of target
10823 remote_target::supports_stopped_by_hw_breakpoint ()
10825 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10829 remote_target::stopped_by_watchpoint ()
10831 struct thread_info
*thread
= inferior_thread ();
10833 return (thread
->priv
!= NULL
10834 && (get_remote_thread_info (thread
)->stop_reason
10835 == TARGET_STOPPED_BY_WATCHPOINT
));
10839 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10841 struct thread_info
*thread
= inferior_thread ();
10843 if (thread
->priv
!= NULL
10844 && (get_remote_thread_info (thread
)->stop_reason
10845 == TARGET_STOPPED_BY_WATCHPOINT
))
10847 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10856 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10857 struct bp_target_info
*bp_tgt
)
10859 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10860 struct remote_state
*rs
;
10864 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10867 /* Make sure the remote is pointing at the right process, if
10869 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10870 set_general_process ();
10872 rs
= get_remote_state ();
10873 p
= rs
->buf
.data ();
10874 endbuf
= p
+ get_remote_packet_size ();
10880 addr
= remote_address_masked (addr
);
10881 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10882 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10884 if (supports_evaluation_of_breakpoint_conditions ())
10885 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10887 if (can_run_breakpoint_commands ())
10888 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10891 getpkt (&rs
->buf
, 0);
10893 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10896 if (rs
->buf
[1] == '.')
10898 message
= strchr (&rs
->buf
[2], '.');
10900 error (_("Remote failure reply: %s"), message
+ 1);
10903 case PACKET_UNKNOWN
:
10908 internal_error (__FILE__
, __LINE__
,
10909 _("remote_insert_hw_breakpoint: reached end of function"));
10914 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10915 struct bp_target_info
*bp_tgt
)
10918 struct remote_state
*rs
= get_remote_state ();
10919 char *p
= rs
->buf
.data ();
10920 char *endbuf
= p
+ get_remote_packet_size ();
10922 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10925 /* Make sure the remote is pointing at the right process, if
10927 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10928 set_general_process ();
10934 addr
= remote_address_masked (bp_tgt
->placed_address
);
10935 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10936 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10939 getpkt (&rs
->buf
, 0);
10941 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10944 case PACKET_UNKNOWN
:
10949 internal_error (__FILE__
, __LINE__
,
10950 _("remote_remove_hw_breakpoint: reached end of function"));
10953 /* Verify memory using the "qCRC:" request. */
10956 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10958 struct remote_state
*rs
= get_remote_state ();
10959 unsigned long host_crc
, target_crc
;
10962 /* It doesn't make sense to use qCRC if the remote target is
10963 connected but not running. */
10964 if (target_has_execution ()
10965 && packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10967 enum packet_result result
;
10969 /* Make sure the remote is pointing at the right process. */
10970 set_general_process ();
10972 /* FIXME: assumes lma can fit into long. */
10973 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10974 (long) lma
, (long) size
);
10977 /* Be clever; compute the host_crc before waiting for target
10979 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10981 getpkt (&rs
->buf
, 0);
10983 result
= packet_ok (rs
->buf
,
10984 &remote_protocol_packets
[PACKET_qCRC
]);
10985 if (result
== PACKET_ERROR
)
10987 else if (result
== PACKET_OK
)
10989 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10990 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10992 return (host_crc
== target_crc
);
10996 return simple_verify_memory (this, data
, lma
, size
);
10999 /* compare-sections command
11001 With no arguments, compares each loadable section in the exec bfd
11002 with the same memory range on the target, and reports mismatches.
11003 Useful for verifying the image on the target against the exec file. */
11006 compare_sections_command (const char *args
, int from_tty
)
11009 const char *sectname
;
11010 bfd_size_type size
;
11013 int mismatched
= 0;
11017 if (!current_program_space
->exec_bfd ())
11018 error (_("command cannot be used without an exec file"));
11020 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
11026 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
11028 if (!(s
->flags
& SEC_LOAD
))
11029 continue; /* Skip non-loadable section. */
11031 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
11032 continue; /* Skip writeable sections */
11034 size
= bfd_section_size (s
);
11036 continue; /* Skip zero-length section. */
11038 sectname
= bfd_section_name (s
);
11039 if (args
&& strcmp (args
, sectname
) != 0)
11040 continue; /* Not the section selected by user. */
11042 matched
= 1; /* Do this section. */
11045 gdb::byte_vector
sectdata (size
);
11046 bfd_get_section_contents (current_program_space
->exec_bfd (), s
,
11047 sectdata
.data (), 0, size
);
11049 res
= target_verify_memory (sectdata
.data (), lma
, size
);
11052 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
11053 paddress (target_gdbarch (), lma
),
11054 paddress (target_gdbarch (), lma
+ size
));
11056 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
11057 paddress (target_gdbarch (), lma
),
11058 paddress (target_gdbarch (), lma
+ size
));
11060 printf_filtered ("matched.\n");
11063 printf_filtered ("MIS-MATCHED!\n");
11067 if (mismatched
> 0)
11068 warning (_("One or more sections of the target image does not match\n\
11069 the loaded file\n"));
11070 if (args
&& !matched
)
11071 printf_filtered (_("No loaded section named '%s'.\n"), args
);
11074 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
11075 into remote target. The number of bytes written to the remote
11076 target is returned, or -1 for error. */
11079 remote_target::remote_write_qxfer (const char *object_name
,
11080 const char *annex
, const gdb_byte
*writebuf
,
11081 ULONGEST offset
, LONGEST len
,
11082 ULONGEST
*xfered_len
,
11083 struct packet_config
*packet
)
11087 struct remote_state
*rs
= get_remote_state ();
11088 int max_size
= get_memory_write_packet_size ();
11090 if (packet_config_support (packet
) == PACKET_DISABLE
)
11091 return TARGET_XFER_E_IO
;
11093 /* Insert header. */
11094 i
= snprintf (rs
->buf
.data (), max_size
,
11095 "qXfer:%s:write:%s:%s:",
11096 object_name
, annex
? annex
: "",
11097 phex_nz (offset
, sizeof offset
));
11098 max_size
-= (i
+ 1);
11100 /* Escape as much data as fits into rs->buf. */
11101 buf_len
= remote_escape_output
11102 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
11104 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
11105 || getpkt_sane (&rs
->buf
, 0) < 0
11106 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11107 return TARGET_XFER_E_IO
;
11109 unpack_varlen_hex (rs
->buf
.data (), &n
);
11112 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11115 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
11116 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
11117 number of bytes read is returned, or 0 for EOF, or -1 for error.
11118 The number of bytes read may be less than LEN without indicating an
11119 EOF. PACKET is checked and updated to indicate whether the remote
11120 target supports this object. */
11123 remote_target::remote_read_qxfer (const char *object_name
,
11125 gdb_byte
*readbuf
, ULONGEST offset
,
11127 ULONGEST
*xfered_len
,
11128 struct packet_config
*packet
)
11130 struct remote_state
*rs
= get_remote_state ();
11131 LONGEST i
, n
, packet_len
;
11133 if (packet_config_support (packet
) == PACKET_DISABLE
)
11134 return TARGET_XFER_E_IO
;
11136 /* Check whether we've cached an end-of-object packet that matches
11138 if (rs
->finished_object
)
11140 if (strcmp (object_name
, rs
->finished_object
) == 0
11141 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
11142 && offset
== rs
->finished_offset
)
11143 return TARGET_XFER_EOF
;
11146 /* Otherwise, we're now reading something different. Discard
11148 xfree (rs
->finished_object
);
11149 xfree (rs
->finished_annex
);
11150 rs
->finished_object
= NULL
;
11151 rs
->finished_annex
= NULL
;
11154 /* Request only enough to fit in a single packet. The actual data
11155 may not, since we don't know how much of it will need to be escaped;
11156 the target is free to respond with slightly less data. We subtract
11157 five to account for the response type and the protocol frame. */
11158 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
11159 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
11160 "qXfer:%s:read:%s:%s,%s",
11161 object_name
, annex
? annex
: "",
11162 phex_nz (offset
, sizeof offset
),
11163 phex_nz (n
, sizeof n
));
11164 i
= putpkt (rs
->buf
);
11166 return TARGET_XFER_E_IO
;
11169 packet_len
= getpkt_sane (&rs
->buf
, 0);
11170 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11171 return TARGET_XFER_E_IO
;
11173 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
11174 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
11176 /* 'm' means there is (or at least might be) more data after this
11177 batch. That does not make sense unless there's at least one byte
11178 of data in this reply. */
11179 if (rs
->buf
[0] == 'm' && packet_len
== 1)
11180 error (_("Remote qXfer reply contained no data."));
11182 /* Got some data. */
11183 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
11184 packet_len
- 1, readbuf
, n
);
11186 /* 'l' is an EOF marker, possibly including a final block of data,
11187 or possibly empty. If we have the final block of a non-empty
11188 object, record this fact to bypass a subsequent partial read. */
11189 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
11191 rs
->finished_object
= xstrdup (object_name
);
11192 rs
->finished_annex
= xstrdup (annex
? annex
: "");
11193 rs
->finished_offset
= offset
+ i
;
11197 return TARGET_XFER_EOF
;
11201 return TARGET_XFER_OK
;
11205 enum target_xfer_status
11206 remote_target::xfer_partial (enum target_object object
,
11207 const char *annex
, gdb_byte
*readbuf
,
11208 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
11209 ULONGEST
*xfered_len
)
11211 struct remote_state
*rs
;
11215 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
11217 set_remote_traceframe ();
11218 set_general_thread (inferior_ptid
);
11220 rs
= get_remote_state ();
11222 /* Handle memory using the standard memory routines. */
11223 if (object
== TARGET_OBJECT_MEMORY
)
11225 /* If the remote target is connected but not running, we should
11226 pass this request down to a lower stratum (e.g. the executable
11228 if (!target_has_execution ())
11229 return TARGET_XFER_EOF
;
11231 if (writebuf
!= NULL
)
11232 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
11235 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
11239 /* Handle extra signal info using qxfer packets. */
11240 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
11243 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
11244 xfered_len
, &remote_protocol_packets
11245 [PACKET_qXfer_siginfo_read
]);
11247 return remote_write_qxfer ("siginfo", annex
,
11248 writebuf
, offset
, len
, xfered_len
,
11249 &remote_protocol_packets
11250 [PACKET_qXfer_siginfo_write
]);
11253 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
11256 return remote_read_qxfer ("statictrace", annex
,
11257 readbuf
, offset
, len
, xfered_len
,
11258 &remote_protocol_packets
11259 [PACKET_qXfer_statictrace_read
]);
11261 return TARGET_XFER_E_IO
;
11264 /* Only handle flash writes. */
11265 if (writebuf
!= NULL
)
11269 case TARGET_OBJECT_FLASH
:
11270 return remote_flash_write (offset
, len
, xfered_len
,
11274 return TARGET_XFER_E_IO
;
11278 /* Map pre-existing objects onto letters. DO NOT do this for new
11279 objects!!! Instead specify new query packets. */
11282 case TARGET_OBJECT_AVR
:
11286 case TARGET_OBJECT_AUXV
:
11287 gdb_assert (annex
== NULL
);
11288 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
11290 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
11292 case TARGET_OBJECT_AVAILABLE_FEATURES
:
11293 return remote_read_qxfer
11294 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
11295 &remote_protocol_packets
[PACKET_qXfer_features
]);
11297 case TARGET_OBJECT_LIBRARIES
:
11298 return remote_read_qxfer
11299 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
11300 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
11302 case TARGET_OBJECT_LIBRARIES_SVR4
:
11303 return remote_read_qxfer
11304 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
11305 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
11307 case TARGET_OBJECT_MEMORY_MAP
:
11308 gdb_assert (annex
== NULL
);
11309 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
11311 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
11313 case TARGET_OBJECT_OSDATA
:
11314 /* Should only get here if we're connected. */
11315 gdb_assert (rs
->remote_desc
);
11316 return remote_read_qxfer
11317 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
11318 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
11320 case TARGET_OBJECT_THREADS
:
11321 gdb_assert (annex
== NULL
);
11322 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
11324 &remote_protocol_packets
[PACKET_qXfer_threads
]);
11326 case TARGET_OBJECT_TRACEFRAME_INFO
:
11327 gdb_assert (annex
== NULL
);
11328 return remote_read_qxfer
11329 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
11330 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
11332 case TARGET_OBJECT_FDPIC
:
11333 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
11335 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
11337 case TARGET_OBJECT_OPENVMS_UIB
:
11338 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
11340 &remote_protocol_packets
[PACKET_qXfer_uib
]);
11342 case TARGET_OBJECT_BTRACE
:
11343 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
11345 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
11347 case TARGET_OBJECT_BTRACE_CONF
:
11348 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
11350 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
11352 case TARGET_OBJECT_EXEC_FILE
:
11353 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
11355 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
11358 return TARGET_XFER_E_IO
;
11361 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
11362 large enough let the caller deal with it. */
11363 if (len
< get_remote_packet_size ())
11364 return TARGET_XFER_E_IO
;
11365 len
= get_remote_packet_size ();
11367 /* Except for querying the minimum buffer size, target must be open. */
11368 if (!rs
->remote_desc
)
11369 error (_("remote query is only available after target open"));
11371 gdb_assert (annex
!= NULL
);
11372 gdb_assert (readbuf
!= NULL
);
11374 p2
= rs
->buf
.data ();
11376 *p2
++ = query_type
;
11378 /* We used one buffer char for the remote protocol q command and
11379 another for the query type. As the remote protocol encapsulation
11380 uses 4 chars plus one extra in case we are debugging
11381 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11384 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11386 /* Bad caller may have sent forbidden characters. */
11387 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11392 gdb_assert (annex
[i
] == '\0');
11394 i
= putpkt (rs
->buf
);
11396 return TARGET_XFER_E_IO
;
11398 getpkt (&rs
->buf
, 0);
11399 strcpy ((char *) readbuf
, rs
->buf
.data ());
11401 *xfered_len
= strlen ((char *) readbuf
);
11402 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11405 /* Implementation of to_get_memory_xfer_limit. */
11408 remote_target::get_memory_xfer_limit ()
11410 return get_memory_write_packet_size ();
11414 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11415 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11416 CORE_ADDR
*found_addrp
)
11418 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11419 struct remote_state
*rs
= get_remote_state ();
11420 int max_size
= get_memory_write_packet_size ();
11421 struct packet_config
*packet
=
11422 &remote_protocol_packets
[PACKET_qSearch_memory
];
11423 /* Number of packet bytes used to encode the pattern;
11424 this could be more than PATTERN_LEN due to escape characters. */
11425 int escaped_pattern_len
;
11426 /* Amount of pattern that was encodable in the packet. */
11427 int used_pattern_len
;
11430 ULONGEST found_addr
;
11432 auto read_memory
= [=] (CORE_ADDR addr
, gdb_byte
*result
, size_t len
)
11434 return (target_read (this, TARGET_OBJECT_MEMORY
, NULL
, result
, addr
, len
)
11438 /* Don't go to the target if we don't have to. This is done before
11439 checking packet_config_support to avoid the possibility that a
11440 success for this edge case means the facility works in
11442 if (pattern_len
> search_space_len
)
11444 if (pattern_len
== 0)
11446 *found_addrp
= start_addr
;
11450 /* If we already know the packet isn't supported, fall back to the simple
11451 way of searching memory. */
11453 if (packet_config_support (packet
) == PACKET_DISABLE
)
11455 /* Target doesn't provided special support, fall back and use the
11456 standard support (copy memory and do the search here). */
11457 return simple_search_memory (read_memory
, start_addr
, search_space_len
,
11458 pattern
, pattern_len
, found_addrp
);
11461 /* Make sure the remote is pointing at the right process. */
11462 set_general_process ();
11464 /* Insert header. */
11465 i
= snprintf (rs
->buf
.data (), max_size
,
11466 "qSearch:memory:%s;%s;",
11467 phex_nz (start_addr
, addr_size
),
11468 phex_nz (search_space_len
, sizeof (search_space_len
)));
11469 max_size
-= (i
+ 1);
11471 /* Escape as much data as fits into rs->buf. */
11472 escaped_pattern_len
=
11473 remote_escape_output (pattern
, pattern_len
, 1,
11474 (gdb_byte
*) rs
->buf
.data () + i
,
11475 &used_pattern_len
, max_size
);
11477 /* Bail if the pattern is too large. */
11478 if (used_pattern_len
!= pattern_len
)
11479 error (_("Pattern is too large to transmit to remote target."));
11481 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11482 || getpkt_sane (&rs
->buf
, 0) < 0
11483 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11485 /* The request may not have worked because the command is not
11486 supported. If so, fall back to the simple way. */
11487 if (packet_config_support (packet
) == PACKET_DISABLE
)
11489 return simple_search_memory (read_memory
, start_addr
, search_space_len
,
11490 pattern
, pattern_len
, found_addrp
);
11495 if (rs
->buf
[0] == '0')
11497 else if (rs
->buf
[0] == '1')
11500 if (rs
->buf
[1] != ',')
11501 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11502 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11503 *found_addrp
= found_addr
;
11506 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11512 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11514 struct remote_state
*rs
= get_remote_state ();
11515 char *p
= rs
->buf
.data ();
11517 if (!rs
->remote_desc
)
11518 error (_("remote rcmd is only available after target open"));
11520 /* Send a NULL command across as an empty command. */
11521 if (command
== NULL
)
11524 /* The query prefix. */
11525 strcpy (rs
->buf
.data (), "qRcmd,");
11526 p
= strchr (rs
->buf
.data (), '\0');
11528 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11529 > get_remote_packet_size ())
11530 error (_("\"monitor\" command ``%s'' is too long."), command
);
11532 /* Encode the actual command. */
11533 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11535 if (putpkt (rs
->buf
) < 0)
11536 error (_("Communication problem with target."));
11538 /* get/display the response */
11543 /* XXX - see also remote_get_noisy_reply(). */
11544 QUIT
; /* Allow user to bail out with ^C. */
11546 if (getpkt_sane (&rs
->buf
, 0) == -1)
11548 /* Timeout. Continue to (try to) read responses.
11549 This is better than stopping with an error, assuming the stub
11550 is still executing the (long) monitor command.
11551 If needed, the user can interrupt gdb using C-c, obtaining
11552 an effect similar to stop on timeout. */
11555 buf
= rs
->buf
.data ();
11556 if (buf
[0] == '\0')
11557 error (_("Target does not support this command."));
11558 if (buf
[0] == 'O' && buf
[1] != 'K')
11560 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11563 if (strcmp (buf
, "OK") == 0)
11565 if (strlen (buf
) == 3 && buf
[0] == 'E'
11566 && isdigit (buf
[1]) && isdigit (buf
[2]))
11568 error (_("Protocol error with Rcmd"));
11570 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11572 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11574 fputc_unfiltered (c
, outbuf
);
11580 std::vector
<mem_region
>
11581 remote_target::memory_map ()
11583 std::vector
<mem_region
> result
;
11584 gdb::optional
<gdb::char_vector
> text
11585 = target_read_stralloc (current_inferior ()->top_target (),
11586 TARGET_OBJECT_MEMORY_MAP
, NULL
);
11589 result
= parse_memory_map (text
->data ());
11594 /* Set of callbacks used to implement the 'maint packet' command. */
11596 struct cli_packet_command_callbacks
: public send_remote_packet_callbacks
11598 /* Called before the packet is sent. BUF is the packet content before
11599 the protocol specific prefix, suffix, and escaping is added. */
11601 void sending (gdb::array_view
<const char> &buf
) override
11603 puts_filtered ("sending: ");
11604 print_packet (buf
);
11605 puts_filtered ("\n");
11608 /* Called with BUF, the reply from the remote target. */
11610 void received (gdb::array_view
<const char> &buf
) override
11612 puts_filtered ("received: \"");
11613 print_packet (buf
);
11614 puts_filtered ("\"\n");
11619 /* Print BUF o gdb_stdout. Any non-printable bytes in BUF are printed as
11620 '\x??' with '??' replaced by the hexadecimal value of the byte. */
11623 print_packet (gdb::array_view
<const char> &buf
)
11627 for (int i
= 0; i
< buf
.size (); ++i
)
11629 gdb_byte c
= buf
[i
];
11631 fputc_unfiltered (c
, &stb
);
11633 fprintf_unfiltered (&stb
, "\\x%02x", (unsigned char) c
);
11636 puts_filtered (stb
.string ().c_str ());
11640 /* See remote.h. */
11643 send_remote_packet (gdb::array_view
<const char> &buf
,
11644 send_remote_packet_callbacks
*callbacks
)
11646 if (buf
.size () == 0 || buf
.data ()[0] == '\0')
11647 error (_("a remote packet must not be empty"));
11649 remote_target
*remote
= get_current_remote_target ();
11650 if (remote
== nullptr)
11651 error (_("packets can only be sent to a remote target"));
11653 callbacks
->sending (buf
);
11655 remote
->putpkt_binary (buf
.data (), buf
.size ());
11656 remote_state
*rs
= remote
->get_remote_state ();
11657 int bytes
= remote
->getpkt_sane (&rs
->buf
, 0);
11660 error (_("error while fetching packet from remote target"));
11662 gdb::array_view
<const char> view (&rs
->buf
[0], bytes
);
11663 callbacks
->received (view
);
11666 /* Entry point for the 'maint packet' command. */
11669 cli_packet_command (const char *args
, int from_tty
)
11671 cli_packet_command_callbacks cb
;
11672 gdb::array_view
<const char> view
11673 = gdb::make_array_view (args
, args
== nullptr ? 0 : strlen (args
));
11674 send_remote_packet (view
, &cb
);
11678 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11680 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11682 static void threadset_test_cmd (char *cmd
, int tty
);
11684 static void threadalive_test (char *cmd
, int tty
);
11686 static void threadlist_test_cmd (char *cmd
, int tty
);
11688 int get_and_display_threadinfo (threadref
*ref
);
11690 static void threadinfo_test_cmd (char *cmd
, int tty
);
11692 static int thread_display_step (threadref
*ref
, void *context
);
11694 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11696 static void init_remote_threadtests (void);
11698 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11701 threadset_test_cmd (const char *cmd
, int tty
)
11703 int sample_thread
= SAMPLE_THREAD
;
11705 printf_filtered (_("Remote threadset test\n"));
11706 set_general_thread (sample_thread
);
11711 threadalive_test (const char *cmd
, int tty
)
11713 int sample_thread
= SAMPLE_THREAD
;
11714 int pid
= inferior_ptid
.pid ();
11715 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11717 if (remote_thread_alive (ptid
))
11718 printf_filtered ("PASS: Thread alive test\n");
11720 printf_filtered ("FAIL: Thread alive test\n");
11723 void output_threadid (char *title
, threadref
*ref
);
11726 output_threadid (char *title
, threadref
*ref
)
11730 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11732 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11736 threadlist_test_cmd (const char *cmd
, int tty
)
11739 threadref nextthread
;
11740 int done
, result_count
;
11741 threadref threadlist
[3];
11743 printf_filtered ("Remote Threadlist test\n");
11744 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11745 &result_count
, &threadlist
[0]))
11746 printf_filtered ("FAIL: threadlist test\n");
11749 threadref
*scan
= threadlist
;
11750 threadref
*limit
= scan
+ result_count
;
11752 while (scan
< limit
)
11753 output_threadid (" thread ", scan
++);
11758 display_thread_info (struct gdb_ext_thread_info
*info
)
11760 output_threadid ("Threadid: ", &info
->threadid
);
11761 printf_filtered ("Name: %s\n ", info
->shortname
);
11762 printf_filtered ("State: %s\n", info
->display
);
11763 printf_filtered ("other: %s\n\n", info
->more_display
);
11767 get_and_display_threadinfo (threadref
*ref
)
11771 struct gdb_ext_thread_info threadinfo
;
11773 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11774 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11775 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11776 display_thread_info (&threadinfo
);
11781 threadinfo_test_cmd (const char *cmd
, int tty
)
11783 int athread
= SAMPLE_THREAD
;
11787 int_to_threadref (&thread
, athread
);
11788 printf_filtered ("Remote Threadinfo test\n");
11789 if (!get_and_display_threadinfo (&thread
))
11790 printf_filtered ("FAIL cannot get thread info\n");
11794 thread_display_step (threadref
*ref
, void *context
)
11796 /* output_threadid(" threadstep ",ref); *//* simple test */
11797 return get_and_display_threadinfo (ref
);
11801 threadlist_update_test_cmd (const char *cmd
, int tty
)
11803 printf_filtered ("Remote Threadlist update test\n");
11804 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11808 init_remote_threadtests (void)
11810 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11811 _("Fetch and print the remote list of "
11812 "thread identifiers, one pkt only."));
11813 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11814 _("Fetch and display info about one thread."));
11815 add_com ("tset", class_obscure
, threadset_test_cmd
,
11816 _("Test setting to a different thread."));
11817 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11818 _("Iterate through updating all remote thread info."));
11819 add_com ("talive", class_obscure
, threadalive_test
,
11820 _("Remote thread alive test."));
11825 /* Convert a thread ID to a string. */
11828 remote_target::pid_to_str (ptid_t ptid
)
11830 struct remote_state
*rs
= get_remote_state ();
11832 if (ptid
== null_ptid
)
11833 return normal_pid_to_str (ptid
);
11834 else if (ptid
.is_pid ())
11836 /* Printing an inferior target id. */
11838 /* When multi-process extensions are off, there's no way in the
11839 remote protocol to know the remote process id, if there's any
11840 at all. There's one exception --- when we're connected with
11841 target extended-remote, and we manually attached to a process
11842 with "attach PID". We don't record anywhere a flag that
11843 allows us to distinguish that case from the case of
11844 connecting with extended-remote and the stub already being
11845 attached to a process, and reporting yes to qAttached, hence
11846 no smart special casing here. */
11847 if (!remote_multi_process_p (rs
))
11848 return "Remote target";
11850 return normal_pid_to_str (ptid
);
11854 if (magic_null_ptid
== ptid
)
11855 return "Thread <main>";
11856 else if (remote_multi_process_p (rs
))
11857 if (ptid
.lwp () == 0)
11858 return normal_pid_to_str (ptid
);
11860 return string_printf ("Thread %d.%ld",
11861 ptid
.pid (), ptid
.lwp ());
11863 return string_printf ("Thread %ld", ptid
.lwp ());
11867 /* Get the address of the thread local variable in OBJFILE which is
11868 stored at OFFSET within the thread local storage for thread PTID. */
11871 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11874 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11876 struct remote_state
*rs
= get_remote_state ();
11877 char *p
= rs
->buf
.data ();
11878 char *endp
= p
+ get_remote_packet_size ();
11879 enum packet_result result
;
11881 strcpy (p
, "qGetTLSAddr:");
11883 p
= write_ptid (p
, endp
, ptid
);
11885 p
+= hexnumstr (p
, offset
);
11887 p
+= hexnumstr (p
, lm
);
11891 getpkt (&rs
->buf
, 0);
11892 result
= packet_ok (rs
->buf
,
11893 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11894 if (result
== PACKET_OK
)
11898 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11901 else if (result
== PACKET_UNKNOWN
)
11902 throw_error (TLS_GENERIC_ERROR
,
11903 _("Remote target doesn't support qGetTLSAddr packet"));
11905 throw_error (TLS_GENERIC_ERROR
,
11906 _("Remote target failed to process qGetTLSAddr request"));
11909 throw_error (TLS_GENERIC_ERROR
,
11910 _("TLS not supported or disabled on this target"));
11915 /* Provide thread local base, i.e. Thread Information Block address.
11916 Returns 1 if ptid is found and thread_local_base is non zero. */
11919 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11921 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11923 struct remote_state
*rs
= get_remote_state ();
11924 char *p
= rs
->buf
.data ();
11925 char *endp
= p
+ get_remote_packet_size ();
11926 enum packet_result result
;
11928 strcpy (p
, "qGetTIBAddr:");
11930 p
= write_ptid (p
, endp
, ptid
);
11934 getpkt (&rs
->buf
, 0);
11935 result
= packet_ok (rs
->buf
,
11936 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11937 if (result
== PACKET_OK
)
11940 unpack_varlen_hex (rs
->buf
.data (), &val
);
11942 *addr
= (CORE_ADDR
) val
;
11945 else if (result
== PACKET_UNKNOWN
)
11946 error (_("Remote target doesn't support qGetTIBAddr packet"));
11948 error (_("Remote target failed to process qGetTIBAddr request"));
11951 error (_("qGetTIBAddr not supported or disabled on this target"));
11956 /* Support for inferring a target description based on the current
11957 architecture and the size of a 'g' packet. While the 'g' packet
11958 can have any size (since optional registers can be left off the
11959 end), some sizes are easily recognizable given knowledge of the
11960 approximate architecture. */
11962 struct remote_g_packet_guess
11964 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11971 const struct target_desc
*tdesc
;
11974 struct remote_g_packet_data
: public allocate_on_obstack
11976 std::vector
<remote_g_packet_guess
> guesses
;
11979 static struct gdbarch_data
*remote_g_packet_data_handle
;
11982 remote_g_packet_data_init (struct obstack
*obstack
)
11984 return new (obstack
) remote_g_packet_data
;
11988 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11989 const struct target_desc
*tdesc
)
11991 struct remote_g_packet_data
*data
11992 = ((struct remote_g_packet_data
*)
11993 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11995 gdb_assert (tdesc
!= NULL
);
11997 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11998 if (guess
.bytes
== bytes
)
11999 internal_error (__FILE__
, __LINE__
,
12000 _("Duplicate g packet description added for size %d"),
12003 data
->guesses
.emplace_back (bytes
, tdesc
);
12006 /* Return true if remote_read_description would do anything on this target
12007 and architecture, false otherwise. */
12010 remote_read_description_p (struct target_ops
*target
)
12012 struct remote_g_packet_data
*data
12013 = ((struct remote_g_packet_data
*)
12014 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
12016 return !data
->guesses
.empty ();
12019 const struct target_desc
*
12020 remote_target::read_description ()
12022 struct remote_g_packet_data
*data
12023 = ((struct remote_g_packet_data
*)
12024 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
12026 /* Do not try this during initial connection, when we do not know
12027 whether there is a running but stopped thread. */
12028 if (!target_has_execution () || inferior_ptid
== null_ptid
)
12029 return beneath ()->read_description ();
12031 if (!data
->guesses
.empty ())
12033 int bytes
= send_g_packet ();
12035 for (const remote_g_packet_guess
&guess
: data
->guesses
)
12036 if (guess
.bytes
== bytes
)
12037 return guess
.tdesc
;
12039 /* We discard the g packet. A minor optimization would be to
12040 hold on to it, and fill the register cache once we have selected
12041 an architecture, but it's too tricky to do safely. */
12044 return beneath ()->read_description ();
12047 /* Remote file transfer support. This is host-initiated I/O, not
12048 target-initiated; for target-initiated, see remote-fileio.c. */
12050 /* If *LEFT is at least the length of STRING, copy STRING to
12051 *BUFFER, update *BUFFER to point to the new end of the buffer, and
12052 decrease *LEFT. Otherwise raise an error. */
12055 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
12057 int len
= strlen (string
);
12060 error (_("Packet too long for target."));
12062 memcpy (*buffer
, string
, len
);
12066 /* NUL-terminate the buffer as a convenience, if there is
12072 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
12073 *BUFFER, update *BUFFER to point to the new end of the buffer, and
12074 decrease *LEFT. Otherwise raise an error. */
12077 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
12080 if (2 * len
> *left
)
12081 error (_("Packet too long for target."));
12083 bin2hex (bytes
, *buffer
, len
);
12084 *buffer
+= 2 * len
;
12087 /* NUL-terminate the buffer as a convenience, if there is
12093 /* If *LEFT is large enough, convert VALUE to hex and add it to
12094 *BUFFER, update *BUFFER to point to the new end of the buffer, and
12095 decrease *LEFT. Otherwise raise an error. */
12098 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
12100 int len
= hexnumlen (value
);
12103 error (_("Packet too long for target."));
12105 hexnumstr (*buffer
, value
);
12109 /* NUL-terminate the buffer as a convenience, if there is
12115 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
12116 value, *REMOTE_ERRNO to the remote error number or zero if none
12117 was included, and *ATTACHMENT to point to the start of the annex
12118 if any. The length of the packet isn't needed here; there may
12119 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
12121 Return 0 if the packet could be parsed, -1 if it could not. If
12122 -1 is returned, the other variables may not be initialized. */
12125 remote_hostio_parse_result (const char *buffer
, int *retcode
,
12126 int *remote_errno
, const char **attachment
)
12131 *attachment
= NULL
;
12133 if (buffer
[0] != 'F')
12137 *retcode
= strtol (&buffer
[1], &p
, 16);
12138 if (errno
!= 0 || p
== &buffer
[1])
12141 /* Check for ",errno". */
12145 *remote_errno
= strtol (p
+ 1, &p2
, 16);
12146 if (errno
!= 0 || p
+ 1 == p2
)
12151 /* Check for ";attachment". If there is no attachment, the
12152 packet should end here. */
12155 *attachment
= p
+ 1;
12158 else if (*p
== '\0')
12164 /* Send a prepared I/O packet to the target and read its response.
12165 The prepared packet is in the global RS->BUF before this function
12166 is called, and the answer is there when we return.
12168 COMMAND_BYTES is the length of the request to send, which may include
12169 binary data. WHICH_PACKET is the packet configuration to check
12170 before attempting a packet. If an error occurs, *REMOTE_ERRNO
12171 is set to the error number and -1 is returned. Otherwise the value
12172 returned by the function is returned.
12174 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
12175 attachment is expected; an error will be reported if there's a
12176 mismatch. If one is found, *ATTACHMENT will be set to point into
12177 the packet buffer and *ATTACHMENT_LEN will be set to the
12178 attachment's length. */
12181 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
12182 int *remote_errno
, const char **attachment
,
12183 int *attachment_len
)
12185 struct remote_state
*rs
= get_remote_state ();
12186 int ret
, bytes_read
;
12187 const char *attachment_tmp
;
12189 if (packet_support (which_packet
) == PACKET_DISABLE
)
12191 *remote_errno
= FILEIO_ENOSYS
;
12195 putpkt_binary (rs
->buf
.data (), command_bytes
);
12196 bytes_read
= getpkt_sane (&rs
->buf
, 0);
12198 /* If it timed out, something is wrong. Don't try to parse the
12200 if (bytes_read
< 0)
12202 *remote_errno
= FILEIO_EINVAL
;
12206 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
12209 *remote_errno
= FILEIO_EINVAL
;
12211 case PACKET_UNKNOWN
:
12212 *remote_errno
= FILEIO_ENOSYS
;
12218 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
12221 *remote_errno
= FILEIO_EINVAL
;
12225 /* Make sure we saw an attachment if and only if we expected one. */
12226 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
12227 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
12229 *remote_errno
= FILEIO_EINVAL
;
12233 /* If an attachment was found, it must point into the packet buffer;
12234 work out how many bytes there were. */
12235 if (attachment_tmp
!= NULL
)
12237 *attachment
= attachment_tmp
;
12238 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
12244 /* See declaration.h. */
12247 readahead_cache::invalidate ()
12252 /* See declaration.h. */
12255 readahead_cache::invalidate_fd (int fd
)
12257 if (this->fd
== fd
)
12261 /* Set the filesystem remote_hostio functions that take FILENAME
12262 arguments will use. Return 0 on success, or -1 if an error
12263 occurs (and set *REMOTE_ERRNO). */
12266 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
12269 struct remote_state
*rs
= get_remote_state ();
12270 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
12271 char *p
= rs
->buf
.data ();
12272 int left
= get_remote_packet_size () - 1;
12276 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
12279 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
12282 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
12284 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
12285 remote_buffer_add_string (&p
, &left
, arg
);
12287 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
12288 remote_errno
, NULL
, NULL
);
12290 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
12294 rs
->fs_pid
= required_pid
;
12299 /* Implementation of to_fileio_open. */
12302 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
12303 int flags
, int mode
, int warn_if_slow
,
12306 struct remote_state
*rs
= get_remote_state ();
12307 char *p
= rs
->buf
.data ();
12308 int left
= get_remote_packet_size () - 1;
12312 static int warning_issued
= 0;
12314 printf_unfiltered (_("Reading %s from remote target...\n"),
12317 if (!warning_issued
)
12319 warning (_("File transfers from remote targets can be slow."
12320 " Use \"set sysroot\" to access files locally"
12322 warning_issued
= 1;
12326 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12329 remote_buffer_add_string (&p
, &left
, "vFile:open:");
12331 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12332 strlen (filename
));
12333 remote_buffer_add_string (&p
, &left
, ",");
12335 remote_buffer_add_int (&p
, &left
, flags
);
12336 remote_buffer_add_string (&p
, &left
, ",");
12338 remote_buffer_add_int (&p
, &left
, mode
);
12340 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
12341 remote_errno
, NULL
, NULL
);
12345 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
12346 int flags
, int mode
, int warn_if_slow
,
12349 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
12353 /* Implementation of to_fileio_pwrite. */
12356 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12357 ULONGEST offset
, int *remote_errno
)
12359 struct remote_state
*rs
= get_remote_state ();
12360 char *p
= rs
->buf
.data ();
12361 int left
= get_remote_packet_size ();
12364 rs
->readahead_cache
.invalidate_fd (fd
);
12366 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
12368 remote_buffer_add_int (&p
, &left
, fd
);
12369 remote_buffer_add_string (&p
, &left
, ",");
12371 remote_buffer_add_int (&p
, &left
, offset
);
12372 remote_buffer_add_string (&p
, &left
, ",");
12374 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
12375 (get_remote_packet_size ()
12376 - (p
- rs
->buf
.data ())));
12378 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
12379 remote_errno
, NULL
, NULL
);
12383 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12384 ULONGEST offset
, int *remote_errno
)
12386 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
12389 /* Helper for the implementation of to_fileio_pread. Read the file
12390 from the remote side with vFile:pread. */
12393 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
12394 ULONGEST offset
, int *remote_errno
)
12396 struct remote_state
*rs
= get_remote_state ();
12397 char *p
= rs
->buf
.data ();
12398 const char *attachment
;
12399 int left
= get_remote_packet_size ();
12400 int ret
, attachment_len
;
12403 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
12405 remote_buffer_add_int (&p
, &left
, fd
);
12406 remote_buffer_add_string (&p
, &left
, ",");
12408 remote_buffer_add_int (&p
, &left
, len
);
12409 remote_buffer_add_string (&p
, &left
, ",");
12411 remote_buffer_add_int (&p
, &left
, offset
);
12413 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
12414 remote_errno
, &attachment
,
12420 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12422 if (read_len
!= ret
)
12423 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
12428 /* See declaration.h. */
12431 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12435 && this->offset
<= offset
12436 && offset
< this->offset
+ this->bufsize
)
12438 ULONGEST max
= this->offset
+ this->bufsize
;
12440 if (offset
+ len
> max
)
12441 len
= max
- offset
;
12443 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12450 /* Implementation of to_fileio_pread. */
12453 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12454 ULONGEST offset
, int *remote_errno
)
12457 struct remote_state
*rs
= get_remote_state ();
12458 readahead_cache
*cache
= &rs
->readahead_cache
;
12460 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12463 cache
->hit_count
++;
12465 remote_debug_printf ("readahead cache hit %s",
12466 pulongest (cache
->hit_count
));
12470 cache
->miss_count
++;
12472 remote_debug_printf ("readahead cache miss %s",
12473 pulongest (cache
->miss_count
));
12476 cache
->offset
= offset
;
12477 cache
->bufsize
= get_remote_packet_size ();
12478 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12480 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12481 cache
->offset
, remote_errno
);
12484 cache
->invalidate_fd (fd
);
12488 cache
->bufsize
= ret
;
12489 return cache
->pread (fd
, read_buf
, len
, offset
);
12493 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12494 ULONGEST offset
, int *remote_errno
)
12496 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12499 /* Implementation of to_fileio_close. */
12502 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12504 struct remote_state
*rs
= get_remote_state ();
12505 char *p
= rs
->buf
.data ();
12506 int left
= get_remote_packet_size () - 1;
12508 rs
->readahead_cache
.invalidate_fd (fd
);
12510 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12512 remote_buffer_add_int (&p
, &left
, fd
);
12514 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12515 remote_errno
, NULL
, NULL
);
12519 remote_target::fileio_close (int fd
, int *remote_errno
)
12521 return remote_hostio_close (fd
, remote_errno
);
12524 /* Implementation of to_fileio_unlink. */
12527 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12530 struct remote_state
*rs
= get_remote_state ();
12531 char *p
= rs
->buf
.data ();
12532 int left
= get_remote_packet_size () - 1;
12534 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12537 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12539 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12540 strlen (filename
));
12542 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12543 remote_errno
, NULL
, NULL
);
12547 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12550 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12553 /* Implementation of to_fileio_readlink. */
12555 gdb::optional
<std::string
>
12556 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12559 struct remote_state
*rs
= get_remote_state ();
12560 char *p
= rs
->buf
.data ();
12561 const char *attachment
;
12562 int left
= get_remote_packet_size ();
12563 int len
, attachment_len
;
12566 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12569 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12571 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12572 strlen (filename
));
12574 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12575 remote_errno
, &attachment
,
12581 std::string
ret (len
, '\0');
12583 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12584 (gdb_byte
*) &ret
[0], len
);
12585 if (read_len
!= len
)
12586 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12591 /* Implementation of to_fileio_fstat. */
12594 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12596 struct remote_state
*rs
= get_remote_state ();
12597 char *p
= rs
->buf
.data ();
12598 int left
= get_remote_packet_size ();
12599 int attachment_len
, ret
;
12600 const char *attachment
;
12601 struct fio_stat fst
;
12604 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12606 remote_buffer_add_int (&p
, &left
, fd
);
12608 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12609 remote_errno
, &attachment
,
12613 if (*remote_errno
!= FILEIO_ENOSYS
)
12616 /* Strictly we should return -1, ENOSYS here, but when
12617 "set sysroot remote:" was implemented in August 2008
12618 BFD's need for a stat function was sidestepped with
12619 this hack. This was not remedied until March 2015
12620 so we retain the previous behavior to avoid breaking
12623 Note that the memset is a March 2015 addition; older
12624 GDBs set st_size *and nothing else* so the structure
12625 would have garbage in all other fields. This might
12626 break something but retaining the previous behavior
12627 here would be just too wrong. */
12629 memset (st
, 0, sizeof (struct stat
));
12630 st
->st_size
= INT_MAX
;
12634 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12635 (gdb_byte
*) &fst
, sizeof (fst
));
12637 if (read_len
!= ret
)
12638 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12640 if (read_len
!= sizeof (fst
))
12641 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12642 read_len
, (int) sizeof (fst
));
12644 remote_fileio_to_host_stat (&fst
, st
);
12649 /* Implementation of to_filesystem_is_local. */
12652 remote_target::filesystem_is_local ()
12654 /* Valgrind GDB presents itself as a remote target but works
12655 on the local filesystem: it does not implement remote get
12656 and users are not expected to set a sysroot. To handle
12657 this case we treat the remote filesystem as local if the
12658 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12659 does not support vFile:open. */
12660 if (gdb_sysroot
== TARGET_SYSROOT_PREFIX
)
12662 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12664 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12666 int fd
, remote_errno
;
12668 /* Try opening a file to probe support. The supplied
12669 filename is irrelevant, we only care about whether
12670 the stub recognizes the packet or not. */
12671 fd
= remote_hostio_open (NULL
, "just probing",
12672 FILEIO_O_RDONLY
, 0700, 0,
12676 remote_hostio_close (fd
, &remote_errno
);
12678 ps
= packet_support (PACKET_vFile_open
);
12681 if (ps
== PACKET_DISABLE
)
12683 static int warning_issued
= 0;
12685 if (!warning_issued
)
12687 warning (_("remote target does not support file"
12688 " transfer, attempting to access files"
12689 " from local filesystem."));
12690 warning_issued
= 1;
12701 remote_fileio_errno_to_host (int errnum
)
12707 case FILEIO_ENOENT
:
12715 case FILEIO_EACCES
:
12717 case FILEIO_EFAULT
:
12721 case FILEIO_EEXIST
:
12723 case FILEIO_ENODEV
:
12725 case FILEIO_ENOTDIR
:
12727 case FILEIO_EISDIR
:
12729 case FILEIO_EINVAL
:
12731 case FILEIO_ENFILE
:
12733 case FILEIO_EMFILE
:
12737 case FILEIO_ENOSPC
:
12739 case FILEIO_ESPIPE
:
12743 case FILEIO_ENOSYS
:
12745 case FILEIO_ENAMETOOLONG
:
12746 return ENAMETOOLONG
;
12752 remote_hostio_error (int errnum
)
12754 int host_error
= remote_fileio_errno_to_host (errnum
);
12756 if (host_error
== -1)
12757 error (_("Unknown remote I/O error %d"), errnum
);
12759 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12762 /* A RAII wrapper around a remote file descriptor. */
12764 class scoped_remote_fd
12767 scoped_remote_fd (remote_target
*remote
, int fd
)
12768 : m_remote (remote
), m_fd (fd
)
12772 ~scoped_remote_fd ()
12779 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12783 /* Swallow exception before it escapes the dtor. If
12784 something goes wrong, likely the connection is gone,
12785 and there's nothing else that can be done. */
12790 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12792 /* Release ownership of the file descriptor, and return it. */
12793 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12800 /* Return the owned file descriptor. */
12801 int get () const noexcept
12807 /* The remote target. */
12808 remote_target
*m_remote
;
12810 /* The owned remote I/O file descriptor. */
12815 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12817 remote_target
*remote
= get_current_remote_target ();
12819 if (remote
== nullptr)
12820 error (_("command can only be used with remote target"));
12822 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12826 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12829 int retcode
, remote_errno
, bytes
, io_size
;
12830 int bytes_in_buffer
;
12834 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12836 perror_with_name (local_file
);
12838 scoped_remote_fd fd
12839 (this, remote_hostio_open (NULL
,
12840 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12842 0700, 0, &remote_errno
));
12843 if (fd
.get () == -1)
12844 remote_hostio_error (remote_errno
);
12846 /* Send up to this many bytes at once. They won't all fit in the
12847 remote packet limit, so we'll transfer slightly fewer. */
12848 io_size
= get_remote_packet_size ();
12849 gdb::byte_vector
buffer (io_size
);
12851 bytes_in_buffer
= 0;
12854 while (bytes_in_buffer
|| !saw_eof
)
12858 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12859 io_size
- bytes_in_buffer
,
12863 if (ferror (file
.get ()))
12864 error (_("Error reading %s."), local_file
);
12867 /* EOF. Unless there is something still in the
12868 buffer from the last iteration, we are done. */
12870 if (bytes_in_buffer
== 0)
12878 bytes
+= bytes_in_buffer
;
12879 bytes_in_buffer
= 0;
12881 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12882 offset
, &remote_errno
);
12885 remote_hostio_error (remote_errno
);
12886 else if (retcode
== 0)
12887 error (_("Remote write of %d bytes returned 0!"), bytes
);
12888 else if (retcode
< bytes
)
12890 /* Short write. Save the rest of the read data for the next
12892 bytes_in_buffer
= bytes
- retcode
;
12893 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12899 if (remote_hostio_close (fd
.release (), &remote_errno
))
12900 remote_hostio_error (remote_errno
);
12903 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12907 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12909 remote_target
*remote
= get_current_remote_target ();
12911 if (remote
== nullptr)
12912 error (_("command can only be used with remote target"));
12914 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12918 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12921 int remote_errno
, bytes
, io_size
;
12924 scoped_remote_fd fd
12925 (this, remote_hostio_open (NULL
,
12926 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12928 if (fd
.get () == -1)
12929 remote_hostio_error (remote_errno
);
12931 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12933 perror_with_name (local_file
);
12935 /* Send up to this many bytes at once. They won't all fit in the
12936 remote packet limit, so we'll transfer slightly fewer. */
12937 io_size
= get_remote_packet_size ();
12938 gdb::byte_vector
buffer (io_size
);
12943 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12946 /* Success, but no bytes, means end-of-file. */
12949 remote_hostio_error (remote_errno
);
12953 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12955 perror_with_name (local_file
);
12958 if (remote_hostio_close (fd
.release (), &remote_errno
))
12959 remote_hostio_error (remote_errno
);
12962 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12966 remote_file_delete (const char *remote_file
, int from_tty
)
12968 remote_target
*remote
= get_current_remote_target ();
12970 if (remote
== nullptr)
12971 error (_("command can only be used with remote target"));
12973 remote
->remote_file_delete (remote_file
, from_tty
);
12977 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12979 int retcode
, remote_errno
;
12981 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12983 remote_hostio_error (remote_errno
);
12986 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12990 remote_put_command (const char *args
, int from_tty
)
12993 error_no_arg (_("file to put"));
12995 gdb_argv
argv (args
);
12996 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12997 error (_("Invalid parameters to remote put"));
12999 remote_file_put (argv
[0], argv
[1], from_tty
);
13003 remote_get_command (const char *args
, int from_tty
)
13006 error_no_arg (_("file to get"));
13008 gdb_argv
argv (args
);
13009 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
13010 error (_("Invalid parameters to remote get"));
13012 remote_file_get (argv
[0], argv
[1], from_tty
);
13016 remote_delete_command (const char *args
, int from_tty
)
13019 error_no_arg (_("file to delete"));
13021 gdb_argv
argv (args
);
13022 if (argv
[0] == NULL
|| argv
[1] != NULL
)
13023 error (_("Invalid parameters to remote delete"));
13025 remote_file_delete (argv
[0], from_tty
);
13029 remote_target::can_execute_reverse ()
13031 if (packet_support (PACKET_bs
) == PACKET_ENABLE
13032 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
13039 remote_target::supports_non_stop ()
13045 remote_target::supports_disable_randomization ()
13047 /* Only supported in extended mode. */
13052 remote_target::supports_multi_process ()
13054 struct remote_state
*rs
= get_remote_state ();
13056 return remote_multi_process_p (rs
);
13060 remote_supports_cond_tracepoints ()
13062 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
13066 remote_target::supports_evaluation_of_breakpoint_conditions ()
13068 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
13072 remote_supports_fast_tracepoints ()
13074 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
13078 remote_supports_static_tracepoints ()
13080 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
13084 remote_supports_install_in_trace ()
13086 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
13090 remote_target::supports_enable_disable_tracepoint ()
13092 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
13097 remote_target::supports_string_tracing ()
13099 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
13103 remote_target::can_run_breakpoint_commands ()
13105 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
13109 remote_target::trace_init ()
13111 struct remote_state
*rs
= get_remote_state ();
13114 remote_get_noisy_reply ();
13115 if (strcmp (rs
->buf
.data (), "OK") != 0)
13116 error (_("Target does not support this command."));
13119 /* Recursive routine to walk through command list including loops, and
13120 download packets for each command. */
13123 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
13124 struct command_line
*cmds
)
13126 struct remote_state
*rs
= get_remote_state ();
13127 struct command_line
*cmd
;
13129 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
13131 QUIT
; /* Allow user to bail out with ^C. */
13132 strcpy (rs
->buf
.data (), "QTDPsrc:");
13133 encode_source_string (num
, addr
, "cmd", cmd
->line
,
13134 rs
->buf
.data () + strlen (rs
->buf
.data ()),
13135 rs
->buf
.size () - strlen (rs
->buf
.data ()));
13137 remote_get_noisy_reply ();
13138 if (strcmp (rs
->buf
.data (), "OK"))
13139 warning (_("Target does not support source download."));
13141 if (cmd
->control_type
== while_control
13142 || cmd
->control_type
== while_stepping_control
)
13144 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
13146 QUIT
; /* Allow user to bail out with ^C. */
13147 strcpy (rs
->buf
.data (), "QTDPsrc:");
13148 encode_source_string (num
, addr
, "cmd", "end",
13149 rs
->buf
.data () + strlen (rs
->buf
.data ()),
13150 rs
->buf
.size () - strlen (rs
->buf
.data ()));
13152 remote_get_noisy_reply ();
13153 if (strcmp (rs
->buf
.data (), "OK"))
13154 warning (_("Target does not support source download."));
13160 remote_target::download_tracepoint (struct bp_location
*loc
)
13164 std::vector
<std::string
> tdp_actions
;
13165 std::vector
<std::string
> stepping_actions
;
13167 struct breakpoint
*b
= loc
->owner
;
13168 struct tracepoint
*t
= (struct tracepoint
*) b
;
13169 struct remote_state
*rs
= get_remote_state ();
13171 const char *err_msg
= _("Tracepoint packet too large for target.");
13174 /* We use a buffer other than rs->buf because we'll build strings
13175 across multiple statements, and other statements in between could
13177 gdb::char_vector
buf (get_remote_packet_size ());
13179 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
13181 tpaddr
= loc
->address
;
13182 strcpy (addrbuf
, phex (tpaddr
, sizeof (CORE_ADDR
)));
13183 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
13184 b
->number
, addrbuf
, /* address */
13185 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
13186 t
->step_count
, t
->pass_count
);
13188 if (ret
< 0 || ret
>= buf
.size ())
13189 error ("%s", err_msg
);
13191 /* Fast tracepoints are mostly handled by the target, but we can
13192 tell the target how big of an instruction block should be moved
13194 if (b
->type
== bp_fast_tracepoint
)
13196 /* Only test for support at download time; we may not know
13197 target capabilities at definition time. */
13198 if (remote_supports_fast_tracepoints ())
13200 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
13203 size_left
= buf
.size () - strlen (buf
.data ());
13204 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13206 gdb_insn_length (loc
->gdbarch
, tpaddr
));
13208 if (ret
< 0 || ret
>= size_left
)
13209 error ("%s", err_msg
);
13212 /* If it passed validation at definition but fails now,
13213 something is very wrong. */
13214 internal_error (__FILE__
, __LINE__
,
13215 _("Fast tracepoint not "
13216 "valid during download"));
13219 /* Fast tracepoints are functionally identical to regular
13220 tracepoints, so don't take lack of support as a reason to
13221 give up on the trace run. */
13222 warning (_("Target does not support fast tracepoints, "
13223 "downloading %d as regular tracepoint"), b
->number
);
13225 else if (b
->type
== bp_static_tracepoint
)
13227 /* Only test for support at download time; we may not know
13228 target capabilities at definition time. */
13229 if (remote_supports_static_tracepoints ())
13231 struct static_tracepoint_marker marker
;
13233 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
13235 size_left
= buf
.size () - strlen (buf
.data ());
13236 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13239 if (ret
< 0 || ret
>= size_left
)
13240 error ("%s", err_msg
);
13243 error (_("Static tracepoint not valid during download"));
13246 /* Fast tracepoints are functionally identical to regular
13247 tracepoints, so don't take lack of support as a reason
13248 to give up on the trace run. */
13249 error (_("Target does not support static tracepoints"));
13251 /* If the tracepoint has a conditional, make it into an agent
13252 expression and append to the definition. */
13255 /* Only test support at download time, we may not know target
13256 capabilities at definition time. */
13257 if (remote_supports_cond_tracepoints ())
13259 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
13262 size_left
= buf
.size () - strlen (buf
.data ());
13264 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13265 size_left
, ":X%x,", aexpr
->len
);
13267 if (ret
< 0 || ret
>= size_left
)
13268 error ("%s", err_msg
);
13270 size_left
= buf
.size () - strlen (buf
.data ());
13272 /* Two bytes to encode each aexpr byte, plus the terminating
13274 if (aexpr
->len
* 2 + 1 > size_left
)
13275 error ("%s", err_msg
);
13277 pkt
= buf
.data () + strlen (buf
.data ());
13279 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
13280 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
13284 warning (_("Target does not support conditional tracepoints, "
13285 "ignoring tp %d cond"), b
->number
);
13288 if (b
->commands
|| !default_collect
.empty ())
13290 size_left
= buf
.size () - strlen (buf
.data ());
13292 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13295 if (ret
< 0 || ret
>= size_left
)
13296 error ("%s", err_msg
);
13299 putpkt (buf
.data ());
13300 remote_get_noisy_reply ();
13301 if (strcmp (rs
->buf
.data (), "OK"))
13302 error (_("Target does not support tracepoints."));
13304 /* do_single_steps (t); */
13305 for (auto action_it
= tdp_actions
.begin ();
13306 action_it
!= tdp_actions
.end (); action_it
++)
13308 QUIT
; /* Allow user to bail out with ^C. */
13310 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
13311 || !stepping_actions
.empty ());
13313 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
13314 b
->number
, addrbuf
, /* address */
13315 action_it
->c_str (),
13316 has_more
? '-' : 0);
13318 if (ret
< 0 || ret
>= buf
.size ())
13319 error ("%s", err_msg
);
13321 putpkt (buf
.data ());
13322 remote_get_noisy_reply ();
13323 if (strcmp (rs
->buf
.data (), "OK"))
13324 error (_("Error on target while setting tracepoints."));
13327 for (auto action_it
= stepping_actions
.begin ();
13328 action_it
!= stepping_actions
.end (); action_it
++)
13330 QUIT
; /* Allow user to bail out with ^C. */
13332 bool is_first
= action_it
== stepping_actions
.begin ();
13333 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
13335 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
13336 b
->number
, addrbuf
, /* address */
13337 is_first
? "S" : "",
13338 action_it
->c_str (),
13339 has_more
? "-" : "");
13341 if (ret
< 0 || ret
>= buf
.size ())
13342 error ("%s", err_msg
);
13344 putpkt (buf
.data ());
13345 remote_get_noisy_reply ();
13346 if (strcmp (rs
->buf
.data (), "OK"))
13347 error (_("Error on target while setting tracepoints."));
13350 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
13352 if (b
->location
!= NULL
)
13354 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13356 if (ret
< 0 || ret
>= buf
.size ())
13357 error ("%s", err_msg
);
13359 encode_source_string (b
->number
, loc
->address
, "at",
13360 event_location_to_string (b
->location
.get ()),
13361 buf
.data () + strlen (buf
.data ()),
13362 buf
.size () - strlen (buf
.data ()));
13363 putpkt (buf
.data ());
13364 remote_get_noisy_reply ();
13365 if (strcmp (rs
->buf
.data (), "OK"))
13366 warning (_("Target does not support source download."));
13368 if (b
->cond_string
)
13370 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13372 if (ret
< 0 || ret
>= buf
.size ())
13373 error ("%s", err_msg
);
13375 encode_source_string (b
->number
, loc
->address
,
13376 "cond", b
->cond_string
.get (),
13377 buf
.data () + strlen (buf
.data ()),
13378 buf
.size () - strlen (buf
.data ()));
13379 putpkt (buf
.data ());
13380 remote_get_noisy_reply ();
13381 if (strcmp (rs
->buf
.data (), "OK"))
13382 warning (_("Target does not support source download."));
13384 remote_download_command_source (b
->number
, loc
->address
,
13385 breakpoint_commands (b
));
13390 remote_target::can_download_tracepoint ()
13392 struct remote_state
*rs
= get_remote_state ();
13393 struct trace_status
*ts
;
13396 /* Don't try to install tracepoints until we've relocated our
13397 symbols, and fetched and merged the target's tracepoint list with
13399 if (rs
->starting_up
)
13402 ts
= current_trace_status ();
13403 status
= get_trace_status (ts
);
13405 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
13408 /* If we are in a tracing experiment, but remote stub doesn't support
13409 installing tracepoint in trace, we have to return. */
13410 if (!remote_supports_install_in_trace ())
13418 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
13420 struct remote_state
*rs
= get_remote_state ();
13423 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13424 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13426 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13427 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13428 >= get_remote_packet_size ())
13429 error (_("Trace state variable name too long for tsv definition packet"));
13430 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13433 remote_get_noisy_reply ();
13434 if (rs
->buf
[0] == '\0')
13435 error (_("Target does not support this command."));
13436 if (strcmp (rs
->buf
.data (), "OK") != 0)
13437 error (_("Error on target while downloading trace state variable."));
13441 remote_target::enable_tracepoint (struct bp_location
*location
)
13443 struct remote_state
*rs
= get_remote_state ();
13445 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13446 location
->owner
->number
,
13447 phex (location
->address
, sizeof (CORE_ADDR
)));
13449 remote_get_noisy_reply ();
13450 if (rs
->buf
[0] == '\0')
13451 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13452 if (strcmp (rs
->buf
.data (), "OK") != 0)
13453 error (_("Error on target while enabling tracepoint."));
13457 remote_target::disable_tracepoint (struct bp_location
*location
)
13459 struct remote_state
*rs
= get_remote_state ();
13461 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13462 location
->owner
->number
,
13463 phex (location
->address
, sizeof (CORE_ADDR
)));
13465 remote_get_noisy_reply ();
13466 if (rs
->buf
[0] == '\0')
13467 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13468 if (strcmp (rs
->buf
.data (), "OK") != 0)
13469 error (_("Error on target while disabling tracepoint."));
13473 remote_target::trace_set_readonly_regions ()
13476 bfd_size_type size
;
13481 if (!current_program_space
->exec_bfd ())
13482 return; /* No information to give. */
13484 struct remote_state
*rs
= get_remote_state ();
13486 strcpy (rs
->buf
.data (), "QTro");
13487 offset
= strlen (rs
->buf
.data ());
13488 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
13490 char tmp1
[40], tmp2
[40];
13493 if ((s
->flags
& SEC_LOAD
) == 0 ||
13494 /* (s->flags & SEC_CODE) == 0 || */
13495 (s
->flags
& SEC_READONLY
) == 0)
13499 vma
= bfd_section_vma (s
);
13500 size
= bfd_section_size (s
);
13501 sprintf_vma (tmp1
, vma
);
13502 sprintf_vma (tmp2
, vma
+ size
);
13503 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13504 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13506 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13508 Too many sections for read-only sections definition packet."));
13511 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13513 offset
+= sec_length
;
13518 getpkt (&rs
->buf
, 0);
13523 remote_target::trace_start ()
13525 struct remote_state
*rs
= get_remote_state ();
13527 putpkt ("QTStart");
13528 remote_get_noisy_reply ();
13529 if (rs
->buf
[0] == '\0')
13530 error (_("Target does not support this command."));
13531 if (strcmp (rs
->buf
.data (), "OK") != 0)
13532 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13536 remote_target::get_trace_status (struct trace_status
*ts
)
13538 /* Initialize it just to avoid a GCC false warning. */
13540 enum packet_result result
;
13541 struct remote_state
*rs
= get_remote_state ();
13543 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13546 /* FIXME we need to get register block size some other way. */
13547 trace_regblock_size
13548 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13550 putpkt ("qTStatus");
13554 p
= remote_get_noisy_reply ();
13556 catch (const gdb_exception_error
&ex
)
13558 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13560 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13566 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13568 /* If the remote target doesn't do tracing, flag it. */
13569 if (result
== PACKET_UNKNOWN
)
13572 /* We're working with a live target. */
13573 ts
->filename
= NULL
;
13576 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13578 /* Function 'parse_trace_status' sets default value of each field of
13579 'ts' at first, so we don't have to do it here. */
13580 parse_trace_status (p
, ts
);
13582 return ts
->running
;
13586 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13587 struct uploaded_tp
*utp
)
13589 struct remote_state
*rs
= get_remote_state ();
13591 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13592 size_t size
= get_remote_packet_size ();
13597 tp
->traceframe_usage
= 0;
13598 for (bp_location
*loc
: tp
->locations ())
13600 /* If the tracepoint was never downloaded, don't go asking for
13602 if (tp
->number_on_target
== 0)
13604 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13605 phex_nz (loc
->address
, 0));
13607 reply
= remote_get_noisy_reply ();
13608 if (reply
&& *reply
)
13611 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13617 utp
->hit_count
= 0;
13618 utp
->traceframe_usage
= 0;
13619 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13620 phex_nz (utp
->addr
, 0));
13622 reply
= remote_get_noisy_reply ();
13623 if (reply
&& *reply
)
13626 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13632 remote_target::trace_stop ()
13634 struct remote_state
*rs
= get_remote_state ();
13637 remote_get_noisy_reply ();
13638 if (rs
->buf
[0] == '\0')
13639 error (_("Target does not support this command."));
13640 if (strcmp (rs
->buf
.data (), "OK") != 0)
13641 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13645 remote_target::trace_find (enum trace_find_type type
, int num
,
13646 CORE_ADDR addr1
, CORE_ADDR addr2
,
13649 struct remote_state
*rs
= get_remote_state ();
13650 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13652 int target_frameno
= -1, target_tracept
= -1;
13654 /* Lookups other than by absolute frame number depend on the current
13655 trace selected, so make sure it is correct on the remote end
13657 if (type
!= tfind_number
)
13658 set_remote_traceframe ();
13660 p
= rs
->buf
.data ();
13661 strcpy (p
, "QTFrame:");
13662 p
= strchr (p
, '\0');
13666 xsnprintf (p
, endbuf
- p
, "%x", num
);
13669 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13672 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13675 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13676 phex_nz (addr2
, 0));
13678 case tfind_outside
:
13679 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13680 phex_nz (addr2
, 0));
13683 error (_("Unknown trace find type %d"), type
);
13687 reply
= remote_get_noisy_reply ();
13688 if (*reply
== '\0')
13689 error (_("Target does not support this command."));
13691 while (reply
&& *reply
)
13696 target_frameno
= (int) strtol (p
, &reply
, 16);
13698 error (_("Unable to parse trace frame number"));
13699 /* Don't update our remote traceframe number cache on failure
13700 to select a remote traceframe. */
13701 if (target_frameno
== -1)
13706 target_tracept
= (int) strtol (p
, &reply
, 16);
13708 error (_("Unable to parse tracepoint number"));
13710 case 'O': /* "OK"? */
13711 if (reply
[1] == 'K' && reply
[2] == '\0')
13714 error (_("Bogus reply from target: %s"), reply
);
13717 error (_("Bogus reply from target: %s"), reply
);
13720 *tpp
= target_tracept
;
13722 rs
->remote_traceframe_number
= target_frameno
;
13723 return target_frameno
;
13727 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13729 struct remote_state
*rs
= get_remote_state ();
13733 set_remote_traceframe ();
13735 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13737 reply
= remote_get_noisy_reply ();
13738 if (reply
&& *reply
)
13742 unpack_varlen_hex (reply
+ 1, &uval
);
13743 *val
= (LONGEST
) uval
;
13751 remote_target::save_trace_data (const char *filename
)
13753 struct remote_state
*rs
= get_remote_state ();
13756 p
= rs
->buf
.data ();
13757 strcpy (p
, "QTSave:");
13759 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13760 >= get_remote_packet_size ())
13761 error (_("Remote file name too long for trace save packet"));
13762 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13765 reply
= remote_get_noisy_reply ();
13766 if (*reply
== '\0')
13767 error (_("Target does not support this command."));
13768 if (strcmp (reply
, "OK") != 0)
13769 error (_("Bogus reply from target: %s"), reply
);
13773 /* This is basically a memory transfer, but needs to be its own packet
13774 because we don't know how the target actually organizes its trace
13775 memory, plus we want to be able to ask for as much as possible, but
13776 not be unhappy if we don't get as much as we ask for. */
13779 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13781 struct remote_state
*rs
= get_remote_state ();
13786 p
= rs
->buf
.data ();
13787 strcpy (p
, "qTBuffer:");
13789 p
+= hexnumstr (p
, offset
);
13791 p
+= hexnumstr (p
, len
);
13795 reply
= remote_get_noisy_reply ();
13796 if (reply
&& *reply
)
13798 /* 'l' by itself means we're at the end of the buffer and
13799 there is nothing more to get. */
13803 /* Convert the reply into binary. Limit the number of bytes to
13804 convert according to our passed-in buffer size, rather than
13805 what was returned in the packet; if the target is
13806 unexpectedly generous and gives us a bigger reply than we
13807 asked for, we don't want to crash. */
13808 rslt
= hex2bin (reply
, buf
, len
);
13812 /* Something went wrong, flag as an error. */
13817 remote_target::set_disconnected_tracing (int val
)
13819 struct remote_state
*rs
= get_remote_state ();
13821 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13825 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13826 "QTDisconnected:%x", val
);
13828 reply
= remote_get_noisy_reply ();
13829 if (*reply
== '\0')
13830 error (_("Target does not support this command."));
13831 if (strcmp (reply
, "OK") != 0)
13832 error (_("Bogus reply from target: %s"), reply
);
13835 warning (_("Target does not support disconnected tracing."));
13839 remote_target::core_of_thread (ptid_t ptid
)
13841 thread_info
*info
= find_thread_ptid (this, ptid
);
13843 if (info
!= NULL
&& info
->priv
!= NULL
)
13844 return get_remote_thread_info (info
)->core
;
13850 remote_target::set_circular_trace_buffer (int val
)
13852 struct remote_state
*rs
= get_remote_state ();
13855 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13856 "QTBuffer:circular:%x", val
);
13858 reply
= remote_get_noisy_reply ();
13859 if (*reply
== '\0')
13860 error (_("Target does not support this command."));
13861 if (strcmp (reply
, "OK") != 0)
13862 error (_("Bogus reply from target: %s"), reply
);
13866 remote_target::traceframe_info ()
13868 gdb::optional
<gdb::char_vector
> text
13869 = target_read_stralloc (current_inferior ()->top_target (),
13870 TARGET_OBJECT_TRACEFRAME_INFO
,
13873 return parse_traceframe_info (text
->data ());
13878 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13879 instruction on which a fast tracepoint may be placed. Returns -1
13880 if the packet is not supported, and 0 if the minimum instruction
13881 length is unknown. */
13884 remote_target::get_min_fast_tracepoint_insn_len ()
13886 struct remote_state
*rs
= get_remote_state ();
13889 /* If we're not debugging a process yet, the IPA can't be
13891 if (!target_has_execution ())
13894 /* Make sure the remote is pointing at the right process. */
13895 set_general_process ();
13897 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13899 reply
= remote_get_noisy_reply ();
13900 if (*reply
== '\0')
13904 ULONGEST min_insn_len
;
13906 unpack_varlen_hex (reply
, &min_insn_len
);
13908 return (int) min_insn_len
;
13913 remote_target::set_trace_buffer_size (LONGEST val
)
13915 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13917 struct remote_state
*rs
= get_remote_state ();
13918 char *buf
= rs
->buf
.data ();
13919 char *endbuf
= buf
+ get_remote_packet_size ();
13920 enum packet_result result
;
13922 gdb_assert (val
>= 0 || val
== -1);
13923 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13924 /* Send -1 as literal "-1" to avoid host size dependency. */
13928 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13931 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13934 remote_get_noisy_reply ();
13935 result
= packet_ok (rs
->buf
,
13936 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13938 if (result
!= PACKET_OK
)
13939 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13944 remote_target::set_trace_notes (const char *user
, const char *notes
,
13945 const char *stop_notes
)
13947 struct remote_state
*rs
= get_remote_state ();
13949 char *buf
= rs
->buf
.data ();
13950 char *endbuf
= buf
+ get_remote_packet_size ();
13953 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13956 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13957 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13963 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13964 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13970 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13971 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13975 /* Ensure the buffer is terminated. */
13979 reply
= remote_get_noisy_reply ();
13980 if (*reply
== '\0')
13983 if (strcmp (reply
, "OK") != 0)
13984 error (_("Bogus reply from target: %s"), reply
);
13990 remote_target::use_agent (bool use
)
13992 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13994 struct remote_state
*rs
= get_remote_state ();
13996 /* If the stub supports QAgent. */
13997 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13999 getpkt (&rs
->buf
, 0);
14001 if (strcmp (rs
->buf
.data (), "OK") == 0)
14012 remote_target::can_use_agent ()
14014 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
14017 struct btrace_target_info
14019 /* The ptid of the traced thread. */
14022 /* The obtained branch trace configuration. */
14023 struct btrace_config conf
;
14026 /* Reset our idea of our target's btrace configuration. */
14029 remote_btrace_reset (remote_state
*rs
)
14031 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
14034 /* Synchronize the configuration with the target. */
14037 remote_target::btrace_sync_conf (const btrace_config
*conf
)
14039 struct packet_config
*packet
;
14040 struct remote_state
*rs
;
14041 char *buf
, *pos
, *endbuf
;
14043 rs
= get_remote_state ();
14044 buf
= rs
->buf
.data ();
14045 endbuf
= buf
+ get_remote_packet_size ();
14047 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
14048 if (packet_config_support (packet
) == PACKET_ENABLE
14049 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
14052 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
14056 getpkt (&rs
->buf
, 0);
14058 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
14060 if (buf
[0] == 'E' && buf
[1] == '.')
14061 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
14063 error (_("Failed to configure the BTS buffer size."));
14066 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
14069 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
14070 if (packet_config_support (packet
) == PACKET_ENABLE
14071 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
14074 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
14078 getpkt (&rs
->buf
, 0);
14080 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
14082 if (buf
[0] == 'E' && buf
[1] == '.')
14083 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
14085 error (_("Failed to configure the trace buffer size."));
14088 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
14092 /* Read TP's btrace configuration from the target and store it into CONF. */
14095 btrace_read_config (thread_info
*tp
, struct btrace_config
*conf
)
14097 /* target_read_stralloc relies on INFERIOR_PTID. */
14098 scoped_restore_current_thread restore_thread
;
14099 switch_to_thread (tp
);
14101 gdb::optional
<gdb::char_vector
> xml
14102 = target_read_stralloc (current_inferior ()->top_target (),
14103 TARGET_OBJECT_BTRACE_CONF
, "");
14105 parse_xml_btrace_conf (conf
, xml
->data ());
14108 /* Maybe reopen target btrace. */
14111 remote_target::remote_btrace_maybe_reopen ()
14113 struct remote_state
*rs
= get_remote_state ();
14114 int btrace_target_pushed
= 0;
14115 #if !defined (HAVE_LIBIPT)
14119 /* Don't bother walking the entirety of the remote thread list when
14120 we know the feature isn't supported by the remote. */
14121 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
14124 for (thread_info
*tp
: all_non_exited_threads (this))
14126 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
14127 btrace_read_config (tp
, &rs
->btrace_config
);
14129 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
14132 #if !defined (HAVE_LIBIPT)
14133 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
14138 warning (_("Target is recording using Intel Processor Trace "
14139 "but support was disabled at compile time."));
14144 #endif /* !defined (HAVE_LIBIPT) */
14146 /* Push target, once, but before anything else happens. This way our
14147 changes to the threads will be cleaned up by unpushing the target
14148 in case btrace_read_config () throws. */
14149 if (!btrace_target_pushed
)
14151 btrace_target_pushed
= 1;
14152 record_btrace_push_target ();
14153 printf_filtered (_("Target is recording using %s.\n"),
14154 btrace_format_string (rs
->btrace_config
.format
));
14157 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
14158 tp
->btrace
.target
->ptid
= tp
->ptid
;
14159 tp
->btrace
.target
->conf
= rs
->btrace_config
;
14163 /* Enable branch tracing. */
14165 struct btrace_target_info
*
14166 remote_target::enable_btrace (thread_info
*tp
,
14167 const struct btrace_config
*conf
)
14169 struct btrace_target_info
*tinfo
= NULL
;
14170 struct packet_config
*packet
= NULL
;
14171 struct remote_state
*rs
= get_remote_state ();
14172 char *buf
= rs
->buf
.data ();
14173 char *endbuf
= buf
+ get_remote_packet_size ();
14175 switch (conf
->format
)
14177 case BTRACE_FORMAT_BTS
:
14178 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
14181 case BTRACE_FORMAT_PT
:
14182 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
14186 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
14187 error (_("Target does not support branch tracing."));
14189 btrace_sync_conf (conf
);
14191 ptid_t ptid
= tp
->ptid
;
14192 set_general_thread (ptid
);
14194 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
14196 getpkt (&rs
->buf
, 0);
14198 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
14200 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
14201 error (_("Could not enable branch tracing for %s: %s"),
14202 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
14204 error (_("Could not enable branch tracing for %s."),
14205 target_pid_to_str (ptid
).c_str ());
14208 tinfo
= XCNEW (struct btrace_target_info
);
14209 tinfo
->ptid
= ptid
;
14211 /* If we fail to read the configuration, we lose some information, but the
14212 tracing itself is not impacted. */
14215 btrace_read_config (tp
, &tinfo
->conf
);
14217 catch (const gdb_exception_error
&err
)
14219 if (err
.message
!= NULL
)
14220 warning ("%s", err
.what ());
14226 /* Disable branch tracing. */
14229 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
14231 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
14232 struct remote_state
*rs
= get_remote_state ();
14233 char *buf
= rs
->buf
.data ();
14234 char *endbuf
= buf
+ get_remote_packet_size ();
14236 if (packet_config_support (packet
) != PACKET_ENABLE
)
14237 error (_("Target does not support branch tracing."));
14239 set_general_thread (tinfo
->ptid
);
14241 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
14243 getpkt (&rs
->buf
, 0);
14245 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
14247 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
14248 error (_("Could not disable branch tracing for %s: %s"),
14249 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
14251 error (_("Could not disable branch tracing for %s."),
14252 target_pid_to_str (tinfo
->ptid
).c_str ());
14258 /* Teardown branch tracing. */
14261 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
14263 /* We must not talk to the target during teardown. */
14267 /* Read the branch trace. */
14270 remote_target::read_btrace (struct btrace_data
*btrace
,
14271 struct btrace_target_info
*tinfo
,
14272 enum btrace_read_type type
)
14274 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
14277 if (packet_config_support (packet
) != PACKET_ENABLE
)
14278 error (_("Target does not support branch tracing."));
14280 #if !defined(HAVE_LIBEXPAT)
14281 error (_("Cannot process branch tracing result. XML parsing not supported."));
14286 case BTRACE_READ_ALL
:
14289 case BTRACE_READ_NEW
:
14292 case BTRACE_READ_DELTA
:
14296 internal_error (__FILE__
, __LINE__
,
14297 _("Bad branch tracing read type: %u."),
14298 (unsigned int) type
);
14301 gdb::optional
<gdb::char_vector
> xml
14302 = target_read_stralloc (current_inferior ()->top_target (),
14303 TARGET_OBJECT_BTRACE
, annex
);
14305 return BTRACE_ERR_UNKNOWN
;
14307 parse_xml_btrace (btrace
, xml
->data ());
14309 return BTRACE_ERR_NONE
;
14312 const struct btrace_config
*
14313 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
14315 return &tinfo
->conf
;
14319 remote_target::augmented_libraries_svr4_read ()
14321 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
14325 /* Implementation of to_load. */
14328 remote_target::load (const char *name
, int from_tty
)
14330 generic_load (name
, from_tty
);
14333 /* Accepts an integer PID; returns a string representing a file that
14334 can be opened on the remote side to get the symbols for the child
14335 process. Returns NULL if the operation is not supported. */
14338 remote_target::pid_to_exec_file (int pid
)
14340 static gdb::optional
<gdb::char_vector
> filename
;
14341 char *annex
= NULL
;
14343 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
14346 inferior
*inf
= find_inferior_pid (this, pid
);
14348 internal_error (__FILE__
, __LINE__
,
14349 _("not currently attached to process %d"), pid
);
14351 if (!inf
->fake_pid_p
)
14353 const int annex_size
= 9;
14355 annex
= (char *) alloca (annex_size
);
14356 xsnprintf (annex
, annex_size
, "%x", pid
);
14359 filename
= target_read_stralloc (current_inferior ()->top_target (),
14360 TARGET_OBJECT_EXEC_FILE
, annex
);
14362 return filename
? filename
->data () : nullptr;
14365 /* Implement the to_can_do_single_step target_ops method. */
14368 remote_target::can_do_single_step ()
14370 /* We can only tell whether target supports single step or not by
14371 supported s and S vCont actions if the stub supports vContSupported
14372 feature. If the stub doesn't support vContSupported feature,
14373 we have conservatively to think target doesn't supports single
14375 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
14377 struct remote_state
*rs
= get_remote_state ();
14379 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14380 remote_vcont_probe ();
14382 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
14388 /* Implementation of the to_execution_direction method for the remote
14391 enum exec_direction_kind
14392 remote_target::execution_direction ()
14394 struct remote_state
*rs
= get_remote_state ();
14396 return rs
->last_resume_exec_dir
;
14399 /* Return pointer to the thread_info struct which corresponds to
14400 THREAD_HANDLE (having length HANDLE_LEN). */
14403 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
14407 for (thread_info
*tp
: all_non_exited_threads (this))
14409 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14411 if (tp
->inf
== inf
&& priv
!= NULL
)
14413 if (handle_len
!= priv
->thread_handle
.size ())
14414 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14415 handle_len
, priv
->thread_handle
.size ());
14416 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14426 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
14428 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14429 return priv
->thread_handle
;
14433 remote_target::can_async_p ()
14435 /* This flag should be checked in the common target.c code. */
14436 gdb_assert (target_async_permitted
);
14438 /* We're async whenever the serial device can. */
14439 struct remote_state
*rs
= get_remote_state ();
14440 return serial_can_async_p (rs
->remote_desc
);
14444 remote_target::is_async_p ()
14446 /* We're async whenever the serial device is. */
14447 struct remote_state
*rs
= get_remote_state ();
14448 return serial_is_async_p (rs
->remote_desc
);
14451 /* Pass the SERIAL event on and up to the client. One day this code
14452 will be able to delay notifying the client of an event until the
14453 point where an entire packet has been received. */
14455 static serial_event_ftype remote_async_serial_handler
;
14458 remote_async_serial_handler (struct serial
*scb
, void *context
)
14460 /* Don't propogate error information up to the client. Instead let
14461 the client find out about the error by querying the target. */
14462 inferior_event_handler (INF_REG_EVENT
);
14466 remote_async_inferior_event_handler (gdb_client_data data
)
14468 inferior_event_handler (INF_REG_EVENT
);
14472 remote_target::async_wait_fd ()
14474 struct remote_state
*rs
= get_remote_state ();
14475 return rs
->remote_desc
->fd
;
14479 remote_target::async (int enable
)
14481 struct remote_state
*rs
= get_remote_state ();
14485 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14487 /* If there are pending events in the stop reply queue tell the
14488 event loop to process them. */
14489 if (!rs
->stop_reply_queue
.empty ())
14490 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14491 /* For simplicity, below we clear the pending events token
14492 without remembering whether it is marked, so here we always
14493 mark it. If there's actually no pending notification to
14494 process, this ends up being a no-op (other than a spurious
14495 event-loop wakeup). */
14496 if (target_is_non_stop_p ())
14497 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14501 serial_async (rs
->remote_desc
, NULL
, NULL
);
14502 /* If the core is disabling async, it doesn't want to be
14503 disturbed with target events. Clear all async event sources
14505 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14506 if (target_is_non_stop_p ())
14507 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14511 /* Implementation of the to_thread_events method. */
14514 remote_target::thread_events (int enable
)
14516 struct remote_state
*rs
= get_remote_state ();
14517 size_t size
= get_remote_packet_size ();
14519 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14522 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14524 getpkt (&rs
->buf
, 0);
14526 switch (packet_ok (rs
->buf
,
14527 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14530 if (strcmp (rs
->buf
.data (), "OK") != 0)
14531 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14534 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14536 case PACKET_UNKNOWN
:
14542 show_remote_cmd (const char *args
, int from_tty
)
14544 /* We can't just use cmd_show_list here, because we want to skip
14545 the redundant "show remote Z-packet" and the legacy aliases. */
14546 struct cmd_list_element
*list
= remote_show_cmdlist
;
14547 struct ui_out
*uiout
= current_uiout
;
14549 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14550 for (; list
!= NULL
; list
= list
->next
)
14551 if (strcmp (list
->name
, "Z-packet") == 0)
14553 else if (list
->type
== not_set_cmd
)
14554 /* Alias commands are exactly like the original, except they
14555 don't have the normal type. */
14559 ui_out_emit_tuple
option_emitter (uiout
, "option");
14561 uiout
->field_string ("name", list
->name
);
14562 uiout
->text (": ");
14563 if (list
->type
== show_cmd
)
14564 do_show_command (NULL
, from_tty
, list
);
14566 cmd_func (list
, NULL
, from_tty
);
14571 /* Function to be called whenever a new objfile (shlib) is detected. */
14573 remote_new_objfile (struct objfile
*objfile
)
14575 remote_target
*remote
= get_current_remote_target ();
14577 /* First, check whether the current inferior's process target is a remote
14579 if (remote
== nullptr)
14582 /* When we are attaching or handling a fork child and the shared library
14583 subsystem reads the list of loaded libraries, we receive new objfile
14584 events in between each found library. The libraries are read in an
14585 undefined order, so if we gave the remote side a chance to look up
14586 symbols between each objfile, we might give it an inconsistent picture
14587 of the inferior. It could appear that a library A appears loaded but
14588 a library B does not, even though library A requires library B. That
14589 would present a state that couldn't normally exist in the inferior.
14591 So, skip these events, we'll give the remote a chance to look up symbols
14592 once all the loaded libraries and their symbols are known to GDB. */
14593 if (current_inferior ()->in_initial_library_scan
)
14596 remote
->remote_check_symbols ();
14599 /* Pull all the tracepoints defined on the target and create local
14600 data structures representing them. We don't want to create real
14601 tracepoints yet, we don't want to mess up the user's existing
14605 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14607 struct remote_state
*rs
= get_remote_state ();
14610 /* Ask for a first packet of tracepoint definition. */
14612 getpkt (&rs
->buf
, 0);
14613 p
= rs
->buf
.data ();
14614 while (*p
&& *p
!= 'l')
14616 parse_tracepoint_definition (p
, utpp
);
14617 /* Ask for another packet of tracepoint definition. */
14619 getpkt (&rs
->buf
, 0);
14620 p
= rs
->buf
.data ();
14626 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14628 struct remote_state
*rs
= get_remote_state ();
14631 /* Ask for a first packet of variable definition. */
14633 getpkt (&rs
->buf
, 0);
14634 p
= rs
->buf
.data ();
14635 while (*p
&& *p
!= 'l')
14637 parse_tsv_definition (p
, utsvp
);
14638 /* Ask for another packet of variable definition. */
14640 getpkt (&rs
->buf
, 0);
14641 p
= rs
->buf
.data ();
14646 /* The "set/show range-stepping" show hook. */
14649 show_range_stepping (struct ui_file
*file
, int from_tty
,
14650 struct cmd_list_element
*c
,
14653 fprintf_filtered (file
,
14654 _("Debugger's willingness to use range stepping "
14655 "is %s.\n"), value
);
14658 /* Return true if the vCont;r action is supported by the remote
14662 remote_target::vcont_r_supported ()
14664 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14665 remote_vcont_probe ();
14667 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14668 && get_remote_state ()->supports_vCont
.r
);
14671 /* The "set/show range-stepping" set hook. */
14674 set_range_stepping (const char *ignore_args
, int from_tty
,
14675 struct cmd_list_element
*c
)
14677 /* When enabling, check whether range stepping is actually supported
14678 by the target, and warn if not. */
14679 if (use_range_stepping
)
14681 remote_target
*remote
= get_current_remote_target ();
14683 || !remote
->vcont_r_supported ())
14684 warning (_("Range stepping is not supported by the current target"));
14689 show_remote_debug (struct ui_file
*file
, int from_tty
,
14690 struct cmd_list_element
*c
, const char *value
)
14692 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
14697 show_remote_timeout (struct ui_file
*file
, int from_tty
,
14698 struct cmd_list_element
*c
, const char *value
)
14700 fprintf_filtered (file
,
14701 _("Timeout limit to wait for target to respond is %s.\n"),
14705 /* Implement the "supports_memory_tagging" target_ops method. */
14708 remote_target::supports_memory_tagging ()
14710 return remote_memory_tagging_p ();
14713 /* Create the qMemTags packet given ADDRESS, LEN and TYPE. */
14716 create_fetch_memtags_request (gdb::char_vector
&packet
, CORE_ADDR address
,
14717 size_t len
, int type
)
14719 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
14721 std::string request
= string_printf ("qMemTags:%s,%s:%s",
14722 phex_nz (address
, addr_size
),
14723 phex_nz (len
, sizeof (len
)),
14724 phex_nz (type
, sizeof (type
)));
14726 strcpy (packet
.data (), request
.c_str ());
14729 /* Parse the qMemTags packet reply into TAGS.
14731 Return true if successful, false otherwise. */
14734 parse_fetch_memtags_reply (const gdb::char_vector
&reply
,
14735 gdb::byte_vector
&tags
)
14737 if (reply
.empty () || reply
[0] == 'E' || reply
[0] != 'm')
14740 /* Copy the tag data. */
14741 tags
= hex2bin (reply
.data () + 1);
14746 /* Create the QMemTags packet given ADDRESS, LEN, TYPE and TAGS. */
14749 create_store_memtags_request (gdb::char_vector
&packet
, CORE_ADDR address
,
14750 size_t len
, int type
,
14751 const gdb::byte_vector
&tags
)
14753 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
14755 /* Put together the main packet, address and length. */
14756 std::string request
= string_printf ("QMemTags:%s,%s:%s:",
14757 phex_nz (address
, addr_size
),
14758 phex_nz (len
, sizeof (len
)),
14759 phex_nz (type
, sizeof (type
)));
14760 request
+= bin2hex (tags
.data (), tags
.size ());
14762 /* Check if we have exceeded the maximum packet size. */
14763 if (packet
.size () < request
.length ())
14764 error (_("Contents too big for packet QMemTags."));
14766 strcpy (packet
.data (), request
.c_str ());
14769 /* Implement the "fetch_memtags" target_ops method. */
14772 remote_target::fetch_memtags (CORE_ADDR address
, size_t len
,
14773 gdb::byte_vector
&tags
, int type
)
14775 /* Make sure the qMemTags packet is supported. */
14776 if (!remote_memory_tagging_p ())
14777 gdb_assert_not_reached ("remote fetch_memtags called with packet disabled");
14779 struct remote_state
*rs
= get_remote_state ();
14781 create_fetch_memtags_request (rs
->buf
, address
, len
, type
);
14784 getpkt (&rs
->buf
, 0);
14786 return parse_fetch_memtags_reply (rs
->buf
, tags
);
14789 /* Implement the "store_memtags" target_ops method. */
14792 remote_target::store_memtags (CORE_ADDR address
, size_t len
,
14793 const gdb::byte_vector
&tags
, int type
)
14795 /* Make sure the QMemTags packet is supported. */
14796 if (!remote_memory_tagging_p ())
14797 gdb_assert_not_reached ("remote store_memtags called with packet disabled");
14799 struct remote_state
*rs
= get_remote_state ();
14801 create_store_memtags_request (rs
->buf
, address
, len
, type
, tags
);
14804 getpkt (&rs
->buf
, 0);
14806 /* Verify if the request was successful. */
14807 return packet_check_result (rs
->buf
.data ()) == PACKET_OK
;
14810 /* Return true if remote target T is non-stop. */
14813 remote_target_is_non_stop_p (remote_target
*t
)
14815 scoped_restore_current_thread restore_thread
;
14816 switch_to_target_no_thread (t
);
14818 return target_is_non_stop_p ();
14823 namespace selftests
{
14826 test_memory_tagging_functions ()
14828 remote_target remote
;
14830 struct packet_config
*config
14831 = &remote_protocol_packets
[PACKET_memory_tagging_feature
];
14833 scoped_restore restore_memtag_support_
14834 = make_scoped_restore (&config
->support
);
14836 /* Test memory tagging packet support. */
14837 config
->support
= PACKET_SUPPORT_UNKNOWN
;
14838 SELF_CHECK (remote
.supports_memory_tagging () == false);
14839 config
->support
= PACKET_DISABLE
;
14840 SELF_CHECK (remote
.supports_memory_tagging () == false);
14841 config
->support
= PACKET_ENABLE
;
14842 SELF_CHECK (remote
.supports_memory_tagging () == true);
14844 /* Setup testing. */
14845 gdb::char_vector packet
;
14846 gdb::byte_vector tags
, bv
;
14847 std::string expected
, reply
;
14848 packet
.resize (32000);
14850 /* Test creating a qMemTags request. */
14852 expected
= "qMemTags:0,0:0";
14853 create_fetch_memtags_request (packet
, 0x0, 0x0, 0);
14854 SELF_CHECK (strcmp (packet
.data (), expected
.c_str ()) == 0);
14856 expected
= "qMemTags:deadbeef,10:1";
14857 create_fetch_memtags_request (packet
, 0xdeadbeef, 16, 1);
14858 SELF_CHECK (strcmp (packet
.data (), expected
.c_str ()) == 0);
14860 /* Test parsing a qMemTags reply. */
14862 /* Error reply, tags vector unmodified. */
14864 strcpy (packet
.data (), reply
.c_str ());
14866 SELF_CHECK (parse_fetch_memtags_reply (packet
, tags
) == false);
14867 SELF_CHECK (tags
.size () == 0);
14869 /* Valid reply, tags vector updated. */
14873 for (int i
= 0; i
< 5; i
++)
14876 reply
= "m" + bin2hex (bv
.data (), bv
.size ());
14877 strcpy (packet
.data (), reply
.c_str ());
14879 SELF_CHECK (parse_fetch_memtags_reply (packet
, tags
) == true);
14880 SELF_CHECK (tags
.size () == 5);
14882 for (int i
= 0; i
< 5; i
++)
14883 SELF_CHECK (tags
[i
] == i
);
14885 /* Test creating a QMemTags request. */
14887 /* Empty tag data. */
14889 expected
= "QMemTags:0,0:0:";
14890 create_store_memtags_request (packet
, 0x0, 0x0, 0, tags
);
14891 SELF_CHECK (memcmp (packet
.data (), expected
.c_str (),
14892 expected
.length ()) == 0);
14894 /* Non-empty tag data. */
14896 for (int i
= 0; i
< 5; i
++)
14897 tags
.push_back (i
);
14898 expected
= "QMemTags:deadbeef,ff:1:0001020304";
14899 create_store_memtags_request (packet
, 0xdeadbeef, 255, 1, tags
);
14900 SELF_CHECK (memcmp (packet
.data (), expected
.c_str (),
14901 expected
.length ()) == 0);
14904 } // namespace selftests
14905 #endif /* GDB_SELF_TEST */
14907 void _initialize_remote ();
14909 _initialize_remote ()
14911 /* architecture specific data */
14912 remote_g_packet_data_handle
=
14913 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14915 add_target (remote_target_info
, remote_target::open
);
14916 add_target (extended_remote_target_info
, extended_remote_target::open
);
14918 /* Hook into new objfile notification. */
14919 gdb::observers::new_objfile
.attach (remote_new_objfile
, "remote");
14922 init_remote_threadtests ();
14925 /* set/show remote ... */
14927 add_basic_prefix_cmd ("remote", class_maintenance
, _("\
14928 Remote protocol specific variables.\n\
14929 Configure various remote-protocol specific variables such as\n\
14930 the packets being used."),
14931 &remote_set_cmdlist
,
14932 0 /* allow-unknown */, &setlist
);
14933 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14934 Remote protocol specific variables.\n\
14935 Configure various remote-protocol specific variables such as\n\
14936 the packets being used."),
14937 &remote_show_cmdlist
,
14938 0 /* allow-unknown */, &showlist
);
14940 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14941 Compare section data on target to the exec file.\n\
14942 Argument is a single section name (default: all loaded sections).\n\
14943 To compare only read-only loaded sections, specify the -r option."),
14946 add_cmd ("packet", class_maintenance
, cli_packet_command
, _("\
14947 Send an arbitrary packet to a remote target.\n\
14948 maintenance packet TEXT\n\
14949 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14950 this command sends the string TEXT to the inferior, and displays the\n\
14951 response packet. GDB supplies the initial `$' character, and the\n\
14952 terminating `#' character and checksum."),
14955 set_show_commands remotebreak_cmds
14956 = add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14957 Set whether to send break if interrupted."), _("\
14958 Show whether to send break if interrupted."), _("\
14959 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14960 set_remotebreak
, show_remotebreak
,
14961 &setlist
, &showlist
);
14962 deprecate_cmd (remotebreak_cmds
.set
, "set remote interrupt-sequence");
14963 deprecate_cmd (remotebreak_cmds
.show
, "show remote interrupt-sequence");
14965 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14966 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14968 Set interrupt sequence to remote target."), _("\
14969 Show interrupt sequence to remote target."), _("\
14970 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14971 NULL
, show_interrupt_sequence
,
14972 &remote_set_cmdlist
,
14973 &remote_show_cmdlist
);
14975 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14976 &interrupt_on_connect
, _("\
14977 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14978 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14979 If set, interrupt sequence is sent to remote target."),
14981 &remote_set_cmdlist
, &remote_show_cmdlist
);
14983 /* Install commands for configuring memory read/write packets. */
14985 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14986 Set the maximum number of bytes per memory write packet (deprecated)."),
14988 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14989 Show the maximum number of bytes per memory write packet (deprecated)."),
14991 add_cmd ("memory-write-packet-size", no_class
,
14992 set_memory_write_packet_size
, _("\
14993 Set the maximum number of bytes per memory-write packet.\n\
14994 Specify the number of bytes in a packet or 0 (zero) for the\n\
14995 default packet size. The actual limit is further reduced\n\
14996 dependent on the target. Specify ``fixed'' to disable the\n\
14997 further restriction and ``limit'' to enable that restriction."),
14998 &remote_set_cmdlist
);
14999 add_cmd ("memory-read-packet-size", no_class
,
15000 set_memory_read_packet_size
, _("\
15001 Set the maximum number of bytes per memory-read packet.\n\
15002 Specify the number of bytes in a packet or 0 (zero) for the\n\
15003 default packet size. The actual limit is further reduced\n\
15004 dependent on the target. Specify ``fixed'' to disable the\n\
15005 further restriction and ``limit'' to enable that restriction."),
15006 &remote_set_cmdlist
);
15007 add_cmd ("memory-write-packet-size", no_class
,
15008 show_memory_write_packet_size
,
15009 _("Show the maximum number of bytes per memory-write packet."),
15010 &remote_show_cmdlist
);
15011 add_cmd ("memory-read-packet-size", no_class
,
15012 show_memory_read_packet_size
,
15013 _("Show the maximum number of bytes per memory-read packet."),
15014 &remote_show_cmdlist
);
15016 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
15017 &remote_hw_watchpoint_limit
, _("\
15018 Set the maximum number of target hardware watchpoints."), _("\
15019 Show the maximum number of target hardware watchpoints."), _("\
15020 Specify \"unlimited\" for unlimited hardware watchpoints."),
15021 NULL
, show_hardware_watchpoint_limit
,
15022 &remote_set_cmdlist
,
15023 &remote_show_cmdlist
);
15024 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
15026 &remote_hw_watchpoint_length_limit
, _("\
15027 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
15028 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
15029 Specify \"unlimited\" to allow watchpoints of unlimited size."),
15030 NULL
, show_hardware_watchpoint_length_limit
,
15031 &remote_set_cmdlist
, &remote_show_cmdlist
);
15032 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
15033 &remote_hw_breakpoint_limit
, _("\
15034 Set the maximum number of target hardware breakpoints."), _("\
15035 Show the maximum number of target hardware breakpoints."), _("\
15036 Specify \"unlimited\" for unlimited hardware breakpoints."),
15037 NULL
, show_hardware_breakpoint_limit
,
15038 &remote_set_cmdlist
, &remote_show_cmdlist
);
15040 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
15041 &remote_address_size
, _("\
15042 Set the maximum size of the address (in bits) in a memory packet."), _("\
15043 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
15045 NULL
, /* FIXME: i18n: */
15046 &setlist
, &showlist
);
15048 init_all_packet_configs ();
15050 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
15051 "X", "binary-download", 1);
15053 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
15054 "vCont", "verbose-resume", 0);
15056 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
15057 "QPassSignals", "pass-signals", 0);
15059 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
15060 "QCatchSyscalls", "catch-syscalls", 0);
15062 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
15063 "QProgramSignals", "program-signals", 0);
15065 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
15066 "QSetWorkingDir", "set-working-dir", 0);
15068 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
15069 "QStartupWithShell", "startup-with-shell", 0);
15071 add_packet_config_cmd (&remote_protocol_packets
15072 [PACKET_QEnvironmentHexEncoded
],
15073 "QEnvironmentHexEncoded", "environment-hex-encoded",
15076 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
15077 "QEnvironmentReset", "environment-reset",
15080 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
15081 "QEnvironmentUnset", "environment-unset",
15084 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
15085 "qSymbol", "symbol-lookup", 0);
15087 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
15088 "P", "set-register", 1);
15090 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
15091 "p", "fetch-register", 1);
15093 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
15094 "Z0", "software-breakpoint", 0);
15096 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
15097 "Z1", "hardware-breakpoint", 0);
15099 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
15100 "Z2", "write-watchpoint", 0);
15102 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
15103 "Z3", "read-watchpoint", 0);
15105 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
15106 "Z4", "access-watchpoint", 0);
15108 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
15109 "qXfer:auxv:read", "read-aux-vector", 0);
15111 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
15112 "qXfer:exec-file:read", "pid-to-exec-file", 0);
15114 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
15115 "qXfer:features:read", "target-features", 0);
15117 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
15118 "qXfer:libraries:read", "library-info", 0);
15120 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
15121 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
15123 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
15124 "qXfer:memory-map:read", "memory-map", 0);
15126 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
15127 "qXfer:osdata:read", "osdata", 0);
15129 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
15130 "qXfer:threads:read", "threads", 0);
15132 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
15133 "qXfer:siginfo:read", "read-siginfo-object", 0);
15135 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
15136 "qXfer:siginfo:write", "write-siginfo-object", 0);
15138 add_packet_config_cmd
15139 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
15140 "qXfer:traceframe-info:read", "traceframe-info", 0);
15142 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
15143 "qXfer:uib:read", "unwind-info-block", 0);
15145 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
15146 "qGetTLSAddr", "get-thread-local-storage-address",
15149 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
15150 "qGetTIBAddr", "get-thread-information-block-address",
15153 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
15154 "bc", "reverse-continue", 0);
15156 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
15157 "bs", "reverse-step", 0);
15159 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
15160 "qSupported", "supported-packets", 0);
15162 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
15163 "qSearch:memory", "search-memory", 0);
15165 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
15166 "qTStatus", "trace-status", 0);
15168 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
15169 "vFile:setfs", "hostio-setfs", 0);
15171 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
15172 "vFile:open", "hostio-open", 0);
15174 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
15175 "vFile:pread", "hostio-pread", 0);
15177 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
15178 "vFile:pwrite", "hostio-pwrite", 0);
15180 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
15181 "vFile:close", "hostio-close", 0);
15183 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
15184 "vFile:unlink", "hostio-unlink", 0);
15186 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
15187 "vFile:readlink", "hostio-readlink", 0);
15189 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
15190 "vFile:fstat", "hostio-fstat", 0);
15192 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
15193 "vAttach", "attach", 0);
15195 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
15198 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
15199 "QStartNoAckMode", "noack", 0);
15201 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
15202 "vKill", "kill", 0);
15204 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
15205 "qAttached", "query-attached", 0);
15207 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
15208 "ConditionalTracepoints",
15209 "conditional-tracepoints", 0);
15211 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
15212 "ConditionalBreakpoints",
15213 "conditional-breakpoints", 0);
15215 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
15216 "BreakpointCommands",
15217 "breakpoint-commands", 0);
15219 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
15220 "FastTracepoints", "fast-tracepoints", 0);
15222 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
15223 "TracepointSource", "TracepointSource", 0);
15225 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
15226 "QAllow", "allow", 0);
15228 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
15229 "StaticTracepoints", "static-tracepoints", 0);
15231 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
15232 "InstallInTrace", "install-in-trace", 0);
15234 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
15235 "qXfer:statictrace:read", "read-sdata-object", 0);
15237 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
15238 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
15240 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
15241 "QDisableRandomization", "disable-randomization", 0);
15243 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
15244 "QAgent", "agent", 0);
15246 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
15247 "QTBuffer:size", "trace-buffer-size", 0);
15249 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
15250 "Qbtrace:off", "disable-btrace", 0);
15252 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
15253 "Qbtrace:bts", "enable-btrace-bts", 0);
15255 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
15256 "Qbtrace:pt", "enable-btrace-pt", 0);
15258 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
15259 "qXfer:btrace", "read-btrace", 0);
15261 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
15262 "qXfer:btrace-conf", "read-btrace-conf", 0);
15264 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
15265 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
15267 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
15268 "multiprocess-feature", "multiprocess-feature", 0);
15270 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
15271 "swbreak-feature", "swbreak-feature", 0);
15273 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
15274 "hwbreak-feature", "hwbreak-feature", 0);
15276 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
15277 "fork-event-feature", "fork-event-feature", 0);
15279 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
15280 "vfork-event-feature", "vfork-event-feature", 0);
15282 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
15283 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
15285 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
15286 "vContSupported", "verbose-resume-supported", 0);
15288 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
15289 "exec-event-feature", "exec-event-feature", 0);
15291 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
15292 "vCtrlC", "ctrl-c", 0);
15294 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
15295 "QThreadEvents", "thread-events", 0);
15297 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
15298 "N stop reply", "no-resumed-stop-reply", 0);
15300 add_packet_config_cmd (&remote_protocol_packets
[PACKET_memory_tagging_feature
],
15301 "memory-tagging-feature", "memory-tagging-feature", 0);
15303 /* Assert that we've registered "set remote foo-packet" commands
15304 for all packet configs. */
15308 for (i
= 0; i
< PACKET_MAX
; i
++)
15310 /* Ideally all configs would have a command associated. Some
15311 still don't though. */
15316 case PACKET_QNonStop
:
15317 case PACKET_EnableDisableTracepoints_feature
:
15318 case PACKET_tracenz_feature
:
15319 case PACKET_DisconnectedTracing_feature
:
15320 case PACKET_augmented_libraries_svr4_read_feature
:
15322 /* Additions to this list need to be well justified:
15323 pre-existing packets are OK; new packets are not. */
15331 /* This catches both forgetting to add a config command, and
15332 forgetting to remove a packet from the exception list. */
15333 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
15337 /* Keep the old ``set remote Z-packet ...'' working. Each individual
15338 Z sub-packet has its own set and show commands, but users may
15339 have sets to this variable in their .gdbinit files (or in their
15341 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
15342 &remote_Z_packet_detect
, _("\
15343 Set use of remote protocol `Z' packets."), _("\
15344 Show use of remote protocol `Z' packets."), _("\
15345 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
15347 set_remote_protocol_Z_packet_cmd
,
15348 show_remote_protocol_Z_packet_cmd
,
15349 /* FIXME: i18n: Use of remote protocol
15350 `Z' packets is %s. */
15351 &remote_set_cmdlist
, &remote_show_cmdlist
);
15353 add_basic_prefix_cmd ("remote", class_files
, _("\
15354 Manipulate files on the remote system.\n\
15355 Transfer files to and from the remote target system."),
15357 0 /* allow-unknown */, &cmdlist
);
15359 add_cmd ("put", class_files
, remote_put_command
,
15360 _("Copy a local file to the remote system."),
15363 add_cmd ("get", class_files
, remote_get_command
,
15364 _("Copy a remote file to the local system."),
15367 add_cmd ("delete", class_files
, remote_delete_command
,
15368 _("Delete a remote file."),
15371 add_setshow_string_noescape_cmd ("exec-file", class_files
,
15372 &remote_exec_file_var
, _("\
15373 Set the remote pathname for \"run\"."), _("\
15374 Show the remote pathname for \"run\"."), NULL
,
15375 set_remote_exec_file
,
15376 show_remote_exec_file
,
15377 &remote_set_cmdlist
,
15378 &remote_show_cmdlist
);
15380 add_setshow_boolean_cmd ("range-stepping", class_run
,
15381 &use_range_stepping
, _("\
15382 Enable or disable range stepping."), _("\
15383 Show whether target-assisted range stepping is enabled."), _("\
15384 If on, and the target supports it, when stepping a source line, GDB\n\
15385 tells the target to step the corresponding range of addresses itself instead\n\
15386 of issuing multiple single-steps. This speeds up source level\n\
15387 stepping. If off, GDB always issues single-steps, even if range\n\
15388 stepping is supported by the target. The default is on."),
15389 set_range_stepping
,
15390 show_range_stepping
,
15394 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
15395 Set watchdog timer."), _("\
15396 Show watchdog timer."), _("\
15397 When non-zero, this timeout is used instead of waiting forever for a target\n\
15398 to finish a low-level step or continue operation. If the specified amount\n\
15399 of time passes without a response from the target, an error occurs."),
15402 &setlist
, &showlist
);
15404 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
15405 &remote_packet_max_chars
, _("\
15406 Set the maximum number of characters to display for each remote packet."), _("\
15407 Show the maximum number of characters to display for each remote packet."), _("\
15408 Specify \"unlimited\" to display all the characters."),
15409 NULL
, show_remote_packet_max_chars
,
15410 &setdebuglist
, &showdebuglist
);
15412 add_setshow_boolean_cmd ("remote", no_class
, &remote_debug
,
15413 _("Set debugging of remote protocol."),
15414 _("Show debugging of remote protocol."),
15416 When enabled, each packet sent or received with the remote target\n\
15420 &setdebuglist
, &showdebuglist
);
15422 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
15423 &remote_timeout
, _("\
15424 Set timeout limit to wait for target to respond."), _("\
15425 Show timeout limit to wait for target to respond."), _("\
15426 This value is used to set the time limit for gdb to wait for a response\n\
15427 from the target."),
15429 show_remote_timeout
,
15430 &setlist
, &showlist
);
15432 /* Eventually initialize fileio. See fileio.c */
15433 initialize_remote_fileio (&remote_set_cmdlist
, &remote_show_cmdlist
);
15436 selftests::register_test ("remote_memory_tagging",
15437 selftests::test_memory_tagging_functions
);