1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2021 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"
83 /* The remote target. */
85 static const char remote_doc
[] = N_("\
86 Use a remote computer via a serial line, using a gdb-specific protocol.\n\
87 Specify the serial device it is connected to\n\
88 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
92 bool remote_debug
= false;
94 #define OPAQUETHREADBYTES 8
96 /* a 64 bit opaque identifier */
97 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
99 struct gdb_ext_thread_info
;
100 struct threads_listing_context
;
101 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
102 struct protocol_feature
;
106 typedef std::unique_ptr
<stop_reply
> stop_reply_up
;
108 /* Generic configuration support for packets the stub optionally
109 supports. Allows the user to specify the use of the packet as well
110 as allowing GDB to auto-detect support in the remote stub. */
114 PACKET_SUPPORT_UNKNOWN
= 0,
119 /* Analyze a packet's return value and update the packet config
129 struct threads_listing_context
;
131 /* Stub vCont actions support.
133 Each field is a boolean flag indicating whether the stub reports
134 support for the corresponding action. */
136 struct vCont_action_support
151 /* About this many threadids fit in a packet. */
153 #define MAXTHREADLISTRESULTS 32
155 /* Data for the vFile:pread readahead cache. */
157 struct readahead_cache
159 /* Invalidate the readahead cache. */
162 /* Invalidate the readahead cache if it is holding data for FD. */
163 void invalidate_fd (int fd
);
165 /* Serve pread from the readahead cache. Returns number of bytes
166 read, or 0 if the request can't be served from the cache. */
167 int pread (int fd
, gdb_byte
*read_buf
, size_t len
, ULONGEST offset
);
169 /* The file descriptor for the file that is being cached. -1 if the
173 /* The offset into the file that the cache buffer corresponds
177 /* The buffer holding the cache contents. */
178 gdb_byte
*buf
= nullptr;
179 /* The buffer's size. We try to read as much as fits into a packet
183 /* Cache hit and miss counters. */
184 ULONGEST hit_count
= 0;
185 ULONGEST miss_count
= 0;
188 /* Description of the remote protocol for a given architecture. */
192 long offset
; /* Offset into G packet. */
193 long regnum
; /* GDB's internal register number. */
194 LONGEST pnum
; /* Remote protocol register number. */
195 int in_g_packet
; /* Always part of G packet. */
196 /* long size in bytes; == register_size (target_gdbarch (), regnum);
198 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
202 struct remote_arch_state
204 explicit remote_arch_state (struct gdbarch
*gdbarch
);
206 /* Description of the remote protocol registers. */
207 long sizeof_g_packet
;
209 /* Description of the remote protocol registers indexed by REGNUM
210 (making an array gdbarch_num_regs in size). */
211 std::unique_ptr
<packet_reg
[]> regs
;
213 /* This is the size (in chars) of the first response to the ``g''
214 packet. It is used as a heuristic when determining the maximum
215 size of memory-read and memory-write packets. A target will
216 typically only reserve a buffer large enough to hold the ``g''
217 packet. The size does not include packet overhead (headers and
219 long actual_register_packet_size
;
221 /* This is the maximum size (in chars) of a non read/write packet.
222 It is also used as a cap on the size of read/write packets. */
223 long remote_packet_size
;
226 /* Description of the remote protocol state for the currently
227 connected target. This is per-target state, and independent of the
228 selected architecture. */
237 /* Get the remote arch state for GDBARCH. */
238 struct remote_arch_state
*get_remote_arch_state (struct gdbarch
*gdbarch
);
242 /* A buffer to use for incoming packets, and its current size. The
243 buffer is grown dynamically for larger incoming packets.
244 Outgoing packets may also be constructed in this buffer.
245 The size of the buffer is always at least REMOTE_PACKET_SIZE;
246 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
248 gdb::char_vector buf
;
250 /* True if we're going through initial connection setup (finding out
251 about the remote side's threads, relocating symbols, etc.). */
252 bool starting_up
= false;
254 /* If we negotiated packet size explicitly (and thus can bypass
255 heuristics for the largest packet size that will not overflow
256 a buffer in the stub), this will be set to that packet size.
257 Otherwise zero, meaning to use the guessed size. */
258 long explicit_packet_size
= 0;
260 /* remote_wait is normally called when the target is running and
261 waits for a stop reply packet. But sometimes we need to call it
262 when the target is already stopped. We can send a "?" packet
263 and have remote_wait read the response. Or, if we already have
264 the response, we can stash it in BUF and tell remote_wait to
265 skip calling getpkt. This flag is set when BUF contains a
266 stop reply packet and the target is not waiting. */
267 int cached_wait_status
= 0;
269 /* True, if in no ack mode. That is, neither GDB nor the stub will
270 expect acks from each other. The connection is assumed to be
272 bool noack_mode
= false;
274 /* True if we're connected in extended remote mode. */
275 bool extended
= false;
277 /* True if we resumed the target and we're waiting for the target to
278 stop. In the mean time, we can't start another command/query.
279 The remote server wouldn't be ready to process it, so we'd
280 timeout waiting for a reply that would never come and eventually
281 we'd close the connection. This can happen in asynchronous mode
282 because we allow GDB commands while the target is running. */
283 bool waiting_for_stop_reply
= false;
285 /* The status of the stub support for the various vCont actions. */
286 vCont_action_support supports_vCont
;
287 /* Whether vCont support was probed already. This is a workaround
288 until packet_support is per-connection. */
289 bool supports_vCont_probed
;
291 /* True if the user has pressed Ctrl-C, but the target hasn't
292 responded to that. */
293 bool ctrlc_pending_p
= false;
295 /* True if we saw a Ctrl-C while reading or writing from/to the
296 remote descriptor. At that point it is not safe to send a remote
297 interrupt packet, so we instead remember we saw the Ctrl-C and
298 process it once we're done with sending/receiving the current
299 packet, which should be shortly. If however that takes too long,
300 and the user presses Ctrl-C again, we offer to disconnect. */
301 bool got_ctrlc_during_io
= false;
303 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
304 remote_open knows that we don't have a file open when the program
306 struct serial
*remote_desc
= nullptr;
308 /* These are the threads which we last sent to the remote system. The
309 TID member will be -1 for all or -2 for not sent yet. */
310 ptid_t general_thread
= null_ptid
;
311 ptid_t continue_thread
= null_ptid
;
313 /* This is the traceframe which we last selected on the remote system.
314 It will be -1 if no traceframe is selected. */
315 int remote_traceframe_number
= -1;
317 char *last_pass_packet
= nullptr;
319 /* The last QProgramSignals packet sent to the target. We bypass
320 sending a new program signals list down to the target if the new
321 packet is exactly the same as the last we sent. IOW, we only let
322 the target know about program signals list changes. */
323 char *last_program_signals_packet
= nullptr;
325 gdb_signal last_sent_signal
= GDB_SIGNAL_0
;
327 bool last_sent_step
= false;
329 /* The execution direction of the last resume we got. */
330 exec_direction_kind last_resume_exec_dir
= EXEC_FORWARD
;
332 char *finished_object
= nullptr;
333 char *finished_annex
= nullptr;
334 ULONGEST finished_offset
= 0;
336 /* Should we try the 'ThreadInfo' query packet?
338 This variable (NOT available to the user: auto-detect only!)
339 determines whether GDB will use the new, simpler "ThreadInfo"
340 query or the older, more complex syntax for thread queries.
341 This is an auto-detect variable (set to true at each connect,
342 and set to false when the target fails to recognize it). */
343 bool use_threadinfo_query
= false;
344 bool use_threadextra_query
= false;
346 threadref echo_nextthread
{};
347 threadref nextthread
{};
348 threadref resultthreadlist
[MAXTHREADLISTRESULTS
] {};
350 /* The state of remote notification. */
351 struct remote_notif_state
*notif_state
= nullptr;
353 /* The branch trace configuration. */
354 struct btrace_config btrace_config
{};
356 /* The argument to the last "vFile:setfs:" packet we sent, used
357 to avoid sending repeated unnecessary "vFile:setfs:" packets.
358 Initialized to -1 to indicate that no "vFile:setfs:" packet
359 has yet been sent. */
362 /* A readahead cache for vFile:pread. Often, reading a binary
363 involves a sequence of small reads. E.g., when parsing an ELF
364 file. A readahead cache helps mostly the case of remote
365 debugging on a connection with higher latency, due to the
366 request/reply nature of the RSP. We only cache data for a single
367 file descriptor at a time. */
368 struct readahead_cache readahead_cache
;
370 /* The list of already fetched and acknowledged stop events. This
371 queue is used for notification Stop, and other notifications
372 don't need queue for their events, because the notification
373 events of Stop can't be consumed immediately, so that events
374 should be queued first, and be consumed by remote_wait_{ns,as}
375 one per time. Other notifications can consume their events
376 immediately, so queue is not needed for them. */
377 std::vector
<stop_reply_up
> stop_reply_queue
;
379 /* Asynchronous signal handle registered as event loop source for
380 when we have pending events ready to be passed to the core. */
381 struct async_event_handler
*remote_async_inferior_event_token
= nullptr;
383 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
384 ``forever'' still use the normal timeout mechanism. This is
385 currently used by the ASYNC code to guarentee that target reads
386 during the initial connect always time-out. Once getpkt has been
387 modified to return a timeout indication and, in turn
388 remote_wait()/wait_for_inferior() have gained a timeout parameter
390 int wait_forever_enabled_p
= 1;
393 /* Mapping of remote protocol data for each gdbarch. Usually there
394 is only one entry here, though we may see more with stubs that
395 support multi-process. */
396 std::unordered_map
<struct gdbarch
*, remote_arch_state
>
400 static const target_info remote_target_info
= {
402 N_("Remote serial target in gdb-specific protocol"),
406 class remote_target
: public process_stratum_target
409 remote_target () = default;
410 ~remote_target () override
;
412 const target_info
&info () const override
413 { return remote_target_info
; }
415 const char *connection_string () override
;
417 thread_control_capabilities
get_thread_control_capabilities () override
418 { return tc_schedlock
; }
420 /* Open a remote connection. */
421 static void open (const char *, int);
423 void close () override
;
425 void detach (inferior
*, int) override
;
426 void disconnect (const char *, int) override
;
428 void commit_resume () override
;
429 void resume (ptid_t
, int, enum gdb_signal
) override
;
430 ptid_t
wait (ptid_t
, struct target_waitstatus
*, target_wait_flags
) override
;
432 void fetch_registers (struct regcache
*, int) override
;
433 void store_registers (struct regcache
*, int) override
;
434 void prepare_to_store (struct regcache
*) override
;
436 void files_info () override
;
438 int insert_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
440 int remove_breakpoint (struct gdbarch
*, struct bp_target_info
*,
441 enum remove_bp_reason
) override
;
444 bool stopped_by_sw_breakpoint () override
;
445 bool supports_stopped_by_sw_breakpoint () override
;
447 bool stopped_by_hw_breakpoint () override
;
449 bool supports_stopped_by_hw_breakpoint () override
;
451 bool stopped_by_watchpoint () override
;
453 bool stopped_data_address (CORE_ADDR
*) override
;
455 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
457 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
459 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
461 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
463 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
465 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
466 struct expression
*) override
;
468 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
469 struct expression
*) override
;
471 void kill () override
;
473 void load (const char *, int) override
;
475 void mourn_inferior () override
;
477 void pass_signals (gdb::array_view
<const unsigned char>) override
;
479 int set_syscall_catchpoint (int, bool, int,
480 gdb::array_view
<const int>) override
;
482 void program_signals (gdb::array_view
<const unsigned char>) override
;
484 bool thread_alive (ptid_t ptid
) override
;
486 const char *thread_name (struct thread_info
*) override
;
488 void update_thread_list () override
;
490 std::string
pid_to_str (ptid_t
) override
;
492 const char *extra_thread_info (struct thread_info
*) override
;
494 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
496 thread_info
*thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
498 inferior
*inf
) override
;
500 gdb::byte_vector
thread_info_to_thread_handle (struct thread_info
*tp
)
503 void stop (ptid_t
) override
;
505 void interrupt () override
;
507 void pass_ctrlc () override
;
509 enum target_xfer_status
xfer_partial (enum target_object object
,
512 const gdb_byte
*writebuf
,
513 ULONGEST offset
, ULONGEST len
,
514 ULONGEST
*xfered_len
) override
;
516 ULONGEST
get_memory_xfer_limit () override
;
518 void rcmd (const char *command
, struct ui_file
*output
) override
;
520 char *pid_to_exec_file (int pid
) override
;
522 void log_command (const char *cmd
) override
524 serial_log_command (this, cmd
);
527 CORE_ADDR
get_thread_local_address (ptid_t ptid
,
528 CORE_ADDR load_module_addr
,
529 CORE_ADDR offset
) override
;
531 bool can_execute_reverse () override
;
533 std::vector
<mem_region
> memory_map () override
;
535 void flash_erase (ULONGEST address
, LONGEST length
) override
;
537 void flash_done () override
;
539 const struct target_desc
*read_description () override
;
541 int search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
542 const gdb_byte
*pattern
, ULONGEST pattern_len
,
543 CORE_ADDR
*found_addrp
) override
;
545 bool can_async_p () override
;
547 bool is_async_p () override
;
549 void async (int) override
;
551 int async_wait_fd () override
;
553 void thread_events (int) override
;
555 int can_do_single_step () override
;
557 void terminal_inferior () override
;
559 void terminal_ours () override
;
561 bool supports_non_stop () override
;
563 bool supports_multi_process () override
;
565 bool supports_disable_randomization () override
;
567 bool filesystem_is_local () override
;
570 int fileio_open (struct inferior
*inf
, const char *filename
,
571 int flags
, int mode
, int warn_if_slow
,
572 int *target_errno
) override
;
574 int fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
575 ULONGEST offset
, int *target_errno
) override
;
577 int fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
578 ULONGEST offset
, int *target_errno
) override
;
580 int fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
) override
;
582 int fileio_close (int fd
, int *target_errno
) override
;
584 int fileio_unlink (struct inferior
*inf
,
585 const char *filename
,
586 int *target_errno
) override
;
588 gdb::optional
<std::string
>
589 fileio_readlink (struct inferior
*inf
,
590 const char *filename
,
591 int *target_errno
) override
;
593 bool supports_enable_disable_tracepoint () override
;
595 bool supports_string_tracing () override
;
597 bool supports_evaluation_of_breakpoint_conditions () override
;
599 bool can_run_breakpoint_commands () override
;
601 void trace_init () override
;
603 void download_tracepoint (struct bp_location
*location
) override
;
605 bool can_download_tracepoint () override
;
607 void download_trace_state_variable (const trace_state_variable
&tsv
) override
;
609 void enable_tracepoint (struct bp_location
*location
) override
;
611 void disable_tracepoint (struct bp_location
*location
) override
;
613 void trace_set_readonly_regions () override
;
615 void trace_start () override
;
617 int get_trace_status (struct trace_status
*ts
) override
;
619 void get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
622 void trace_stop () override
;
624 int trace_find (enum trace_find_type type
, int num
,
625 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
) override
;
627 bool get_trace_state_variable_value (int tsv
, LONGEST
*val
) override
;
629 int save_trace_data (const char *filename
) override
;
631 int upload_tracepoints (struct uploaded_tp
**utpp
) override
;
633 int upload_trace_state_variables (struct uploaded_tsv
**utsvp
) override
;
635 LONGEST
get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
) override
;
637 int get_min_fast_tracepoint_insn_len () override
;
639 void set_disconnected_tracing (int val
) override
;
641 void set_circular_trace_buffer (int val
) override
;
643 void set_trace_buffer_size (LONGEST val
) override
;
645 bool set_trace_notes (const char *user
, const char *notes
,
646 const char *stopnotes
) override
;
648 int core_of_thread (ptid_t ptid
) override
;
650 int verify_memory (const gdb_byte
*data
,
651 CORE_ADDR memaddr
, ULONGEST size
) override
;
654 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
656 void set_permissions () override
;
658 bool static_tracepoint_marker_at (CORE_ADDR
,
659 struct static_tracepoint_marker
*marker
)
662 std::vector
<static_tracepoint_marker
>
663 static_tracepoint_markers_by_strid (const char *id
) override
;
665 traceframe_info_up
traceframe_info () override
;
667 bool use_agent (bool use
) override
;
668 bool can_use_agent () override
;
670 struct btrace_target_info
*enable_btrace (ptid_t ptid
,
671 const struct btrace_config
*conf
) override
;
673 void disable_btrace (struct btrace_target_info
*tinfo
) override
;
675 void teardown_btrace (struct btrace_target_info
*tinfo
) override
;
677 enum btrace_error
read_btrace (struct btrace_data
*data
,
678 struct btrace_target_info
*btinfo
,
679 enum btrace_read_type type
) override
;
681 const struct btrace_config
*btrace_conf (const struct btrace_target_info
*) override
;
682 bool augmented_libraries_svr4_read () override
;
683 bool follow_fork (bool, bool) override
;
684 void follow_exec (struct inferior
*, const char *) override
;
685 int insert_fork_catchpoint (int) override
;
686 int remove_fork_catchpoint (int) override
;
687 int insert_vfork_catchpoint (int) override
;
688 int remove_vfork_catchpoint (int) override
;
689 int insert_exec_catchpoint (int) override
;
690 int remove_exec_catchpoint (int) override
;
691 enum exec_direction_kind
execution_direction () override
;
693 bool supports_memory_tagging () override
;
695 bool fetch_memtags (CORE_ADDR address
, size_t len
,
696 gdb::byte_vector
&tags
, int type
) override
;
698 bool store_memtags (CORE_ADDR address
, size_t len
,
699 const gdb::byte_vector
&tags
, int type
) override
;
701 public: /* Remote specific methods. */
703 void remote_download_command_source (int num
, ULONGEST addr
,
704 struct command_line
*cmds
);
706 void remote_file_put (const char *local_file
, const char *remote_file
,
708 void remote_file_get (const char *remote_file
, const char *local_file
,
710 void remote_file_delete (const char *remote_file
, int from_tty
);
712 int remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
713 ULONGEST offset
, int *remote_errno
);
714 int remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
715 ULONGEST offset
, int *remote_errno
);
716 int remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
717 ULONGEST offset
, int *remote_errno
);
719 int remote_hostio_send_command (int command_bytes
, int which_packet
,
720 int *remote_errno
, const char **attachment
,
721 int *attachment_len
);
722 int remote_hostio_set_filesystem (struct inferior
*inf
,
724 /* We should get rid of this and use fileio_open directly. */
725 int remote_hostio_open (struct inferior
*inf
, const char *filename
,
726 int flags
, int mode
, int warn_if_slow
,
728 int remote_hostio_close (int fd
, int *remote_errno
);
730 int remote_hostio_unlink (inferior
*inf
, const char *filename
,
733 struct remote_state
*get_remote_state ();
735 long get_remote_packet_size (void);
736 long get_memory_packet_size (struct memory_packet_config
*config
);
738 long get_memory_write_packet_size ();
739 long get_memory_read_packet_size ();
741 char *append_pending_thread_resumptions (char *p
, char *endp
,
743 static void open_1 (const char *name
, int from_tty
, int extended_p
);
744 void start_remote (int from_tty
, int extended_p
);
745 void remote_detach_1 (struct inferior
*inf
, int from_tty
);
747 char *append_resumption (char *p
, char *endp
,
748 ptid_t ptid
, int step
, gdb_signal siggnal
);
749 int remote_resume_with_vcont (ptid_t ptid
, int step
,
752 thread_info
*add_current_inferior_and_thread (const char *wait_status
);
754 ptid_t
wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
755 target_wait_flags options
);
756 ptid_t
wait_as (ptid_t ptid
, target_waitstatus
*status
,
757 target_wait_flags options
);
759 ptid_t
process_stop_reply (struct stop_reply
*stop_reply
,
760 target_waitstatus
*status
);
762 ptid_t select_thread_for_ambiguous_stop_reply
763 (const struct target_waitstatus
*status
);
765 void remote_notice_new_inferior (ptid_t currthread
, int executing
);
767 void process_initial_stop_replies (int from_tty
);
769 thread_info
*remote_add_thread (ptid_t ptid
, bool running
, bool executing
);
771 void btrace_sync_conf (const btrace_config
*conf
);
773 void remote_btrace_maybe_reopen ();
775 void remove_new_fork_children (threads_listing_context
*context
);
776 void kill_new_fork_children (int pid
);
777 void discard_pending_stop_replies (struct inferior
*inf
);
778 int stop_reply_queue_length ();
780 void check_pending_events_prevent_wildcard_vcont
781 (int *may_global_wildcard_vcont
);
783 void discard_pending_stop_replies_in_queue ();
784 struct stop_reply
*remote_notif_remove_queued_reply (ptid_t ptid
);
785 struct stop_reply
*queued_stop_reply (ptid_t ptid
);
786 int peek_stop_reply (ptid_t ptid
);
787 void remote_parse_stop_reply (const char *buf
, stop_reply
*event
);
789 void remote_stop_ns (ptid_t ptid
);
790 void remote_interrupt_as ();
791 void remote_interrupt_ns ();
793 char *remote_get_noisy_reply ();
794 int remote_query_attached (int pid
);
795 inferior
*remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
798 ptid_t
remote_current_thread (ptid_t oldpid
);
799 ptid_t
get_current_thread (const char *wait_status
);
801 void set_thread (ptid_t ptid
, int gen
);
802 void set_general_thread (ptid_t ptid
);
803 void set_continue_thread (ptid_t ptid
);
804 void set_general_process ();
806 char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
808 int remote_unpack_thread_info_response (const char *pkt
, threadref
*expectedref
,
809 gdb_ext_thread_info
*info
);
810 int remote_get_threadinfo (threadref
*threadid
, int fieldset
,
811 gdb_ext_thread_info
*info
);
813 int parse_threadlist_response (const char *pkt
, int result_limit
,
814 threadref
*original_echo
,
815 threadref
*resultlist
,
817 int remote_get_threadlist (int startflag
, threadref
*nextthread
,
818 int result_limit
, int *done
, int *result_count
,
819 threadref
*threadlist
);
821 int remote_threadlist_iterator (rmt_thread_action stepfunction
,
822 void *context
, int looplimit
);
824 int remote_get_threads_with_ql (threads_listing_context
*context
);
825 int remote_get_threads_with_qxfer (threads_listing_context
*context
);
826 int remote_get_threads_with_qthreadinfo (threads_listing_context
*context
);
828 void extended_remote_restart ();
832 void remote_check_symbols ();
834 void remote_supported_packet (const struct protocol_feature
*feature
,
835 enum packet_support support
,
836 const char *argument
);
838 void remote_query_supported ();
840 void remote_packet_size (const protocol_feature
*feature
,
841 packet_support support
, const char *value
);
843 void remote_serial_quit_handler ();
845 void remote_detach_pid (int pid
);
847 void remote_vcont_probe ();
849 void remote_resume_with_hc (ptid_t ptid
, int step
,
852 void send_interrupt_sequence ();
853 void interrupt_query ();
855 void remote_notif_get_pending_events (notif_client
*nc
);
857 int fetch_register_using_p (struct regcache
*regcache
,
859 int send_g_packet ();
860 void process_g_packet (struct regcache
*regcache
);
861 void fetch_registers_using_g (struct regcache
*regcache
);
862 int store_register_using_P (const struct regcache
*regcache
,
864 void store_registers_using_G (const struct regcache
*regcache
);
866 void set_remote_traceframe ();
868 void check_binary_download (CORE_ADDR addr
);
870 target_xfer_status
remote_write_bytes_aux (const char *header
,
872 const gdb_byte
*myaddr
,
875 ULONGEST
*xfered_len_units
,
879 target_xfer_status
remote_write_bytes (CORE_ADDR memaddr
,
880 const gdb_byte
*myaddr
, ULONGEST len
,
881 int unit_size
, ULONGEST
*xfered_len
);
883 target_xfer_status
remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
885 int unit_size
, ULONGEST
*xfered_len_units
);
887 target_xfer_status
remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
891 ULONGEST
*xfered_len
);
893 target_xfer_status
remote_read_bytes (CORE_ADDR memaddr
,
894 gdb_byte
*myaddr
, ULONGEST len
,
896 ULONGEST
*xfered_len
);
898 packet_result
remote_send_printf (const char *format
, ...)
899 ATTRIBUTE_PRINTF (2, 3);
901 target_xfer_status
remote_flash_write (ULONGEST address
,
902 ULONGEST length
, ULONGEST
*xfered_len
,
903 const gdb_byte
*data
);
905 int readchar (int timeout
);
907 void remote_serial_write (const char *str
, int len
);
909 int putpkt (const char *buf
);
910 int putpkt_binary (const char *buf
, int cnt
);
912 int putpkt (const gdb::char_vector
&buf
)
914 return putpkt (buf
.data ());
918 long read_frame (gdb::char_vector
*buf_p
);
919 void getpkt (gdb::char_vector
*buf
, int forever
);
920 int getpkt_or_notif_sane_1 (gdb::char_vector
*buf
, int forever
,
921 int expecting_notif
, int *is_notif
);
922 int getpkt_sane (gdb::char_vector
*buf
, int forever
);
923 int getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
925 int remote_vkill (int pid
);
926 void remote_kill_k ();
928 void extended_remote_disable_randomization (int val
);
929 int extended_remote_run (const std::string
&args
);
931 void send_environment_packet (const char *action
,
935 void extended_remote_environment_support ();
936 void extended_remote_set_inferior_cwd ();
938 target_xfer_status
remote_write_qxfer (const char *object_name
,
940 const gdb_byte
*writebuf
,
941 ULONGEST offset
, LONGEST len
,
942 ULONGEST
*xfered_len
,
943 struct packet_config
*packet
);
945 target_xfer_status
remote_read_qxfer (const char *object_name
,
947 gdb_byte
*readbuf
, ULONGEST offset
,
949 ULONGEST
*xfered_len
,
950 struct packet_config
*packet
);
952 void push_stop_reply (struct stop_reply
*new_event
);
954 bool vcont_r_supported ();
956 void packet_command (const char *args
, int from_tty
);
958 private: /* data fields */
960 /* The remote state. Don't reference this directly. Use the
961 get_remote_state method instead. */
962 remote_state m_remote_state
;
965 static const target_info extended_remote_target_info
= {
967 N_("Extended remote serial target in gdb-specific protocol"),
971 /* Set up the extended remote target by extending the standard remote
972 target and adding to it. */
974 class extended_remote_target final
: public remote_target
977 const target_info
&info () const override
978 { return extended_remote_target_info
; }
980 /* Open an extended-remote connection. */
981 static void open (const char *, int);
983 bool can_create_inferior () override
{ return true; }
984 void create_inferior (const char *, const std::string
&,
985 char **, int) override
;
987 void detach (inferior
*, int) override
;
989 bool can_attach () override
{ return true; }
990 void attach (const char *, int) override
;
992 void post_attach (int) override
;
993 bool supports_disable_randomization () override
;
996 /* Per-program-space data key. */
997 static const struct program_space_key
<char, gdb::xfree_deleter
<char>>
1000 /* The variable registered as the control variable used by the
1001 remote exec-file commands. While the remote exec-file setting is
1002 per-program-space, the set/show machinery uses this as the
1003 location of the remote exec-file value. */
1004 static char *remote_exec_file_var
;
1006 /* The size to align memory write packets, when practical. The protocol
1007 does not guarantee any alignment, and gdb will generate short
1008 writes and unaligned writes, but even as a best-effort attempt this
1009 can improve bulk transfers. For instance, if a write is misaligned
1010 relative to the target's data bus, the stub may need to make an extra
1011 round trip fetching data from the target. This doesn't make a
1012 huge difference, but it's easy to do, so we try to be helpful.
1014 The alignment chosen is arbitrary; usually data bus width is
1015 important here, not the possibly larger cache line size. */
1016 enum { REMOTE_ALIGN_WRITES
= 16 };
1018 /* Prototypes for local functions. */
1020 static int hexnumlen (ULONGEST num
);
1022 static int stubhex (int ch
);
1024 static int hexnumstr (char *, ULONGEST
);
1026 static int hexnumnstr (char *, ULONGEST
, int);
1028 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
1030 static void print_packet (const char *);
1032 static int stub_unpack_int (const char *buff
, int fieldlength
);
1034 struct packet_config
;
1036 static void show_packet_config_cmd (struct packet_config
*config
);
1038 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
1040 struct cmd_list_element
*c
,
1043 static ptid_t
read_ptid (const char *buf
, const char **obuf
);
1045 static void remote_async_inferior_event_handler (gdb_client_data
);
1047 static bool remote_read_description_p (struct target_ops
*target
);
1049 static void remote_console_output (const char *msg
);
1051 static void remote_btrace_reset (remote_state
*rs
);
1053 static void remote_unpush_and_throw (remote_target
*target
);
1057 static struct cmd_list_element
*remote_cmdlist
;
1059 /* For "set remote" and "show remote". */
1061 static struct cmd_list_element
*remote_set_cmdlist
;
1062 static struct cmd_list_element
*remote_show_cmdlist
;
1064 /* Controls whether GDB is willing to use range stepping. */
1066 static bool use_range_stepping
= true;
1068 /* From the remote target's point of view, each thread is in one of these three
1070 enum class resume_state
1072 /* Not resumed - we haven't been asked to resume this thread. */
1075 /* We have been asked to resume this thread, but haven't sent a vCont action
1076 for it yet. We'll need to consider it next time commit_resume is
1078 RESUMED_PENDING_VCONT
,
1080 /* We have been asked to resume this thread, and we have sent a vCont action
1085 /* Information about a thread's pending vCont-resume. Used when a thread is in
1086 the remote_resume_state::RESUMED_PENDING_VCONT state. remote_target::resume
1087 stores this information which is then picked up by
1088 remote_target::commit_resume to know which is the proper action for this
1089 thread to include in the vCont packet. */
1090 struct resumed_pending_vcont_info
1092 /* True if the last resume call for this thread was a step request, false
1093 if a continue request. */
1096 /* The signal specified in the last resume call for this thread. */
1100 /* Private data that we'll store in (struct thread_info)->priv. */
1101 struct remote_thread_info
: public private_thread_info
1107 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1108 sequence of bytes. */
1109 gdb::byte_vector thread_handle
;
1111 /* Whether the target stopped for a breakpoint/watchpoint. */
1112 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1114 /* This is set to the data address of the access causing the target
1115 to stop for a watchpoint. */
1116 CORE_ADDR watch_data_address
= 0;
1118 /* Get the thread's resume state. */
1119 enum resume_state
get_resume_state () const
1121 return m_resume_state
;
1124 /* Put the thread in the NOT_RESUMED state. */
1125 void set_not_resumed ()
1127 m_resume_state
= resume_state::NOT_RESUMED
;
1130 /* Put the thread in the RESUMED_PENDING_VCONT state. */
1131 void set_resumed_pending_vcont (bool step
, gdb_signal sig
)
1133 m_resume_state
= resume_state::RESUMED_PENDING_VCONT
;
1134 m_resumed_pending_vcont_info
.step
= step
;
1135 m_resumed_pending_vcont_info
.sig
= sig
;
1138 /* Get the information this thread's pending vCont-resumption.
1140 Must only be called if the thread is in the RESUMED_PENDING_VCONT resume
1142 const struct resumed_pending_vcont_info
&resumed_pending_vcont_info () const
1144 gdb_assert (m_resume_state
== resume_state::RESUMED_PENDING_VCONT
);
1146 return m_resumed_pending_vcont_info
;
1149 /* Put the thread in the VCONT_RESUMED state. */
1152 m_resume_state
= resume_state::RESUMED
;
1156 /* Resume state for this thread. This is used to implement vCont action
1157 coalescing (only when the target operates in non-stop mode).
1159 remote_target::resume moves the thread to the RESUMED_PENDING_VCONT state,
1160 which notes that this thread must be considered in the next commit_resume
1163 remote_target::commit_resume sends a vCont packet with actions for the
1164 threads in the RESUMED_PENDING_VCONT state and moves them to the
1165 VCONT_RESUMED state.
1167 When reporting a stop to the core for a thread, that thread is moved back
1168 to the NOT_RESUMED state. */
1169 enum resume_state m_resume_state
= resume_state::NOT_RESUMED
;
1171 /* Extra info used if the thread is in the RESUMED_PENDING_VCONT state. */
1172 struct resumed_pending_vcont_info m_resumed_pending_vcont_info
;
1175 remote_state::remote_state ()
1180 remote_state::~remote_state ()
1182 xfree (this->last_pass_packet
);
1183 xfree (this->last_program_signals_packet
);
1184 xfree (this->finished_object
);
1185 xfree (this->finished_annex
);
1188 /* Utility: generate error from an incoming stub packet. */
1190 trace_error (char *buf
)
1193 return; /* not an error msg */
1196 case '1': /* malformed packet error */
1197 if (*++buf
== '0') /* general case: */
1198 error (_("remote.c: error in outgoing packet."));
1200 error (_("remote.c: error in outgoing packet at field #%ld."),
1201 strtol (buf
, NULL
, 16));
1203 error (_("Target returns error code '%s'."), buf
);
1207 /* Utility: wait for reply from stub, while accepting "O" packets. */
1210 remote_target::remote_get_noisy_reply ()
1212 struct remote_state
*rs
= get_remote_state ();
1214 do /* Loop on reply from remote stub. */
1218 QUIT
; /* Allow user to bail out with ^C. */
1219 getpkt (&rs
->buf
, 0);
1220 buf
= rs
->buf
.data ();
1223 else if (startswith (buf
, "qRelocInsn:"))
1226 CORE_ADDR from
, to
, org_to
;
1228 int adjusted_size
= 0;
1231 p
= buf
+ strlen ("qRelocInsn:");
1232 pp
= unpack_varlen_hex (p
, &ul
);
1234 error (_("invalid qRelocInsn packet: %s"), buf
);
1238 unpack_varlen_hex (p
, &ul
);
1245 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1248 catch (const gdb_exception
&ex
)
1250 if (ex
.error
== MEMORY_ERROR
)
1252 /* Propagate memory errors silently back to the
1253 target. The stub may have limited the range of
1254 addresses we can write to, for example. */
1258 /* Something unexpectedly bad happened. Be verbose
1259 so we can tell what, and propagate the error back
1260 to the stub, so it doesn't get stuck waiting for
1262 exception_fprintf (gdb_stderr
, ex
,
1263 _("warning: relocating instruction: "));
1270 adjusted_size
= to
- org_to
;
1272 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1276 else if (buf
[0] == 'O' && buf
[1] != 'K')
1277 remote_console_output (buf
+ 1); /* 'O' message from stub */
1279 return buf
; /* Here's the actual reply. */
1284 struct remote_arch_state
*
1285 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1287 remote_arch_state
*rsa
;
1289 auto it
= this->m_arch_states
.find (gdbarch
);
1290 if (it
== this->m_arch_states
.end ())
1292 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1293 std::forward_as_tuple (gdbarch
),
1294 std::forward_as_tuple (gdbarch
));
1295 rsa
= &p
.first
->second
;
1297 /* Make sure that the packet buffer is plenty big enough for
1298 this architecture. */
1299 if (this->buf
.size () < rsa
->remote_packet_size
)
1300 this->buf
.resize (2 * rsa
->remote_packet_size
);
1308 /* Fetch the global remote target state. */
1311 remote_target::get_remote_state ()
1313 /* Make sure that the remote architecture state has been
1314 initialized, because doing so might reallocate rs->buf. Any
1315 function which calls getpkt also needs to be mindful of changes
1316 to rs->buf, but this call limits the number of places which run
1318 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1320 return &m_remote_state
;
1323 /* Fetch the remote exec-file from the current program space. */
1326 get_remote_exec_file (void)
1328 char *remote_exec_file
;
1330 remote_exec_file
= remote_pspace_data
.get (current_program_space
);
1331 if (remote_exec_file
== NULL
)
1334 return remote_exec_file
;
1337 /* Set the remote exec file for PSPACE. */
1340 set_pspace_remote_exec_file (struct program_space
*pspace
,
1341 const char *remote_exec_file
)
1343 char *old_file
= remote_pspace_data
.get (pspace
);
1346 remote_pspace_data
.set (pspace
, xstrdup (remote_exec_file
));
1349 /* The "set/show remote exec-file" set command hook. */
1352 set_remote_exec_file (const char *ignored
, int from_tty
,
1353 struct cmd_list_element
*c
)
1355 gdb_assert (remote_exec_file_var
!= NULL
);
1356 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
1359 /* The "set/show remote exec-file" show command hook. */
1362 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1363 struct cmd_list_element
*cmd
, const char *value
)
1365 fprintf_filtered (file
, "%s\n", get_remote_exec_file ());
1369 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1371 int regnum
, num_remote_regs
, offset
;
1372 struct packet_reg
**remote_regs
;
1374 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1376 struct packet_reg
*r
= ®s
[regnum
];
1378 if (register_size (gdbarch
, regnum
) == 0)
1379 /* Do not try to fetch zero-sized (placeholder) registers. */
1382 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1387 /* Define the g/G packet format as the contents of each register
1388 with a remote protocol number, in order of ascending protocol
1391 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1392 for (num_remote_regs
= 0, regnum
= 0;
1393 regnum
< gdbarch_num_regs (gdbarch
);
1395 if (regs
[regnum
].pnum
!= -1)
1396 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1398 std::sort (remote_regs
, remote_regs
+ num_remote_regs
,
1399 [] (const packet_reg
*a
, const packet_reg
*b
)
1400 { return a
->pnum
< b
->pnum
; });
1402 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1404 remote_regs
[regnum
]->in_g_packet
= 1;
1405 remote_regs
[regnum
]->offset
= offset
;
1406 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1412 /* Given the architecture described by GDBARCH, return the remote
1413 protocol register's number and the register's offset in the g/G
1414 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1415 If the target does not have a mapping for REGNUM, return false,
1416 otherwise, return true. */
1419 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1420 int *pnum
, int *poffset
)
1422 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1424 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1426 map_regcache_remote_table (gdbarch
, regs
.data ());
1428 *pnum
= regs
[regnum
].pnum
;
1429 *poffset
= regs
[regnum
].offset
;
1434 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1436 /* Use the architecture to build a regnum<->pnum table, which will be
1437 1:1 unless a feature set specifies otherwise. */
1438 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1440 /* Record the maximum possible size of the g packet - it may turn out
1442 this->sizeof_g_packet
1443 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1445 /* Default maximum number of characters in a packet body. Many
1446 remote stubs have a hardwired buffer size of 400 bytes
1447 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1448 as the maximum packet-size to ensure that the packet and an extra
1449 NUL character can always fit in the buffer. This stops GDB
1450 trashing stubs that try to squeeze an extra NUL into what is
1451 already a full buffer (As of 1999-12-04 that was most stubs). */
1452 this->remote_packet_size
= 400 - 1;
1454 /* This one is filled in when a ``g'' packet is received. */
1455 this->actual_register_packet_size
= 0;
1457 /* Should rsa->sizeof_g_packet needs more space than the
1458 default, adjust the size accordingly. Remember that each byte is
1459 encoded as two characters. 32 is the overhead for the packet
1460 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1461 (``$NN:G...#NN'') is a better guess, the below has been padded a
1463 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1464 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1467 /* Get a pointer to the current remote target. If not connected to a
1468 remote target, return NULL. */
1470 static remote_target
*
1471 get_current_remote_target ()
1473 target_ops
*proc_target
= current_inferior ()->process_target ();
1474 return dynamic_cast<remote_target
*> (proc_target
);
1477 /* Return the current allowed size of a remote packet. This is
1478 inferred from the current architecture, and should be used to
1479 limit the length of outgoing packets. */
1481 remote_target::get_remote_packet_size ()
1483 struct remote_state
*rs
= get_remote_state ();
1484 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1486 if (rs
->explicit_packet_size
)
1487 return rs
->explicit_packet_size
;
1489 return rsa
->remote_packet_size
;
1492 static struct packet_reg
*
1493 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1496 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1500 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1502 gdb_assert (r
->regnum
== regnum
);
1507 static struct packet_reg
*
1508 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1513 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1515 struct packet_reg
*r
= &rsa
->regs
[i
];
1517 if (r
->pnum
== pnum
)
1523 /* Allow the user to specify what sequence to send to the remote
1524 when he requests a program interruption: Although ^C is usually
1525 what remote systems expect (this is the default, here), it is
1526 sometimes preferable to send a break. On other systems such
1527 as the Linux kernel, a break followed by g, which is Magic SysRq g
1528 is required in order to interrupt the execution. */
1529 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1530 const char interrupt_sequence_break
[] = "BREAK";
1531 const char interrupt_sequence_break_g
[] = "BREAK-g";
1532 static const char *const interrupt_sequence_modes
[] =
1534 interrupt_sequence_control_c
,
1535 interrupt_sequence_break
,
1536 interrupt_sequence_break_g
,
1539 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1542 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1543 struct cmd_list_element
*c
,
1546 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1547 fprintf_filtered (file
,
1548 _("Send the ASCII ETX character (Ctrl-c) "
1549 "to the remote target to interrupt the "
1550 "execution of the program.\n"));
1551 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1552 fprintf_filtered (file
,
1553 _("send a break signal to the remote target "
1554 "to interrupt the execution of the program.\n"));
1555 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1556 fprintf_filtered (file
,
1557 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1558 "the remote target to interrupt the execution "
1559 "of Linux kernel.\n"));
1561 internal_error (__FILE__
, __LINE__
,
1562 _("Invalid value for interrupt_sequence_mode: %s."),
1563 interrupt_sequence_mode
);
1566 /* This boolean variable specifies whether interrupt_sequence is sent
1567 to the remote target when gdb connects to it.
1568 This is mostly needed when you debug the Linux kernel: The Linux kernel
1569 expects BREAK g which is Magic SysRq g for connecting gdb. */
1570 static bool interrupt_on_connect
= false;
1572 /* This variable is used to implement the "set/show remotebreak" commands.
1573 Since these commands are now deprecated in favor of "set/show remote
1574 interrupt-sequence", it no longer has any effect on the code. */
1575 static bool remote_break
;
1578 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1581 interrupt_sequence_mode
= interrupt_sequence_break
;
1583 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1587 show_remotebreak (struct ui_file
*file
, int from_tty
,
1588 struct cmd_list_element
*c
,
1593 /* This variable sets the number of bits in an address that are to be
1594 sent in a memory ("M" or "m") packet. Normally, after stripping
1595 leading zeros, the entire address would be sent. This variable
1596 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1597 initial implementation of remote.c restricted the address sent in
1598 memory packets to ``host::sizeof long'' bytes - (typically 32
1599 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1600 address was never sent. Since fixing this bug may cause a break in
1601 some remote targets this variable is principally provided to
1602 facilitate backward compatibility. */
1604 static unsigned int remote_address_size
;
1607 /* User configurable variables for the number of characters in a
1608 memory read/write packet. MIN (rsa->remote_packet_size,
1609 rsa->sizeof_g_packet) is the default. Some targets need smaller
1610 values (fifo overruns, et.al.) and some users need larger values
1611 (speed up transfers). The variables ``preferred_*'' (the user
1612 request), ``current_*'' (what was actually set) and ``forced_*''
1613 (Positive - a soft limit, negative - a hard limit). */
1615 struct memory_packet_config
1622 /* The default max memory-write-packet-size, when the setting is
1623 "fixed". The 16k is historical. (It came from older GDB's using
1624 alloca for buffers and the knowledge (folklore?) that some hosts
1625 don't cope very well with large alloca calls.) */
1626 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1628 /* The minimum remote packet size for memory transfers. Ensures we
1629 can write at least one byte. */
1630 #define MIN_MEMORY_PACKET_SIZE 20
1632 /* Get the memory packet size, assuming it is fixed. */
1635 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1637 gdb_assert (config
->fixed_p
);
1639 if (config
->size
<= 0)
1640 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1642 return config
->size
;
1645 /* Compute the current size of a read/write packet. Since this makes
1646 use of ``actual_register_packet_size'' the computation is dynamic. */
1649 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1651 struct remote_state
*rs
= get_remote_state ();
1652 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1655 if (config
->fixed_p
)
1656 what_they_get
= get_fixed_memory_packet_size (config
);
1659 what_they_get
= get_remote_packet_size ();
1660 /* Limit the packet to the size specified by the user. */
1661 if (config
->size
> 0
1662 && what_they_get
> config
->size
)
1663 what_they_get
= config
->size
;
1665 /* Limit it to the size of the targets ``g'' response unless we have
1666 permission from the stub to use a larger packet size. */
1667 if (rs
->explicit_packet_size
== 0
1668 && rsa
->actual_register_packet_size
> 0
1669 && what_they_get
> rsa
->actual_register_packet_size
)
1670 what_they_get
= rsa
->actual_register_packet_size
;
1672 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1673 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1675 /* Make sure there is room in the global buffer for this packet
1676 (including its trailing NUL byte). */
1677 if (rs
->buf
.size () < what_they_get
+ 1)
1678 rs
->buf
.resize (2 * what_they_get
);
1680 return what_they_get
;
1683 /* Update the size of a read/write packet. If they user wants
1684 something really big then do a sanity check. */
1687 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1689 int fixed_p
= config
->fixed_p
;
1690 long size
= config
->size
;
1693 error (_("Argument required (integer, `fixed' or `limited')."));
1694 else if (strcmp (args
, "hard") == 0
1695 || strcmp (args
, "fixed") == 0)
1697 else if (strcmp (args
, "soft") == 0
1698 || strcmp (args
, "limit") == 0)
1704 size
= strtoul (args
, &end
, 0);
1706 error (_("Invalid %s (bad syntax)."), config
->name
);
1708 /* Instead of explicitly capping the size of a packet to or
1709 disallowing it, the user is allowed to set the size to
1710 something arbitrarily large. */
1714 if (fixed_p
&& !config
->fixed_p
)
1716 /* So that the query shows the correct value. */
1717 long query_size
= (size
<= 0
1718 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1721 if (! query (_("The target may not be able to correctly handle a %s\n"
1722 "of %ld bytes. Change the packet size? "),
1723 config
->name
, query_size
))
1724 error (_("Packet size not changed."));
1726 /* Update the config. */
1727 config
->fixed_p
= fixed_p
;
1728 config
->size
= size
;
1732 show_memory_packet_size (struct memory_packet_config
*config
)
1734 if (config
->size
== 0)
1735 printf_filtered (_("The %s is 0 (default). "), config
->name
);
1737 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1738 if (config
->fixed_p
)
1739 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1740 get_fixed_memory_packet_size (config
));
1743 remote_target
*remote
= get_current_remote_target ();
1746 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1747 remote
->get_memory_packet_size (config
));
1749 puts_filtered ("The actual limit will be further reduced "
1750 "dependent on the target.\n");
1754 /* FIXME: needs to be per-remote-target. */
1755 static struct memory_packet_config memory_write_packet_config
=
1757 "memory-write-packet-size",
1761 set_memory_write_packet_size (const char *args
, int from_tty
)
1763 set_memory_packet_size (args
, &memory_write_packet_config
);
1767 show_memory_write_packet_size (const char *args
, int from_tty
)
1769 show_memory_packet_size (&memory_write_packet_config
);
1772 /* Show the number of hardware watchpoints that can be used. */
1775 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1776 struct cmd_list_element
*c
,
1779 fprintf_filtered (file
, _("The maximum number of target hardware "
1780 "watchpoints is %s.\n"), value
);
1783 /* Show the length limit (in bytes) for hardware watchpoints. */
1786 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1787 struct cmd_list_element
*c
,
1790 fprintf_filtered (file
, _("The maximum length (in bytes) of a target "
1791 "hardware watchpoint is %s.\n"), value
);
1794 /* Show the number of hardware breakpoints that can be used. */
1797 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1798 struct cmd_list_element
*c
,
1801 fprintf_filtered (file
, _("The maximum number of target hardware "
1802 "breakpoints is %s.\n"), value
);
1805 /* Controls the maximum number of characters to display in the debug output
1806 for each remote packet. The remaining characters are omitted. */
1808 static int remote_packet_max_chars
= 512;
1810 /* Show the maximum number of characters to display for each remote packet
1811 when remote debugging is enabled. */
1814 show_remote_packet_max_chars (struct ui_file
*file
, int from_tty
,
1815 struct cmd_list_element
*c
,
1818 fprintf_filtered (file
, _("Number of remote packet characters to "
1819 "display is %s.\n"), value
);
1823 remote_target::get_memory_write_packet_size ()
1825 return get_memory_packet_size (&memory_write_packet_config
);
1828 /* FIXME: needs to be per-remote-target. */
1829 static struct memory_packet_config memory_read_packet_config
=
1831 "memory-read-packet-size",
1835 set_memory_read_packet_size (const char *args
, int from_tty
)
1837 set_memory_packet_size (args
, &memory_read_packet_config
);
1841 show_memory_read_packet_size (const char *args
, int from_tty
)
1843 show_memory_packet_size (&memory_read_packet_config
);
1847 remote_target::get_memory_read_packet_size ()
1849 long size
= get_memory_packet_size (&memory_read_packet_config
);
1851 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1852 extra buffer size argument before the memory read size can be
1853 increased beyond this. */
1854 if (size
> get_remote_packet_size ())
1855 size
= get_remote_packet_size ();
1861 struct packet_config
1866 /* If auto, GDB auto-detects support for this packet or feature,
1867 either through qSupported, or by trying the packet and looking
1868 at the response. If true, GDB assumes the target supports this
1869 packet. If false, the packet is disabled. Configs that don't
1870 have an associated command always have this set to auto. */
1871 enum auto_boolean detect
;
1873 /* Does the target support this packet? */
1874 enum packet_support support
;
1877 static enum packet_support
packet_config_support (struct packet_config
*config
);
1878 static enum packet_support
packet_support (int packet
);
1881 show_packet_config_cmd (struct packet_config
*config
)
1883 const char *support
= "internal-error";
1885 switch (packet_config_support (config
))
1888 support
= "enabled";
1890 case PACKET_DISABLE
:
1891 support
= "disabled";
1893 case PACKET_SUPPORT_UNKNOWN
:
1894 support
= "unknown";
1897 switch (config
->detect
)
1899 case AUTO_BOOLEAN_AUTO
:
1900 printf_filtered (_("Support for the `%s' packet "
1901 "is auto-detected, currently %s.\n"),
1902 config
->name
, support
);
1904 case AUTO_BOOLEAN_TRUE
:
1905 case AUTO_BOOLEAN_FALSE
:
1906 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1907 config
->name
, support
);
1913 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1914 const char *title
, int legacy
)
1920 config
->name
= name
;
1921 config
->title
= title
;
1922 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1924 show_doc
= xstrprintf ("Show current use of remote "
1925 "protocol `%s' (%s) packet.",
1927 /* set/show TITLE-packet {auto,on,off} */
1928 cmd_name
= xstrprintf ("%s-packet", title
);
1929 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1930 &config
->detect
, set_doc
,
1931 show_doc
, NULL
, /* help_doc */
1933 show_remote_protocol_packet_cmd
,
1934 &remote_set_cmdlist
, &remote_show_cmdlist
);
1935 /* The command code copies the documentation strings. */
1938 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1943 legacy_name
= xstrprintf ("%s-packet", name
);
1944 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1945 &remote_set_cmdlist
);
1946 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1947 &remote_show_cmdlist
);
1951 static enum packet_result
1952 packet_check_result (const char *buf
)
1956 /* The stub recognized the packet request. Check that the
1957 operation succeeded. */
1959 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1961 /* "Enn" - definitely an error. */
1962 return PACKET_ERROR
;
1964 /* Always treat "E." as an error. This will be used for
1965 more verbose error messages, such as E.memtypes. */
1966 if (buf
[0] == 'E' && buf
[1] == '.')
1967 return PACKET_ERROR
;
1969 /* The packet may or may not be OK. Just assume it is. */
1973 /* The stub does not support the packet. */
1974 return PACKET_UNKNOWN
;
1977 static enum packet_result
1978 packet_check_result (const gdb::char_vector
&buf
)
1980 return packet_check_result (buf
.data ());
1983 static enum packet_result
1984 packet_ok (const char *buf
, struct packet_config
*config
)
1986 enum packet_result result
;
1988 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1989 && config
->support
== PACKET_DISABLE
)
1990 internal_error (__FILE__
, __LINE__
,
1991 _("packet_ok: attempt to use a disabled packet"));
1993 result
= packet_check_result (buf
);
1998 /* The stub recognized the packet request. */
1999 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
2001 remote_debug_printf ("Packet %s (%s) is supported",
2002 config
->name
, config
->title
);
2003 config
->support
= PACKET_ENABLE
;
2006 case PACKET_UNKNOWN
:
2007 /* The stub does not support the packet. */
2008 if (config
->detect
== AUTO_BOOLEAN_AUTO
2009 && config
->support
== PACKET_ENABLE
)
2011 /* If the stub previously indicated that the packet was
2012 supported then there is a protocol error. */
2013 error (_("Protocol error: %s (%s) conflicting enabled responses."),
2014 config
->name
, config
->title
);
2016 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
2018 /* The user set it wrong. */
2019 error (_("Enabled packet %s (%s) not recognized by stub"),
2020 config
->name
, config
->title
);
2023 remote_debug_printf ("Packet %s (%s) is NOT supported",
2024 config
->name
, config
->title
);
2025 config
->support
= PACKET_DISABLE
;
2032 static enum packet_result
2033 packet_ok (const gdb::char_vector
&buf
, struct packet_config
*config
)
2035 return packet_ok (buf
.data (), config
);
2052 PACKET_vFile_pwrite
,
2054 PACKET_vFile_unlink
,
2055 PACKET_vFile_readlink
,
2058 PACKET_qXfer_features
,
2059 PACKET_qXfer_exec_file
,
2060 PACKET_qXfer_libraries
,
2061 PACKET_qXfer_libraries_svr4
,
2062 PACKET_qXfer_memory_map
,
2063 PACKET_qXfer_osdata
,
2064 PACKET_qXfer_threads
,
2065 PACKET_qXfer_statictrace_read
,
2066 PACKET_qXfer_traceframe_info
,
2072 PACKET_QPassSignals
,
2073 PACKET_QCatchSyscalls
,
2074 PACKET_QProgramSignals
,
2075 PACKET_QSetWorkingDir
,
2076 PACKET_QStartupWithShell
,
2077 PACKET_QEnvironmentHexEncoded
,
2078 PACKET_QEnvironmentReset
,
2079 PACKET_QEnvironmentUnset
,
2081 PACKET_qSearch_memory
,
2084 PACKET_QStartNoAckMode
,
2086 PACKET_qXfer_siginfo_read
,
2087 PACKET_qXfer_siginfo_write
,
2090 /* Support for conditional tracepoints. */
2091 PACKET_ConditionalTracepoints
,
2093 /* Support for target-side breakpoint conditions. */
2094 PACKET_ConditionalBreakpoints
,
2096 /* Support for target-side breakpoint commands. */
2097 PACKET_BreakpointCommands
,
2099 /* Support for fast tracepoints. */
2100 PACKET_FastTracepoints
,
2102 /* Support for static tracepoints. */
2103 PACKET_StaticTracepoints
,
2105 /* Support for installing tracepoints while a trace experiment is
2107 PACKET_InstallInTrace
,
2111 PACKET_TracepointSource
,
2114 PACKET_QDisableRandomization
,
2116 PACKET_QTBuffer_size
,
2120 PACKET_qXfer_btrace
,
2122 /* Support for the QNonStop packet. */
2125 /* Support for the QThreadEvents packet. */
2126 PACKET_QThreadEvents
,
2128 /* Support for multi-process extensions. */
2129 PACKET_multiprocess_feature
,
2131 /* Support for enabling and disabling tracepoints while a trace
2132 experiment is running. */
2133 PACKET_EnableDisableTracepoints_feature
,
2135 /* Support for collecting strings using the tracenz bytecode. */
2136 PACKET_tracenz_feature
,
2138 /* Support for continuing to run a trace experiment while GDB is
2140 PACKET_DisconnectedTracing_feature
,
2142 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2143 PACKET_augmented_libraries_svr4_read_feature
,
2145 /* Support for the qXfer:btrace-conf:read packet. */
2146 PACKET_qXfer_btrace_conf
,
2148 /* Support for the Qbtrace-conf:bts:size packet. */
2149 PACKET_Qbtrace_conf_bts_size
,
2151 /* Support for swbreak+ feature. */
2152 PACKET_swbreak_feature
,
2154 /* Support for hwbreak+ feature. */
2155 PACKET_hwbreak_feature
,
2157 /* Support for fork events. */
2158 PACKET_fork_event_feature
,
2160 /* Support for vfork events. */
2161 PACKET_vfork_event_feature
,
2163 /* Support for the Qbtrace-conf:pt:size packet. */
2164 PACKET_Qbtrace_conf_pt_size
,
2166 /* Support for exec events. */
2167 PACKET_exec_event_feature
,
2169 /* Support for query supported vCont actions. */
2170 PACKET_vContSupported
,
2172 /* Support remote CTRL-C. */
2175 /* Support TARGET_WAITKIND_NO_RESUMED. */
2178 /* Support for memory tagging, allocation tag fetch/store
2179 packets and the tag violation stop replies. */
2180 PACKET_memory_tagging_feature
,
2185 /* FIXME: needs to be per-remote-target. Ignoring this for now,
2186 assuming all remote targets are the same server (thus all support
2187 the same packets). */
2188 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
2190 /* Returns the packet's corresponding "set remote foo-packet" command
2191 state. See struct packet_config for more details. */
2193 static enum auto_boolean
2194 packet_set_cmd_state (int packet
)
2196 return remote_protocol_packets
[packet
].detect
;
2199 /* Returns whether a given packet or feature is supported. This takes
2200 into account the state of the corresponding "set remote foo-packet"
2201 command, which may be used to bypass auto-detection. */
2203 static enum packet_support
2204 packet_config_support (struct packet_config
*config
)
2206 switch (config
->detect
)
2208 case AUTO_BOOLEAN_TRUE
:
2209 return PACKET_ENABLE
;
2210 case AUTO_BOOLEAN_FALSE
:
2211 return PACKET_DISABLE
;
2212 case AUTO_BOOLEAN_AUTO
:
2213 return config
->support
;
2215 gdb_assert_not_reached (_("bad switch"));
2219 /* Same as packet_config_support, but takes the packet's enum value as
2222 static enum packet_support
2223 packet_support (int packet
)
2225 struct packet_config
*config
= &remote_protocol_packets
[packet
];
2227 return packet_config_support (config
);
2231 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
2232 struct cmd_list_element
*c
,
2235 struct packet_config
*packet
;
2237 for (packet
= remote_protocol_packets
;
2238 packet
< &remote_protocol_packets
[PACKET_MAX
];
2241 if (&packet
->detect
== c
->var
)
2243 show_packet_config_cmd (packet
);
2247 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
2251 /* Should we try one of the 'Z' requests? */
2255 Z_PACKET_SOFTWARE_BP
,
2256 Z_PACKET_HARDWARE_BP
,
2263 /* For compatibility with older distributions. Provide a ``set remote
2264 Z-packet ...'' command that updates all the Z packet types. */
2266 static enum auto_boolean remote_Z_packet_detect
;
2269 set_remote_protocol_Z_packet_cmd (const char *args
, int from_tty
,
2270 struct cmd_list_element
*c
)
2274 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2275 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
2279 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
2280 struct cmd_list_element
*c
,
2285 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2287 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
2291 /* Returns true if the multi-process extensions are in effect. */
2294 remote_multi_process_p (struct remote_state
*rs
)
2296 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
2299 /* Returns true if fork events are supported. */
2302 remote_fork_event_p (struct remote_state
*rs
)
2304 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
2307 /* Returns true if vfork events are supported. */
2310 remote_vfork_event_p (struct remote_state
*rs
)
2312 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
2315 /* Returns true if exec events are supported. */
2318 remote_exec_event_p (struct remote_state
*rs
)
2320 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
2323 /* Returns true if memory tagging is supported, false otherwise. */
2326 remote_memory_tagging_p ()
2328 return packet_support (PACKET_memory_tagging_feature
) == PACKET_ENABLE
;
2331 /* Insert fork catchpoint target routine. If fork events are enabled
2332 then return success, nothing more to do. */
2335 remote_target::insert_fork_catchpoint (int pid
)
2337 struct remote_state
*rs
= get_remote_state ();
2339 return !remote_fork_event_p (rs
);
2342 /* Remove fork catchpoint target routine. Nothing to do, just
2346 remote_target::remove_fork_catchpoint (int pid
)
2351 /* Insert vfork catchpoint target routine. If vfork events are enabled
2352 then return success, nothing more to do. */
2355 remote_target::insert_vfork_catchpoint (int pid
)
2357 struct remote_state
*rs
= get_remote_state ();
2359 return !remote_vfork_event_p (rs
);
2362 /* Remove vfork catchpoint target routine. Nothing to do, just
2366 remote_target::remove_vfork_catchpoint (int pid
)
2371 /* Insert exec catchpoint target routine. If exec events are
2372 enabled, just return success. */
2375 remote_target::insert_exec_catchpoint (int pid
)
2377 struct remote_state
*rs
= get_remote_state ();
2379 return !remote_exec_event_p (rs
);
2382 /* Remove exec catchpoint target routine. Nothing to do, just
2386 remote_target::remove_exec_catchpoint (int pid
)
2393 /* Take advantage of the fact that the TID field is not used, to tag
2394 special ptids with it set to != 0. */
2395 static const ptid_t
magic_null_ptid (42000, -1, 1);
2396 static const ptid_t
not_sent_ptid (42000, -2, 1);
2397 static const ptid_t
any_thread_ptid (42000, 0, 1);
2399 /* Find out if the stub attached to PID (and hence GDB should offer to
2400 detach instead of killing it when bailing out). */
2403 remote_target::remote_query_attached (int pid
)
2405 struct remote_state
*rs
= get_remote_state ();
2406 size_t size
= get_remote_packet_size ();
2408 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
2411 if (remote_multi_process_p (rs
))
2412 xsnprintf (rs
->buf
.data (), size
, "qAttached:%x", pid
);
2414 xsnprintf (rs
->buf
.data (), size
, "qAttached");
2417 getpkt (&rs
->buf
, 0);
2419 switch (packet_ok (rs
->buf
,
2420 &remote_protocol_packets
[PACKET_qAttached
]))
2423 if (strcmp (rs
->buf
.data (), "1") == 0)
2427 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
2429 case PACKET_UNKNOWN
:
2436 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2437 has been invented by GDB, instead of reported by the target. Since
2438 we can be connected to a remote system before before knowing about
2439 any inferior, mark the target with execution when we find the first
2440 inferior. If ATTACHED is 1, then we had just attached to this
2441 inferior. If it is 0, then we just created this inferior. If it
2442 is -1, then try querying the remote stub to find out if it had
2443 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2444 attempt to open this inferior's executable as the main executable
2445 if no main executable is open already. */
2448 remote_target::remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
2451 struct inferior
*inf
;
2453 /* Check whether this process we're learning about is to be
2454 considered attached, or if is to be considered to have been
2455 spawned by the stub. */
2457 attached
= remote_query_attached (pid
);
2459 if (gdbarch_has_global_solist (target_gdbarch ()))
2461 /* If the target shares code across all inferiors, then every
2462 attach adds a new inferior. */
2463 inf
= add_inferior (pid
);
2465 /* ... and every inferior is bound to the same program space.
2466 However, each inferior may still have its own address
2468 inf
->aspace
= maybe_new_address_space ();
2469 inf
->pspace
= current_program_space
;
2473 /* In the traditional debugging scenario, there's a 1-1 match
2474 between program/address spaces. We simply bind the inferior
2475 to the program space's address space. */
2476 inf
= current_inferior ();
2478 /* However, if the current inferior is already bound to a
2479 process, find some other empty inferior. */
2483 for (inferior
*it
: all_inferiors ())
2492 /* Since all inferiors were already bound to a process, add
2494 inf
= add_inferior_with_spaces ();
2496 switch_to_inferior_no_thread (inf
);
2497 inf
->push_target (this);
2498 inferior_appeared (inf
, pid
);
2501 inf
->attach_flag
= attached
;
2502 inf
->fake_pid_p
= fake_pid_p
;
2504 /* If no main executable is currently open then attempt to
2505 open the file that was executed to create this inferior. */
2506 if (try_open_exec
&& get_exec_file (0) == NULL
)
2507 exec_file_locate_attach (pid
, 0, 1);
2509 /* Check for exec file mismatch, and let the user solve it. */
2510 validate_exec_file (1);
2515 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2516 static remote_thread_info
*get_remote_thread_info (remote_target
*target
,
2519 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2520 according to RUNNING. */
2523 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
)
2525 struct remote_state
*rs
= get_remote_state ();
2526 struct thread_info
*thread
;
2528 /* GDB historically didn't pull threads in the initial connection
2529 setup. If the remote target doesn't even have a concept of
2530 threads (e.g., a bare-metal target), even if internally we
2531 consider that a single-threaded target, mentioning a new thread
2532 might be confusing to the user. Be silent then, preserving the
2533 age old behavior. */
2534 if (rs
->starting_up
)
2535 thread
= add_thread_silent (this, ptid
);
2537 thread
= add_thread (this, ptid
);
2539 /* We start by assuming threads are resumed. That state then gets updated
2540 when we process a matching stop reply. */
2541 get_remote_thread_info (thread
)->set_resumed ();
2543 set_executing (this, ptid
, executing
);
2544 set_running (this, ptid
, running
);
2549 /* Come here when we learn about a thread id from the remote target.
2550 It may be the first time we hear about such thread, so take the
2551 opportunity to add it to GDB's thread list. In case this is the
2552 first time we're noticing its corresponding inferior, add it to
2553 GDB's inferior list as well. EXECUTING indicates whether the
2554 thread is (internally) executing or stopped. */
2557 remote_target::remote_notice_new_inferior (ptid_t currthread
, int executing
)
2559 /* In non-stop mode, we assume new found threads are (externally)
2560 running until proven otherwise with a stop reply. In all-stop,
2561 we can only get here if all threads are stopped. */
2562 int running
= target_is_non_stop_p () ? 1 : 0;
2564 /* If this is a new thread, add it to GDB's thread list.
2565 If we leave it up to WFI to do this, bad things will happen. */
2567 thread_info
*tp
= find_thread_ptid (this, currthread
);
2568 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2570 /* We're seeing an event on a thread id we knew had exited.
2571 This has to be a new thread reusing the old id. Add it. */
2572 remote_add_thread (currthread
, running
, executing
);
2576 if (!in_thread_list (this, currthread
))
2578 struct inferior
*inf
= NULL
;
2579 int pid
= currthread
.pid ();
2581 if (inferior_ptid
.is_pid ()
2582 && pid
== inferior_ptid
.pid ())
2584 /* inferior_ptid has no thread member yet. This can happen
2585 with the vAttach -> remote_wait,"TAAthread:" path if the
2586 stub doesn't support qC. This is the first stop reported
2587 after an attach, so this is the main thread. Update the
2588 ptid in the thread list. */
2589 if (in_thread_list (this, ptid_t (pid
)))
2590 thread_change_ptid (this, inferior_ptid
, currthread
);
2594 = remote_add_thread (currthread
, running
, executing
);
2595 switch_to_thread (thr
);
2600 if (magic_null_ptid
== inferior_ptid
)
2602 /* inferior_ptid is not set yet. This can happen with the
2603 vRun -> remote_wait,"TAAthread:" path if the stub
2604 doesn't support qC. This is the first stop reported
2605 after an attach, so this is the main thread. Update the
2606 ptid in the thread list. */
2607 thread_change_ptid (this, inferior_ptid
, currthread
);
2611 /* When connecting to a target remote, or to a target
2612 extended-remote which already was debugging an inferior, we
2613 may not know about it yet. Add it before adding its child
2614 thread, so notifications are emitted in a sensible order. */
2615 if (find_inferior_pid (this, currthread
.pid ()) == NULL
)
2617 struct remote_state
*rs
= get_remote_state ();
2618 bool fake_pid_p
= !remote_multi_process_p (rs
);
2620 inf
= remote_add_inferior (fake_pid_p
,
2621 currthread
.pid (), -1, 1);
2624 /* This is really a new thread. Add it. */
2625 thread_info
*new_thr
2626 = remote_add_thread (currthread
, running
, executing
);
2628 /* If we found a new inferior, let the common code do whatever
2629 it needs to with it (e.g., read shared libraries, insert
2630 breakpoints), unless we're just setting up an all-stop
2634 struct remote_state
*rs
= get_remote_state ();
2636 if (!rs
->starting_up
)
2637 notice_new_inferior (new_thr
, executing
, 0);
2642 /* Return THREAD's private thread data, creating it if necessary. */
2644 static remote_thread_info
*
2645 get_remote_thread_info (thread_info
*thread
)
2647 gdb_assert (thread
!= NULL
);
2649 if (thread
->priv
== NULL
)
2650 thread
->priv
.reset (new remote_thread_info
);
2652 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2655 /* Return PTID's private thread data, creating it if necessary. */
2657 static remote_thread_info
*
2658 get_remote_thread_info (remote_target
*target
, ptid_t ptid
)
2660 thread_info
*thr
= find_thread_ptid (target
, ptid
);
2661 return get_remote_thread_info (thr
);
2664 /* Call this function as a result of
2665 1) A halt indication (T packet) containing a thread id
2666 2) A direct query of currthread
2667 3) Successful execution of set thread */
2670 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2672 rs
->general_thread
= currthread
;
2675 /* If 'QPassSignals' is supported, tell the remote stub what signals
2676 it can simply pass through to the inferior without reporting. */
2679 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2681 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2683 char *pass_packet
, *p
;
2685 struct remote_state
*rs
= get_remote_state ();
2687 gdb_assert (pass_signals
.size () < 256);
2688 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2690 if (pass_signals
[i
])
2693 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2694 strcpy (pass_packet
, "QPassSignals:");
2695 p
= pass_packet
+ strlen (pass_packet
);
2696 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2698 if (pass_signals
[i
])
2701 *p
++ = tohex (i
>> 4);
2702 *p
++ = tohex (i
& 15);
2711 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2713 putpkt (pass_packet
);
2714 getpkt (&rs
->buf
, 0);
2715 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2716 xfree (rs
->last_pass_packet
);
2717 rs
->last_pass_packet
= pass_packet
;
2720 xfree (pass_packet
);
2724 /* If 'QCatchSyscalls' is supported, tell the remote stub
2725 to report syscalls to GDB. */
2728 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2729 gdb::array_view
<const int> syscall_counts
)
2731 const char *catch_packet
;
2732 enum packet_result result
;
2735 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2737 /* Not supported. */
2741 if (needed
&& any_count
== 0)
2743 /* Count how many syscalls are to be caught. */
2744 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2746 if (syscall_counts
[i
] != 0)
2751 remote_debug_printf ("pid %d needed %d any_count %d n_sysno %d",
2752 pid
, needed
, any_count
, n_sysno
);
2754 std::string built_packet
;
2757 /* Prepare a packet with the sysno list, assuming max 8+1
2758 characters for a sysno. If the resulting packet size is too
2759 big, fallback on the non-selective packet. */
2760 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2761 built_packet
.reserve (maxpktsz
);
2762 built_packet
= "QCatchSyscalls:1";
2765 /* Add in each syscall to be caught. */
2766 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2768 if (syscall_counts
[i
] != 0)
2769 string_appendf (built_packet
, ";%zx", i
);
2772 if (built_packet
.size () > get_remote_packet_size ())
2774 /* catch_packet too big. Fallback to less efficient
2775 non selective mode, with GDB doing the filtering. */
2776 catch_packet
= "QCatchSyscalls:1";
2779 catch_packet
= built_packet
.c_str ();
2782 catch_packet
= "QCatchSyscalls:0";
2784 struct remote_state
*rs
= get_remote_state ();
2786 putpkt (catch_packet
);
2787 getpkt (&rs
->buf
, 0);
2788 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2789 if (result
== PACKET_OK
)
2795 /* If 'QProgramSignals' is supported, tell the remote stub what
2796 signals it should pass through to the inferior when detaching. */
2799 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2801 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2805 struct remote_state
*rs
= get_remote_state ();
2807 gdb_assert (signals
.size () < 256);
2808 for (size_t i
= 0; i
< signals
.size (); i
++)
2813 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2814 strcpy (packet
, "QProgramSignals:");
2815 p
= packet
+ strlen (packet
);
2816 for (size_t i
= 0; i
< signals
.size (); i
++)
2818 if (signal_pass_state (i
))
2821 *p
++ = tohex (i
>> 4);
2822 *p
++ = tohex (i
& 15);
2831 if (!rs
->last_program_signals_packet
2832 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2835 getpkt (&rs
->buf
, 0);
2836 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2837 xfree (rs
->last_program_signals_packet
);
2838 rs
->last_program_signals_packet
= packet
;
2845 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2846 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2847 thread. If GEN is set, set the general thread, if not, then set
2848 the step/continue thread. */
2850 remote_target::set_thread (ptid_t ptid
, int gen
)
2852 struct remote_state
*rs
= get_remote_state ();
2853 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2854 char *buf
= rs
->buf
.data ();
2855 char *endbuf
= buf
+ get_remote_packet_size ();
2861 *buf
++ = gen
? 'g' : 'c';
2862 if (ptid
== magic_null_ptid
)
2863 xsnprintf (buf
, endbuf
- buf
, "0");
2864 else if (ptid
== any_thread_ptid
)
2865 xsnprintf (buf
, endbuf
- buf
, "0");
2866 else if (ptid
== minus_one_ptid
)
2867 xsnprintf (buf
, endbuf
- buf
, "-1");
2869 write_ptid (buf
, endbuf
, ptid
);
2871 getpkt (&rs
->buf
, 0);
2873 rs
->general_thread
= ptid
;
2875 rs
->continue_thread
= ptid
;
2879 remote_target::set_general_thread (ptid_t ptid
)
2881 set_thread (ptid
, 1);
2885 remote_target::set_continue_thread (ptid_t ptid
)
2887 set_thread (ptid
, 0);
2890 /* Change the remote current process. Which thread within the process
2891 ends up selected isn't important, as long as it is the same process
2892 as what INFERIOR_PTID points to.
2894 This comes from that fact that there is no explicit notion of
2895 "selected process" in the protocol. The selected process for
2896 general operations is the process the selected general thread
2900 remote_target::set_general_process ()
2902 struct remote_state
*rs
= get_remote_state ();
2904 /* If the remote can't handle multiple processes, don't bother. */
2905 if (!remote_multi_process_p (rs
))
2908 /* We only need to change the remote current thread if it's pointing
2909 at some other process. */
2910 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2911 set_general_thread (inferior_ptid
);
2915 /* Return nonzero if this is the main thread that we made up ourselves
2916 to model non-threaded targets as single-threaded. */
2919 remote_thread_always_alive (ptid_t ptid
)
2921 if (ptid
== magic_null_ptid
)
2922 /* The main thread is always alive. */
2925 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2926 /* The main thread is always alive. This can happen after a
2927 vAttach, if the remote side doesn't support
2934 /* Return nonzero if the thread PTID is still alive on the remote
2938 remote_target::thread_alive (ptid_t ptid
)
2940 struct remote_state
*rs
= get_remote_state ();
2943 /* Check if this is a thread that we made up ourselves to model
2944 non-threaded targets as single-threaded. */
2945 if (remote_thread_always_alive (ptid
))
2948 p
= rs
->buf
.data ();
2949 endp
= p
+ get_remote_packet_size ();
2952 write_ptid (p
, endp
, ptid
);
2955 getpkt (&rs
->buf
, 0);
2956 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2959 /* Return a pointer to a thread name if we know it and NULL otherwise.
2960 The thread_info object owns the memory for the name. */
2963 remote_target::thread_name (struct thread_info
*info
)
2965 if (info
->priv
!= NULL
)
2967 const std::string
&name
= get_remote_thread_info (info
)->name
;
2968 return !name
.empty () ? name
.c_str () : NULL
;
2974 /* About these extended threadlist and threadinfo packets. They are
2975 variable length packets but, the fields within them are often fixed
2976 length. They are redundant enough to send over UDP as is the
2977 remote protocol in general. There is a matching unit test module
2980 /* WARNING: This threadref data structure comes from the remote O.S.,
2981 libstub protocol encoding, and remote.c. It is not particularly
2984 /* Right now, the internal structure is int. We want it to be bigger.
2985 Plan to fix this. */
2987 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2989 /* gdb_ext_thread_info is an internal GDB data structure which is
2990 equivalent to the reply of the remote threadinfo packet. */
2992 struct gdb_ext_thread_info
2994 threadref threadid
; /* External form of thread reference. */
2995 int active
; /* Has state interesting to GDB?
2997 char display
[256]; /* Brief state display, name,
2998 blocked/suspended. */
2999 char shortname
[32]; /* To be used to name threads. */
3000 char more_display
[256]; /* Long info, statistics, queue depth,
3004 /* The volume of remote transfers can be limited by submitting
3005 a mask containing bits specifying the desired information.
3006 Use a union of these values as the 'selection' parameter to
3007 get_thread_info. FIXME: Make these TAG names more thread specific. */
3009 #define TAG_THREADID 1
3010 #define TAG_EXISTS 2
3011 #define TAG_DISPLAY 4
3012 #define TAG_THREADNAME 8
3013 #define TAG_MOREDISPLAY 16
3015 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
3017 static const char *unpack_nibble (const char *buf
, int *val
);
3019 static const char *unpack_byte (const char *buf
, int *value
);
3021 static char *pack_int (char *buf
, int value
);
3023 static const char *unpack_int (const char *buf
, int *value
);
3025 static const char *unpack_string (const char *src
, char *dest
, int length
);
3027 static char *pack_threadid (char *pkt
, threadref
*id
);
3029 static const char *unpack_threadid (const char *inbuf
, threadref
*id
);
3031 void int_to_threadref (threadref
*id
, int value
);
3033 static int threadref_to_int (threadref
*ref
);
3035 static void copy_threadref (threadref
*dest
, threadref
*src
);
3037 static int threadmatch (threadref
*dest
, threadref
*src
);
3039 static char *pack_threadinfo_request (char *pkt
, int mode
,
3042 static char *pack_threadlist_request (char *pkt
, int startflag
,
3044 threadref
*nextthread
);
3046 static int remote_newthread_step (threadref
*ref
, void *context
);
3049 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
3050 buffer we're allowed to write to. Returns
3051 BUF+CHARACTERS_WRITTEN. */
3054 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
3057 struct remote_state
*rs
= get_remote_state ();
3059 if (remote_multi_process_p (rs
))
3063 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
3065 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
3069 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
3071 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
3076 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
3077 last parsed char. Returns null_ptid if no thread id is found, and
3078 throws an error if the thread id has an invalid format. */
3081 read_ptid (const char *buf
, const char **obuf
)
3083 const char *p
= buf
;
3085 ULONGEST pid
= 0, tid
= 0;
3089 /* Multi-process ptid. */
3090 pp
= unpack_varlen_hex (p
+ 1, &pid
);
3092 error (_("invalid remote ptid: %s"), p
);
3095 pp
= unpack_varlen_hex (p
+ 1, &tid
);
3098 return ptid_t (pid
, tid
, 0);
3101 /* No multi-process. Just a tid. */
3102 pp
= unpack_varlen_hex (p
, &tid
);
3104 /* Return null_ptid when no thread id is found. */
3112 /* Since the stub is not sending a process id, then default to
3113 what's in inferior_ptid, unless it's null at this point. If so,
3114 then since there's no way to know the pid of the reported
3115 threads, use the magic number. */
3116 if (inferior_ptid
== null_ptid
)
3117 pid
= magic_null_ptid
.pid ();
3119 pid
= inferior_ptid
.pid ();
3123 return ptid_t (pid
, tid
, 0);
3129 if (ch
>= 'a' && ch
<= 'f')
3130 return ch
- 'a' + 10;
3131 if (ch
>= '0' && ch
<= '9')
3133 if (ch
>= 'A' && ch
<= 'F')
3134 return ch
- 'A' + 10;
3139 stub_unpack_int (const char *buff
, int fieldlength
)
3146 nibble
= stubhex (*buff
++);
3150 retval
= retval
<< 4;
3156 unpack_nibble (const char *buf
, int *val
)
3158 *val
= fromhex (*buf
++);
3163 unpack_byte (const char *buf
, int *value
)
3165 *value
= stub_unpack_int (buf
, 2);
3170 pack_int (char *buf
, int value
)
3172 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3173 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3174 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3175 buf
= pack_hex_byte (buf
, (value
& 0xff));
3180 unpack_int (const char *buf
, int *value
)
3182 *value
= stub_unpack_int (buf
, 8);
3186 #if 0 /* Currently unused, uncomment when needed. */
3187 static char *pack_string (char *pkt
, char *string
);
3190 pack_string (char *pkt
, char *string
)
3195 len
= strlen (string
);
3197 len
= 200; /* Bigger than most GDB packets, junk??? */
3198 pkt
= pack_hex_byte (pkt
, len
);
3202 if ((ch
== '\0') || (ch
== '#'))
3203 ch
= '*'; /* Protect encapsulation. */
3208 #endif /* 0 (unused) */
3211 unpack_string (const char *src
, char *dest
, int length
)
3220 pack_threadid (char *pkt
, threadref
*id
)
3223 unsigned char *altid
;
3225 altid
= (unsigned char *) id
;
3226 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3228 pkt
= pack_hex_byte (pkt
, *altid
++);
3234 unpack_threadid (const char *inbuf
, threadref
*id
)
3237 const char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3240 altref
= (char *) id
;
3242 while (inbuf
< limit
)
3244 x
= stubhex (*inbuf
++);
3245 y
= stubhex (*inbuf
++);
3246 *altref
++ = (x
<< 4) | y
;
3251 /* Externally, threadrefs are 64 bits but internally, they are still
3252 ints. This is due to a mismatch of specifications. We would like
3253 to use 64bit thread references internally. This is an adapter
3257 int_to_threadref (threadref
*id
, int value
)
3259 unsigned char *scan
;
3261 scan
= (unsigned char *) id
;
3267 *scan
++ = (value
>> 24) & 0xff;
3268 *scan
++ = (value
>> 16) & 0xff;
3269 *scan
++ = (value
>> 8) & 0xff;
3270 *scan
++ = (value
& 0xff);
3274 threadref_to_int (threadref
*ref
)
3277 unsigned char *scan
;
3283 value
= (value
<< 8) | ((*scan
++) & 0xff);
3288 copy_threadref (threadref
*dest
, threadref
*src
)
3291 unsigned char *csrc
, *cdest
;
3293 csrc
= (unsigned char *) src
;
3294 cdest
= (unsigned char *) dest
;
3301 threadmatch (threadref
*dest
, threadref
*src
)
3303 /* Things are broken right now, so just assume we got a match. */
3305 unsigned char *srcp
, *destp
;
3307 srcp
= (char *) src
;
3308 destp
= (char *) dest
;
3312 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3319 threadid:1, # always request threadid
3326 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3329 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3331 *pkt
++ = 'q'; /* Info Query */
3332 *pkt
++ = 'P'; /* process or thread info */
3333 pkt
= pack_int (pkt
, mode
); /* mode */
3334 pkt
= pack_threadid (pkt
, id
); /* threadid */
3335 *pkt
= '\0'; /* terminate */
3339 /* These values tag the fields in a thread info response packet. */
3340 /* Tagging the fields allows us to request specific fields and to
3341 add more fields as time goes by. */
3343 #define TAG_THREADID 1 /* Echo the thread identifier. */
3344 #define TAG_EXISTS 2 /* Is this process defined enough to
3345 fetch registers and its stack? */
3346 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3347 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3348 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3352 remote_target::remote_unpack_thread_info_response (const char *pkt
,
3353 threadref
*expectedref
,
3354 gdb_ext_thread_info
*info
)
3356 struct remote_state
*rs
= get_remote_state ();
3360 const char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3363 /* info->threadid = 0; FIXME: implement zero_threadref. */
3365 info
->display
[0] = '\0';
3366 info
->shortname
[0] = '\0';
3367 info
->more_display
[0] = '\0';
3369 /* Assume the characters indicating the packet type have been
3371 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3372 pkt
= unpack_threadid (pkt
, &ref
);
3375 warning (_("Incomplete response to threadinfo request."));
3376 if (!threadmatch (&ref
, expectedref
))
3377 { /* This is an answer to a different request. */
3378 warning (_("ERROR RMT Thread info mismatch."));
3381 copy_threadref (&info
->threadid
, &ref
);
3383 /* Loop on tagged fields , try to bail if something goes wrong. */
3385 /* Packets are terminated with nulls. */
3386 while ((pkt
< limit
) && mask
&& *pkt
)
3388 pkt
= unpack_int (pkt
, &tag
); /* tag */
3389 pkt
= unpack_byte (pkt
, &length
); /* length */
3390 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3392 warning (_("ERROR RMT: threadinfo tag mismatch."));
3396 if (tag
== TAG_THREADID
)
3400 warning (_("ERROR RMT: length of threadid is not 16."));
3404 pkt
= unpack_threadid (pkt
, &ref
);
3405 mask
= mask
& ~TAG_THREADID
;
3408 if (tag
== TAG_EXISTS
)
3410 info
->active
= stub_unpack_int (pkt
, length
);
3412 mask
= mask
& ~(TAG_EXISTS
);
3415 warning (_("ERROR RMT: 'exists' length too long."));
3421 if (tag
== TAG_THREADNAME
)
3423 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3424 mask
= mask
& ~TAG_THREADNAME
;
3427 if (tag
== TAG_DISPLAY
)
3429 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3430 mask
= mask
& ~TAG_DISPLAY
;
3433 if (tag
== TAG_MOREDISPLAY
)
3435 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3436 mask
= mask
& ~TAG_MOREDISPLAY
;
3439 warning (_("ERROR RMT: unknown thread info tag."));
3440 break; /* Not a tag we know about. */
3446 remote_target::remote_get_threadinfo (threadref
*threadid
,
3448 gdb_ext_thread_info
*info
)
3450 struct remote_state
*rs
= get_remote_state ();
3453 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3455 getpkt (&rs
->buf
, 0);
3457 if (rs
->buf
[0] == '\0')
3460 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3465 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3468 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3469 threadref
*nextthread
)
3471 *pkt
++ = 'q'; /* info query packet */
3472 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3473 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3474 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3475 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3480 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3483 remote_target::parse_threadlist_response (const char *pkt
, int result_limit
,
3484 threadref
*original_echo
,
3485 threadref
*resultlist
,
3488 struct remote_state
*rs
= get_remote_state ();
3489 int count
, resultcount
, done
;
3492 /* Assume the 'q' and 'M chars have been stripped. */
3493 const char *limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3494 /* done parse past here */
3495 pkt
= unpack_byte (pkt
, &count
); /* count field */
3496 pkt
= unpack_nibble (pkt
, &done
);
3497 /* The first threadid is the argument threadid. */
3498 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3499 while ((count
-- > 0) && (pkt
< limit
))
3501 pkt
= unpack_threadid (pkt
, resultlist
++);
3502 if (resultcount
++ >= result_limit
)
3510 /* Fetch the next batch of threads from the remote. Returns -1 if the
3511 qL packet is not supported, 0 on error and 1 on success. */
3514 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3515 int result_limit
, int *done
, int *result_count
,
3516 threadref
*threadlist
)
3518 struct remote_state
*rs
= get_remote_state ();
3521 /* Truncate result limit to be smaller than the packet size. */
3522 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3523 >= get_remote_packet_size ())
3524 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3526 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3529 getpkt (&rs
->buf
, 0);
3530 if (rs
->buf
[0] == '\0')
3532 /* Packet not supported. */
3537 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3538 &rs
->echo_nextthread
, threadlist
, done
);
3540 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3542 /* FIXME: This is a good reason to drop the packet. */
3543 /* Possibly, there is a duplicate response. */
3545 retransmit immediatly - race conditions
3546 retransmit after timeout - yes
3548 wait for packet, then exit
3550 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3551 return 0; /* I choose simply exiting. */
3553 if (*result_count
<= 0)
3557 warning (_("RMT ERROR : failed to get remote thread list."));
3560 return result
; /* break; */
3562 if (*result_count
> result_limit
)
3565 warning (_("RMT ERROR: threadlist response longer than requested."));
3571 /* Fetch the list of remote threads, with the qL packet, and call
3572 STEPFUNCTION for each thread found. Stops iterating and returns 1
3573 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3574 STEPFUNCTION returns false. If the packet is not supported,
3578 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3579 void *context
, int looplimit
)
3581 struct remote_state
*rs
= get_remote_state ();
3582 int done
, i
, result_count
;
3590 if (loopcount
++ > looplimit
)
3593 warning (_("Remote fetch threadlist -infinite loop-."));
3596 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3597 MAXTHREADLISTRESULTS
,
3598 &done
, &result_count
,
3599 rs
->resultthreadlist
);
3602 /* Clear for later iterations. */
3604 /* Setup to resume next batch of thread references, set nextthread. */
3605 if (result_count
>= 1)
3606 copy_threadref (&rs
->nextthread
,
3607 &rs
->resultthreadlist
[result_count
- 1]);
3609 while (result_count
--)
3611 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3621 /* A thread found on the remote target. */
3625 explicit thread_item (ptid_t ptid_
)
3629 thread_item (thread_item
&&other
) = default;
3630 thread_item
&operator= (thread_item
&&other
) = default;
3632 DISABLE_COPY_AND_ASSIGN (thread_item
);
3634 /* The thread's PTID. */
3637 /* The thread's extra info. */
3640 /* The thread's name. */
3643 /* The core the thread was running on. -1 if not known. */
3646 /* The thread handle associated with the thread. */
3647 gdb::byte_vector thread_handle
;
3650 /* Context passed around to the various methods listing remote
3651 threads. As new threads are found, they're added to the ITEMS
3654 struct threads_listing_context
3656 /* Return true if this object contains an entry for a thread with ptid
3659 bool contains_thread (ptid_t ptid
) const
3661 auto match_ptid
= [&] (const thread_item
&item
)
3663 return item
.ptid
== ptid
;
3666 auto it
= std::find_if (this->items
.begin (),
3670 return it
!= this->items
.end ();
3673 /* Remove the thread with ptid PTID. */
3675 void remove_thread (ptid_t ptid
)
3677 auto match_ptid
= [&] (const thread_item
&item
)
3679 return item
.ptid
== ptid
;
3682 auto it
= std::remove_if (this->items
.begin (),
3686 if (it
!= this->items
.end ())
3687 this->items
.erase (it
);
3690 /* The threads found on the remote target. */
3691 std::vector
<thread_item
> items
;
3695 remote_newthread_step (threadref
*ref
, void *data
)
3697 struct threads_listing_context
*context
3698 = (struct threads_listing_context
*) data
;
3699 int pid
= inferior_ptid
.pid ();
3700 int lwp
= threadref_to_int (ref
);
3701 ptid_t
ptid (pid
, lwp
);
3703 context
->items
.emplace_back (ptid
);
3705 return 1; /* continue iterator */
3708 #define CRAZY_MAX_THREADS 1000
3711 remote_target::remote_current_thread (ptid_t oldpid
)
3713 struct remote_state
*rs
= get_remote_state ();
3716 getpkt (&rs
->buf
, 0);
3717 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3722 result
= read_ptid (&rs
->buf
[2], &obuf
);
3724 remote_debug_printf ("warning: garbage in qC reply");
3732 /* List remote threads using the deprecated qL packet. */
3735 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3737 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3738 CRAZY_MAX_THREADS
) >= 0)
3744 #if defined(HAVE_LIBEXPAT)
3747 start_thread (struct gdb_xml_parser
*parser
,
3748 const struct gdb_xml_element
*element
,
3750 std::vector
<gdb_xml_value
> &attributes
)
3752 struct threads_listing_context
*data
3753 = (struct threads_listing_context
*) user_data
;
3754 struct gdb_xml_value
*attr
;
3756 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3757 ptid_t ptid
= read_ptid (id
, NULL
);
3759 data
->items
.emplace_back (ptid
);
3760 thread_item
&item
= data
->items
.back ();
3762 attr
= xml_find_attribute (attributes
, "core");
3764 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3766 attr
= xml_find_attribute (attributes
, "name");
3768 item
.name
= (const char *) attr
->value
.get ();
3770 attr
= xml_find_attribute (attributes
, "handle");
3772 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3776 end_thread (struct gdb_xml_parser
*parser
,
3777 const struct gdb_xml_element
*element
,
3778 void *user_data
, const char *body_text
)
3780 struct threads_listing_context
*data
3781 = (struct threads_listing_context
*) user_data
;
3783 if (body_text
!= NULL
&& *body_text
!= '\0')
3784 data
->items
.back ().extra
= body_text
;
3787 const struct gdb_xml_attribute thread_attributes
[] = {
3788 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3789 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3790 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3791 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3792 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3795 const struct gdb_xml_element thread_children
[] = {
3796 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3799 const struct gdb_xml_element threads_children
[] = {
3800 { "thread", thread_attributes
, thread_children
,
3801 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3802 start_thread
, end_thread
},
3803 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3806 const struct gdb_xml_element threads_elements
[] = {
3807 { "threads", NULL
, threads_children
,
3808 GDB_XML_EF_NONE
, NULL
, NULL
},
3809 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3814 /* List remote threads using qXfer:threads:read. */
3817 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3819 #if defined(HAVE_LIBEXPAT)
3820 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3822 gdb::optional
<gdb::char_vector
> xml
3823 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3825 if (xml
&& (*xml
)[0] != '\0')
3827 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3828 threads_elements
, xml
->data (), context
);
3838 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3841 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3843 struct remote_state
*rs
= get_remote_state ();
3845 if (rs
->use_threadinfo_query
)
3849 putpkt ("qfThreadInfo");
3850 getpkt (&rs
->buf
, 0);
3851 bufp
= rs
->buf
.data ();
3852 if (bufp
[0] != '\0') /* q packet recognized */
3854 while (*bufp
++ == 'm') /* reply contains one or more TID */
3858 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3859 context
->items
.emplace_back (ptid
);
3861 while (*bufp
++ == ','); /* comma-separated list */
3862 putpkt ("qsThreadInfo");
3863 getpkt (&rs
->buf
, 0);
3864 bufp
= rs
->buf
.data ();
3870 /* Packet not recognized. */
3871 rs
->use_threadinfo_query
= 0;
3878 /* Return true if INF only has one non-exited thread. */
3881 has_single_non_exited_thread (inferior
*inf
)
3884 for (thread_info
*tp ATTRIBUTE_UNUSED
: inf
->non_exited_threads ())
3890 /* Implement the to_update_thread_list function for the remote
3894 remote_target::update_thread_list ()
3896 struct threads_listing_context context
;
3899 /* We have a few different mechanisms to fetch the thread list. Try
3900 them all, starting with the most preferred one first, falling
3901 back to older methods. */
3902 if (remote_get_threads_with_qxfer (&context
)
3903 || remote_get_threads_with_qthreadinfo (&context
)
3904 || remote_get_threads_with_ql (&context
))
3908 if (context
.items
.empty ()
3909 && remote_thread_always_alive (inferior_ptid
))
3911 /* Some targets don't really support threads, but still
3912 reply an (empty) thread list in response to the thread
3913 listing packets, instead of replying "packet not
3914 supported". Exit early so we don't delete the main
3919 /* CONTEXT now holds the current thread list on the remote
3920 target end. Delete GDB-side threads no longer found on the
3922 for (thread_info
*tp
: all_threads_safe ())
3924 if (tp
->inf
->process_target () != this)
3927 if (!context
.contains_thread (tp
->ptid
))
3929 /* Do not remove the thread if it is the last thread in
3930 the inferior. This situation happens when we have a
3931 pending exit process status to process. Otherwise we
3932 may end up with a seemingly live inferior (i.e. pid
3933 != 0) that has no threads. */
3934 if (has_single_non_exited_thread (tp
->inf
))
3942 /* Remove any unreported fork child threads from CONTEXT so
3943 that we don't interfere with follow fork, which is where
3944 creation of such threads is handled. */
3945 remove_new_fork_children (&context
);
3947 /* And now add threads we don't know about yet to our list. */
3948 for (thread_item
&item
: context
.items
)
3950 if (item
.ptid
!= null_ptid
)
3952 /* In non-stop mode, we assume new found threads are
3953 executing until proven otherwise with a stop reply.
3954 In all-stop, we can only get here if all threads are
3956 int executing
= target_is_non_stop_p () ? 1 : 0;
3958 remote_notice_new_inferior (item
.ptid
, executing
);
3960 thread_info
*tp
= find_thread_ptid (this, item
.ptid
);
3961 remote_thread_info
*info
= get_remote_thread_info (tp
);
3962 info
->core
= item
.core
;
3963 info
->extra
= std::move (item
.extra
);
3964 info
->name
= std::move (item
.name
);
3965 info
->thread_handle
= std::move (item
.thread_handle
);
3972 /* If no thread listing method is supported, then query whether
3973 each known thread is alive, one by one, with the T packet.
3974 If the target doesn't support threads at all, then this is a
3975 no-op. See remote_thread_alive. */
3981 * Collect a descriptive string about the given thread.
3982 * The target may say anything it wants to about the thread
3983 * (typically info about its blocked / runnable state, name, etc.).
3984 * This string will appear in the info threads display.
3986 * Optional: targets are not required to implement this function.
3990 remote_target::extra_thread_info (thread_info
*tp
)
3992 struct remote_state
*rs
= get_remote_state ();
3995 struct gdb_ext_thread_info threadinfo
;
3997 if (rs
->remote_desc
== 0) /* paranoia */
3998 internal_error (__FILE__
, __LINE__
,
3999 _("remote_threads_extra_info"));
4001 if (tp
->ptid
== magic_null_ptid
4002 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
4003 /* This is the main thread which was added by GDB. The remote
4004 server doesn't know about it. */
4007 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
4009 /* If already have cached info, use it. */
4010 if (!extra
.empty ())
4011 return extra
.c_str ();
4013 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
4015 /* If we're using qXfer:threads:read, then the extra info is
4016 included in the XML. So if we didn't have anything cached,
4017 it's because there's really no extra info. */
4021 if (rs
->use_threadextra_query
)
4023 char *b
= rs
->buf
.data ();
4024 char *endb
= b
+ get_remote_packet_size ();
4026 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
4028 write_ptid (b
, endb
, tp
->ptid
);
4031 getpkt (&rs
->buf
, 0);
4032 if (rs
->buf
[0] != 0)
4034 extra
.resize (strlen (rs
->buf
.data ()) / 2);
4035 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
4036 return extra
.c_str ();
4040 /* If the above query fails, fall back to the old method. */
4041 rs
->use_threadextra_query
= 0;
4042 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
4043 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
4044 int_to_threadref (&id
, tp
->ptid
.lwp ());
4045 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
4046 if (threadinfo
.active
)
4048 if (*threadinfo
.shortname
)
4049 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
4050 if (*threadinfo
.display
)
4052 if (!extra
.empty ())
4054 string_appendf (extra
, " State: %s", threadinfo
.display
);
4056 if (*threadinfo
.more_display
)
4058 if (!extra
.empty ())
4060 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
4062 return extra
.c_str ();
4069 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
4070 struct static_tracepoint_marker
*marker
)
4072 struct remote_state
*rs
= get_remote_state ();
4073 char *p
= rs
->buf
.data ();
4075 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
4077 p
+= hexnumstr (p
, addr
);
4079 getpkt (&rs
->buf
, 0);
4080 p
= rs
->buf
.data ();
4083 error (_("Remote failure reply: %s"), p
);
4087 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
4094 std::vector
<static_tracepoint_marker
>
4095 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
4097 struct remote_state
*rs
= get_remote_state ();
4098 std::vector
<static_tracepoint_marker
> markers
;
4100 static_tracepoint_marker marker
;
4102 /* Ask for a first packet of static tracepoint marker
4105 getpkt (&rs
->buf
, 0);
4106 p
= rs
->buf
.data ();
4108 error (_("Remote failure reply: %s"), p
);
4114 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
4116 if (strid
== NULL
|| marker
.str_id
== strid
)
4117 markers
.push_back (std::move (marker
));
4119 while (*p
++ == ','); /* comma-separated list */
4120 /* Ask for another packet of static tracepoint definition. */
4122 getpkt (&rs
->buf
, 0);
4123 p
= rs
->buf
.data ();
4130 /* Implement the to_get_ada_task_ptid function for the remote targets. */
4133 remote_target::get_ada_task_ptid (long lwp
, long thread
)
4135 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
4139 /* Restart the remote side; this is an extended protocol operation. */
4142 remote_target::extended_remote_restart ()
4144 struct remote_state
*rs
= get_remote_state ();
4146 /* Send the restart command; for reasons I don't understand the
4147 remote side really expects a number after the "R". */
4148 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
4151 remote_fileio_reset ();
4154 /* Clean up connection to a remote debugger. */
4157 remote_target::close ()
4159 /* Make sure we leave stdin registered in the event loop. */
4162 trace_reset_local_state ();
4167 remote_target::~remote_target ()
4169 struct remote_state
*rs
= get_remote_state ();
4171 /* Check for NULL because we may get here with a partially
4172 constructed target/connection. */
4173 if (rs
->remote_desc
== nullptr)
4176 serial_close (rs
->remote_desc
);
4178 /* We are destroying the remote target, so we should discard
4179 everything of this target. */
4180 discard_pending_stop_replies_in_queue ();
4182 if (rs
->remote_async_inferior_event_token
)
4183 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4185 delete rs
->notif_state
;
4188 /* Query the remote side for the text, data and bss offsets. */
4191 remote_target::get_offsets ()
4193 struct remote_state
*rs
= get_remote_state ();
4196 int lose
, num_segments
= 0, do_sections
, do_segments
;
4197 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4199 if (current_program_space
->symfile_object_file
== NULL
)
4202 putpkt ("qOffsets");
4203 getpkt (&rs
->buf
, 0);
4204 buf
= rs
->buf
.data ();
4206 if (buf
[0] == '\000')
4207 return; /* Return silently. Stub doesn't support
4211 warning (_("Remote failure reply: %s"), buf
);
4215 /* Pick up each field in turn. This used to be done with scanf, but
4216 scanf will make trouble if CORE_ADDR size doesn't match
4217 conversion directives correctly. The following code will work
4218 with any size of CORE_ADDR. */
4219 text_addr
= data_addr
= bss_addr
= 0;
4223 if (startswith (ptr
, "Text="))
4226 /* Don't use strtol, could lose on big values. */
4227 while (*ptr
&& *ptr
!= ';')
4228 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4230 if (startswith (ptr
, ";Data="))
4233 while (*ptr
&& *ptr
!= ';')
4234 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4239 if (!lose
&& startswith (ptr
, ";Bss="))
4242 while (*ptr
&& *ptr
!= ';')
4243 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4245 if (bss_addr
!= data_addr
)
4246 warning (_("Target reported unsupported offsets: %s"), buf
);
4251 else if (startswith (ptr
, "TextSeg="))
4254 /* Don't use strtol, could lose on big values. */
4255 while (*ptr
&& *ptr
!= ';')
4256 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4259 if (startswith (ptr
, ";DataSeg="))
4262 while (*ptr
&& *ptr
!= ';')
4263 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4271 error (_("Malformed response to offset query, %s"), buf
);
4272 else if (*ptr
!= '\0')
4273 warning (_("Target reported unsupported offsets: %s"), buf
);
4275 objfile
*objf
= current_program_space
->symfile_object_file
;
4276 section_offsets offs
= objf
->section_offsets
;
4278 symfile_segment_data_up data
= get_symfile_segment_data (objf
->obfd
);
4279 do_segments
= (data
!= NULL
);
4280 do_sections
= num_segments
== 0;
4282 if (num_segments
> 0)
4284 segments
[0] = text_addr
;
4285 segments
[1] = data_addr
;
4287 /* If we have two segments, we can still try to relocate everything
4288 by assuming that the .text and .data offsets apply to the whole
4289 text and data segments. Convert the offsets given in the packet
4290 to base addresses for symfile_map_offsets_to_segments. */
4291 else if (data
!= nullptr && data
->segments
.size () == 2)
4293 segments
[0] = data
->segments
[0].base
+ text_addr
;
4294 segments
[1] = data
->segments
[1].base
+ data_addr
;
4297 /* If the object file has only one segment, assume that it is text
4298 rather than data; main programs with no writable data are rare,
4299 but programs with no code are useless. Of course the code might
4300 have ended up in the data segment... to detect that we would need
4301 the permissions here. */
4302 else if (data
&& data
->segments
.size () == 1)
4304 segments
[0] = data
->segments
[0].base
+ text_addr
;
4307 /* There's no way to relocate by segment. */
4313 int ret
= symfile_map_offsets_to_segments (objf
->obfd
,
4315 num_segments
, segments
);
4317 if (ret
== 0 && !do_sections
)
4318 error (_("Can not handle qOffsets TextSeg "
4319 "response with this symbol file"));
4327 offs
[SECT_OFF_TEXT (objf
)] = text_addr
;
4329 /* This is a temporary kludge to force data and bss to use the
4330 same offsets because that's what nlmconv does now. The real
4331 solution requires changes to the stub and remote.c that I
4332 don't have time to do right now. */
4334 offs
[SECT_OFF_DATA (objf
)] = data_addr
;
4335 offs
[SECT_OFF_BSS (objf
)] = data_addr
;
4338 objfile_relocate (objf
, offs
);
4341 /* Send interrupt_sequence to remote target. */
4344 remote_target::send_interrupt_sequence ()
4346 struct remote_state
*rs
= get_remote_state ();
4348 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4349 remote_serial_write ("\x03", 1);
4350 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4351 serial_send_break (rs
->remote_desc
);
4352 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4354 serial_send_break (rs
->remote_desc
);
4355 remote_serial_write ("g", 1);
4358 internal_error (__FILE__
, __LINE__
,
4359 _("Invalid value for interrupt_sequence_mode: %s."),
4360 interrupt_sequence_mode
);
4364 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4365 and extract the PTID. Returns NULL_PTID if not found. */
4368 stop_reply_extract_thread (const char *stop_reply
)
4370 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4374 /* Txx r:val ; r:val (...) */
4377 /* Look for "register" named "thread". */
4382 p1
= strchr (p
, ':');
4386 if (strncmp (p
, "thread", p1
- p
) == 0)
4387 return read_ptid (++p1
, &p
);
4389 p1
= strchr (p
, ';');
4401 /* Determine the remote side's current thread. If we have a stop
4402 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4403 "thread" register we can extract the current thread from. If not,
4404 ask the remote which is the current thread with qC. The former
4405 method avoids a roundtrip. */
4408 remote_target::get_current_thread (const char *wait_status
)
4410 ptid_t ptid
= null_ptid
;
4412 /* Note we don't use remote_parse_stop_reply as that makes use of
4413 the target architecture, which we haven't yet fully determined at
4415 if (wait_status
!= NULL
)
4416 ptid
= stop_reply_extract_thread (wait_status
);
4417 if (ptid
== null_ptid
)
4418 ptid
= remote_current_thread (inferior_ptid
);
4423 /* Query the remote target for which is the current thread/process,
4424 add it to our tables, and update INFERIOR_PTID. The caller is
4425 responsible for setting the state such that the remote end is ready
4426 to return the current thread.
4428 This function is called after handling the '?' or 'vRun' packets,
4429 whose response is a stop reply from which we can also try
4430 extracting the thread. If the target doesn't support the explicit
4431 qC query, we infer the current thread from that stop reply, passed
4432 in in WAIT_STATUS, which may be NULL.
4434 The function returns pointer to the main thread of the inferior. */
4437 remote_target::add_current_inferior_and_thread (const char *wait_status
)
4439 struct remote_state
*rs
= get_remote_state ();
4440 bool fake_pid_p
= false;
4442 switch_to_no_thread ();
4444 /* Now, if we have thread information, update the current thread's
4446 ptid_t curr_ptid
= get_current_thread (wait_status
);
4448 if (curr_ptid
!= null_ptid
)
4450 if (!remote_multi_process_p (rs
))
4455 /* Without this, some commands which require an active target
4456 (such as kill) won't work. This variable serves (at least)
4457 double duty as both the pid of the target process (if it has
4458 such), and as a flag indicating that a target is active. */
4459 curr_ptid
= magic_null_ptid
;
4463 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4465 /* Add the main thread and switch to it. Don't try reading
4466 registers yet, since we haven't fetched the target description
4468 thread_info
*tp
= add_thread_silent (this, curr_ptid
);
4469 switch_to_thread_no_regs (tp
);
4474 /* Print info about a thread that was found already stopped on
4478 print_one_stopped_thread (struct thread_info
*thread
)
4480 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4482 switch_to_thread (thread
);
4483 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4484 set_current_sal_from_frame (get_current_frame ());
4486 thread
->suspend
.waitstatus_pending_p
= 0;
4488 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4490 enum gdb_signal sig
= ws
->value
.sig
;
4492 if (signal_print_state (sig
))
4493 gdb::observers::signal_received
.notify (sig
);
4495 gdb::observers::normal_stop
.notify (NULL
, 1);
4498 /* Process all initial stop replies the remote side sent in response
4499 to the ? packet. These indicate threads that were already stopped
4500 on initial connection. We mark these threads as stopped and print
4501 their current frame before giving the user the prompt. */
4504 remote_target::process_initial_stop_replies (int from_tty
)
4506 int pending_stop_replies
= stop_reply_queue_length ();
4507 struct thread_info
*selected
= NULL
;
4508 struct thread_info
*lowest_stopped
= NULL
;
4509 struct thread_info
*first
= NULL
;
4511 /* Consume the initial pending events. */
4512 while (pending_stop_replies
-- > 0)
4514 ptid_t waiton_ptid
= minus_one_ptid
;
4516 struct target_waitstatus ws
;
4517 int ignore_event
= 0;
4519 memset (&ws
, 0, sizeof (ws
));
4520 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4522 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4526 case TARGET_WAITKIND_IGNORE
:
4527 case TARGET_WAITKIND_NO_RESUMED
:
4528 case TARGET_WAITKIND_SIGNALLED
:
4529 case TARGET_WAITKIND_EXITED
:
4530 /* We shouldn't see these, but if we do, just ignore. */
4531 remote_debug_printf ("event ignored");
4535 case TARGET_WAITKIND_EXECD
:
4536 xfree (ws
.value
.execd_pathname
);
4545 thread_info
*evthread
= find_thread_ptid (this, event_ptid
);
4547 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4549 enum gdb_signal sig
= ws
.value
.sig
;
4551 /* Stubs traditionally report SIGTRAP as initial signal,
4552 instead of signal 0. Suppress it. */
4553 if (sig
== GDB_SIGNAL_TRAP
)
4555 evthread
->suspend
.stop_signal
= sig
;
4559 evthread
->suspend
.waitstatus
= ws
;
4561 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4562 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4563 evthread
->suspend
.waitstatus_pending_p
= 1;
4565 set_executing (this, event_ptid
, false);
4566 set_running (this, event_ptid
, false);
4567 get_remote_thread_info (evthread
)->set_not_resumed ();
4570 /* "Notice" the new inferiors before anything related to
4571 registers/memory. */
4572 for (inferior
*inf
: all_non_exited_inferiors (this))
4574 inf
->needs_setup
= 1;
4578 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4579 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4584 /* If all-stop on top of non-stop, pause all threads. Note this
4585 records the threads' stop pc, so must be done after "noticing"
4589 stop_all_threads ();
4591 /* If all threads of an inferior were already stopped, we
4592 haven't setup the inferior yet. */
4593 for (inferior
*inf
: all_non_exited_inferiors (this))
4595 if (inf
->needs_setup
)
4597 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4598 switch_to_thread_no_regs (thread
);
4604 /* Now go over all threads that are stopped, and print their current
4605 frame. If all-stop, then if there's a signalled thread, pick
4607 for (thread_info
*thread
: all_non_exited_threads (this))
4613 thread
->set_running (false);
4614 else if (thread
->state
!= THREAD_STOPPED
)
4617 if (selected
== NULL
4618 && thread
->suspend
.waitstatus_pending_p
)
4621 if (lowest_stopped
== NULL
4622 || thread
->inf
->num
< lowest_stopped
->inf
->num
4623 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4624 lowest_stopped
= thread
;
4627 print_one_stopped_thread (thread
);
4630 /* In all-stop, we only print the status of one thread, and leave
4631 others with their status pending. */
4634 thread_info
*thread
= selected
;
4636 thread
= lowest_stopped
;
4640 print_one_stopped_thread (thread
);
4643 /* For "info program". */
4644 thread_info
*thread
= inferior_thread ();
4645 if (thread
->state
== THREAD_STOPPED
)
4646 set_last_target_status (this, inferior_ptid
, thread
->suspend
.waitstatus
);
4649 /* Start the remote connection and sync state. */
4652 remote_target::start_remote (int from_tty
, int extended_p
)
4654 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
4656 struct remote_state
*rs
= get_remote_state ();
4657 struct packet_config
*noack_config
;
4659 /* Signal other parts that we're going through the initial setup,
4660 and so things may not be stable yet. E.g., we don't try to
4661 install tracepoints until we've relocated symbols. Also, a
4662 Ctrl-C before we're connected and synced up can't interrupt the
4663 target. Instead, it offers to drop the (potentially wedged)
4665 rs
->starting_up
= 1;
4669 if (interrupt_on_connect
)
4670 send_interrupt_sequence ();
4672 /* Ack any packet which the remote side has already sent. */
4673 remote_serial_write ("+", 1);
4675 /* The first packet we send to the target is the optional "supported
4676 packets" request. If the target can answer this, it will tell us
4677 which later probes to skip. */
4678 remote_query_supported ();
4680 /* If the stub wants to get a QAllow, compose one and send it. */
4681 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4684 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4685 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4686 as a reply to known packet. For packet "vFile:setfs:" it is an
4687 invalid reply and GDB would return error in
4688 remote_hostio_set_filesystem, making remote files access impossible.
4689 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4690 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4692 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4694 putpkt (v_mustreplyempty
);
4695 getpkt (&rs
->buf
, 0);
4696 if (strcmp (rs
->buf
.data (), "OK") == 0)
4697 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4698 else if (strcmp (rs
->buf
.data (), "") != 0)
4699 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4703 /* Next, we possibly activate noack mode.
4705 If the QStartNoAckMode packet configuration is set to AUTO,
4706 enable noack mode if the stub reported a wish for it with
4709 If set to TRUE, then enable noack mode even if the stub didn't
4710 report it in qSupported. If the stub doesn't reply OK, the
4711 session ends with an error.
4713 If FALSE, then don't activate noack mode, regardless of what the
4714 stub claimed should be the default with qSupported. */
4716 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4717 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4719 putpkt ("QStartNoAckMode");
4720 getpkt (&rs
->buf
, 0);
4721 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4727 /* Tell the remote that we are using the extended protocol. */
4729 getpkt (&rs
->buf
, 0);
4732 /* Let the target know which signals it is allowed to pass down to
4734 update_signals_program_target ();
4736 /* Next, if the target can specify a description, read it. We do
4737 this before anything involving memory or registers. */
4738 target_find_description ();
4740 /* Next, now that we know something about the target, update the
4741 address spaces in the program spaces. */
4742 update_address_spaces ();
4744 /* On OSs where the list of libraries is global to all
4745 processes, we fetch them early. */
4746 if (gdbarch_has_global_solist (target_gdbarch ()))
4747 solib_add (NULL
, from_tty
, auto_solib_add
);
4749 if (target_is_non_stop_p ())
4751 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4752 error (_("Non-stop mode requested, but remote "
4753 "does not support non-stop"));
4755 putpkt ("QNonStop:1");
4756 getpkt (&rs
->buf
, 0);
4758 if (strcmp (rs
->buf
.data (), "OK") != 0)
4759 error (_("Remote refused setting non-stop mode with: %s"),
4762 /* Find about threads and processes the stub is already
4763 controlling. We default to adding them in the running state.
4764 The '?' query below will then tell us about which threads are
4766 this->update_thread_list ();
4768 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4770 /* Don't assume that the stub can operate in all-stop mode.
4771 Request it explicitly. */
4772 putpkt ("QNonStop:0");
4773 getpkt (&rs
->buf
, 0);
4775 if (strcmp (rs
->buf
.data (), "OK") != 0)
4776 error (_("Remote refused setting all-stop mode with: %s"),
4780 /* Upload TSVs regardless of whether the target is running or not. The
4781 remote stub, such as GDBserver, may have some predefined or builtin
4782 TSVs, even if the target is not running. */
4783 if (get_trace_status (current_trace_status ()) != -1)
4785 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4787 upload_trace_state_variables (&uploaded_tsvs
);
4788 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4791 /* Check whether the target is running now. */
4793 getpkt (&rs
->buf
, 0);
4795 if (!target_is_non_stop_p ())
4797 char *wait_status
= NULL
;
4799 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4802 error (_("The target is not running (try extended-remote?)"));
4804 /* We're connected, but not running. Drop out before we
4805 call start_remote. */
4806 rs
->starting_up
= 0;
4811 /* Save the reply for later. */
4812 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4813 strcpy (wait_status
, rs
->buf
.data ());
4816 /* Fetch thread list. */
4817 target_update_thread_list ();
4819 /* Let the stub know that we want it to return the thread. */
4820 set_continue_thread (minus_one_ptid
);
4822 if (thread_count (this) == 0)
4824 /* Target has no concept of threads at all. GDB treats
4825 non-threaded target as single-threaded; add a main
4827 thread_info
*tp
= add_current_inferior_and_thread (wait_status
);
4828 get_remote_thread_info (tp
)->set_resumed ();
4832 /* We have thread information; select the thread the target
4833 says should be current. If we're reconnecting to a
4834 multi-threaded program, this will ideally be the thread
4835 that last reported an event before GDB disconnected. */
4836 ptid_t curr_thread
= get_current_thread (wait_status
);
4837 if (curr_thread
== null_ptid
)
4839 /* Odd... The target was able to list threads, but not
4840 tell us which thread was current (no "thread"
4841 register in T stop reply?). Just pick the first
4842 thread in the thread list then. */
4844 remote_debug_printf ("warning: couldn't determine remote "
4845 "current thread; picking first in list.");
4847 for (thread_info
*tp
: all_non_exited_threads (this,
4850 switch_to_thread (tp
);
4855 switch_to_thread (find_thread_ptid (this, curr_thread
));
4858 /* init_wait_for_inferior should be called before get_offsets in order
4859 to manage `inserted' flag in bp loc in a correct state.
4860 breakpoint_init_inferior, called from init_wait_for_inferior, set
4861 `inserted' flag to 0, while before breakpoint_re_set, called from
4862 start_remote, set `inserted' flag to 1. In the initialization of
4863 inferior, breakpoint_init_inferior should be called first, and then
4864 breakpoint_re_set can be called. If this order is broken, state of
4865 `inserted' flag is wrong, and cause some problems on breakpoint
4867 init_wait_for_inferior ();
4869 get_offsets (); /* Get text, data & bss offsets. */
4871 /* If we could not find a description using qXfer, and we know
4872 how to do it some other way, try again. This is not
4873 supported for non-stop; it could be, but it is tricky if
4874 there are no stopped threads when we connect. */
4875 if (remote_read_description_p (this)
4876 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4878 target_clear_description ();
4879 target_find_description ();
4882 /* Use the previously fetched status. */
4883 gdb_assert (wait_status
!= NULL
);
4884 strcpy (rs
->buf
.data (), wait_status
);
4885 rs
->cached_wait_status
= 1;
4887 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4891 /* Clear WFI global state. Do this before finding about new
4892 threads and inferiors, and setting the current inferior.
4893 Otherwise we would clear the proceed status of the current
4894 inferior when we want its stop_soon state to be preserved
4895 (see notice_new_inferior). */
4896 init_wait_for_inferior ();
4898 /* In non-stop, we will either get an "OK", meaning that there
4899 are no stopped threads at this time; or, a regular stop
4900 reply. In the latter case, there may be more than one thread
4901 stopped --- we pull them all out using the vStopped
4903 if (strcmp (rs
->buf
.data (), "OK") != 0)
4905 struct notif_client
*notif
= ¬if_client_stop
;
4907 /* remote_notif_get_pending_replies acks this one, and gets
4909 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4910 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4911 remote_notif_get_pending_events (notif
);
4914 if (thread_count (this) == 0)
4917 error (_("The target is not running (try extended-remote?)"));
4919 /* We're connected, but not running. Drop out before we
4920 call start_remote. */
4921 rs
->starting_up
= 0;
4925 /* Report all signals during attach/startup. */
4928 /* If there are already stopped threads, mark them stopped and
4929 report their stops before giving the prompt to the user. */
4930 process_initial_stop_replies (from_tty
);
4932 if (target_can_async_p ())
4936 /* If we connected to a live target, do some additional setup. */
4937 if (target_has_execution ())
4939 /* No use without a symbol-file. */
4940 if (current_program_space
->symfile_object_file
)
4941 remote_check_symbols ();
4944 /* Possibly the target has been engaged in a trace run started
4945 previously; find out where things are at. */
4946 if (get_trace_status (current_trace_status ()) != -1)
4948 struct uploaded_tp
*uploaded_tps
= NULL
;
4950 if (current_trace_status ()->running
)
4951 printf_filtered (_("Trace is already running on the target.\n"));
4953 upload_tracepoints (&uploaded_tps
);
4955 merge_uploaded_tracepoints (&uploaded_tps
);
4958 /* Possibly the target has been engaged in a btrace record started
4959 previously; find out where things are at. */
4960 remote_btrace_maybe_reopen ();
4962 /* The thread and inferior lists are now synchronized with the
4963 target, our symbols have been relocated, and we're merged the
4964 target's tracepoints with ours. We're done with basic start
4966 rs
->starting_up
= 0;
4968 /* Maybe breakpoints are global and need to be inserted now. */
4969 if (breakpoints_should_be_inserted_now ())
4970 insert_breakpoints ();
4974 remote_target::connection_string ()
4976 remote_state
*rs
= get_remote_state ();
4978 if (rs
->remote_desc
->name
!= NULL
)
4979 return rs
->remote_desc
->name
;
4984 /* Open a connection to a remote debugger.
4985 NAME is the filename used for communication. */
4988 remote_target::open (const char *name
, int from_tty
)
4990 open_1 (name
, from_tty
, 0);
4993 /* Open a connection to a remote debugger using the extended
4994 remote gdb protocol. NAME is the filename used for communication. */
4997 extended_remote_target::open (const char *name
, int from_tty
)
4999 open_1 (name
, from_tty
, 1 /*extended_p */);
5002 /* Reset all packets back to "unknown support". Called when opening a
5003 new connection to a remote target. */
5006 reset_all_packet_configs_support (void)
5010 for (i
= 0; i
< PACKET_MAX
; i
++)
5011 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
5014 /* Initialize all packet configs. */
5017 init_all_packet_configs (void)
5021 for (i
= 0; i
< PACKET_MAX
; i
++)
5023 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
5024 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
5028 /* Symbol look-up. */
5031 remote_target::remote_check_symbols ()
5036 /* The remote side has no concept of inferiors that aren't running
5037 yet, it only knows about running processes. If we're connected
5038 but our current inferior is not running, we should not invite the
5039 remote target to request symbol lookups related to its
5040 (unrelated) current process. */
5041 if (!target_has_execution ())
5044 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
5047 /* Make sure the remote is pointing at the right process. Note
5048 there's no way to select "no process". */
5049 set_general_process ();
5051 /* Allocate a message buffer. We can't reuse the input buffer in RS,
5052 because we need both at the same time. */
5053 gdb::char_vector
msg (get_remote_packet_size ());
5054 gdb::char_vector
reply (get_remote_packet_size ());
5056 /* Invite target to request symbol lookups. */
5058 putpkt ("qSymbol::");
5060 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
5062 while (startswith (reply
.data (), "qSymbol:"))
5064 struct bound_minimal_symbol sym
;
5067 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
5070 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
5071 if (sym
.minsym
== NULL
)
5072 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
5076 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
5077 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
5079 /* If this is a function address, return the start of code
5080 instead of any data function descriptor. */
5081 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
5083 current_top_target ());
5085 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
5086 phex_nz (sym_addr
, addr_size
), &reply
[8]);
5089 putpkt (msg
.data ());
5094 static struct serial
*
5095 remote_serial_open (const char *name
)
5097 static int udp_warning
= 0;
5099 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
5100 of in ser-tcp.c, because it is the remote protocol assuming that the
5101 serial connection is reliable and not the serial connection promising
5103 if (!udp_warning
&& startswith (name
, "udp:"))
5105 warning (_("The remote protocol may be unreliable over UDP.\n"
5106 "Some events may be lost, rendering further debugging "
5111 return serial_open (name
);
5114 /* Inform the target of our permission settings. The permission flags
5115 work without this, but if the target knows the settings, it can do
5116 a couple things. First, it can add its own check, to catch cases
5117 that somehow manage to get by the permissions checks in target
5118 methods. Second, if the target is wired to disallow particular
5119 settings (for instance, a system in the field that is not set up to
5120 be able to stop at a breakpoint), it can object to any unavailable
5124 remote_target::set_permissions ()
5126 struct remote_state
*rs
= get_remote_state ();
5128 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
5129 "WriteReg:%x;WriteMem:%x;"
5130 "InsertBreak:%x;InsertTrace:%x;"
5131 "InsertFastTrace:%x;Stop:%x",
5132 may_write_registers
, may_write_memory
,
5133 may_insert_breakpoints
, may_insert_tracepoints
,
5134 may_insert_fast_tracepoints
, may_stop
);
5136 getpkt (&rs
->buf
, 0);
5138 /* If the target didn't like the packet, warn the user. Do not try
5139 to undo the user's settings, that would just be maddening. */
5140 if (strcmp (rs
->buf
.data (), "OK") != 0)
5141 warning (_("Remote refused setting permissions with: %s"),
5145 /* This type describes each known response to the qSupported
5147 struct protocol_feature
5149 /* The name of this protocol feature. */
5152 /* The default for this protocol feature. */
5153 enum packet_support default_support
;
5155 /* The function to call when this feature is reported, or after
5156 qSupported processing if the feature is not supported.
5157 The first argument points to this structure. The second
5158 argument indicates whether the packet requested support be
5159 enabled, disabled, or probed (or the default, if this function
5160 is being called at the end of processing and this feature was
5161 not reported). The third argument may be NULL; if not NULL, it
5162 is a NUL-terminated string taken from the packet following
5163 this feature's name and an equals sign. */
5164 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5165 enum packet_support
, const char *);
5167 /* The corresponding packet for this feature. Only used if
5168 FUNC is remote_supported_packet. */
5173 remote_supported_packet (remote_target
*remote
,
5174 const struct protocol_feature
*feature
,
5175 enum packet_support support
,
5176 const char *argument
)
5180 warning (_("Remote qSupported response supplied an unexpected value for"
5181 " \"%s\"."), feature
->name
);
5185 remote_protocol_packets
[feature
->packet
].support
= support
;
5189 remote_target::remote_packet_size (const protocol_feature
*feature
,
5190 enum packet_support support
, const char *value
)
5192 struct remote_state
*rs
= get_remote_state ();
5197 if (support
!= PACKET_ENABLE
)
5200 if (value
== NULL
|| *value
== '\0')
5202 warning (_("Remote target reported \"%s\" without a size."),
5208 packet_size
= strtol (value
, &value_end
, 16);
5209 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5211 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5212 feature
->name
, value
);
5216 /* Record the new maximum packet size. */
5217 rs
->explicit_packet_size
= packet_size
;
5221 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5222 enum packet_support support
, const char *value
)
5224 remote
->remote_packet_size (feature
, support
, value
);
5227 static const struct protocol_feature remote_protocol_features
[] = {
5228 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5229 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5230 PACKET_qXfer_auxv
},
5231 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5232 PACKET_qXfer_exec_file
},
5233 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5234 PACKET_qXfer_features
},
5235 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5236 PACKET_qXfer_libraries
},
5237 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5238 PACKET_qXfer_libraries_svr4
},
5239 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5240 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5241 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5242 PACKET_qXfer_memory_map
},
5243 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5244 PACKET_qXfer_osdata
},
5245 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5246 PACKET_qXfer_threads
},
5247 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5248 PACKET_qXfer_traceframe_info
},
5249 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5250 PACKET_QPassSignals
},
5251 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5252 PACKET_QCatchSyscalls
},
5253 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5254 PACKET_QProgramSignals
},
5255 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5256 PACKET_QSetWorkingDir
},
5257 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5258 PACKET_QStartupWithShell
},
5259 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5260 PACKET_QEnvironmentHexEncoded
},
5261 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5262 PACKET_QEnvironmentReset
},
5263 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5264 PACKET_QEnvironmentUnset
},
5265 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5266 PACKET_QStartNoAckMode
},
5267 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5268 PACKET_multiprocess_feature
},
5269 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5270 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5271 PACKET_qXfer_siginfo_read
},
5272 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5273 PACKET_qXfer_siginfo_write
},
5274 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5275 PACKET_ConditionalTracepoints
},
5276 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5277 PACKET_ConditionalBreakpoints
},
5278 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5279 PACKET_BreakpointCommands
},
5280 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5281 PACKET_FastTracepoints
},
5282 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5283 PACKET_StaticTracepoints
},
5284 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5285 PACKET_InstallInTrace
},
5286 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5287 PACKET_DisconnectedTracing_feature
},
5288 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5290 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5292 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5293 PACKET_TracepointSource
},
5294 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5296 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5297 PACKET_EnableDisableTracepoints_feature
},
5298 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5299 PACKET_qXfer_fdpic
},
5300 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5302 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5303 PACKET_QDisableRandomization
},
5304 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5305 { "QTBuffer:size", PACKET_DISABLE
,
5306 remote_supported_packet
, PACKET_QTBuffer_size
},
5307 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5308 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5309 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5310 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5311 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5312 PACKET_qXfer_btrace
},
5313 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5314 PACKET_qXfer_btrace_conf
},
5315 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5316 PACKET_Qbtrace_conf_bts_size
},
5317 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5318 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5319 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5320 PACKET_fork_event_feature
},
5321 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5322 PACKET_vfork_event_feature
},
5323 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5324 PACKET_exec_event_feature
},
5325 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5326 PACKET_Qbtrace_conf_pt_size
},
5327 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5328 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5329 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5330 { "memory-tagging", PACKET_DISABLE
, remote_supported_packet
,
5331 PACKET_memory_tagging_feature
},
5334 static char *remote_support_xml
;
5336 /* Register string appended to "xmlRegisters=" in qSupported query. */
5339 register_remote_support_xml (const char *xml
)
5341 #if defined(HAVE_LIBEXPAT)
5342 if (remote_support_xml
== NULL
)
5343 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5346 char *copy
= xstrdup (remote_support_xml
+ 13);
5348 char *p
= strtok_r (copy
, ",", &saveptr
);
5352 if (strcmp (p
, xml
) == 0)
5359 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5362 remote_support_xml
= reconcat (remote_support_xml
,
5363 remote_support_xml
, ",", xml
,
5370 remote_query_supported_append (std::string
*msg
, const char *append
)
5374 msg
->append (append
);
5378 remote_target::remote_query_supported ()
5380 struct remote_state
*rs
= get_remote_state ();
5383 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5385 /* The packet support flags are handled differently for this packet
5386 than for most others. We treat an error, a disabled packet, and
5387 an empty response identically: any features which must be reported
5388 to be used will be automatically disabled. An empty buffer
5389 accomplishes this, since that is also the representation for a list
5390 containing no features. */
5393 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5397 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5398 remote_query_supported_append (&q
, "multiprocess+");
5400 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5401 remote_query_supported_append (&q
, "swbreak+");
5402 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5403 remote_query_supported_append (&q
, "hwbreak+");
5405 remote_query_supported_append (&q
, "qRelocInsn+");
5407 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5408 != AUTO_BOOLEAN_FALSE
)
5409 remote_query_supported_append (&q
, "fork-events+");
5410 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5411 != AUTO_BOOLEAN_FALSE
)
5412 remote_query_supported_append (&q
, "vfork-events+");
5413 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5414 != AUTO_BOOLEAN_FALSE
)
5415 remote_query_supported_append (&q
, "exec-events+");
5417 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5418 remote_query_supported_append (&q
, "vContSupported+");
5420 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5421 remote_query_supported_append (&q
, "QThreadEvents+");
5423 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5424 remote_query_supported_append (&q
, "no-resumed+");
5426 if (packet_set_cmd_state (PACKET_memory_tagging_feature
)
5427 != AUTO_BOOLEAN_FALSE
)
5428 remote_query_supported_append (&q
, "memory-tagging+");
5430 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5431 the qSupported:xmlRegisters=i386 handling. */
5432 if (remote_support_xml
!= NULL
5433 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5434 remote_query_supported_append (&q
, remote_support_xml
);
5436 q
= "qSupported:" + q
;
5437 putpkt (q
.c_str ());
5439 getpkt (&rs
->buf
, 0);
5441 /* If an error occured, warn, but do not return - just reset the
5442 buffer to empty and go on to disable features. */
5443 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5446 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5451 memset (seen
, 0, sizeof (seen
));
5453 next
= rs
->buf
.data ();
5456 enum packet_support is_supported
;
5457 char *p
, *end
, *name_end
, *value
;
5459 /* First separate out this item from the rest of the packet. If
5460 there's another item after this, we overwrite the separator
5461 (terminated strings are much easier to work with). */
5463 end
= strchr (p
, ';');
5466 end
= p
+ strlen (p
);
5476 warning (_("empty item in \"qSupported\" response"));
5481 name_end
= strchr (p
, '=');
5484 /* This is a name=value entry. */
5485 is_supported
= PACKET_ENABLE
;
5486 value
= name_end
+ 1;
5495 is_supported
= PACKET_ENABLE
;
5499 is_supported
= PACKET_DISABLE
;
5503 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5507 warning (_("unrecognized item \"%s\" "
5508 "in \"qSupported\" response"), p
);
5514 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5515 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5517 const struct protocol_feature
*feature
;
5520 feature
= &remote_protocol_features
[i
];
5521 feature
->func (this, feature
, is_supported
, value
);
5526 /* If we increased the packet size, make sure to increase the global
5527 buffer size also. We delay this until after parsing the entire
5528 qSupported packet, because this is the same buffer we were
5530 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5531 rs
->buf
.resize (rs
->explicit_packet_size
);
5533 /* Handle the defaults for unmentioned features. */
5534 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5537 const struct protocol_feature
*feature
;
5539 feature
= &remote_protocol_features
[i
];
5540 feature
->func (this, feature
, feature
->default_support
, NULL
);
5544 /* Serial QUIT handler for the remote serial descriptor.
5546 Defers handling a Ctrl-C until we're done with the current
5547 command/response packet sequence, unless:
5549 - We're setting up the connection. Don't send a remote interrupt
5550 request, as we're not fully synced yet. Quit immediately
5553 - The target has been resumed in the foreground
5554 (target_terminal::is_ours is false) with a synchronous resume
5555 packet, and we're blocked waiting for the stop reply, thus a
5556 Ctrl-C should be immediately sent to the target.
5558 - We get a second Ctrl-C while still within the same serial read or
5559 write. In that case the serial is seemingly wedged --- offer to
5562 - We see a second Ctrl-C without target response, after having
5563 previously interrupted the target. In that case the target/stub
5564 is probably wedged --- offer to quit/disconnect.
5568 remote_target::remote_serial_quit_handler ()
5570 struct remote_state
*rs
= get_remote_state ();
5572 if (check_quit_flag ())
5574 /* If we're starting up, we're not fully synced yet. Quit
5576 if (rs
->starting_up
)
5578 else if (rs
->got_ctrlc_during_io
)
5580 if (query (_("The target is not responding to GDB commands.\n"
5581 "Stop debugging it? ")))
5582 remote_unpush_and_throw (this);
5584 /* If ^C has already been sent once, offer to disconnect. */
5585 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5587 /* All-stop protocol, and blocked waiting for stop reply. Send
5588 an interrupt request. */
5589 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5590 target_interrupt ();
5592 rs
->got_ctrlc_during_io
= 1;
5596 /* The remote_target that is current while the quit handler is
5597 overridden with remote_serial_quit_handler. */
5598 static remote_target
*curr_quit_handler_target
;
5601 remote_serial_quit_handler ()
5603 curr_quit_handler_target
->remote_serial_quit_handler ();
5606 /* Remove the remote target from the target stack of each inferior
5607 that is using it. Upper targets depend on it so remove them
5611 remote_unpush_target (remote_target
*target
)
5613 /* We have to unpush the target from all inferiors, even those that
5615 scoped_restore_current_inferior restore_current_inferior
;
5617 for (inferior
*inf
: all_inferiors (target
))
5619 switch_to_inferior_no_thread (inf
);
5620 pop_all_targets_at_and_above (process_stratum
);
5621 generic_mourn_inferior ();
5626 remote_unpush_and_throw (remote_target
*target
)
5628 remote_unpush_target (target
);
5629 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5633 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5635 remote_target
*curr_remote
= get_current_remote_target ();
5638 error (_("To open a remote debug connection, you need to specify what\n"
5639 "serial device is attached to the remote system\n"
5640 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5642 /* If we're connected to a running target, target_preopen will kill it.
5643 Ask this question first, before target_preopen has a chance to kill
5645 if (curr_remote
!= NULL
&& !target_has_execution ())
5648 && !query (_("Already connected to a remote target. Disconnect? ")))
5649 error (_("Still connected."));
5652 /* Here the possibly existing remote target gets unpushed. */
5653 target_preopen (from_tty
);
5655 remote_fileio_reset ();
5656 reopen_exec_file ();
5659 remote_target
*remote
5660 = (extended_p
? new extended_remote_target () : new remote_target ());
5661 target_ops_up
target_holder (remote
);
5663 remote_state
*rs
= remote
->get_remote_state ();
5665 /* See FIXME above. */
5666 if (!target_async_permitted
)
5667 rs
->wait_forever_enabled_p
= 1;
5669 rs
->remote_desc
= remote_serial_open (name
);
5670 if (!rs
->remote_desc
)
5671 perror_with_name (name
);
5673 if (baud_rate
!= -1)
5675 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5677 /* The requested speed could not be set. Error out to
5678 top level after closing remote_desc. Take care to
5679 set remote_desc to NULL to avoid closing remote_desc
5681 serial_close (rs
->remote_desc
);
5682 rs
->remote_desc
= NULL
;
5683 perror_with_name (name
);
5687 serial_setparity (rs
->remote_desc
, serial_parity
);
5688 serial_raw (rs
->remote_desc
);
5690 /* If there is something sitting in the buffer we might take it as a
5691 response to a command, which would be bad. */
5692 serial_flush_input (rs
->remote_desc
);
5696 puts_filtered ("Remote debugging using ");
5697 puts_filtered (name
);
5698 puts_filtered ("\n");
5701 /* Switch to using the remote target now. */
5702 current_inferior ()->push_target (std::move (target_holder
));
5704 /* Register extra event sources in the event loop. */
5705 rs
->remote_async_inferior_event_token
5706 = create_async_event_handler (remote_async_inferior_event_handler
, nullptr,
5708 rs
->notif_state
= remote_notif_state_allocate (remote
);
5710 /* Reset the target state; these things will be queried either by
5711 remote_query_supported or as they are needed. */
5712 reset_all_packet_configs_support ();
5713 rs
->cached_wait_status
= 0;
5714 rs
->explicit_packet_size
= 0;
5716 rs
->extended
= extended_p
;
5717 rs
->waiting_for_stop_reply
= 0;
5718 rs
->ctrlc_pending_p
= 0;
5719 rs
->got_ctrlc_during_io
= 0;
5721 rs
->general_thread
= not_sent_ptid
;
5722 rs
->continue_thread
= not_sent_ptid
;
5723 rs
->remote_traceframe_number
= -1;
5725 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5727 /* Probe for ability to use "ThreadInfo" query, as required. */
5728 rs
->use_threadinfo_query
= 1;
5729 rs
->use_threadextra_query
= 1;
5731 rs
->readahead_cache
.invalidate ();
5733 if (target_async_permitted
)
5735 /* FIXME: cagney/1999-09-23: During the initial connection it is
5736 assumed that the target is already ready and able to respond to
5737 requests. Unfortunately remote_start_remote() eventually calls
5738 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5739 around this. Eventually a mechanism that allows
5740 wait_for_inferior() to expect/get timeouts will be
5742 rs
->wait_forever_enabled_p
= 0;
5745 /* First delete any symbols previously loaded from shared libraries. */
5746 no_shared_libraries (NULL
, 0);
5748 /* Start the remote connection. If error() or QUIT, discard this
5749 target (we'd otherwise be in an inconsistent state) and then
5750 propogate the error on up the exception chain. This ensures that
5751 the caller doesn't stumble along blindly assuming that the
5752 function succeeded. The CLI doesn't have this problem but other
5753 UI's, such as MI do.
5755 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5756 this function should return an error indication letting the
5757 caller restore the previous state. Unfortunately the command
5758 ``target remote'' is directly wired to this function making that
5759 impossible. On a positive note, the CLI side of this problem has
5760 been fixed - the function set_cmd_context() makes it possible for
5761 all the ``target ....'' commands to share a common callback
5762 function. See cli-dump.c. */
5767 remote
->start_remote (from_tty
, extended_p
);
5769 catch (const gdb_exception
&ex
)
5771 /* Pop the partially set up target - unless something else did
5772 already before throwing the exception. */
5773 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5774 remote_unpush_target (remote
);
5779 remote_btrace_reset (rs
);
5781 if (target_async_permitted
)
5782 rs
->wait_forever_enabled_p
= 1;
5785 /* Detach the specified process. */
5788 remote_target::remote_detach_pid (int pid
)
5790 struct remote_state
*rs
= get_remote_state ();
5792 /* This should not be necessary, but the handling for D;PID in
5793 GDBserver versions prior to 8.2 incorrectly assumes that the
5794 selected process points to the same process we're detaching,
5795 leading to misbehavior (and possibly GDBserver crashing) when it
5796 does not. Since it's easy and cheap, work around it by forcing
5797 GDBserver to select GDB's current process. */
5798 set_general_process ();
5800 if (remote_multi_process_p (rs
))
5801 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5803 strcpy (rs
->buf
.data (), "D");
5806 getpkt (&rs
->buf
, 0);
5808 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5810 else if (rs
->buf
[0] == '\0')
5811 error (_("Remote doesn't know how to detach"));
5813 error (_("Can't detach process."));
5816 /* This detaches a program to which we previously attached, using
5817 inferior_ptid to identify the process. After this is done, GDB
5818 can be used to debug some other program. We better not have left
5819 any breakpoints in the target program or it'll die when it hits
5823 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5825 int pid
= inferior_ptid
.pid ();
5826 struct remote_state
*rs
= get_remote_state ();
5829 if (!target_has_execution ())
5830 error (_("No process to detach from."));
5832 target_announce_detach (from_tty
);
5834 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
5836 /* If we're in breakpoints-always-inserted mode, or the inferior
5837 is running, we have to remove breakpoints before detaching.
5838 We don't do this in common code instead because not all
5839 targets support removing breakpoints while the target is
5840 running. The remote target / gdbserver does, though. */
5841 remove_breakpoints_inf (current_inferior ());
5844 /* Tell the remote target to detach. */
5845 remote_detach_pid (pid
);
5847 /* Exit only if this is the only active inferior. */
5848 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors (this) == 1)
5849 puts_filtered (_("Ending remote debugging.\n"));
5851 thread_info
*tp
= find_thread_ptid (this, inferior_ptid
);
5853 /* Check to see if we are detaching a fork parent. Note that if we
5854 are detaching a fork child, tp == NULL. */
5855 is_fork_parent
= (tp
!= NULL
5856 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5858 /* If doing detach-on-fork, we don't mourn, because that will delete
5859 breakpoints that should be available for the followed inferior. */
5860 if (!is_fork_parent
)
5862 /* Save the pid as a string before mourning, since that will
5863 unpush the remote target, and we need the string after. */
5864 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5866 target_mourn_inferior (inferior_ptid
);
5867 if (print_inferior_events
)
5868 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5869 inf
->num
, infpid
.c_str ());
5873 switch_to_no_thread ();
5874 detach_inferior (current_inferior ());
5879 remote_target::detach (inferior
*inf
, int from_tty
)
5881 remote_detach_1 (inf
, from_tty
);
5885 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5887 remote_detach_1 (inf
, from_tty
);
5890 /* Target follow-fork function for remote targets. On entry, and
5891 at return, the current inferior is the fork parent.
5893 Note that although this is currently only used for extended-remote,
5894 it is named remote_follow_fork in anticipation of using it for the
5895 remote target as well. */
5898 remote_target::follow_fork (bool follow_child
, bool detach_fork
)
5900 struct remote_state
*rs
= get_remote_state ();
5901 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5903 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5904 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5906 /* When following the parent and detaching the child, we detach
5907 the child here. For the case of following the child and
5908 detaching the parent, the detach is done in the target-
5909 independent follow fork code in infrun.c. We can't use
5910 target_detach when detaching an unfollowed child because
5911 the client side doesn't know anything about the child. */
5912 if (detach_fork
&& !follow_child
)
5914 /* Detach the fork child. */
5918 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5919 child_pid
= child_ptid
.pid ();
5921 remote_detach_pid (child_pid
);
5928 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5929 in the program space of the new inferior. On entry and at return the
5930 current inferior is the exec'ing inferior. INF is the new exec'd
5931 inferior, which may be the same as the exec'ing inferior unless
5932 follow-exec-mode is "new". */
5935 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5937 /* We know that this is a target file name, so if it has the "target:"
5938 prefix we strip it off before saving it in the program space. */
5939 if (is_target_filename (execd_pathname
))
5940 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5942 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5945 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5948 remote_target::disconnect (const char *args
, int from_tty
)
5951 error (_("Argument given to \"disconnect\" when remotely debugging."));
5953 /* Make sure we unpush even the extended remote targets. Calling
5954 target_mourn_inferior won't unpush, and
5955 remote_target::mourn_inferior won't unpush if there is more than
5956 one inferior left. */
5957 remote_unpush_target (this);
5960 puts_filtered ("Ending remote debugging.\n");
5963 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5964 be chatty about it. */
5967 extended_remote_target::attach (const char *args
, int from_tty
)
5969 struct remote_state
*rs
= get_remote_state ();
5971 char *wait_status
= NULL
;
5973 pid
= parse_pid_to_attach (args
);
5975 /* Remote PID can be freely equal to getpid, do not check it here the same
5976 way as in other targets. */
5978 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5979 error (_("This target does not support attaching to a process"));
5983 const char *exec_file
= get_exec_file (0);
5986 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5987 target_pid_to_str (ptid_t (pid
)).c_str ());
5989 printf_unfiltered (_("Attaching to %s\n"),
5990 target_pid_to_str (ptid_t (pid
)).c_str ());
5993 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5995 getpkt (&rs
->buf
, 0);
5997 switch (packet_ok (rs
->buf
,
5998 &remote_protocol_packets
[PACKET_vAttach
]))
6001 if (!target_is_non_stop_p ())
6003 /* Save the reply for later. */
6004 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
6005 strcpy (wait_status
, rs
->buf
.data ());
6007 else if (strcmp (rs
->buf
.data (), "OK") != 0)
6008 error (_("Attaching to %s failed with: %s"),
6009 target_pid_to_str (ptid_t (pid
)).c_str (),
6012 case PACKET_UNKNOWN
:
6013 error (_("This target does not support attaching to a process"));
6015 error (_("Attaching to %s failed"),
6016 target_pid_to_str (ptid_t (pid
)).c_str ());
6019 switch_to_inferior_no_thread (remote_add_inferior (false, pid
, 1, 0));
6021 inferior_ptid
= ptid_t (pid
);
6023 if (target_is_non_stop_p ())
6025 /* Get list of threads. */
6026 update_thread_list ();
6028 thread_info
*thread
= first_thread_of_inferior (current_inferior ());
6029 if (thread
!= nullptr)
6030 switch_to_thread (thread
);
6032 /* Invalidate our notion of the remote current thread. */
6033 record_currthread (rs
, minus_one_ptid
);
6037 /* Now, if we have thread information, update the main thread's
6039 ptid_t curr_ptid
= remote_current_thread (ptid_t (pid
));
6041 /* Add the main thread to the thread list. */
6042 thread_info
*thr
= add_thread_silent (this, curr_ptid
);
6044 switch_to_thread (thr
);
6046 /* Don't consider the thread stopped until we've processed the
6047 saved stop reply. */
6048 set_executing (this, thr
->ptid
, true);
6051 /* Next, if the target can specify a description, read it. We do
6052 this before anything involving memory or registers. */
6053 target_find_description ();
6055 if (!target_is_non_stop_p ())
6057 /* Use the previously fetched status. */
6058 gdb_assert (wait_status
!= NULL
);
6060 if (target_can_async_p ())
6062 struct notif_event
*reply
6063 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
6065 push_stop_reply ((struct stop_reply
*) reply
);
6071 gdb_assert (wait_status
!= NULL
);
6072 strcpy (rs
->buf
.data (), wait_status
);
6073 rs
->cached_wait_status
= 1;
6078 gdb_assert (wait_status
== NULL
);
6080 gdb_assert (target_can_async_p ());
6085 /* Implementation of the to_post_attach method. */
6088 extended_remote_target::post_attach (int pid
)
6090 /* Get text, data & bss offsets. */
6093 /* In certain cases GDB might not have had the chance to start
6094 symbol lookup up until now. This could happen if the debugged
6095 binary is not using shared libraries, the vsyscall page is not
6096 present (on Linux) and the binary itself hadn't changed since the
6097 debugging process was started. */
6098 if (current_program_space
->symfile_object_file
!= NULL
)
6099 remote_check_symbols();
6103 /* Check for the availability of vCont. This function should also check
6107 remote_target::remote_vcont_probe ()
6109 remote_state
*rs
= get_remote_state ();
6112 strcpy (rs
->buf
.data (), "vCont?");
6114 getpkt (&rs
->buf
, 0);
6115 buf
= rs
->buf
.data ();
6117 /* Make sure that the features we assume are supported. */
6118 if (startswith (buf
, "vCont"))
6121 int support_c
, support_C
;
6123 rs
->supports_vCont
.s
= 0;
6124 rs
->supports_vCont
.S
= 0;
6127 rs
->supports_vCont
.t
= 0;
6128 rs
->supports_vCont
.r
= 0;
6129 while (p
&& *p
== ';')
6132 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6133 rs
->supports_vCont
.s
= 1;
6134 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6135 rs
->supports_vCont
.S
= 1;
6136 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6138 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6140 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6141 rs
->supports_vCont
.t
= 1;
6142 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6143 rs
->supports_vCont
.r
= 1;
6145 p
= strchr (p
, ';');
6148 /* If c, and C are not all supported, we can't use vCont. Clearing
6149 BUF will make packet_ok disable the packet. */
6150 if (!support_c
|| !support_C
)
6154 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
6155 rs
->supports_vCont_probed
= true;
6158 /* Helper function for building "vCont" resumptions. Write a
6159 resumption to P. ENDP points to one-passed-the-end of the buffer
6160 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
6161 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
6162 resumed thread should be single-stepped and/or signalled. If PTID
6163 equals minus_one_ptid, then all threads are resumed; if PTID
6164 represents a process, then all threads of the process are resumed;
6165 the thread to be stepped and/or signalled is given in the global
6169 remote_target::append_resumption (char *p
, char *endp
,
6170 ptid_t ptid
, int step
, gdb_signal siggnal
)
6172 struct remote_state
*rs
= get_remote_state ();
6174 if (step
&& siggnal
!= GDB_SIGNAL_0
)
6175 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
6177 /* GDB is willing to range step. */
6178 && use_range_stepping
6179 /* Target supports range stepping. */
6180 && rs
->supports_vCont
.r
6181 /* We don't currently support range stepping multiple
6182 threads with a wildcard (though the protocol allows it,
6183 so stubs shouldn't make an active effort to forbid
6185 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6187 struct thread_info
*tp
;
6189 if (ptid
== minus_one_ptid
)
6191 /* If we don't know about the target thread's tid, then
6192 we're resuming magic_null_ptid (see caller). */
6193 tp
= find_thread_ptid (this, magic_null_ptid
);
6196 tp
= find_thread_ptid (this, ptid
);
6197 gdb_assert (tp
!= NULL
);
6199 if (tp
->control
.may_range_step
)
6201 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6203 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6204 phex_nz (tp
->control
.step_range_start
,
6206 phex_nz (tp
->control
.step_range_end
,
6210 p
+= xsnprintf (p
, endp
- p
, ";s");
6213 p
+= xsnprintf (p
, endp
- p
, ";s");
6214 else if (siggnal
!= GDB_SIGNAL_0
)
6215 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6217 p
+= xsnprintf (p
, endp
- p
, ";c");
6219 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6223 /* All (-1) threads of process. */
6224 nptid
= ptid_t (ptid
.pid (), -1, 0);
6226 p
+= xsnprintf (p
, endp
- p
, ":");
6227 p
= write_ptid (p
, endp
, nptid
);
6229 else if (ptid
!= minus_one_ptid
)
6231 p
+= xsnprintf (p
, endp
- p
, ":");
6232 p
= write_ptid (p
, endp
, ptid
);
6238 /* Clear the thread's private info on resume. */
6241 resume_clear_thread_private_info (struct thread_info
*thread
)
6243 if (thread
->priv
!= NULL
)
6245 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6247 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6248 priv
->watch_data_address
= 0;
6252 /* Append a vCont continue-with-signal action for threads that have a
6253 non-zero stop signal. */
6256 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6259 for (thread_info
*thread
: all_non_exited_threads (this, ptid
))
6260 if (inferior_ptid
!= thread
->ptid
6261 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6263 p
= append_resumption (p
, endp
, thread
->ptid
,
6264 0, thread
->suspend
.stop_signal
);
6265 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6266 resume_clear_thread_private_info (thread
);
6272 /* Set the target running, using the packets that use Hc
6276 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6279 struct remote_state
*rs
= get_remote_state ();
6282 rs
->last_sent_signal
= siggnal
;
6283 rs
->last_sent_step
= step
;
6285 /* The c/s/C/S resume packets use Hc, so set the continue
6287 if (ptid
== minus_one_ptid
)
6288 set_continue_thread (any_thread_ptid
);
6290 set_continue_thread (ptid
);
6292 for (thread_info
*thread
: all_non_exited_threads (this))
6293 resume_clear_thread_private_info (thread
);
6295 buf
= rs
->buf
.data ();
6296 if (::execution_direction
== EXEC_REVERSE
)
6298 /* We don't pass signals to the target in reverse exec mode. */
6299 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6300 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6303 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6304 error (_("Remote reverse-step not supported."));
6305 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6306 error (_("Remote reverse-continue not supported."));
6308 strcpy (buf
, step
? "bs" : "bc");
6310 else if (siggnal
!= GDB_SIGNAL_0
)
6312 buf
[0] = step
? 'S' : 'C';
6313 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6314 buf
[2] = tohex (((int) siggnal
) & 0xf);
6318 strcpy (buf
, step
? "s" : "c");
6323 /* Resume the remote inferior by using a "vCont" packet. The thread
6324 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6325 resumed thread should be single-stepped and/or signalled. If PTID
6326 equals minus_one_ptid, then all threads are resumed; the thread to
6327 be stepped and/or signalled is given in the global INFERIOR_PTID.
6328 This function returns non-zero iff it resumes the inferior.
6330 This function issues a strict subset of all possible vCont commands
6334 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6335 enum gdb_signal siggnal
)
6337 struct remote_state
*rs
= get_remote_state ();
6341 /* No reverse execution actions defined for vCont. */
6342 if (::execution_direction
== EXEC_REVERSE
)
6345 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6346 remote_vcont_probe ();
6348 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6351 p
= rs
->buf
.data ();
6352 endp
= p
+ get_remote_packet_size ();
6354 /* If we could generate a wider range of packets, we'd have to worry
6355 about overflowing BUF. Should there be a generic
6356 "multi-part-packet" packet? */
6358 p
+= xsnprintf (p
, endp
- p
, "vCont");
6360 if (ptid
== magic_null_ptid
)
6362 /* MAGIC_NULL_PTID means that we don't have any active threads,
6363 so we don't have any TID numbers the inferior will
6364 understand. Make sure to only send forms that do not specify
6366 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6368 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6370 /* Resume all threads (of all processes, or of a single
6371 process), with preference for INFERIOR_PTID. This assumes
6372 inferior_ptid belongs to the set of all threads we are about
6374 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6376 /* Step inferior_ptid, with or without signal. */
6377 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6380 /* Also pass down any pending signaled resumption for other
6381 threads not the current. */
6382 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6384 /* And continue others without a signal. */
6385 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6389 /* Scheduler locking; resume only PTID. */
6390 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6393 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6396 if (target_is_non_stop_p ())
6398 /* In non-stop, the stub replies to vCont with "OK". The stop
6399 reply will be reported asynchronously by means of a `%Stop'
6401 getpkt (&rs
->buf
, 0);
6402 if (strcmp (rs
->buf
.data (), "OK") != 0)
6403 error (_("Unexpected vCont reply in non-stop mode: %s"),
6410 /* Tell the remote machine to resume. */
6413 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6415 struct remote_state
*rs
= get_remote_state ();
6417 /* When connected in non-stop mode, the core resumes threads
6418 individually. Resuming remote threads directly in target_resume
6419 would thus result in sending one packet per thread. Instead, to
6420 minimize roundtrip latency, here we just store the resume
6421 request (put the thread in RESUMED_PENDING_VCONT state); the actual remote
6422 resumption will be done in remote_target::commit_resume, where we'll be
6423 able to do vCont action coalescing. */
6424 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6426 remote_thread_info
*remote_thr
;
6428 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6429 remote_thr
= get_remote_thread_info (this, inferior_ptid
);
6431 remote_thr
= get_remote_thread_info (this, ptid
);
6433 /* We don't expect the core to ask to resume an already resumed (from
6434 its point of view) thread. */
6435 gdb_assert (remote_thr
->get_resume_state () == resume_state::NOT_RESUMED
);
6437 remote_thr
->set_resumed_pending_vcont (step
, siggnal
);
6441 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6442 (explained in remote-notif.c:handle_notification) so
6443 remote_notif_process is not called. We need find a place where
6444 it is safe to start a 'vNotif' sequence. It is good to do it
6445 before resuming inferior, because inferior was stopped and no RSP
6446 traffic at that moment. */
6447 if (!target_is_non_stop_p ())
6448 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6450 rs
->last_resume_exec_dir
= ::execution_direction
;
6452 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6453 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6454 remote_resume_with_hc (ptid
, step
, siggnal
);
6456 /* Update resumed state tracked by the remote target. */
6457 for (thread_info
*tp
: all_non_exited_threads (this, ptid
))
6458 get_remote_thread_info (tp
)->set_resumed ();
6460 /* We are about to start executing the inferior, let's register it
6461 with the event loop. NOTE: this is the one place where all the
6462 execution commands end up. We could alternatively do this in each
6463 of the execution commands in infcmd.c. */
6464 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6465 into infcmd.c in order to allow inferior function calls to work
6466 NOT asynchronously. */
6467 if (target_can_async_p ())
6470 /* We've just told the target to resume. The remote server will
6471 wait for the inferior to stop, and then send a stop reply. In
6472 the mean time, we can't start another command/query ourselves
6473 because the stub wouldn't be ready to process it. This applies
6474 only to the base all-stop protocol, however. In non-stop (which
6475 only supports vCont), the stub replies with an "OK", and is
6476 immediate able to process further serial input. */
6477 if (!target_is_non_stop_p ())
6478 rs
->waiting_for_stop_reply
= 1;
6481 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6483 /* Private per-inferior info for target remote processes. */
6485 struct remote_inferior
: public private_inferior
6487 /* Whether we can send a wildcard vCont for this process. */
6488 bool may_wildcard_vcont
= true;
6491 /* Get the remote private inferior data associated to INF. */
6493 static remote_inferior
*
6494 get_remote_inferior (inferior
*inf
)
6496 if (inf
->priv
== NULL
)
6497 inf
->priv
.reset (new remote_inferior
);
6499 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6502 /* Class used to track the construction of a vCont packet in the
6503 outgoing packet buffer. This is used to send multiple vCont
6504 packets if we have more actions than would fit a single packet. */
6509 explicit vcont_builder (remote_target
*remote
)
6516 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6521 /* The remote target. */
6522 remote_target
*m_remote
;
6524 /* Pointer to the first action. P points here if no action has been
6526 char *m_first_action
;
6528 /* Where the next action will be appended. */
6531 /* The end of the buffer. Must never write past this. */
6535 /* Prepare the outgoing buffer for a new vCont packet. */
6538 vcont_builder::restart ()
6540 struct remote_state
*rs
= m_remote
->get_remote_state ();
6542 m_p
= rs
->buf
.data ();
6543 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6544 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6545 m_first_action
= m_p
;
6548 /* If the vCont packet being built has any action, send it to the
6552 vcont_builder::flush ()
6554 struct remote_state
*rs
;
6556 if (m_p
== m_first_action
)
6559 rs
= m_remote
->get_remote_state ();
6560 m_remote
->putpkt (rs
->buf
);
6561 m_remote
->getpkt (&rs
->buf
, 0);
6562 if (strcmp (rs
->buf
.data (), "OK") != 0)
6563 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6566 /* The largest action is range-stepping, with its two addresses. This
6567 is more than sufficient. If a new, bigger action is created, it'll
6568 quickly trigger a failed assertion in append_resumption (and we'll
6570 #define MAX_ACTION_SIZE 200
6572 /* Append a new vCont action in the outgoing packet being built. If
6573 the action doesn't fit the packet along with previous actions, push
6574 what we've got so far to the remote end and start over a new vCont
6575 packet (with the new action). */
6578 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6580 char buf
[MAX_ACTION_SIZE
+ 1];
6582 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6583 ptid
, step
, siggnal
);
6585 /* Check whether this new action would fit in the vCont packet along
6586 with previous actions. If not, send what we've got so far and
6587 start a new vCont packet. */
6588 size_t rsize
= endp
- buf
;
6589 if (rsize
> m_endp
- m_p
)
6594 /* Should now fit. */
6595 gdb_assert (rsize
<= m_endp
- m_p
);
6598 memcpy (m_p
, buf
, rsize
);
6603 /* to_commit_resume implementation. */
6606 remote_target::commit_resume ()
6608 int any_process_wildcard
;
6609 int may_global_wildcard_vcont
;
6611 /* If connected in all-stop mode, we'd send the remote resume
6612 request directly from remote_resume. Likewise if
6613 reverse-debugging, as there are no defined vCont actions for
6614 reverse execution. */
6615 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6618 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6619 instead of resuming all threads of each process individually.
6620 However, if any thread of a process must remain halted, we can't
6621 send wildcard resumes and must send one action per thread.
6623 Care must be taken to not resume threads/processes the server
6624 side already told us are stopped, but the core doesn't know about
6625 yet, because the events are still in the vStopped notification
6628 #1 => vCont s:p1.1;c
6630 #3 <= %Stopped T05 p1.1
6635 #8 (infrun handles the stop for p1.1 and continues stepping)
6636 #9 => vCont s:p1.1;c
6638 The last vCont above would resume thread p1.2 by mistake, because
6639 the server has no idea that the event for p1.2 had not been
6642 The server side must similarly ignore resume actions for the
6643 thread that has a pending %Stopped notification (and any other
6644 threads with events pending), until GDB acks the notification
6645 with vStopped. Otherwise, e.g., the following case is
6648 #1 => g (or any other packet)
6650 #3 <= %Stopped T05 p1.2
6651 #4 => vCont s:p1.1;c
6654 Above, the server must not resume thread p1.2. GDB can't know
6655 that p1.2 stopped until it acks the %Stopped notification, and
6656 since from GDB's perspective all threads should be running, it
6659 Finally, special care must also be given to handling fork/vfork
6660 events. A (v)fork event actually tells us that two processes
6661 stopped -- the parent and the child. Until we follow the fork,
6662 we must not resume the child. Therefore, if we have a pending
6663 fork follow, we must not send a global wildcard resume action
6664 (vCont;c). We can still send process-wide wildcards though. */
6666 /* Start by assuming a global wildcard (vCont;c) is possible. */
6667 may_global_wildcard_vcont
= 1;
6669 /* And assume every process is individually wildcard-able too. */
6670 for (inferior
*inf
: all_non_exited_inferiors (this))
6672 remote_inferior
*priv
= get_remote_inferior (inf
);
6674 priv
->may_wildcard_vcont
= true;
6677 /* Check for any pending events (not reported or processed yet) and
6678 disable process and global wildcard resumes appropriately. */
6679 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6681 for (thread_info
*tp
: all_non_exited_threads (this))
6683 remote_thread_info
*priv
= get_remote_thread_info (tp
);
6685 /* If a thread of a process is not meant to be resumed, then we
6686 can't wildcard that process. */
6687 if (priv
->get_resume_state () == resume_state::NOT_RESUMED
)
6689 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6691 /* And if we can't wildcard a process, we can't wildcard
6692 everything either. */
6693 may_global_wildcard_vcont
= 0;
6697 /* If a thread is the parent of an unfollowed fork, then we
6698 can't do a global wildcard, as that would resume the fork
6700 if (is_pending_fork_parent_thread (tp
))
6701 may_global_wildcard_vcont
= 0;
6704 /* Now let's build the vCont packet(s). Actions must be appended
6705 from narrower to wider scopes (thread -> process -> global). If
6706 we end up with too many actions for a single packet vcont_builder
6707 flushes the current vCont packet to the remote side and starts a
6709 struct vcont_builder
vcont_builder (this);
6711 /* Threads first. */
6712 for (thread_info
*tp
: all_non_exited_threads (this))
6714 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6716 /* If the thread was previously vCont-resumed, no need to send a specific
6717 action for it. If we didn't receive a resume request for it, don't
6718 send an action for it either. */
6719 if (remote_thr
->get_resume_state () != resume_state::RESUMED_PENDING_VCONT
)
6722 gdb_assert (!thread_is_in_step_over_chain (tp
));
6724 const resumed_pending_vcont_info
&info
6725 = remote_thr
->resumed_pending_vcont_info ();
6727 /* Check if we need to send a specific action for this thread. If not,
6728 it will be included in a wildcard resume instead. */
6729 if (info
.step
|| info
.sig
!= GDB_SIGNAL_0
6730 || !get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6731 vcont_builder
.push_action (tp
->ptid
, info
.step
, info
.sig
);
6733 remote_thr
->set_resumed ();
6736 /* Now check whether we can send any process-wide wildcard. This is
6737 to avoid sending a global wildcard in the case nothing is
6738 supposed to be resumed. */
6739 any_process_wildcard
= 0;
6741 for (inferior
*inf
: all_non_exited_inferiors (this))
6743 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6745 any_process_wildcard
= 1;
6750 if (any_process_wildcard
)
6752 /* If all processes are wildcard-able, then send a single "c"
6753 action, otherwise, send an "all (-1) threads of process"
6754 continue action for each running process, if any. */
6755 if (may_global_wildcard_vcont
)
6757 vcont_builder
.push_action (minus_one_ptid
,
6758 false, GDB_SIGNAL_0
);
6762 for (inferior
*inf
: all_non_exited_inferiors (this))
6764 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6766 vcont_builder
.push_action (ptid_t (inf
->pid
),
6767 false, GDB_SIGNAL_0
);
6773 vcont_builder
.flush ();
6778 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6779 thread, all threads of a remote process, or all threads of all
6783 remote_target::remote_stop_ns (ptid_t ptid
)
6785 struct remote_state
*rs
= get_remote_state ();
6786 char *p
= rs
->buf
.data ();
6787 char *endp
= p
+ get_remote_packet_size ();
6789 /* FIXME: This supports_vCont_probed check is a workaround until
6790 packet_support is per-connection. */
6791 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
6792 || !rs
->supports_vCont_probed
)
6793 remote_vcont_probe ();
6795 if (!rs
->supports_vCont
.t
)
6796 error (_("Remote server does not support stopping threads"));
6798 if (ptid
== minus_one_ptid
6799 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6800 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6805 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6808 /* All (-1) threads of process. */
6809 nptid
= ptid_t (ptid
.pid (), -1, 0);
6812 /* Small optimization: if we already have a stop reply for
6813 this thread, no use in telling the stub we want this
6815 if (peek_stop_reply (ptid
))
6821 write_ptid (p
, endp
, nptid
);
6824 /* In non-stop, we get an immediate OK reply. The stop reply will
6825 come in asynchronously by notification. */
6827 getpkt (&rs
->buf
, 0);
6828 if (strcmp (rs
->buf
.data (), "OK") != 0)
6829 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6833 /* All-stop version of target_interrupt. Sends a break or a ^C to
6834 interrupt the remote target. It is undefined which thread of which
6835 process reports the interrupt. */
6838 remote_target::remote_interrupt_as ()
6840 struct remote_state
*rs
= get_remote_state ();
6842 rs
->ctrlc_pending_p
= 1;
6844 /* If the inferior is stopped already, but the core didn't know
6845 about it yet, just ignore the request. The cached wait status
6846 will be collected in remote_wait. */
6847 if (rs
->cached_wait_status
)
6850 /* Send interrupt_sequence to remote target. */
6851 send_interrupt_sequence ();
6854 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6855 the remote target. It is undefined which thread of which process
6856 reports the interrupt. Throws an error if the packet is not
6857 supported by the server. */
6860 remote_target::remote_interrupt_ns ()
6862 struct remote_state
*rs
= get_remote_state ();
6863 char *p
= rs
->buf
.data ();
6864 char *endp
= p
+ get_remote_packet_size ();
6866 xsnprintf (p
, endp
- p
, "vCtrlC");
6868 /* In non-stop, we get an immediate OK reply. The stop reply will
6869 come in asynchronously by notification. */
6871 getpkt (&rs
->buf
, 0);
6873 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6877 case PACKET_UNKNOWN
:
6878 error (_("No support for interrupting the remote target."));
6880 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6884 /* Implement the to_stop function for the remote targets. */
6887 remote_target::stop (ptid_t ptid
)
6889 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
6891 if (target_is_non_stop_p ())
6892 remote_stop_ns (ptid
);
6895 /* We don't currently have a way to transparently pause the
6896 remote target in all-stop mode. Interrupt it instead. */
6897 remote_interrupt_as ();
6901 /* Implement the to_interrupt function for the remote targets. */
6904 remote_target::interrupt ()
6906 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
6908 if (target_is_non_stop_p ())
6909 remote_interrupt_ns ();
6911 remote_interrupt_as ();
6914 /* Implement the to_pass_ctrlc function for the remote targets. */
6917 remote_target::pass_ctrlc ()
6919 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
6921 struct remote_state
*rs
= get_remote_state ();
6923 /* If we're starting up, we're not fully synced yet. Quit
6925 if (rs
->starting_up
)
6927 /* If ^C has already been sent once, offer to disconnect. */
6928 else if (rs
->ctrlc_pending_p
)
6931 target_interrupt ();
6934 /* Ask the user what to do when an interrupt is received. */
6937 remote_target::interrupt_query ()
6939 struct remote_state
*rs
= get_remote_state ();
6941 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6943 if (query (_("The target is not responding to interrupt requests.\n"
6944 "Stop debugging it? ")))
6946 remote_unpush_target (this);
6947 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6952 if (query (_("Interrupted while waiting for the program.\n"
6953 "Give up waiting? ")))
6958 /* Enable/disable target terminal ownership. Most targets can use
6959 terminal groups to control terminal ownership. Remote targets are
6960 different in that explicit transfer of ownership to/from GDB/target
6964 remote_target::terminal_inferior ()
6966 /* NOTE: At this point we could also register our selves as the
6967 recipient of all input. Any characters typed could then be
6968 passed on down to the target. */
6972 remote_target::terminal_ours ()
6977 remote_console_output (const char *msg
)
6981 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6984 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6988 gdb_stdtarg
->puts (tb
);
6990 gdb_stdtarg
->flush ();
6993 struct stop_reply
: public notif_event
6997 /* The identifier of the thread about this event */
7000 /* The remote state this event is associated with. When the remote
7001 connection, represented by a remote_state object, is closed,
7002 all the associated stop_reply events should be released. */
7003 struct remote_state
*rs
;
7005 struct target_waitstatus ws
;
7007 /* The architecture associated with the expedited registers. */
7010 /* Expedited registers. This makes remote debugging a bit more
7011 efficient for those targets that provide critical registers as
7012 part of their normal status mechanism (as another roundtrip to
7013 fetch them is avoided). */
7014 std::vector
<cached_reg_t
> regcache
;
7016 enum target_stop_reason stop_reason
;
7018 CORE_ADDR watch_data_address
;
7023 /* Return the length of the stop reply queue. */
7026 remote_target::stop_reply_queue_length ()
7028 remote_state
*rs
= get_remote_state ();
7029 return rs
->stop_reply_queue
.size ();
7033 remote_notif_stop_parse (remote_target
*remote
,
7034 struct notif_client
*self
, const char *buf
,
7035 struct notif_event
*event
)
7037 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
7041 remote_notif_stop_ack (remote_target
*remote
,
7042 struct notif_client
*self
, const char *buf
,
7043 struct notif_event
*event
)
7045 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
7048 putpkt (remote
, self
->ack_command
);
7050 /* Kind can be TARGET_WAITKIND_IGNORE if we have meanwhile discarded
7051 the notification. It was left in the queue because we need to
7052 acknowledge it and pull the rest of the notifications out. */
7053 if (stop_reply
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7054 remote
->push_stop_reply (stop_reply
);
7058 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
7059 struct notif_client
*self
)
7061 /* We can't get pending events in remote_notif_process for
7062 notification stop, and we have to do this in remote_wait_ns
7063 instead. If we fetch all queued events from stub, remote stub
7064 may exit and we have no chance to process them back in
7066 remote_state
*rs
= remote
->get_remote_state ();
7067 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7071 stop_reply::~stop_reply ()
7073 for (cached_reg_t
®
: regcache
)
7077 static notif_event_up
7078 remote_notif_stop_alloc_reply ()
7080 return notif_event_up (new struct stop_reply ());
7083 /* A client of notification Stop. */
7085 struct notif_client notif_client_stop
=
7089 remote_notif_stop_parse
,
7090 remote_notif_stop_ack
,
7091 remote_notif_stop_can_get_pending_events
,
7092 remote_notif_stop_alloc_reply
,
7096 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
7097 the pid of the process that owns the threads we want to check, or
7098 -1 if we want to check all threads. */
7101 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
7104 if (ws
->kind
== TARGET_WAITKIND_FORKED
7105 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
7107 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
7114 /* Return the thread's pending status used to determine whether the
7115 thread is a fork parent stopped at a fork event. */
7117 static struct target_waitstatus
*
7118 thread_pending_fork_status (struct thread_info
*thread
)
7120 if (thread
->suspend
.waitstatus_pending_p
)
7121 return &thread
->suspend
.waitstatus
;
7123 return &thread
->pending_follow
;
7126 /* Determine if THREAD is a pending fork parent thread. */
7129 is_pending_fork_parent_thread (struct thread_info
*thread
)
7131 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
7134 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
7137 /* If CONTEXT contains any fork child threads that have not been
7138 reported yet, remove them from the CONTEXT list. If such a
7139 thread exists it is because we are stopped at a fork catchpoint
7140 and have not yet called follow_fork, which will set up the
7141 host-side data structures for the new process. */
7144 remote_target::remove_new_fork_children (threads_listing_context
*context
)
7147 struct notif_client
*notif
= ¬if_client_stop
;
7149 /* For any threads stopped at a fork event, remove the corresponding
7150 fork child threads from the CONTEXT list. */
7151 for (thread_info
*thread
: all_non_exited_threads (this))
7153 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
7155 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
7156 context
->remove_thread (ws
->value
.related_pid
);
7159 /* Check for any pending fork events (not reported or processed yet)
7160 in process PID and remove those fork child threads from the
7161 CONTEXT list as well. */
7162 remote_notif_get_pending_events (notif
);
7163 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7164 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7165 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
7166 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
7167 context
->remove_thread (event
->ws
.value
.related_pid
);
7170 /* Check whether any event pending in the vStopped queue would prevent
7171 a global or process wildcard vCont action. Clear
7172 *may_global_wildcard if we can't do a global wildcard (vCont;c),
7173 and clear the event inferior's may_wildcard_vcont flag if we can't
7174 do a process-wide wildcard resume (vCont;c:pPID.-1). */
7177 remote_target::check_pending_events_prevent_wildcard_vcont
7178 (int *may_global_wildcard
)
7180 struct notif_client
*notif
= ¬if_client_stop
;
7182 remote_notif_get_pending_events (notif
);
7183 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7185 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
7186 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
7189 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7190 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
7191 *may_global_wildcard
= 0;
7193 struct inferior
*inf
= find_inferior_ptid (this, event
->ptid
);
7195 /* This may be the first time we heard about this process.
7196 Regardless, we must not do a global wildcard resume, otherwise
7197 we'd resume this process too. */
7198 *may_global_wildcard
= 0;
7200 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7204 /* Discard all pending stop replies of inferior INF. */
7207 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7209 struct stop_reply
*reply
;
7210 struct remote_state
*rs
= get_remote_state ();
7211 struct remote_notif_state
*rns
= rs
->notif_state
;
7213 /* This function can be notified when an inferior exists. When the
7214 target is not remote, the notification state is NULL. */
7215 if (rs
->remote_desc
== NULL
)
7218 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7220 /* Discard the in-flight notification. */
7221 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7223 /* Leave the notification pending, since the server expects that
7224 we acknowledge it with vStopped. But clear its contents, so
7225 that later on when we acknowledge it, we also discard it. */
7226 reply
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7229 fprintf_unfiltered (gdb_stdlog
,
7230 "discarded in-flight notification\n");
7233 /* Discard the stop replies we have already pulled with
7235 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7236 rs
->stop_reply_queue
.end (),
7237 [=] (const stop_reply_up
&event
)
7239 return event
->ptid
.pid () == inf
->pid
;
7241 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7244 /* Discard the stop replies for RS in stop_reply_queue. */
7247 remote_target::discard_pending_stop_replies_in_queue ()
7249 remote_state
*rs
= get_remote_state ();
7251 /* Discard the stop replies we have already pulled with
7253 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7254 rs
->stop_reply_queue
.end (),
7255 [=] (const stop_reply_up
&event
)
7257 return event
->rs
== rs
;
7259 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7262 /* Remove the first reply in 'stop_reply_queue' which matches
7266 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7268 remote_state
*rs
= get_remote_state ();
7270 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7271 rs
->stop_reply_queue
.end (),
7272 [=] (const stop_reply_up
&event
)
7274 return event
->ptid
.matches (ptid
);
7276 struct stop_reply
*result
;
7277 if (iter
== rs
->stop_reply_queue
.end ())
7281 result
= iter
->release ();
7282 rs
->stop_reply_queue
.erase (iter
);
7286 fprintf_unfiltered (gdb_stdlog
,
7287 "notif: discard queued event: 'Stop' in %s\n",
7288 target_pid_to_str (ptid
).c_str ());
7293 /* Look for a queued stop reply belonging to PTID. If one is found,
7294 remove it from the queue, and return it. Returns NULL if none is
7295 found. If there are still queued events left to process, tell the
7296 event loop to get back to target_wait soon. */
7299 remote_target::queued_stop_reply (ptid_t ptid
)
7301 remote_state
*rs
= get_remote_state ();
7302 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7304 if (!rs
->stop_reply_queue
.empty ())
7306 /* There's still at least an event left. */
7307 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7313 /* Push a fully parsed stop reply in the stop reply queue. Since we
7314 know that we now have at least one queued event left to pass to the
7315 core side, tell the event loop to get back to target_wait soon. */
7318 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7320 remote_state
*rs
= get_remote_state ();
7321 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7324 fprintf_unfiltered (gdb_stdlog
,
7325 "notif: push 'Stop' %s to queue %d\n",
7326 target_pid_to_str (new_event
->ptid
).c_str (),
7327 int (rs
->stop_reply_queue
.size ()));
7329 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7332 /* Returns true if we have a stop reply for PTID. */
7335 remote_target::peek_stop_reply (ptid_t ptid
)
7337 remote_state
*rs
= get_remote_state ();
7338 for (auto &event
: rs
->stop_reply_queue
)
7339 if (ptid
== event
->ptid
7340 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7345 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7346 starting with P and ending with PEND matches PREFIX. */
7349 strprefix (const char *p
, const char *pend
, const char *prefix
)
7351 for ( ; p
< pend
; p
++, prefix
++)
7354 return *prefix
== '\0';
7357 /* Parse the stop reply in BUF. Either the function succeeds, and the
7358 result is stored in EVENT, or throws an error. */
7361 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7363 remote_arch_state
*rsa
= NULL
;
7368 event
->ptid
= null_ptid
;
7369 event
->rs
= get_remote_state ();
7370 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7371 event
->ws
.value
.integer
= 0;
7372 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7373 event
->regcache
.clear ();
7378 case 'T': /* Status with PC, SP, FP, ... */
7379 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7380 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7382 n... = register number
7383 r... = register contents
7386 p
= &buf
[3]; /* after Txx */
7392 p1
= strchr (p
, ':');
7394 error (_("Malformed packet(a) (missing colon): %s\n\
7398 error (_("Malformed packet(a) (missing register number): %s\n\
7402 /* Some "registers" are actually extended stop information.
7403 Note if you're adding a new entry here: GDB 7.9 and
7404 earlier assume that all register "numbers" that start
7405 with an hex digit are real register numbers. Make sure
7406 the server only sends such a packet if it knows the
7407 client understands it. */
7409 if (strprefix (p
, p1
, "thread"))
7410 event
->ptid
= read_ptid (++p1
, &p
);
7411 else if (strprefix (p
, p1
, "syscall_entry"))
7415 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7416 p
= unpack_varlen_hex (++p1
, &sysno
);
7417 event
->ws
.value
.syscall_number
= (int) sysno
;
7419 else if (strprefix (p
, p1
, "syscall_return"))
7423 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7424 p
= unpack_varlen_hex (++p1
, &sysno
);
7425 event
->ws
.value
.syscall_number
= (int) sysno
;
7427 else if (strprefix (p
, p1
, "watch")
7428 || strprefix (p
, p1
, "rwatch")
7429 || strprefix (p
, p1
, "awatch"))
7431 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7432 p
= unpack_varlen_hex (++p1
, &addr
);
7433 event
->watch_data_address
= (CORE_ADDR
) addr
;
7435 else if (strprefix (p
, p1
, "swbreak"))
7437 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7439 /* Make sure the stub doesn't forget to indicate support
7441 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7442 error (_("Unexpected swbreak stop reason"));
7444 /* The value part is documented as "must be empty",
7445 though we ignore it, in case we ever decide to make
7446 use of it in a backward compatible way. */
7447 p
= strchrnul (p1
+ 1, ';');
7449 else if (strprefix (p
, p1
, "hwbreak"))
7451 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7453 /* Make sure the stub doesn't forget to indicate support
7455 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7456 error (_("Unexpected hwbreak stop reason"));
7459 p
= strchrnul (p1
+ 1, ';');
7461 else if (strprefix (p
, p1
, "library"))
7463 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7464 p
= strchrnul (p1
+ 1, ';');
7466 else if (strprefix (p
, p1
, "replaylog"))
7468 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7469 /* p1 will indicate "begin" or "end", but it makes
7470 no difference for now, so ignore it. */
7471 p
= strchrnul (p1
+ 1, ';');
7473 else if (strprefix (p
, p1
, "core"))
7477 p
= unpack_varlen_hex (++p1
, &c
);
7480 else if (strprefix (p
, p1
, "fork"))
7482 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7483 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7485 else if (strprefix (p
, p1
, "vfork"))
7487 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7488 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7490 else if (strprefix (p
, p1
, "vforkdone"))
7492 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7493 p
= strchrnul (p1
+ 1, ';');
7495 else if (strprefix (p
, p1
, "exec"))
7500 /* Determine the length of the execd pathname. */
7501 p
= unpack_varlen_hex (++p1
, &ignored
);
7502 pathlen
= (p
- p1
) / 2;
7504 /* Save the pathname for event reporting and for
7505 the next run command. */
7506 gdb::unique_xmalloc_ptr
<char[]> pathname
7507 ((char *) xmalloc (pathlen
+ 1));
7508 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7509 pathname
[pathlen
] = '\0';
7511 /* This is freed during event handling. */
7512 event
->ws
.value
.execd_pathname
= pathname
.release ();
7513 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7515 /* Skip the registers included in this packet, since
7516 they may be for an architecture different from the
7517 one used by the original program. */
7520 else if (strprefix (p
, p1
, "create"))
7522 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7523 p
= strchrnul (p1
+ 1, ';');
7532 p
= strchrnul (p1
+ 1, ';');
7537 /* Maybe a real ``P'' register number. */
7538 p_temp
= unpack_varlen_hex (p
, &pnum
);
7539 /* If the first invalid character is the colon, we got a
7540 register number. Otherwise, it's an unknown stop
7544 /* If we haven't parsed the event's thread yet, find
7545 it now, in order to find the architecture of the
7546 reported expedited registers. */
7547 if (event
->ptid
== null_ptid
)
7549 /* If there is no thread-id information then leave
7550 the event->ptid as null_ptid. Later in
7551 process_stop_reply we will pick a suitable
7553 const char *thr
= strstr (p1
+ 1, ";thread:");
7555 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7562 = (event
->ptid
== null_ptid
7564 : find_inferior_ptid (this, event
->ptid
));
7565 /* If this is the first time we learn anything
7566 about this process, skip the registers
7567 included in this packet, since we don't yet
7568 know which architecture to use to parse them.
7569 We'll determine the architecture later when
7570 we process the stop reply and retrieve the
7571 target description, via
7572 remote_notice_new_inferior ->
7573 post_create_inferior. */
7576 p
= strchrnul (p1
+ 1, ';');
7581 event
->arch
= inf
->gdbarch
;
7582 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7586 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7587 cached_reg_t cached_reg
;
7590 error (_("Remote sent bad register number %s: %s\n\
7592 hex_string (pnum
), p
, buf
);
7594 cached_reg
.num
= reg
->regnum
;
7595 cached_reg
.data
= (gdb_byte
*)
7596 xmalloc (register_size (event
->arch
, reg
->regnum
));
7599 fieldsize
= hex2bin (p
, cached_reg
.data
,
7600 register_size (event
->arch
, reg
->regnum
));
7602 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7603 warning (_("Remote reply is too short: %s"), buf
);
7605 event
->regcache
.push_back (cached_reg
);
7609 /* Not a number. Silently skip unknown optional
7611 p
= strchrnul (p1
+ 1, ';');
7616 error (_("Remote register badly formatted: %s\nhere: %s"),
7621 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7625 case 'S': /* Old style status, just signal only. */
7629 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7630 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7631 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7632 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7634 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7637 case 'w': /* Thread exited. */
7641 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7642 p
= unpack_varlen_hex (&buf
[1], &value
);
7643 event
->ws
.value
.integer
= value
;
7645 error (_("stop reply packet badly formatted: %s"), buf
);
7646 event
->ptid
= read_ptid (++p
, NULL
);
7649 case 'W': /* Target exited. */
7654 /* GDB used to accept only 2 hex chars here. Stubs should
7655 only send more if they detect GDB supports multi-process
7657 p
= unpack_varlen_hex (&buf
[1], &value
);
7661 /* The remote process exited. */
7662 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7663 event
->ws
.value
.integer
= value
;
7667 /* The remote process exited with a signal. */
7668 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7669 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7670 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7672 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7675 /* If no process is specified, return null_ptid, and let the
7676 caller figure out the right process to use. */
7686 else if (startswith (p
, "process:"))
7690 p
+= sizeof ("process:") - 1;
7691 unpack_varlen_hex (p
, &upid
);
7695 error (_("unknown stop reply packet: %s"), buf
);
7698 error (_("unknown stop reply packet: %s"), buf
);
7699 event
->ptid
= ptid_t (pid
);
7703 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7704 event
->ptid
= minus_one_ptid
;
7709 /* When the stub wants to tell GDB about a new notification reply, it
7710 sends a notification (%Stop, for example). Those can come it at
7711 any time, hence, we have to make sure that any pending
7712 putpkt/getpkt sequence we're making is finished, before querying
7713 the stub for more events with the corresponding ack command
7714 (vStopped, for example). E.g., if we started a vStopped sequence
7715 immediately upon receiving the notification, something like this
7723 1.6) <-- (registers reply to step #1.3)
7725 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7728 To solve this, whenever we parse a %Stop notification successfully,
7729 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7730 doing whatever we were doing:
7736 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7737 2.5) <-- (registers reply to step #2.3)
7739 Eventually after step #2.5, we return to the event loop, which
7740 notices there's an event on the
7741 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7742 associated callback --- the function below. At this point, we're
7743 always safe to start a vStopped sequence. :
7746 2.7) <-- T05 thread:2
7752 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7754 struct remote_state
*rs
= get_remote_state ();
7756 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7759 fprintf_unfiltered (gdb_stdlog
,
7760 "notif: process: '%s' ack pending event\n",
7764 nc
->ack (this, nc
, rs
->buf
.data (),
7765 rs
->notif_state
->pending_event
[nc
->id
]);
7766 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7770 getpkt (&rs
->buf
, 0);
7771 if (strcmp (rs
->buf
.data (), "OK") == 0)
7774 remote_notif_ack (this, nc
, rs
->buf
.data ());
7780 fprintf_unfiltered (gdb_stdlog
,
7781 "notif: process: '%s' no pending reply\n",
7786 /* Wrapper around remote_target::remote_notif_get_pending_events to
7787 avoid having to export the whole remote_target class. */
7790 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7792 remote
->remote_notif_get_pending_events (nc
);
7795 /* Called from process_stop_reply when the stop packet we are responding
7796 to didn't include a process-id or thread-id. STATUS is the stop event
7797 we are responding to.
7799 It is the task of this function to select a suitable thread (or process)
7800 and return its ptid, this is the thread (or process) we will assume the
7801 stop event came from.
7803 In some cases there isn't really any choice about which thread (or
7804 process) is selected, a basic remote with a single process containing a
7805 single thread might choose not to send any process-id or thread-id in
7806 its stop packets, this function will select and return the one and only
7809 However, if a target supports multiple threads (or processes) and still
7810 doesn't include a thread-id (or process-id) in its stop packet then
7811 first, this is a badly behaving target, and second, we're going to have
7812 to select a thread (or process) at random and use that. This function
7813 will print a warning to the user if it detects that there is the
7814 possibility that GDB is guessing which thread (or process) to
7817 Note that this is called before GDB fetches the updated thread list from the
7818 target. So it's possible for the stop reply to be ambiguous and for GDB to
7819 not realize it. For example, if there's initially one thread, the target
7820 spawns a second thread, and then sends a stop reply without an id that
7821 concerns the first thread. GDB will assume the stop reply is about the
7822 first thread - the only thread it knows about - without printing a warning.
7823 Anyway, if the remote meant for the stop reply to be about the second thread,
7824 then it would be really broken, because GDB doesn't know about that thread
7828 remote_target::select_thread_for_ambiguous_stop_reply
7829 (const struct target_waitstatus
*status
)
7831 /* Some stop events apply to all threads in an inferior, while others
7832 only apply to a single thread. */
7833 bool process_wide_stop
7834 = (status
->kind
== TARGET_WAITKIND_EXITED
7835 || status
->kind
== TARGET_WAITKIND_SIGNALLED
);
7837 thread_info
*first_resumed_thread
= nullptr;
7838 bool ambiguous
= false;
7840 /* Consider all non-exited threads of the target, find the first resumed
7842 for (thread_info
*thr
: all_non_exited_threads (this))
7844 remote_thread_info
*remote_thr
= get_remote_thread_info (thr
);
7846 if (remote_thr
->get_resume_state () != resume_state::RESUMED
)
7849 if (first_resumed_thread
== nullptr)
7850 first_resumed_thread
= thr
;
7851 else if (!process_wide_stop
7852 || first_resumed_thread
->ptid
.pid () != thr
->ptid
.pid ())
7856 gdb_assert (first_resumed_thread
!= nullptr);
7858 /* Warn if the remote target is sending ambiguous stop replies. */
7861 static bool warned
= false;
7865 /* If you are seeing this warning then the remote target has
7866 stopped without specifying a thread-id, but the target
7867 does have multiple threads (or inferiors), and so GDB is
7868 having to guess which thread stopped.
7870 Examples of what might cause this are the target sending
7871 and 'S' stop packet, or a 'T' stop packet and not
7872 including a thread-id.
7874 Additionally, the target might send a 'W' or 'X packet
7875 without including a process-id, when the target has
7876 multiple running inferiors. */
7877 if (process_wide_stop
)
7878 warning (_("multi-inferior target stopped without "
7879 "sending a process-id, using first "
7880 "non-exited inferior"));
7882 warning (_("multi-threaded target stopped without "
7883 "sending a thread-id, using first "
7884 "non-exited thread"));
7889 /* If this is a stop for all threads then don't use a particular threads
7890 ptid, instead create a new ptid where only the pid field is set. */
7891 if (process_wide_stop
)
7892 return ptid_t (first_resumed_thread
->ptid
.pid ());
7894 return first_resumed_thread
->ptid
;
7897 /* Called when it is decided that STOP_REPLY holds the info of the
7898 event that is to be returned to the core. This function always
7899 destroys STOP_REPLY. */
7902 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7903 struct target_waitstatus
*status
)
7905 *status
= stop_reply
->ws
;
7906 ptid_t ptid
= stop_reply
->ptid
;
7908 /* If no thread/process was reported by the stub then select a suitable
7910 if (ptid
== null_ptid
)
7911 ptid
= select_thread_for_ambiguous_stop_reply (status
);
7912 gdb_assert (ptid
!= null_ptid
);
7914 if (status
->kind
!= TARGET_WAITKIND_EXITED
7915 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7916 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7918 /* Expedited registers. */
7919 if (!stop_reply
->regcache
.empty ())
7921 struct regcache
*regcache
7922 = get_thread_arch_regcache (this, ptid
, stop_reply
->arch
);
7924 for (cached_reg_t
®
: stop_reply
->regcache
)
7926 regcache
->raw_supply (reg
.num
, reg
.data
);
7930 stop_reply
->regcache
.clear ();
7933 remote_notice_new_inferior (ptid
, 0);
7934 remote_thread_info
*remote_thr
= get_remote_thread_info (this, ptid
);
7935 remote_thr
->core
= stop_reply
->core
;
7936 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7937 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7939 if (target_is_non_stop_p ())
7941 /* If the target works in non-stop mode, a stop-reply indicates that
7942 only this thread stopped. */
7943 remote_thr
->set_not_resumed ();
7947 /* If the target works in all-stop mode, a stop-reply indicates that
7948 all the target's threads stopped. */
7949 for (thread_info
*tp
: all_non_exited_threads (this))
7950 get_remote_thread_info (tp
)->set_not_resumed ();
7958 /* The non-stop mode version of target_wait. */
7961 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
7962 target_wait_flags options
)
7964 struct remote_state
*rs
= get_remote_state ();
7965 struct stop_reply
*stop_reply
;
7969 /* If in non-stop mode, get out of getpkt even if a
7970 notification is received. */
7972 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7975 if (ret
!= -1 && !is_notif
)
7978 case 'E': /* Error of some sort. */
7979 /* We're out of sync with the target now. Did it continue
7980 or not? We can't tell which thread it was in non-stop,
7981 so just ignore this. */
7982 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7984 case 'O': /* Console output. */
7985 remote_console_output (&rs
->buf
[1]);
7988 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7992 /* Acknowledge a pending stop reply that may have arrived in the
7994 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7995 remote_notif_get_pending_events (¬if_client_stop
);
7997 /* If indeed we noticed a stop reply, we're done. */
7998 stop_reply
= queued_stop_reply (ptid
);
7999 if (stop_reply
!= NULL
)
8000 return process_stop_reply (stop_reply
, status
);
8002 /* Still no event. If we're just polling for an event, then
8003 return to the event loop. */
8004 if (options
& TARGET_WNOHANG
)
8006 status
->kind
= TARGET_WAITKIND_IGNORE
;
8007 return minus_one_ptid
;
8010 /* Otherwise do a blocking wait. */
8011 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
8015 /* Return the first resumed thread. */
8018 first_remote_resumed_thread (remote_target
*target
)
8020 for (thread_info
*tp
: all_non_exited_threads (target
, minus_one_ptid
))
8026 /* Wait until the remote machine stops, then return, storing status in
8027 STATUS just as `wait' would. */
8030 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
,
8031 target_wait_flags options
)
8033 struct remote_state
*rs
= get_remote_state ();
8034 ptid_t event_ptid
= null_ptid
;
8036 struct stop_reply
*stop_reply
;
8040 status
->kind
= TARGET_WAITKIND_IGNORE
;
8041 status
->value
.integer
= 0;
8043 stop_reply
= queued_stop_reply (ptid
);
8044 if (stop_reply
!= NULL
)
8045 return process_stop_reply (stop_reply
, status
);
8047 if (rs
->cached_wait_status
)
8048 /* Use the cached wait status, but only once. */
8049 rs
->cached_wait_status
= 0;
8054 int forever
= ((options
& TARGET_WNOHANG
) == 0
8055 && rs
->wait_forever_enabled_p
);
8057 if (!rs
->waiting_for_stop_reply
)
8059 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
8060 return minus_one_ptid
;
8063 /* FIXME: cagney/1999-09-27: If we're in async mode we should
8064 _never_ wait for ever -> test on target_is_async_p().
8065 However, before we do that we need to ensure that the caller
8066 knows how to take the target into/out of async mode. */
8067 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
8069 /* GDB gets a notification. Return to core as this event is
8071 if (ret
!= -1 && is_notif
)
8072 return minus_one_ptid
;
8074 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
8075 return minus_one_ptid
;
8078 buf
= rs
->buf
.data ();
8080 /* Assume that the target has acknowledged Ctrl-C unless we receive
8081 an 'F' or 'O' packet. */
8082 if (buf
[0] != 'F' && buf
[0] != 'O')
8083 rs
->ctrlc_pending_p
= 0;
8087 case 'E': /* Error of some sort. */
8088 /* We're out of sync with the target now. Did it continue or
8089 not? Not is more likely, so report a stop. */
8090 rs
->waiting_for_stop_reply
= 0;
8092 warning (_("Remote failure reply: %s"), buf
);
8093 status
->kind
= TARGET_WAITKIND_STOPPED
;
8094 status
->value
.sig
= GDB_SIGNAL_0
;
8096 case 'F': /* File-I/O request. */
8097 /* GDB may access the inferior memory while handling the File-I/O
8098 request, but we don't want GDB accessing memory while waiting
8099 for a stop reply. See the comments in putpkt_binary. Set
8100 waiting_for_stop_reply to 0 temporarily. */
8101 rs
->waiting_for_stop_reply
= 0;
8102 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
8103 rs
->ctrlc_pending_p
= 0;
8104 /* GDB handled the File-I/O request, and the target is running
8105 again. Keep waiting for events. */
8106 rs
->waiting_for_stop_reply
= 1;
8108 case 'N': case 'T': case 'S': case 'X': case 'W':
8110 /* There is a stop reply to handle. */
8111 rs
->waiting_for_stop_reply
= 0;
8114 = (struct stop_reply
*) remote_notif_parse (this,
8118 event_ptid
= process_stop_reply (stop_reply
, status
);
8121 case 'O': /* Console output. */
8122 remote_console_output (buf
+ 1);
8125 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
8127 /* Zero length reply means that we tried 'S' or 'C' and the
8128 remote system doesn't support it. */
8129 target_terminal::ours_for_output ();
8131 ("Can't send signals to this remote system. %s not sent.\n",
8132 gdb_signal_to_name (rs
->last_sent_signal
));
8133 rs
->last_sent_signal
= GDB_SIGNAL_0
;
8134 target_terminal::inferior ();
8136 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
8142 warning (_("Invalid remote reply: %s"), buf
);
8146 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
8147 return minus_one_ptid
;
8148 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
8150 /* Nothing interesting happened. If we're doing a non-blocking
8151 poll, we're done. Otherwise, go back to waiting. */
8152 if (options
& TARGET_WNOHANG
)
8153 return minus_one_ptid
;
8157 else if (status
->kind
!= TARGET_WAITKIND_EXITED
8158 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
8160 if (event_ptid
!= null_ptid
)
8161 record_currthread (rs
, event_ptid
);
8163 event_ptid
= first_remote_resumed_thread (this);
8167 /* A process exit. Invalidate our notion of current thread. */
8168 record_currthread (rs
, minus_one_ptid
);
8169 /* It's possible that the packet did not include a pid. */
8170 if (event_ptid
== null_ptid
)
8171 event_ptid
= first_remote_resumed_thread (this);
8172 /* EVENT_PTID could still be NULL_PTID. Double-check. */
8173 if (event_ptid
== null_ptid
)
8174 event_ptid
= magic_null_ptid
;
8180 /* Wait until the remote machine stops, then return, storing status in
8181 STATUS just as `wait' would. */
8184 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
8185 target_wait_flags options
)
8187 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
8189 remote_state
*rs
= get_remote_state ();
8191 /* Start by clearing the flag that asks for our wait method to be called,
8192 we'll mark it again at the end if needed. */
8193 if (target_is_async_p ())
8194 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
8198 if (target_is_non_stop_p ())
8199 event_ptid
= wait_ns (ptid
, status
, options
);
8201 event_ptid
= wait_as (ptid
, status
, options
);
8203 if (target_is_async_p ())
8205 /* If there are events left in the queue, or unacknowledged
8206 notifications, then tell the event loop to call us again. */
8207 if (!rs
->stop_reply_queue
.empty ()
8208 || rs
->notif_state
->pending_event
[notif_client_stop
.id
] != nullptr)
8209 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
8215 /* Fetch a single register using a 'p' packet. */
8218 remote_target::fetch_register_using_p (struct regcache
*regcache
,
8221 struct gdbarch
*gdbarch
= regcache
->arch ();
8222 struct remote_state
*rs
= get_remote_state ();
8224 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8227 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
8230 if (reg
->pnum
== -1)
8233 p
= rs
->buf
.data ();
8235 p
+= hexnumstr (p
, reg
->pnum
);
8238 getpkt (&rs
->buf
, 0);
8240 buf
= rs
->buf
.data ();
8242 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
8246 case PACKET_UNKNOWN
:
8249 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
8250 gdbarch_register_name (regcache
->arch (),
8255 /* If this register is unfetchable, tell the regcache. */
8258 regcache
->raw_supply (reg
->regnum
, NULL
);
8262 /* Otherwise, parse and supply the value. */
8268 error (_("fetch_register_using_p: early buf termination"));
8270 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8273 regcache
->raw_supply (reg
->regnum
, regp
);
8277 /* Fetch the registers included in the target's 'g' packet. */
8280 remote_target::send_g_packet ()
8282 struct remote_state
*rs
= get_remote_state ();
8285 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
8287 getpkt (&rs
->buf
, 0);
8288 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8289 error (_("Could not read registers; remote failure reply '%s'"),
8292 /* We can get out of synch in various cases. If the first character
8293 in the buffer is not a hex character, assume that has happened
8294 and try to fetch another packet to read. */
8295 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
8296 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
8297 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
8298 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
8300 remote_debug_printf ("Bad register packet; fetching a new packet");
8301 getpkt (&rs
->buf
, 0);
8304 buf_len
= strlen (rs
->buf
.data ());
8306 /* Sanity check the received packet. */
8307 if (buf_len
% 2 != 0)
8308 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
8314 remote_target::process_g_packet (struct regcache
*regcache
)
8316 struct gdbarch
*gdbarch
= regcache
->arch ();
8317 struct remote_state
*rs
= get_remote_state ();
8318 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8323 buf_len
= strlen (rs
->buf
.data ());
8325 /* Further sanity checks, with knowledge of the architecture. */
8326 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
8327 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8329 rsa
->sizeof_g_packet
, buf_len
/ 2,
8332 /* Save the size of the packet sent to us by the target. It is used
8333 as a heuristic when determining the max size of packets that the
8334 target can safely receive. */
8335 if (rsa
->actual_register_packet_size
== 0)
8336 rsa
->actual_register_packet_size
= buf_len
;
8338 /* If this is smaller than we guessed the 'g' packet would be,
8339 update our records. A 'g' reply that doesn't include a register's
8340 value implies either that the register is not available, or that
8341 the 'p' packet must be used. */
8342 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8344 long sizeof_g_packet
= buf_len
/ 2;
8346 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8348 long offset
= rsa
->regs
[i
].offset
;
8349 long reg_size
= register_size (gdbarch
, i
);
8351 if (rsa
->regs
[i
].pnum
== -1)
8354 if (offset
>= sizeof_g_packet
)
8355 rsa
->regs
[i
].in_g_packet
= 0;
8356 else if (offset
+ reg_size
> sizeof_g_packet
)
8357 error (_("Truncated register %d in remote 'g' packet"), i
);
8359 rsa
->regs
[i
].in_g_packet
= 1;
8362 /* Looks valid enough, we can assume this is the correct length
8363 for a 'g' packet. It's important not to adjust
8364 rsa->sizeof_g_packet if we have truncated registers otherwise
8365 this "if" won't be run the next time the method is called
8366 with a packet of the same size and one of the internal errors
8367 below will trigger instead. */
8368 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8371 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8373 /* Unimplemented registers read as all bits zero. */
8374 memset (regs
, 0, rsa
->sizeof_g_packet
);
8376 /* Reply describes registers byte by byte, each byte encoded as two
8377 hex characters. Suck them all up, then supply them to the
8378 register cacheing/storage mechanism. */
8380 p
= rs
->buf
.data ();
8381 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8383 if (p
[0] == 0 || p
[1] == 0)
8384 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8385 internal_error (__FILE__
, __LINE__
,
8386 _("unexpected end of 'g' packet reply"));
8388 if (p
[0] == 'x' && p
[1] == 'x')
8389 regs
[i
] = 0; /* 'x' */
8391 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8395 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8397 struct packet_reg
*r
= &rsa
->regs
[i
];
8398 long reg_size
= register_size (gdbarch
, i
);
8402 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8403 /* This shouldn't happen - we adjusted in_g_packet above. */
8404 internal_error (__FILE__
, __LINE__
,
8405 _("unexpected end of 'g' packet reply"));
8406 else if (rs
->buf
[r
->offset
* 2] == 'x')
8408 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8409 /* The register isn't available, mark it as such (at
8410 the same time setting the value to zero). */
8411 regcache
->raw_supply (r
->regnum
, NULL
);
8414 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8420 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8423 process_g_packet (regcache
);
8426 /* Make the remote selected traceframe match GDB's selected
8430 remote_target::set_remote_traceframe ()
8433 struct remote_state
*rs
= get_remote_state ();
8435 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8438 /* Avoid recursion, remote_trace_find calls us again. */
8439 rs
->remote_traceframe_number
= get_traceframe_number ();
8441 newnum
= target_trace_find (tfind_number
,
8442 get_traceframe_number (), 0, 0, NULL
);
8444 /* Should not happen. If it does, all bets are off. */
8445 if (newnum
!= get_traceframe_number ())
8446 warning (_("could not set remote traceframe"));
8450 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8452 struct gdbarch
*gdbarch
= regcache
->arch ();
8453 struct remote_state
*rs
= get_remote_state ();
8454 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8457 set_remote_traceframe ();
8458 set_general_thread (regcache
->ptid ());
8462 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8464 gdb_assert (reg
!= NULL
);
8466 /* If this register might be in the 'g' packet, try that first -
8467 we are likely to read more than one register. If this is the
8468 first 'g' packet, we might be overly optimistic about its
8469 contents, so fall back to 'p'. */
8470 if (reg
->in_g_packet
)
8472 fetch_registers_using_g (regcache
);
8473 if (reg
->in_g_packet
)
8477 if (fetch_register_using_p (regcache
, reg
))
8480 /* This register is not available. */
8481 regcache
->raw_supply (reg
->regnum
, NULL
);
8486 fetch_registers_using_g (regcache
);
8488 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8489 if (!rsa
->regs
[i
].in_g_packet
)
8490 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8492 /* This register is not available. */
8493 regcache
->raw_supply (i
, NULL
);
8497 /* Prepare to store registers. Since we may send them all (using a
8498 'G' request), we have to read out the ones we don't want to change
8502 remote_target::prepare_to_store (struct regcache
*regcache
)
8504 struct remote_state
*rs
= get_remote_state ();
8505 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8508 /* Make sure the entire registers array is valid. */
8509 switch (packet_support (PACKET_P
))
8511 case PACKET_DISABLE
:
8512 case PACKET_SUPPORT_UNKNOWN
:
8513 /* Make sure all the necessary registers are cached. */
8514 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8515 if (rsa
->regs
[i
].in_g_packet
)
8516 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8523 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8524 packet was not recognized. */
8527 remote_target::store_register_using_P (const struct regcache
*regcache
,
8530 struct gdbarch
*gdbarch
= regcache
->arch ();
8531 struct remote_state
*rs
= get_remote_state ();
8532 /* Try storing a single register. */
8533 char *buf
= rs
->buf
.data ();
8534 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8537 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8540 if (reg
->pnum
== -1)
8543 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8544 p
= buf
+ strlen (buf
);
8545 regcache
->raw_collect (reg
->regnum
, regp
);
8546 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8548 getpkt (&rs
->buf
, 0);
8550 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8555 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8556 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8557 case PACKET_UNKNOWN
:
8560 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8564 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8565 contents of the register cache buffer. FIXME: ignores errors. */
8568 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8570 struct remote_state
*rs
= get_remote_state ();
8571 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8575 /* Extract all the registers in the regcache copying them into a
8580 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8581 memset (regs
, 0, rsa
->sizeof_g_packet
);
8582 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8584 struct packet_reg
*r
= &rsa
->regs
[i
];
8587 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8591 /* Command describes registers byte by byte,
8592 each byte encoded as two hex characters. */
8593 p
= rs
->buf
.data ();
8595 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8597 getpkt (&rs
->buf
, 0);
8598 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8599 error (_("Could not write registers; remote failure reply '%s'"),
8603 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8604 of the register cache buffer. FIXME: ignores errors. */
8607 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8609 struct gdbarch
*gdbarch
= regcache
->arch ();
8610 struct remote_state
*rs
= get_remote_state ();
8611 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8614 set_remote_traceframe ();
8615 set_general_thread (regcache
->ptid ());
8619 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8621 gdb_assert (reg
!= NULL
);
8623 /* Always prefer to store registers using the 'P' packet if
8624 possible; we often change only a small number of registers.
8625 Sometimes we change a larger number; we'd need help from a
8626 higher layer to know to use 'G'. */
8627 if (store_register_using_P (regcache
, reg
))
8630 /* For now, don't complain if we have no way to write the
8631 register. GDB loses track of unavailable registers too
8632 easily. Some day, this may be an error. We don't have
8633 any way to read the register, either... */
8634 if (!reg
->in_g_packet
)
8637 store_registers_using_G (regcache
);
8641 store_registers_using_G (regcache
);
8643 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8644 if (!rsa
->regs
[i
].in_g_packet
)
8645 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8646 /* See above for why we do not issue an error here. */
8651 /* Return the number of hex digits in num. */
8654 hexnumlen (ULONGEST num
)
8658 for (i
= 0; num
!= 0; i
++)
8661 return std::max (i
, 1);
8664 /* Set BUF to the minimum number of hex digits representing NUM. */
8667 hexnumstr (char *buf
, ULONGEST num
)
8669 int len
= hexnumlen (num
);
8671 return hexnumnstr (buf
, num
, len
);
8675 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8678 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8684 for (i
= width
- 1; i
>= 0; i
--)
8686 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8693 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8696 remote_address_masked (CORE_ADDR addr
)
8698 unsigned int address_size
= remote_address_size
;
8700 /* If "remoteaddresssize" was not set, default to target address size. */
8702 address_size
= gdbarch_addr_bit (target_gdbarch ());
8704 if (address_size
> 0
8705 && address_size
< (sizeof (ULONGEST
) * 8))
8707 /* Only create a mask when that mask can safely be constructed
8708 in a ULONGEST variable. */
8711 mask
= (mask
<< address_size
) - 1;
8717 /* Determine whether the remote target supports binary downloading.
8718 This is accomplished by sending a no-op memory write of zero length
8719 to the target at the specified address. It does not suffice to send
8720 the whole packet, since many stubs strip the eighth bit and
8721 subsequently compute a wrong checksum, which causes real havoc with
8724 NOTE: This can still lose if the serial line is not eight-bit
8725 clean. In cases like this, the user should clear "remote
8729 remote_target::check_binary_download (CORE_ADDR addr
)
8731 struct remote_state
*rs
= get_remote_state ();
8733 switch (packet_support (PACKET_X
))
8735 case PACKET_DISABLE
:
8739 case PACKET_SUPPORT_UNKNOWN
:
8743 p
= rs
->buf
.data ();
8745 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8747 p
+= hexnumstr (p
, (ULONGEST
) 0);
8751 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8752 getpkt (&rs
->buf
, 0);
8754 if (rs
->buf
[0] == '\0')
8756 remote_debug_printf ("binary downloading NOT supported by target");
8757 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8761 remote_debug_printf ("binary downloading supported by target");
8762 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8769 /* Helper function to resize the payload in order to try to get a good
8770 alignment. We try to write an amount of data such that the next write will
8771 start on an address aligned on REMOTE_ALIGN_WRITES. */
8774 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8776 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8779 /* Write memory data directly to the remote machine.
8780 This does not inform the data cache; the data cache uses this.
8781 HEADER is the starting part of the packet.
8782 MEMADDR is the address in the remote memory space.
8783 MYADDR is the address of the buffer in our space.
8784 LEN_UNITS is the number of addressable units to write.
8785 UNIT_SIZE is the length in bytes of an addressable unit.
8786 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8787 should send data as binary ('X'), or hex-encoded ('M').
8789 The function creates packet of the form
8790 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8792 where encoding of <DATA> is terminated by PACKET_FORMAT.
8794 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8797 Return the transferred status, error or OK (an
8798 'enum target_xfer_status' value). Save the number of addressable units
8799 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8801 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8802 exchange between gdb and the stub could look like (?? in place of the
8808 -> $M1000,3:eeeeffffeeee#??
8812 <- eeeeffffeeeedddd */
8815 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8816 const gdb_byte
*myaddr
,
8819 ULONGEST
*xfered_len_units
,
8820 char packet_format
, int use_length
)
8822 struct remote_state
*rs
= get_remote_state ();
8828 int payload_capacity_bytes
;
8829 int payload_length_bytes
;
8831 if (packet_format
!= 'X' && packet_format
!= 'M')
8832 internal_error (__FILE__
, __LINE__
,
8833 _("remote_write_bytes_aux: bad packet format"));
8836 return TARGET_XFER_EOF
;
8838 payload_capacity_bytes
= get_memory_write_packet_size ();
8840 /* The packet buffer will be large enough for the payload;
8841 get_memory_packet_size ensures this. */
8844 /* Compute the size of the actual payload by subtracting out the
8845 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8847 payload_capacity_bytes
-= strlen ("$,:#NN");
8849 /* The comma won't be used. */
8850 payload_capacity_bytes
+= 1;
8851 payload_capacity_bytes
-= strlen (header
);
8852 payload_capacity_bytes
-= hexnumlen (memaddr
);
8854 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8856 strcat (rs
->buf
.data (), header
);
8857 p
= rs
->buf
.data () + strlen (header
);
8859 /* Compute a best guess of the number of bytes actually transfered. */
8860 if (packet_format
== 'X')
8862 /* Best guess at number of bytes that will fit. */
8863 todo_units
= std::min (len_units
,
8864 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8866 payload_capacity_bytes
-= hexnumlen (todo_units
);
8867 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8871 /* Number of bytes that will fit. */
8873 = std::min (len_units
,
8874 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8876 payload_capacity_bytes
-= hexnumlen (todo_units
);
8877 todo_units
= std::min (todo_units
,
8878 (payload_capacity_bytes
/ unit_size
) / 2);
8881 if (todo_units
<= 0)
8882 internal_error (__FILE__
, __LINE__
,
8883 _("minimum packet size too small to write data"));
8885 /* If we already need another packet, then try to align the end
8886 of this packet to a useful boundary. */
8887 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8888 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8890 /* Append "<memaddr>". */
8891 memaddr
= remote_address_masked (memaddr
);
8892 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8899 /* Append the length and retain its location and size. It may need to be
8900 adjusted once the packet body has been created. */
8902 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8910 /* Append the packet body. */
8911 if (packet_format
== 'X')
8913 /* Binary mode. Send target system values byte by byte, in
8914 increasing byte addresses. Only escape certain critical
8916 payload_length_bytes
=
8917 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8918 &units_written
, payload_capacity_bytes
);
8920 /* If not all TODO units fit, then we'll need another packet. Make
8921 a second try to keep the end of the packet aligned. Don't do
8922 this if the packet is tiny. */
8923 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8927 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8929 if (new_todo_units
!= units_written
)
8930 payload_length_bytes
=
8931 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8932 (gdb_byte
*) p
, &units_written
,
8933 payload_capacity_bytes
);
8936 p
+= payload_length_bytes
;
8937 if (use_length
&& units_written
< todo_units
)
8939 /* Escape chars have filled up the buffer prematurely,
8940 and we have actually sent fewer units than planned.
8941 Fix-up the length field of the packet. Use the same
8942 number of characters as before. */
8943 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8945 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8950 /* Normal mode: Send target system values byte by byte, in
8951 increasing byte addresses. Each byte is encoded as a two hex
8953 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8954 units_written
= todo_units
;
8957 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8958 getpkt (&rs
->buf
, 0);
8960 if (rs
->buf
[0] == 'E')
8961 return TARGET_XFER_E_IO
;
8963 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8964 send fewer units than we'd planned. */
8965 *xfered_len_units
= (ULONGEST
) units_written
;
8966 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8969 /* Write memory data directly to the remote machine.
8970 This does not inform the data cache; the data cache uses this.
8971 MEMADDR is the address in the remote memory space.
8972 MYADDR is the address of the buffer in our space.
8973 LEN is the number of bytes.
8975 Return the transferred status, error or OK (an
8976 'enum target_xfer_status' value). Save the number of bytes
8977 transferred in *XFERED_LEN. Only transfer a single packet. */
8980 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8981 ULONGEST len
, int unit_size
,
8982 ULONGEST
*xfered_len
)
8984 const char *packet_format
= NULL
;
8986 /* Check whether the target supports binary download. */
8987 check_binary_download (memaddr
);
8989 switch (packet_support (PACKET_X
))
8992 packet_format
= "X";
8994 case PACKET_DISABLE
:
8995 packet_format
= "M";
8997 case PACKET_SUPPORT_UNKNOWN
:
8998 internal_error (__FILE__
, __LINE__
,
8999 _("remote_write_bytes: bad internal state"));
9001 internal_error (__FILE__
, __LINE__
, _("bad switch"));
9004 return remote_write_bytes_aux (packet_format
,
9005 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
9006 packet_format
[0], 1);
9009 /* Read memory data directly from the remote machine.
9010 This does not use the data cache; the data cache uses this.
9011 MEMADDR is the address in the remote memory space.
9012 MYADDR is the address of the buffer in our space.
9013 LEN_UNITS is the number of addressable memory units to read..
9014 UNIT_SIZE is the length in bytes of an addressable unit.
9016 Return the transferred status, error or OK (an
9017 'enum target_xfer_status' value). Save the number of bytes
9018 transferred in *XFERED_LEN_UNITS.
9020 See the comment of remote_write_bytes_aux for an example of
9021 memory read/write exchange between gdb and the stub. */
9024 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
9026 int unit_size
, ULONGEST
*xfered_len_units
)
9028 struct remote_state
*rs
= get_remote_state ();
9029 int buf_size_bytes
; /* Max size of packet output buffer. */
9034 buf_size_bytes
= get_memory_read_packet_size ();
9035 /* The packet buffer will be large enough for the payload;
9036 get_memory_packet_size ensures this. */
9038 /* Number of units that will fit. */
9039 todo_units
= std::min (len_units
,
9040 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
9042 /* Construct "m"<memaddr>","<len>". */
9043 memaddr
= remote_address_masked (memaddr
);
9044 p
= rs
->buf
.data ();
9046 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
9048 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
9051 getpkt (&rs
->buf
, 0);
9052 if (rs
->buf
[0] == 'E'
9053 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
9054 && rs
->buf
[3] == '\0')
9055 return TARGET_XFER_E_IO
;
9056 /* Reply describes memory byte by byte, each byte encoded as two hex
9058 p
= rs
->buf
.data ();
9059 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
9060 /* Return what we have. Let higher layers handle partial reads. */
9061 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
9062 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
9065 /* Using the set of read-only target sections of remote, read live
9068 For interface/parameters/return description see target.h,
9072 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
9076 ULONGEST
*xfered_len
)
9078 const struct target_section
*secp
;
9080 secp
= target_section_by_addr (this, memaddr
);
9082 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
9084 ULONGEST memend
= memaddr
+ len
;
9086 const target_section_table
*table
= target_get_section_table (this);
9087 for (const target_section
&p
: *table
)
9089 if (memaddr
>= p
.addr
)
9091 if (memend
<= p
.endaddr
)
9093 /* Entire transfer is within this section. */
9094 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
9097 else if (memaddr
>= p
.endaddr
)
9099 /* This section ends before the transfer starts. */
9104 /* This section overlaps the transfer. Just do half. */
9105 len
= p
.endaddr
- memaddr
;
9106 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
9113 return TARGET_XFER_EOF
;
9116 /* Similar to remote_read_bytes_1, but it reads from the remote stub
9117 first if the requested memory is unavailable in traceframe.
9118 Otherwise, fall back to remote_read_bytes_1. */
9121 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
9122 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
9123 ULONGEST
*xfered_len
)
9126 return TARGET_XFER_EOF
;
9128 if (get_traceframe_number () != -1)
9130 std::vector
<mem_range
> available
;
9132 /* If we fail to get the set of available memory, then the
9133 target does not support querying traceframe info, and so we
9134 attempt reading from the traceframe anyway (assuming the
9135 target implements the old QTro packet then). */
9136 if (traceframe_available_memory (&available
, memaddr
, len
))
9138 if (available
.empty () || available
[0].start
!= memaddr
)
9140 enum target_xfer_status res
;
9142 /* Don't read into the traceframe's available
9144 if (!available
.empty ())
9146 LONGEST oldlen
= len
;
9148 len
= available
[0].start
- memaddr
;
9149 gdb_assert (len
<= oldlen
);
9152 /* This goes through the topmost target again. */
9153 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
9154 len
, unit_size
, xfered_len
);
9155 if (res
== TARGET_XFER_OK
)
9156 return TARGET_XFER_OK
;
9159 /* No use trying further, we know some memory starting
9160 at MEMADDR isn't available. */
9162 return (*xfered_len
!= 0) ?
9163 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
9167 /* Don't try to read more than how much is available, in
9168 case the target implements the deprecated QTro packet to
9169 cater for older GDBs (the target's knowledge of read-only
9170 sections may be outdated by now). */
9171 len
= available
[0].length
;
9175 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
9180 /* Sends a packet with content determined by the printf format string
9181 FORMAT and the remaining arguments, then gets the reply. Returns
9182 whether the packet was a success, a failure, or unknown. */
9185 remote_target::remote_send_printf (const char *format
, ...)
9187 struct remote_state
*rs
= get_remote_state ();
9188 int max_size
= get_remote_packet_size ();
9191 va_start (ap
, format
);
9194 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
9198 if (size
>= max_size
)
9199 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
9201 if (putpkt (rs
->buf
) < 0)
9202 error (_("Communication problem with target."));
9205 getpkt (&rs
->buf
, 0);
9207 return packet_check_result (rs
->buf
);
9210 /* Flash writing can take quite some time. We'll set
9211 effectively infinite timeout for flash operations.
9212 In future, we'll need to decide on a better approach. */
9213 static const int remote_flash_timeout
= 1000;
9216 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
9218 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
9219 enum packet_result ret
;
9220 scoped_restore restore_timeout
9221 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9223 ret
= remote_send_printf ("vFlashErase:%s,%s",
9224 phex (address
, addr_size
),
9228 case PACKET_UNKNOWN
:
9229 error (_("Remote target does not support flash erase"));
9231 error (_("Error erasing flash with vFlashErase packet"));
9238 remote_target::remote_flash_write (ULONGEST address
,
9239 ULONGEST length
, ULONGEST
*xfered_len
,
9240 const gdb_byte
*data
)
9242 scoped_restore restore_timeout
9243 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9244 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
9249 remote_target::flash_done ()
9253 scoped_restore restore_timeout
9254 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9256 ret
= remote_send_printf ("vFlashDone");
9260 case PACKET_UNKNOWN
:
9261 error (_("Remote target does not support vFlashDone"));
9263 error (_("Error finishing flash operation"));
9270 remote_target::files_info ()
9272 puts_filtered ("Debugging a target over a serial line.\n");
9275 /* Stuff for dealing with the packets which are part of this protocol.
9276 See comment at top of file for details. */
9278 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
9279 error to higher layers. Called when a serial error is detected.
9280 The exception message is STRING, followed by a colon and a blank,
9281 the system error message for errno at function entry and final dot
9282 for output compatibility with throw_perror_with_name. */
9285 unpush_and_perror (remote_target
*target
, const char *string
)
9287 int saved_errno
= errno
;
9289 remote_unpush_target (target
);
9290 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
9291 safe_strerror (saved_errno
));
9294 /* Read a single character from the remote end. The current quit
9295 handler is overridden to avoid quitting in the middle of packet
9296 sequence, as that would break communication with the remote server.
9297 See remote_serial_quit_handler for more detail. */
9300 remote_target::readchar (int timeout
)
9303 struct remote_state
*rs
= get_remote_state ();
9306 scoped_restore restore_quit_target
9307 = make_scoped_restore (&curr_quit_handler_target
, this);
9308 scoped_restore restore_quit
9309 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9311 rs
->got_ctrlc_during_io
= 0;
9313 ch
= serial_readchar (rs
->remote_desc
, timeout
);
9315 if (rs
->got_ctrlc_during_io
)
9322 switch ((enum serial_rc
) ch
)
9325 remote_unpush_target (this);
9326 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9329 unpush_and_perror (this, _("Remote communication error. "
9330 "Target disconnected."));
9332 case SERIAL_TIMEOUT
:
9338 /* Wrapper for serial_write that closes the target and throws if
9339 writing fails. The current quit handler is overridden to avoid
9340 quitting in the middle of packet sequence, as that would break
9341 communication with the remote server. See
9342 remote_serial_quit_handler for more detail. */
9345 remote_target::remote_serial_write (const char *str
, int len
)
9347 struct remote_state
*rs
= get_remote_state ();
9349 scoped_restore restore_quit_target
9350 = make_scoped_restore (&curr_quit_handler_target
, this);
9351 scoped_restore restore_quit
9352 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9354 rs
->got_ctrlc_during_io
= 0;
9356 if (serial_write (rs
->remote_desc
, str
, len
))
9358 unpush_and_perror (this, _("Remote communication error. "
9359 "Target disconnected."));
9362 if (rs
->got_ctrlc_during_io
)
9366 /* Return a string representing an escaped version of BUF, of len N.
9367 E.g. \n is converted to \\n, \t to \\t, etc. */
9370 escape_buffer (const char *buf
, int n
)
9374 stb
.putstrn (buf
, n
, '\\');
9375 return std::move (stb
.string ());
9378 /* Display a null-terminated packet on stdout, for debugging, using C
9382 print_packet (const char *buf
)
9384 puts_filtered ("\"");
9385 fputstr_filtered (buf
, '"', gdb_stdout
);
9386 puts_filtered ("\"");
9390 remote_target::putpkt (const char *buf
)
9392 return putpkt_binary (buf
, strlen (buf
));
9395 /* Wrapper around remote_target::putpkt to avoid exporting
9399 putpkt (remote_target
*remote
, const char *buf
)
9401 return remote
->putpkt (buf
);
9404 /* Send a packet to the remote machine, with error checking. The data
9405 of the packet is in BUF. The string in BUF can be at most
9406 get_remote_packet_size () - 5 to account for the $, # and checksum,
9407 and for a possible /0 if we are debugging (remote_debug) and want
9408 to print the sent packet as a string. */
9411 remote_target::putpkt_binary (const char *buf
, int cnt
)
9413 struct remote_state
*rs
= get_remote_state ();
9415 unsigned char csum
= 0;
9416 gdb::def_vector
<char> data (cnt
+ 6);
9417 char *buf2
= data
.data ();
9423 /* Catch cases like trying to read memory or listing threads while
9424 we're waiting for a stop reply. The remote server wouldn't be
9425 ready to handle this request, so we'd hang and timeout. We don't
9426 have to worry about this in synchronous mode, because in that
9427 case it's not possible to issue a command while the target is
9428 running. This is not a problem in non-stop mode, because in that
9429 case, the stub is always ready to process serial input. */
9430 if (!target_is_non_stop_p ()
9431 && target_is_async_p ()
9432 && rs
->waiting_for_stop_reply
)
9434 error (_("Cannot execute this command while the target is running.\n"
9435 "Use the \"interrupt\" command to stop the target\n"
9436 "and then try again."));
9439 /* We're sending out a new packet. Make sure we don't look at a
9440 stale cached response. */
9441 rs
->cached_wait_status
= 0;
9443 /* Copy the packet into buffer BUF2, encapsulating it
9444 and giving it a checksum. */
9449 for (i
= 0; i
< cnt
; i
++)
9455 *p
++ = tohex ((csum
>> 4) & 0xf);
9456 *p
++ = tohex (csum
& 0xf);
9458 /* Send it over and over until we get a positive ack. */
9466 int len
= (int) (p
- buf2
);
9469 if (remote_packet_max_chars
< 0)
9472 max_chars
= remote_packet_max_chars
;
9475 = escape_buffer (buf2
, std::min (len
, max_chars
));
9477 if (len
> max_chars
)
9478 remote_debug_printf_nofunc
9479 ("Sending packet: %s [%d bytes omitted]", str
.c_str (),
9482 remote_debug_printf_nofunc ("Sending packet: %s", str
.c_str ());
9484 remote_serial_write (buf2
, p
- buf2
);
9486 /* If this is a no acks version of the remote protocol, send the
9487 packet and move on. */
9491 /* Read until either a timeout occurs (-2) or '+' is read.
9492 Handle any notification that arrives in the mean time. */
9495 ch
= readchar (remote_timeout
);
9500 remote_debug_printf_nofunc ("Received Ack");
9503 remote_debug_printf_nofunc ("Received Nak");
9505 case SERIAL_TIMEOUT
:
9509 break; /* Retransmit buffer. */
9512 remote_debug_printf ("Packet instead of Ack, ignoring it");
9513 /* It's probably an old response sent because an ACK
9514 was lost. Gobble up the packet and ack it so it
9515 doesn't get retransmitted when we resend this
9518 remote_serial_write ("+", 1);
9519 continue; /* Now, go look for +. */
9526 /* If we got a notification, handle it, and go back to looking
9528 /* We've found the start of a notification. Now
9529 collect the data. */
9530 val
= read_frame (&rs
->buf
);
9533 remote_debug_printf_nofunc
9534 (" Notification received: %s",
9535 escape_buffer (rs
->buf
.data (), val
).c_str ());
9537 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9538 /* We're in sync now, rewait for the ack. */
9542 remote_debug_printf_nofunc ("Junk: %c%s", ch
& 0177,
9548 remote_debug_printf_nofunc ("Junk: %c%s", ch
& 0177,
9552 break; /* Here to retransmit. */
9556 /* This is wrong. If doing a long backtrace, the user should be
9557 able to get out next time we call QUIT, without anything as
9558 violent as interrupt_query. If we want to provide a way out of
9559 here without getting to the next QUIT, it should be based on
9560 hitting ^C twice as in remote_wait. */
9572 /* Come here after finding the start of a frame when we expected an
9573 ack. Do our best to discard the rest of this packet. */
9576 remote_target::skip_frame ()
9582 c
= readchar (remote_timeout
);
9585 case SERIAL_TIMEOUT
:
9586 /* Nothing we can do. */
9589 /* Discard the two bytes of checksum and stop. */
9590 c
= readchar (remote_timeout
);
9592 c
= readchar (remote_timeout
);
9595 case '*': /* Run length encoding. */
9596 /* Discard the repeat count. */
9597 c
= readchar (remote_timeout
);
9602 /* A regular character. */
9608 /* Come here after finding the start of the frame. Collect the rest
9609 into *BUF, verifying the checksum, length, and handling run-length
9610 compression. NUL terminate the buffer. If there is not enough room,
9613 Returns -1 on error, number of characters in buffer (ignoring the
9614 trailing NULL) on success. (could be extended to return one of the
9615 SERIAL status indications). */
9618 remote_target::read_frame (gdb::char_vector
*buf_p
)
9623 char *buf
= buf_p
->data ();
9624 struct remote_state
*rs
= get_remote_state ();
9631 c
= readchar (remote_timeout
);
9634 case SERIAL_TIMEOUT
:
9635 remote_debug_printf ("Timeout in mid-packet, retrying");
9639 remote_debug_printf ("Saw new packet start in middle of old one");
9640 return -1; /* Start a new packet, count retries. */
9644 unsigned char pktcsum
;
9650 check_0
= readchar (remote_timeout
);
9652 check_1
= readchar (remote_timeout
);
9654 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9656 remote_debug_printf ("Timeout in checksum, retrying");
9659 else if (check_0
< 0 || check_1
< 0)
9661 remote_debug_printf ("Communication error in checksum");
9665 /* Don't recompute the checksum; with no ack packets we
9666 don't have any way to indicate a packet retransmission
9671 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9672 if (csum
== pktcsum
)
9676 ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s",
9677 pktcsum
, csum
, escape_buffer (buf
, bc
).c_str ());
9679 /* Number of characters in buffer ignoring trailing
9683 case '*': /* Run length encoding. */
9688 c
= readchar (remote_timeout
);
9690 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9692 /* The character before ``*'' is repeated. */
9694 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9696 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9698 /* Make some more room in the buffer. */
9699 buf_p
->resize (buf_p
->size () + repeat
);
9700 buf
= buf_p
->data ();
9703 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9709 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9713 if (bc
>= buf_p
->size () - 1)
9715 /* Make some more room in the buffer. */
9716 buf_p
->resize (buf_p
->size () * 2);
9717 buf
= buf_p
->data ();
9727 /* Set this to the maximum number of seconds to wait instead of waiting forever
9728 in target_wait(). If this timer times out, then it generates an error and
9729 the command is aborted. This replaces most of the need for timeouts in the
9730 GDB test suite, and makes it possible to distinguish between a hung target
9731 and one with slow communications. */
9733 static int watchdog
= 0;
9735 show_watchdog (struct ui_file
*file
, int from_tty
,
9736 struct cmd_list_element
*c
, const char *value
)
9738 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9741 /* Read a packet from the remote machine, with error checking, and
9742 store it in *BUF. Resize *BUF if necessary to hold the result. If
9743 FOREVER, wait forever rather than timing out; this is used (in
9744 synchronous mode) to wait for a target that is is executing user
9746 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9747 don't have to change all the calls to getpkt to deal with the
9748 return value, because at the moment I don't know what the right
9749 thing to do it for those. */
9752 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9754 getpkt_sane (buf
, forever
);
9758 /* Read a packet from the remote machine, with error checking, and
9759 store it in *BUF. Resize *BUF if necessary to hold the result. If
9760 FOREVER, wait forever rather than timing out; this is used (in
9761 synchronous mode) to wait for a target that is is executing user
9762 code to stop. If FOREVER == 0, this function is allowed to time
9763 out gracefully and return an indication of this to the caller.
9764 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9765 consider receiving a notification enough reason to return to the
9766 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9767 holds a notification or not (a regular packet). */
9770 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9771 int forever
, int expecting_notif
,
9774 struct remote_state
*rs
= get_remote_state ();
9780 /* We're reading a new response. Make sure we don't look at a
9781 previously cached response. */
9782 rs
->cached_wait_status
= 0;
9784 strcpy (buf
->data (), "timeout");
9787 timeout
= watchdog
> 0 ? watchdog
: -1;
9788 else if (expecting_notif
)
9789 timeout
= 0; /* There should already be a char in the buffer. If
9792 timeout
= remote_timeout
;
9796 /* Process any number of notifications, and then return when
9800 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9802 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9804 /* This can loop forever if the remote side sends us
9805 characters continuously, but if it pauses, we'll get
9806 SERIAL_TIMEOUT from readchar because of timeout. Then
9807 we'll count that as a retry.
9809 Note that even when forever is set, we will only wait
9810 forever prior to the start of a packet. After that, we
9811 expect characters to arrive at a brisk pace. They should
9812 show up within remote_timeout intervals. */
9814 c
= readchar (timeout
);
9815 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9817 if (c
== SERIAL_TIMEOUT
)
9819 if (expecting_notif
)
9820 return -1; /* Don't complain, it's normal to not get
9821 anything in this case. */
9823 if (forever
) /* Watchdog went off? Kill the target. */
9825 remote_unpush_target (this);
9826 throw_error (TARGET_CLOSE_ERROR
,
9827 _("Watchdog timeout has expired. "
9828 "Target detached."));
9831 remote_debug_printf ("Timed out.");
9835 /* We've found the start of a packet or notification.
9836 Now collect the data. */
9837 val
= read_frame (buf
);
9842 remote_serial_write ("-", 1);
9845 if (tries
> MAX_TRIES
)
9847 /* We have tried hard enough, and just can't receive the
9848 packet/notification. Give up. */
9849 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9851 /* Skip the ack char if we're in no-ack mode. */
9852 if (!rs
->noack_mode
)
9853 remote_serial_write ("+", 1);
9857 /* If we got an ordinary packet, return that to our caller. */
9864 if (remote_packet_max_chars
< 0)
9867 max_chars
= remote_packet_max_chars
;
9870 = escape_buffer (buf
->data (),
9871 std::min (val
, max_chars
));
9873 if (val
> max_chars
)
9874 remote_debug_printf_nofunc
9875 ("Packet received: %s [%d bytes omitted]", str
.c_str (),
9878 remote_debug_printf_nofunc ("Packet received: %s",
9882 /* Skip the ack char if we're in no-ack mode. */
9883 if (!rs
->noack_mode
)
9884 remote_serial_write ("+", 1);
9885 if (is_notif
!= NULL
)
9890 /* If we got a notification, handle it, and go back to looking
9894 gdb_assert (c
== '%');
9896 remote_debug_printf_nofunc
9897 (" Notification received: %s",
9898 escape_buffer (buf
->data (), val
).c_str ());
9900 if (is_notif
!= NULL
)
9903 handle_notification (rs
->notif_state
, buf
->data ());
9905 /* Notifications require no acknowledgement. */
9907 if (expecting_notif
)
9914 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9916 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9920 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9923 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9926 /* Kill any new fork children of process PID that haven't been
9927 processed by follow_fork. */
9930 remote_target::kill_new_fork_children (int pid
)
9932 remote_state
*rs
= get_remote_state ();
9933 struct notif_client
*notif
= ¬if_client_stop
;
9935 /* Kill the fork child threads of any threads in process PID
9936 that are stopped at a fork event. */
9937 for (thread_info
*thread
: all_non_exited_threads (this))
9939 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9941 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9943 int child_pid
= ws
->value
.related_pid
.pid ();
9946 res
= remote_vkill (child_pid
);
9948 error (_("Can't kill fork child process %d"), child_pid
);
9952 /* Check for any pending fork events (not reported or processed yet)
9953 in process PID and kill those fork child threads as well. */
9954 remote_notif_get_pending_events (notif
);
9955 for (auto &event
: rs
->stop_reply_queue
)
9956 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9958 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9961 res
= remote_vkill (child_pid
);
9963 error (_("Can't kill fork child process %d"), child_pid
);
9968 /* Target hook to kill the current inferior. */
9971 remote_target::kill ()
9974 int pid
= inferior_ptid
.pid ();
9975 struct remote_state
*rs
= get_remote_state ();
9977 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9979 /* If we're stopped while forking and we haven't followed yet,
9980 kill the child task. We need to do this before killing the
9981 parent task because if this is a vfork then the parent will
9983 kill_new_fork_children (pid
);
9985 res
= remote_vkill (pid
);
9988 target_mourn_inferior (inferior_ptid
);
9993 /* If we are in 'target remote' mode and we are killing the only
9994 inferior, then we will tell gdbserver to exit and unpush the
9996 if (res
== -1 && !remote_multi_process_p (rs
)
9997 && number_of_live_inferiors (this) == 1)
10001 /* We've killed the remote end, we get to mourn it. If we are
10002 not in extended mode, mourning the inferior also unpushes
10003 remote_ops from the target stack, which closes the remote
10005 target_mourn_inferior (inferior_ptid
);
10010 error (_("Can't kill process"));
10013 /* Send a kill request to the target using the 'vKill' packet. */
10016 remote_target::remote_vkill (int pid
)
10018 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
10021 remote_state
*rs
= get_remote_state ();
10023 /* Tell the remote target to detach. */
10024 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
10026 getpkt (&rs
->buf
, 0);
10028 switch (packet_ok (rs
->buf
,
10029 &remote_protocol_packets
[PACKET_vKill
]))
10035 case PACKET_UNKNOWN
:
10038 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
10042 /* Send a kill request to the target using the 'k' packet. */
10045 remote_target::remote_kill_k ()
10047 /* Catch errors so the user can quit from gdb even when we
10048 aren't on speaking terms with the remote system. */
10053 catch (const gdb_exception_error
&ex
)
10055 if (ex
.error
== TARGET_CLOSE_ERROR
)
10057 /* If we got an (EOF) error that caused the target
10058 to go away, then we're done, that's what we wanted.
10059 "k" is susceptible to cause a premature EOF, given
10060 that the remote server isn't actually required to
10061 reply to "k", and it can happen that it doesn't
10062 even get to reply ACK to the "k". */
10066 /* Otherwise, something went wrong. We didn't actually kill
10067 the target. Just propagate the exception, and let the
10068 user or higher layers decide what to do. */
10074 remote_target::mourn_inferior ()
10076 struct remote_state
*rs
= get_remote_state ();
10078 /* We're no longer interested in notification events of an inferior
10079 that exited or was killed/detached. */
10080 discard_pending_stop_replies (current_inferior ());
10082 /* In 'target remote' mode with one inferior, we close the connection. */
10083 if (!rs
->extended
&& number_of_live_inferiors (this) <= 1)
10085 remote_unpush_target (this);
10089 /* In case we got here due to an error, but we're going to stay
10091 rs
->waiting_for_stop_reply
= 0;
10093 /* If the current general thread belonged to the process we just
10094 detached from or has exited, the remote side current general
10095 thread becomes undefined. Considering a case like this:
10097 - We just got here due to a detach.
10098 - The process that we're detaching from happens to immediately
10099 report a global breakpoint being hit in non-stop mode, in the
10100 same thread we had selected before.
10101 - GDB attaches to this process again.
10102 - This event happens to be the next event we handle.
10104 GDB would consider that the current general thread didn't need to
10105 be set on the stub side (with Hg), since for all it knew,
10106 GENERAL_THREAD hadn't changed.
10108 Notice that although in all-stop mode, the remote server always
10109 sets the current thread to the thread reporting the stop event,
10110 that doesn't happen in non-stop mode; in non-stop, the stub *must
10111 not* change the current thread when reporting a breakpoint hit,
10112 due to the decoupling of event reporting and event handling.
10114 To keep things simple, we always invalidate our notion of the
10116 record_currthread (rs
, minus_one_ptid
);
10118 /* Call common code to mark the inferior as not running. */
10119 generic_mourn_inferior ();
10123 extended_remote_target::supports_disable_randomization ()
10125 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
10129 remote_target::extended_remote_disable_randomization (int val
)
10131 struct remote_state
*rs
= get_remote_state ();
10134 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10135 "QDisableRandomization:%x", val
);
10137 reply
= remote_get_noisy_reply ();
10138 if (*reply
== '\0')
10139 error (_("Target does not support QDisableRandomization."));
10140 if (strcmp (reply
, "OK") != 0)
10141 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
10145 remote_target::extended_remote_run (const std::string
&args
)
10147 struct remote_state
*rs
= get_remote_state ();
10149 const char *remote_exec_file
= get_remote_exec_file ();
10151 /* If the user has disabled vRun support, or we have detected that
10152 support is not available, do not try it. */
10153 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
10156 strcpy (rs
->buf
.data (), "vRun;");
10157 len
= strlen (rs
->buf
.data ());
10159 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
10160 error (_("Remote file name too long for run packet"));
10161 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
10162 strlen (remote_exec_file
));
10164 if (!args
.empty ())
10168 gdb_argv
argv (args
.c_str ());
10169 for (i
= 0; argv
[i
] != NULL
; i
++)
10171 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
10172 error (_("Argument list too long for run packet"));
10173 rs
->buf
[len
++] = ';';
10174 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
10179 rs
->buf
[len
++] = '\0';
10182 getpkt (&rs
->buf
, 0);
10184 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
10187 /* We have a wait response. All is well. */
10189 case PACKET_UNKNOWN
:
10192 if (remote_exec_file
[0] == '\0')
10193 error (_("Running the default executable on the remote target failed; "
10194 "try \"set remote exec-file\"?"));
10196 error (_("Running \"%s\" on the remote target failed"),
10199 gdb_assert_not_reached (_("bad switch"));
10203 /* Helper function to send set/unset environment packets. ACTION is
10204 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
10205 or "QEnvironmentUnsetVariable". VALUE is the variable to be
10209 remote_target::send_environment_packet (const char *action
,
10210 const char *packet
,
10213 remote_state
*rs
= get_remote_state ();
10215 /* Convert the environment variable to an hex string, which
10216 is the best format to be transmitted over the wire. */
10217 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
10220 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10221 "%s:%s", packet
, encoded_value
.c_str ());
10224 getpkt (&rs
->buf
, 0);
10225 if (strcmp (rs
->buf
.data (), "OK") != 0)
10226 warning (_("Unable to %s environment variable '%s' on remote."),
10230 /* Helper function to handle the QEnvironment* packets. */
10233 remote_target::extended_remote_environment_support ()
10235 remote_state
*rs
= get_remote_state ();
10237 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
10239 putpkt ("QEnvironmentReset");
10240 getpkt (&rs
->buf
, 0);
10241 if (strcmp (rs
->buf
.data (), "OK") != 0)
10242 warning (_("Unable to reset environment on remote."));
10245 gdb_environ
*e
= ¤t_inferior ()->environment
;
10247 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
10248 for (const std::string
&el
: e
->user_set_env ())
10249 send_environment_packet ("set", "QEnvironmentHexEncoded",
10252 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
10253 for (const std::string
&el
: e
->user_unset_env ())
10254 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10257 /* Helper function to set the current working directory for the
10258 inferior in the remote target. */
10261 remote_target::extended_remote_set_inferior_cwd ()
10263 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10265 const char *inferior_cwd
= get_inferior_cwd ();
10266 remote_state
*rs
= get_remote_state ();
10268 if (inferior_cwd
!= NULL
)
10270 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10271 strlen (inferior_cwd
));
10273 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10274 "QSetWorkingDir:%s", hexpath
.c_str ());
10278 /* An empty inferior_cwd means that the user wants us to
10279 reset the remote server's inferior's cwd. */
10280 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10281 "QSetWorkingDir:");
10285 getpkt (&rs
->buf
, 0);
10286 if (packet_ok (rs
->buf
,
10287 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10290 Remote replied unexpectedly while setting the inferior's working\n\
10297 /* In the extended protocol we want to be able to do things like
10298 "run" and have them basically work as expected. So we need
10299 a special create_inferior function. We support changing the
10300 executable file and the command line arguments, but not the
10304 extended_remote_target::create_inferior (const char *exec_file
,
10305 const std::string
&args
,
10306 char **env
, int from_tty
)
10310 struct remote_state
*rs
= get_remote_state ();
10311 const char *remote_exec_file
= get_remote_exec_file ();
10313 /* If running asynchronously, register the target file descriptor
10314 with the event loop. */
10315 if (target_can_async_p ())
10318 /* Disable address space randomization if requested (and supported). */
10319 if (supports_disable_randomization ())
10320 extended_remote_disable_randomization (disable_randomization
);
10322 /* If startup-with-shell is on, we inform gdbserver to start the
10323 remote inferior using a shell. */
10324 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10326 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10327 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10329 getpkt (&rs
->buf
, 0);
10330 if (strcmp (rs
->buf
.data (), "OK") != 0)
10332 Remote replied unexpectedly while setting startup-with-shell: %s"),
10336 extended_remote_environment_support ();
10338 extended_remote_set_inferior_cwd ();
10340 /* Now restart the remote server. */
10341 run_worked
= extended_remote_run (args
) != -1;
10344 /* vRun was not supported. Fail if we need it to do what the
10346 if (remote_exec_file
[0])
10347 error (_("Remote target does not support \"set remote exec-file\""));
10348 if (!args
.empty ())
10349 error (_("Remote target does not support \"set args\" or run ARGS"));
10351 /* Fall back to "R". */
10352 extended_remote_restart ();
10355 /* vRun's success return is a stop reply. */
10356 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10357 add_current_inferior_and_thread (stop_reply
);
10359 /* Get updated offsets, if the stub uses qOffsets. */
10364 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10365 the list of conditions (in agent expression bytecode format), if any, the
10366 target needs to evaluate. The output is placed into the packet buffer
10367 started from BUF and ended at BUF_END. */
10370 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10371 struct bp_target_info
*bp_tgt
, char *buf
,
10374 if (bp_tgt
->conditions
.empty ())
10377 buf
+= strlen (buf
);
10378 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10381 /* Send conditions to the target. */
10382 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10384 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10385 buf
+= strlen (buf
);
10386 for (int i
= 0; i
< aexpr
->len
; ++i
)
10387 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10394 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10395 struct bp_target_info
*bp_tgt
, char *buf
)
10397 if (bp_tgt
->tcommands
.empty ())
10400 buf
+= strlen (buf
);
10402 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10403 buf
+= strlen (buf
);
10405 /* Concatenate all the agent expressions that are commands into the
10407 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10409 sprintf (buf
, "X%x,", aexpr
->len
);
10410 buf
+= strlen (buf
);
10411 for (int i
= 0; i
< aexpr
->len
; ++i
)
10412 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10417 /* Insert a breakpoint. On targets that have software breakpoint
10418 support, we ask the remote target to do the work; on targets
10419 which don't, we insert a traditional memory breakpoint. */
10422 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10423 struct bp_target_info
*bp_tgt
)
10425 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10426 If it succeeds, then set the support to PACKET_ENABLE. If it
10427 fails, and the user has explicitly requested the Z support then
10428 report an error, otherwise, mark it disabled and go on. */
10430 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10432 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10433 struct remote_state
*rs
;
10436 /* Make sure the remote is pointing at the right process, if
10438 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10439 set_general_process ();
10441 rs
= get_remote_state ();
10442 p
= rs
->buf
.data ();
10443 endbuf
= p
+ get_remote_packet_size ();
10448 addr
= (ULONGEST
) remote_address_masked (addr
);
10449 p
+= hexnumstr (p
, addr
);
10450 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10452 if (supports_evaluation_of_breakpoint_conditions ())
10453 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10455 if (can_run_breakpoint_commands ())
10456 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10459 getpkt (&rs
->buf
, 0);
10461 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10467 case PACKET_UNKNOWN
:
10472 /* If this breakpoint has target-side commands but this stub doesn't
10473 support Z0 packets, throw error. */
10474 if (!bp_tgt
->tcommands
.empty ())
10475 throw_error (NOT_SUPPORTED_ERROR
, _("\
10476 Target doesn't support breakpoints that have target side commands."));
10478 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10482 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10483 struct bp_target_info
*bp_tgt
,
10484 enum remove_bp_reason reason
)
10486 CORE_ADDR addr
= bp_tgt
->placed_address
;
10487 struct remote_state
*rs
= get_remote_state ();
10489 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10491 char *p
= rs
->buf
.data ();
10492 char *endbuf
= p
+ get_remote_packet_size ();
10494 /* Make sure the remote is pointing at the right process, if
10496 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10497 set_general_process ();
10503 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10504 p
+= hexnumstr (p
, addr
);
10505 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10508 getpkt (&rs
->buf
, 0);
10510 return (rs
->buf
[0] == 'E');
10513 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10516 static enum Z_packet_type
10517 watchpoint_to_Z_packet (int type
)
10522 return Z_PACKET_WRITE_WP
;
10525 return Z_PACKET_READ_WP
;
10528 return Z_PACKET_ACCESS_WP
;
10531 internal_error (__FILE__
, __LINE__
,
10532 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10537 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10538 enum target_hw_bp_type type
, struct expression
*cond
)
10540 struct remote_state
*rs
= get_remote_state ();
10541 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10543 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10545 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10548 /* Make sure the remote is pointing at the right process, if
10550 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10551 set_general_process ();
10553 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10554 p
= strchr (rs
->buf
.data (), '\0');
10555 addr
= remote_address_masked (addr
);
10556 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10557 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10560 getpkt (&rs
->buf
, 0);
10562 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10566 case PACKET_UNKNOWN
:
10571 internal_error (__FILE__
, __LINE__
,
10572 _("remote_insert_watchpoint: reached end of function"));
10576 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10577 CORE_ADDR start
, int length
)
10579 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10581 return diff
< length
;
10586 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10587 enum target_hw_bp_type type
, struct expression
*cond
)
10589 struct remote_state
*rs
= get_remote_state ();
10590 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10592 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10594 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10597 /* Make sure the remote is pointing at the right process, if
10599 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10600 set_general_process ();
10602 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10603 p
= strchr (rs
->buf
.data (), '\0');
10604 addr
= remote_address_masked (addr
);
10605 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10606 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10608 getpkt (&rs
->buf
, 0);
10610 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10613 case PACKET_UNKNOWN
:
10618 internal_error (__FILE__
, __LINE__
,
10619 _("remote_remove_watchpoint: reached end of function"));
10623 static int remote_hw_watchpoint_limit
= -1;
10624 static int remote_hw_watchpoint_length_limit
= -1;
10625 static int remote_hw_breakpoint_limit
= -1;
10628 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10630 if (remote_hw_watchpoint_length_limit
== 0)
10632 else if (remote_hw_watchpoint_length_limit
< 0)
10634 else if (len
<= remote_hw_watchpoint_length_limit
)
10641 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10643 if (type
== bp_hardware_breakpoint
)
10645 if (remote_hw_breakpoint_limit
== 0)
10647 else if (remote_hw_breakpoint_limit
< 0)
10649 else if (cnt
<= remote_hw_breakpoint_limit
)
10654 if (remote_hw_watchpoint_limit
== 0)
10656 else if (remote_hw_watchpoint_limit
< 0)
10660 else if (cnt
<= remote_hw_watchpoint_limit
)
10666 /* The to_stopped_by_sw_breakpoint method of target remote. */
10669 remote_target::stopped_by_sw_breakpoint ()
10671 struct thread_info
*thread
= inferior_thread ();
10673 return (thread
->priv
!= NULL
10674 && (get_remote_thread_info (thread
)->stop_reason
10675 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10678 /* The to_supports_stopped_by_sw_breakpoint method of target
10682 remote_target::supports_stopped_by_sw_breakpoint ()
10684 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10687 /* The to_stopped_by_hw_breakpoint method of target remote. */
10690 remote_target::stopped_by_hw_breakpoint ()
10692 struct thread_info
*thread
= inferior_thread ();
10694 return (thread
->priv
!= NULL
10695 && (get_remote_thread_info (thread
)->stop_reason
10696 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10699 /* The to_supports_stopped_by_hw_breakpoint method of target
10703 remote_target::supports_stopped_by_hw_breakpoint ()
10705 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10709 remote_target::stopped_by_watchpoint ()
10711 struct thread_info
*thread
= inferior_thread ();
10713 return (thread
->priv
!= NULL
10714 && (get_remote_thread_info (thread
)->stop_reason
10715 == TARGET_STOPPED_BY_WATCHPOINT
));
10719 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10721 struct thread_info
*thread
= inferior_thread ();
10723 if (thread
->priv
!= NULL
10724 && (get_remote_thread_info (thread
)->stop_reason
10725 == TARGET_STOPPED_BY_WATCHPOINT
))
10727 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10736 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10737 struct bp_target_info
*bp_tgt
)
10739 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10740 struct remote_state
*rs
;
10744 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10747 /* Make sure the remote is pointing at the right process, if
10749 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10750 set_general_process ();
10752 rs
= get_remote_state ();
10753 p
= rs
->buf
.data ();
10754 endbuf
= p
+ get_remote_packet_size ();
10760 addr
= remote_address_masked (addr
);
10761 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10762 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10764 if (supports_evaluation_of_breakpoint_conditions ())
10765 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10767 if (can_run_breakpoint_commands ())
10768 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10771 getpkt (&rs
->buf
, 0);
10773 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10776 if (rs
->buf
[1] == '.')
10778 message
= strchr (&rs
->buf
[2], '.');
10780 error (_("Remote failure reply: %s"), message
+ 1);
10783 case PACKET_UNKNOWN
:
10788 internal_error (__FILE__
, __LINE__
,
10789 _("remote_insert_hw_breakpoint: reached end of function"));
10794 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10795 struct bp_target_info
*bp_tgt
)
10798 struct remote_state
*rs
= get_remote_state ();
10799 char *p
= rs
->buf
.data ();
10800 char *endbuf
= p
+ get_remote_packet_size ();
10802 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10805 /* Make sure the remote is pointing at the right process, if
10807 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10808 set_general_process ();
10814 addr
= remote_address_masked (bp_tgt
->placed_address
);
10815 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10816 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10819 getpkt (&rs
->buf
, 0);
10821 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10824 case PACKET_UNKNOWN
:
10829 internal_error (__FILE__
, __LINE__
,
10830 _("remote_remove_hw_breakpoint: reached end of function"));
10833 /* Verify memory using the "qCRC:" request. */
10836 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10838 struct remote_state
*rs
= get_remote_state ();
10839 unsigned long host_crc
, target_crc
;
10842 /* It doesn't make sense to use qCRC if the remote target is
10843 connected but not running. */
10844 if (target_has_execution ()
10845 && packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10847 enum packet_result result
;
10849 /* Make sure the remote is pointing at the right process. */
10850 set_general_process ();
10852 /* FIXME: assumes lma can fit into long. */
10853 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10854 (long) lma
, (long) size
);
10857 /* Be clever; compute the host_crc before waiting for target
10859 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10861 getpkt (&rs
->buf
, 0);
10863 result
= packet_ok (rs
->buf
,
10864 &remote_protocol_packets
[PACKET_qCRC
]);
10865 if (result
== PACKET_ERROR
)
10867 else if (result
== PACKET_OK
)
10869 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10870 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10872 return (host_crc
== target_crc
);
10876 return simple_verify_memory (this, data
, lma
, size
);
10879 /* compare-sections command
10881 With no arguments, compares each loadable section in the exec bfd
10882 with the same memory range on the target, and reports mismatches.
10883 Useful for verifying the image on the target against the exec file. */
10886 compare_sections_command (const char *args
, int from_tty
)
10889 const char *sectname
;
10890 bfd_size_type size
;
10893 int mismatched
= 0;
10897 if (!current_program_space
->exec_bfd ())
10898 error (_("command cannot be used without an exec file"));
10900 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10906 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
10908 if (!(s
->flags
& SEC_LOAD
))
10909 continue; /* Skip non-loadable section. */
10911 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10912 continue; /* Skip writeable sections */
10914 size
= bfd_section_size (s
);
10916 continue; /* Skip zero-length section. */
10918 sectname
= bfd_section_name (s
);
10919 if (args
&& strcmp (args
, sectname
) != 0)
10920 continue; /* Not the section selected by user. */
10922 matched
= 1; /* Do this section. */
10925 gdb::byte_vector
sectdata (size
);
10926 bfd_get_section_contents (current_program_space
->exec_bfd (), s
,
10927 sectdata
.data (), 0, size
);
10929 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10932 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10933 paddress (target_gdbarch (), lma
),
10934 paddress (target_gdbarch (), lma
+ size
));
10936 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10937 paddress (target_gdbarch (), lma
),
10938 paddress (target_gdbarch (), lma
+ size
));
10940 printf_filtered ("matched.\n");
10943 printf_filtered ("MIS-MATCHED!\n");
10947 if (mismatched
> 0)
10948 warning (_("One or more sections of the target image does not match\n\
10949 the loaded file\n"));
10950 if (args
&& !matched
)
10951 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10954 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10955 into remote target. The number of bytes written to the remote
10956 target is returned, or -1 for error. */
10959 remote_target::remote_write_qxfer (const char *object_name
,
10960 const char *annex
, const gdb_byte
*writebuf
,
10961 ULONGEST offset
, LONGEST len
,
10962 ULONGEST
*xfered_len
,
10963 struct packet_config
*packet
)
10967 struct remote_state
*rs
= get_remote_state ();
10968 int max_size
= get_memory_write_packet_size ();
10970 if (packet_config_support (packet
) == PACKET_DISABLE
)
10971 return TARGET_XFER_E_IO
;
10973 /* Insert header. */
10974 i
= snprintf (rs
->buf
.data (), max_size
,
10975 "qXfer:%s:write:%s:%s:",
10976 object_name
, annex
? annex
: "",
10977 phex_nz (offset
, sizeof offset
));
10978 max_size
-= (i
+ 1);
10980 /* Escape as much data as fits into rs->buf. */
10981 buf_len
= remote_escape_output
10982 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10984 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10985 || getpkt_sane (&rs
->buf
, 0) < 0
10986 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10987 return TARGET_XFER_E_IO
;
10989 unpack_varlen_hex (rs
->buf
.data (), &n
);
10992 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10995 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10996 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10997 number of bytes read is returned, or 0 for EOF, or -1 for error.
10998 The number of bytes read may be less than LEN without indicating an
10999 EOF. PACKET is checked and updated to indicate whether the remote
11000 target supports this object. */
11003 remote_target::remote_read_qxfer (const char *object_name
,
11005 gdb_byte
*readbuf
, ULONGEST offset
,
11007 ULONGEST
*xfered_len
,
11008 struct packet_config
*packet
)
11010 struct remote_state
*rs
= get_remote_state ();
11011 LONGEST i
, n
, packet_len
;
11013 if (packet_config_support (packet
) == PACKET_DISABLE
)
11014 return TARGET_XFER_E_IO
;
11016 /* Check whether we've cached an end-of-object packet that matches
11018 if (rs
->finished_object
)
11020 if (strcmp (object_name
, rs
->finished_object
) == 0
11021 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
11022 && offset
== rs
->finished_offset
)
11023 return TARGET_XFER_EOF
;
11026 /* Otherwise, we're now reading something different. Discard
11028 xfree (rs
->finished_object
);
11029 xfree (rs
->finished_annex
);
11030 rs
->finished_object
= NULL
;
11031 rs
->finished_annex
= NULL
;
11034 /* Request only enough to fit in a single packet. The actual data
11035 may not, since we don't know how much of it will need to be escaped;
11036 the target is free to respond with slightly less data. We subtract
11037 five to account for the response type and the protocol frame. */
11038 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
11039 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
11040 "qXfer:%s:read:%s:%s,%s",
11041 object_name
, annex
? annex
: "",
11042 phex_nz (offset
, sizeof offset
),
11043 phex_nz (n
, sizeof n
));
11044 i
= putpkt (rs
->buf
);
11046 return TARGET_XFER_E_IO
;
11049 packet_len
= getpkt_sane (&rs
->buf
, 0);
11050 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11051 return TARGET_XFER_E_IO
;
11053 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
11054 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
11056 /* 'm' means there is (or at least might be) more data after this
11057 batch. That does not make sense unless there's at least one byte
11058 of data in this reply. */
11059 if (rs
->buf
[0] == 'm' && packet_len
== 1)
11060 error (_("Remote qXfer reply contained no data."));
11062 /* Got some data. */
11063 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
11064 packet_len
- 1, readbuf
, n
);
11066 /* 'l' is an EOF marker, possibly including a final block of data,
11067 or possibly empty. If we have the final block of a non-empty
11068 object, record this fact to bypass a subsequent partial read. */
11069 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
11071 rs
->finished_object
= xstrdup (object_name
);
11072 rs
->finished_annex
= xstrdup (annex
? annex
: "");
11073 rs
->finished_offset
= offset
+ i
;
11077 return TARGET_XFER_EOF
;
11081 return TARGET_XFER_OK
;
11085 enum target_xfer_status
11086 remote_target::xfer_partial (enum target_object object
,
11087 const char *annex
, gdb_byte
*readbuf
,
11088 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
11089 ULONGEST
*xfered_len
)
11091 struct remote_state
*rs
;
11095 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
11097 set_remote_traceframe ();
11098 set_general_thread (inferior_ptid
);
11100 rs
= get_remote_state ();
11102 /* Handle memory using the standard memory routines. */
11103 if (object
== TARGET_OBJECT_MEMORY
)
11105 /* If the remote target is connected but not running, we should
11106 pass this request down to a lower stratum (e.g. the executable
11108 if (!target_has_execution ())
11109 return TARGET_XFER_EOF
;
11111 if (writebuf
!= NULL
)
11112 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
11115 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
11119 /* Handle extra signal info using qxfer packets. */
11120 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
11123 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
11124 xfered_len
, &remote_protocol_packets
11125 [PACKET_qXfer_siginfo_read
]);
11127 return remote_write_qxfer ("siginfo", annex
,
11128 writebuf
, offset
, len
, xfered_len
,
11129 &remote_protocol_packets
11130 [PACKET_qXfer_siginfo_write
]);
11133 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
11136 return remote_read_qxfer ("statictrace", annex
,
11137 readbuf
, offset
, len
, xfered_len
,
11138 &remote_protocol_packets
11139 [PACKET_qXfer_statictrace_read
]);
11141 return TARGET_XFER_E_IO
;
11144 /* Only handle flash writes. */
11145 if (writebuf
!= NULL
)
11149 case TARGET_OBJECT_FLASH
:
11150 return remote_flash_write (offset
, len
, xfered_len
,
11154 return TARGET_XFER_E_IO
;
11158 /* Map pre-existing objects onto letters. DO NOT do this for new
11159 objects!!! Instead specify new query packets. */
11162 case TARGET_OBJECT_AVR
:
11166 case TARGET_OBJECT_AUXV
:
11167 gdb_assert (annex
== NULL
);
11168 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
11170 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
11172 case TARGET_OBJECT_AVAILABLE_FEATURES
:
11173 return remote_read_qxfer
11174 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
11175 &remote_protocol_packets
[PACKET_qXfer_features
]);
11177 case TARGET_OBJECT_LIBRARIES
:
11178 return remote_read_qxfer
11179 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
11180 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
11182 case TARGET_OBJECT_LIBRARIES_SVR4
:
11183 return remote_read_qxfer
11184 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
11185 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
11187 case TARGET_OBJECT_MEMORY_MAP
:
11188 gdb_assert (annex
== NULL
);
11189 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
11191 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
11193 case TARGET_OBJECT_OSDATA
:
11194 /* Should only get here if we're connected. */
11195 gdb_assert (rs
->remote_desc
);
11196 return remote_read_qxfer
11197 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
11198 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
11200 case TARGET_OBJECT_THREADS
:
11201 gdb_assert (annex
== NULL
);
11202 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
11204 &remote_protocol_packets
[PACKET_qXfer_threads
]);
11206 case TARGET_OBJECT_TRACEFRAME_INFO
:
11207 gdb_assert (annex
== NULL
);
11208 return remote_read_qxfer
11209 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
11210 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
11212 case TARGET_OBJECT_FDPIC
:
11213 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
11215 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
11217 case TARGET_OBJECT_OPENVMS_UIB
:
11218 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
11220 &remote_protocol_packets
[PACKET_qXfer_uib
]);
11222 case TARGET_OBJECT_BTRACE
:
11223 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
11225 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
11227 case TARGET_OBJECT_BTRACE_CONF
:
11228 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
11230 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
11232 case TARGET_OBJECT_EXEC_FILE
:
11233 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
11235 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
11238 return TARGET_XFER_E_IO
;
11241 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
11242 large enough let the caller deal with it. */
11243 if (len
< get_remote_packet_size ())
11244 return TARGET_XFER_E_IO
;
11245 len
= get_remote_packet_size ();
11247 /* Except for querying the minimum buffer size, target must be open. */
11248 if (!rs
->remote_desc
)
11249 error (_("remote query is only available after target open"));
11251 gdb_assert (annex
!= NULL
);
11252 gdb_assert (readbuf
!= NULL
);
11254 p2
= rs
->buf
.data ();
11256 *p2
++ = query_type
;
11258 /* We used one buffer char for the remote protocol q command and
11259 another for the query type. As the remote protocol encapsulation
11260 uses 4 chars plus one extra in case we are debugging
11261 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11264 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11266 /* Bad caller may have sent forbidden characters. */
11267 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11272 gdb_assert (annex
[i
] == '\0');
11274 i
= putpkt (rs
->buf
);
11276 return TARGET_XFER_E_IO
;
11278 getpkt (&rs
->buf
, 0);
11279 strcpy ((char *) readbuf
, rs
->buf
.data ());
11281 *xfered_len
= strlen ((char *) readbuf
);
11282 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11285 /* Implementation of to_get_memory_xfer_limit. */
11288 remote_target::get_memory_xfer_limit ()
11290 return get_memory_write_packet_size ();
11294 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11295 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11296 CORE_ADDR
*found_addrp
)
11298 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11299 struct remote_state
*rs
= get_remote_state ();
11300 int max_size
= get_memory_write_packet_size ();
11301 struct packet_config
*packet
=
11302 &remote_protocol_packets
[PACKET_qSearch_memory
];
11303 /* Number of packet bytes used to encode the pattern;
11304 this could be more than PATTERN_LEN due to escape characters. */
11305 int escaped_pattern_len
;
11306 /* Amount of pattern that was encodable in the packet. */
11307 int used_pattern_len
;
11310 ULONGEST found_addr
;
11312 auto read_memory
= [=] (CORE_ADDR addr
, gdb_byte
*result
, size_t len
)
11314 return (target_read (this, TARGET_OBJECT_MEMORY
, NULL
, result
, addr
, len
)
11318 /* Don't go to the target if we don't have to. This is done before
11319 checking packet_config_support to avoid the possibility that a
11320 success for this edge case means the facility works in
11322 if (pattern_len
> search_space_len
)
11324 if (pattern_len
== 0)
11326 *found_addrp
= start_addr
;
11330 /* If we already know the packet isn't supported, fall back to the simple
11331 way of searching memory. */
11333 if (packet_config_support (packet
) == PACKET_DISABLE
)
11335 /* Target doesn't provided special support, fall back and use the
11336 standard support (copy memory and do the search here). */
11337 return simple_search_memory (read_memory
, start_addr
, search_space_len
,
11338 pattern
, pattern_len
, found_addrp
);
11341 /* Make sure the remote is pointing at the right process. */
11342 set_general_process ();
11344 /* Insert header. */
11345 i
= snprintf (rs
->buf
.data (), max_size
,
11346 "qSearch:memory:%s;%s;",
11347 phex_nz (start_addr
, addr_size
),
11348 phex_nz (search_space_len
, sizeof (search_space_len
)));
11349 max_size
-= (i
+ 1);
11351 /* Escape as much data as fits into rs->buf. */
11352 escaped_pattern_len
=
11353 remote_escape_output (pattern
, pattern_len
, 1,
11354 (gdb_byte
*) rs
->buf
.data () + i
,
11355 &used_pattern_len
, max_size
);
11357 /* Bail if the pattern is too large. */
11358 if (used_pattern_len
!= pattern_len
)
11359 error (_("Pattern is too large to transmit to remote target."));
11361 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11362 || getpkt_sane (&rs
->buf
, 0) < 0
11363 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11365 /* The request may not have worked because the command is not
11366 supported. If so, fall back to the simple way. */
11367 if (packet_config_support (packet
) == PACKET_DISABLE
)
11369 return simple_search_memory (read_memory
, start_addr
, search_space_len
,
11370 pattern
, pattern_len
, found_addrp
);
11375 if (rs
->buf
[0] == '0')
11377 else if (rs
->buf
[0] == '1')
11380 if (rs
->buf
[1] != ',')
11381 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11382 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11383 *found_addrp
= found_addr
;
11386 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11392 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11394 struct remote_state
*rs
= get_remote_state ();
11395 char *p
= rs
->buf
.data ();
11397 if (!rs
->remote_desc
)
11398 error (_("remote rcmd is only available after target open"));
11400 /* Send a NULL command across as an empty command. */
11401 if (command
== NULL
)
11404 /* The query prefix. */
11405 strcpy (rs
->buf
.data (), "qRcmd,");
11406 p
= strchr (rs
->buf
.data (), '\0');
11408 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11409 > get_remote_packet_size ())
11410 error (_("\"monitor\" command ``%s'' is too long."), command
);
11412 /* Encode the actual command. */
11413 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11415 if (putpkt (rs
->buf
) < 0)
11416 error (_("Communication problem with target."));
11418 /* get/display the response */
11423 /* XXX - see also remote_get_noisy_reply(). */
11424 QUIT
; /* Allow user to bail out with ^C. */
11426 if (getpkt_sane (&rs
->buf
, 0) == -1)
11428 /* Timeout. Continue to (try to) read responses.
11429 This is better than stopping with an error, assuming the stub
11430 is still executing the (long) monitor command.
11431 If needed, the user can interrupt gdb using C-c, obtaining
11432 an effect similar to stop on timeout. */
11435 buf
= rs
->buf
.data ();
11436 if (buf
[0] == '\0')
11437 error (_("Target does not support this command."));
11438 if (buf
[0] == 'O' && buf
[1] != 'K')
11440 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11443 if (strcmp (buf
, "OK") == 0)
11445 if (strlen (buf
) == 3 && buf
[0] == 'E'
11446 && isdigit (buf
[1]) && isdigit (buf
[2]))
11448 error (_("Protocol error with Rcmd"));
11450 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11452 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11454 fputc_unfiltered (c
, outbuf
);
11460 std::vector
<mem_region
>
11461 remote_target::memory_map ()
11463 std::vector
<mem_region
> result
;
11464 gdb::optional
<gdb::char_vector
> text
11465 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11468 result
= parse_memory_map (text
->data ());
11474 packet_command (const char *args
, int from_tty
)
11476 remote_target
*remote
= get_current_remote_target ();
11478 if (remote
== nullptr)
11479 error (_("command can only be used with remote target"));
11481 remote
->packet_command (args
, from_tty
);
11485 remote_target::packet_command (const char *args
, int from_tty
)
11488 error (_("remote-packet command requires packet text as argument"));
11490 puts_filtered ("sending: ");
11491 print_packet (args
);
11492 puts_filtered ("\n");
11495 remote_state
*rs
= get_remote_state ();
11497 getpkt (&rs
->buf
, 0);
11498 puts_filtered ("received: ");
11499 print_packet (rs
->buf
.data ());
11500 puts_filtered ("\n");
11504 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11506 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11508 static void threadset_test_cmd (char *cmd
, int tty
);
11510 static void threadalive_test (char *cmd
, int tty
);
11512 static void threadlist_test_cmd (char *cmd
, int tty
);
11514 int get_and_display_threadinfo (threadref
*ref
);
11516 static void threadinfo_test_cmd (char *cmd
, int tty
);
11518 static int thread_display_step (threadref
*ref
, void *context
);
11520 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11522 static void init_remote_threadtests (void);
11524 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11527 threadset_test_cmd (const char *cmd
, int tty
)
11529 int sample_thread
= SAMPLE_THREAD
;
11531 printf_filtered (_("Remote threadset test\n"));
11532 set_general_thread (sample_thread
);
11537 threadalive_test (const char *cmd
, int tty
)
11539 int sample_thread
= SAMPLE_THREAD
;
11540 int pid
= inferior_ptid
.pid ();
11541 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11543 if (remote_thread_alive (ptid
))
11544 printf_filtered ("PASS: Thread alive test\n");
11546 printf_filtered ("FAIL: Thread alive test\n");
11549 void output_threadid (char *title
, threadref
*ref
);
11552 output_threadid (char *title
, threadref
*ref
)
11556 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11558 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11562 threadlist_test_cmd (const char *cmd
, int tty
)
11565 threadref nextthread
;
11566 int done
, result_count
;
11567 threadref threadlist
[3];
11569 printf_filtered ("Remote Threadlist test\n");
11570 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11571 &result_count
, &threadlist
[0]))
11572 printf_filtered ("FAIL: threadlist test\n");
11575 threadref
*scan
= threadlist
;
11576 threadref
*limit
= scan
+ result_count
;
11578 while (scan
< limit
)
11579 output_threadid (" thread ", scan
++);
11584 display_thread_info (struct gdb_ext_thread_info
*info
)
11586 output_threadid ("Threadid: ", &info
->threadid
);
11587 printf_filtered ("Name: %s\n ", info
->shortname
);
11588 printf_filtered ("State: %s\n", info
->display
);
11589 printf_filtered ("other: %s\n\n", info
->more_display
);
11593 get_and_display_threadinfo (threadref
*ref
)
11597 struct gdb_ext_thread_info threadinfo
;
11599 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11600 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11601 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11602 display_thread_info (&threadinfo
);
11607 threadinfo_test_cmd (const char *cmd
, int tty
)
11609 int athread
= SAMPLE_THREAD
;
11613 int_to_threadref (&thread
, athread
);
11614 printf_filtered ("Remote Threadinfo test\n");
11615 if (!get_and_display_threadinfo (&thread
))
11616 printf_filtered ("FAIL cannot get thread info\n");
11620 thread_display_step (threadref
*ref
, void *context
)
11622 /* output_threadid(" threadstep ",ref); *//* simple test */
11623 return get_and_display_threadinfo (ref
);
11627 threadlist_update_test_cmd (const char *cmd
, int tty
)
11629 printf_filtered ("Remote Threadlist update test\n");
11630 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11634 init_remote_threadtests (void)
11636 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11637 _("Fetch and print the remote list of "
11638 "thread identifiers, one pkt only."));
11639 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11640 _("Fetch and display info about one thread."));
11641 add_com ("tset", class_obscure
, threadset_test_cmd
,
11642 _("Test setting to a different thread."));
11643 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11644 _("Iterate through updating all remote thread info."));
11645 add_com ("talive", class_obscure
, threadalive_test
,
11646 _("Remote thread alive test."));
11651 /* Convert a thread ID to a string. */
11654 remote_target::pid_to_str (ptid_t ptid
)
11656 struct remote_state
*rs
= get_remote_state ();
11658 if (ptid
== null_ptid
)
11659 return normal_pid_to_str (ptid
);
11660 else if (ptid
.is_pid ())
11662 /* Printing an inferior target id. */
11664 /* When multi-process extensions are off, there's no way in the
11665 remote protocol to know the remote process id, if there's any
11666 at all. There's one exception --- when we're connected with
11667 target extended-remote, and we manually attached to a process
11668 with "attach PID". We don't record anywhere a flag that
11669 allows us to distinguish that case from the case of
11670 connecting with extended-remote and the stub already being
11671 attached to a process, and reporting yes to qAttached, hence
11672 no smart special casing here. */
11673 if (!remote_multi_process_p (rs
))
11674 return "Remote target";
11676 return normal_pid_to_str (ptid
);
11680 if (magic_null_ptid
== ptid
)
11681 return "Thread <main>";
11682 else if (remote_multi_process_p (rs
))
11683 if (ptid
.lwp () == 0)
11684 return normal_pid_to_str (ptid
);
11686 return string_printf ("Thread %d.%ld",
11687 ptid
.pid (), ptid
.lwp ());
11689 return string_printf ("Thread %ld", ptid
.lwp ());
11693 /* Get the address of the thread local variable in OBJFILE which is
11694 stored at OFFSET within the thread local storage for thread PTID. */
11697 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11700 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11702 struct remote_state
*rs
= get_remote_state ();
11703 char *p
= rs
->buf
.data ();
11704 char *endp
= p
+ get_remote_packet_size ();
11705 enum packet_result result
;
11707 strcpy (p
, "qGetTLSAddr:");
11709 p
= write_ptid (p
, endp
, ptid
);
11711 p
+= hexnumstr (p
, offset
);
11713 p
+= hexnumstr (p
, lm
);
11717 getpkt (&rs
->buf
, 0);
11718 result
= packet_ok (rs
->buf
,
11719 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11720 if (result
== PACKET_OK
)
11724 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11727 else if (result
== PACKET_UNKNOWN
)
11728 throw_error (TLS_GENERIC_ERROR
,
11729 _("Remote target doesn't support qGetTLSAddr packet"));
11731 throw_error (TLS_GENERIC_ERROR
,
11732 _("Remote target failed to process qGetTLSAddr request"));
11735 throw_error (TLS_GENERIC_ERROR
,
11736 _("TLS not supported or disabled on this target"));
11741 /* Provide thread local base, i.e. Thread Information Block address.
11742 Returns 1 if ptid is found and thread_local_base is non zero. */
11745 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11747 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11749 struct remote_state
*rs
= get_remote_state ();
11750 char *p
= rs
->buf
.data ();
11751 char *endp
= p
+ get_remote_packet_size ();
11752 enum packet_result result
;
11754 strcpy (p
, "qGetTIBAddr:");
11756 p
= write_ptid (p
, endp
, ptid
);
11760 getpkt (&rs
->buf
, 0);
11761 result
= packet_ok (rs
->buf
,
11762 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11763 if (result
== PACKET_OK
)
11766 unpack_varlen_hex (rs
->buf
.data (), &val
);
11768 *addr
= (CORE_ADDR
) val
;
11771 else if (result
== PACKET_UNKNOWN
)
11772 error (_("Remote target doesn't support qGetTIBAddr packet"));
11774 error (_("Remote target failed to process qGetTIBAddr request"));
11777 error (_("qGetTIBAddr not supported or disabled on this target"));
11782 /* Support for inferring a target description based on the current
11783 architecture and the size of a 'g' packet. While the 'g' packet
11784 can have any size (since optional registers can be left off the
11785 end), some sizes are easily recognizable given knowledge of the
11786 approximate architecture. */
11788 struct remote_g_packet_guess
11790 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11797 const struct target_desc
*tdesc
;
11800 struct remote_g_packet_data
: public allocate_on_obstack
11802 std::vector
<remote_g_packet_guess
> guesses
;
11805 static struct gdbarch_data
*remote_g_packet_data_handle
;
11808 remote_g_packet_data_init (struct obstack
*obstack
)
11810 return new (obstack
) remote_g_packet_data
;
11814 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11815 const struct target_desc
*tdesc
)
11817 struct remote_g_packet_data
*data
11818 = ((struct remote_g_packet_data
*)
11819 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11821 gdb_assert (tdesc
!= NULL
);
11823 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11824 if (guess
.bytes
== bytes
)
11825 internal_error (__FILE__
, __LINE__
,
11826 _("Duplicate g packet description added for size %d"),
11829 data
->guesses
.emplace_back (bytes
, tdesc
);
11832 /* Return true if remote_read_description would do anything on this target
11833 and architecture, false otherwise. */
11836 remote_read_description_p (struct target_ops
*target
)
11838 struct remote_g_packet_data
*data
11839 = ((struct remote_g_packet_data
*)
11840 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11842 return !data
->guesses
.empty ();
11845 const struct target_desc
*
11846 remote_target::read_description ()
11848 struct remote_g_packet_data
*data
11849 = ((struct remote_g_packet_data
*)
11850 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11852 /* Do not try this during initial connection, when we do not know
11853 whether there is a running but stopped thread. */
11854 if (!target_has_execution () || inferior_ptid
== null_ptid
)
11855 return beneath ()->read_description ();
11857 if (!data
->guesses
.empty ())
11859 int bytes
= send_g_packet ();
11861 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11862 if (guess
.bytes
== bytes
)
11863 return guess
.tdesc
;
11865 /* We discard the g packet. A minor optimization would be to
11866 hold on to it, and fill the register cache once we have selected
11867 an architecture, but it's too tricky to do safely. */
11870 return beneath ()->read_description ();
11873 /* Remote file transfer support. This is host-initiated I/O, not
11874 target-initiated; for target-initiated, see remote-fileio.c. */
11876 /* If *LEFT is at least the length of STRING, copy STRING to
11877 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11878 decrease *LEFT. Otherwise raise an error. */
11881 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11883 int len
= strlen (string
);
11886 error (_("Packet too long for target."));
11888 memcpy (*buffer
, string
, len
);
11892 /* NUL-terminate the buffer as a convenience, if there is
11898 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11899 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11900 decrease *LEFT. Otherwise raise an error. */
11903 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11906 if (2 * len
> *left
)
11907 error (_("Packet too long for target."));
11909 bin2hex (bytes
, *buffer
, len
);
11910 *buffer
+= 2 * len
;
11913 /* NUL-terminate the buffer as a convenience, if there is
11919 /* If *LEFT is large enough, convert VALUE to hex and add it to
11920 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11921 decrease *LEFT. Otherwise raise an error. */
11924 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11926 int len
= hexnumlen (value
);
11929 error (_("Packet too long for target."));
11931 hexnumstr (*buffer
, value
);
11935 /* NUL-terminate the buffer as a convenience, if there is
11941 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11942 value, *REMOTE_ERRNO to the remote error number or zero if none
11943 was included, and *ATTACHMENT to point to the start of the annex
11944 if any. The length of the packet isn't needed here; there may
11945 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11947 Return 0 if the packet could be parsed, -1 if it could not. If
11948 -1 is returned, the other variables may not be initialized. */
11951 remote_hostio_parse_result (const char *buffer
, int *retcode
,
11952 int *remote_errno
, const char **attachment
)
11957 *attachment
= NULL
;
11959 if (buffer
[0] != 'F')
11963 *retcode
= strtol (&buffer
[1], &p
, 16);
11964 if (errno
!= 0 || p
== &buffer
[1])
11967 /* Check for ",errno". */
11971 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11972 if (errno
!= 0 || p
+ 1 == p2
)
11977 /* Check for ";attachment". If there is no attachment, the
11978 packet should end here. */
11981 *attachment
= p
+ 1;
11984 else if (*p
== '\0')
11990 /* Send a prepared I/O packet to the target and read its response.
11991 The prepared packet is in the global RS->BUF before this function
11992 is called, and the answer is there when we return.
11994 COMMAND_BYTES is the length of the request to send, which may include
11995 binary data. WHICH_PACKET is the packet configuration to check
11996 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11997 is set to the error number and -1 is returned. Otherwise the value
11998 returned by the function is returned.
12000 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
12001 attachment is expected; an error will be reported if there's a
12002 mismatch. If one is found, *ATTACHMENT will be set to point into
12003 the packet buffer and *ATTACHMENT_LEN will be set to the
12004 attachment's length. */
12007 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
12008 int *remote_errno
, const char **attachment
,
12009 int *attachment_len
)
12011 struct remote_state
*rs
= get_remote_state ();
12012 int ret
, bytes_read
;
12013 const char *attachment_tmp
;
12015 if (packet_support (which_packet
) == PACKET_DISABLE
)
12017 *remote_errno
= FILEIO_ENOSYS
;
12021 putpkt_binary (rs
->buf
.data (), command_bytes
);
12022 bytes_read
= getpkt_sane (&rs
->buf
, 0);
12024 /* If it timed out, something is wrong. Don't try to parse the
12026 if (bytes_read
< 0)
12028 *remote_errno
= FILEIO_EINVAL
;
12032 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
12035 *remote_errno
= FILEIO_EINVAL
;
12037 case PACKET_UNKNOWN
:
12038 *remote_errno
= FILEIO_ENOSYS
;
12044 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
12047 *remote_errno
= FILEIO_EINVAL
;
12051 /* Make sure we saw an attachment if and only if we expected one. */
12052 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
12053 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
12055 *remote_errno
= FILEIO_EINVAL
;
12059 /* If an attachment was found, it must point into the packet buffer;
12060 work out how many bytes there were. */
12061 if (attachment_tmp
!= NULL
)
12063 *attachment
= attachment_tmp
;
12064 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
12070 /* See declaration.h. */
12073 readahead_cache::invalidate ()
12078 /* See declaration.h. */
12081 readahead_cache::invalidate_fd (int fd
)
12083 if (this->fd
== fd
)
12087 /* Set the filesystem remote_hostio functions that take FILENAME
12088 arguments will use. Return 0 on success, or -1 if an error
12089 occurs (and set *REMOTE_ERRNO). */
12092 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
12095 struct remote_state
*rs
= get_remote_state ();
12096 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
12097 char *p
= rs
->buf
.data ();
12098 int left
= get_remote_packet_size () - 1;
12102 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
12105 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
12108 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
12110 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
12111 remote_buffer_add_string (&p
, &left
, arg
);
12113 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
12114 remote_errno
, NULL
, NULL
);
12116 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
12120 rs
->fs_pid
= required_pid
;
12125 /* Implementation of to_fileio_open. */
12128 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
12129 int flags
, int mode
, int warn_if_slow
,
12132 struct remote_state
*rs
= get_remote_state ();
12133 char *p
= rs
->buf
.data ();
12134 int left
= get_remote_packet_size () - 1;
12138 static int warning_issued
= 0;
12140 printf_unfiltered (_("Reading %s from remote target...\n"),
12143 if (!warning_issued
)
12145 warning (_("File transfers from remote targets can be slow."
12146 " Use \"set sysroot\" to access files locally"
12148 warning_issued
= 1;
12152 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12155 remote_buffer_add_string (&p
, &left
, "vFile:open:");
12157 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12158 strlen (filename
));
12159 remote_buffer_add_string (&p
, &left
, ",");
12161 remote_buffer_add_int (&p
, &left
, flags
);
12162 remote_buffer_add_string (&p
, &left
, ",");
12164 remote_buffer_add_int (&p
, &left
, mode
);
12166 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
12167 remote_errno
, NULL
, NULL
);
12171 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
12172 int flags
, int mode
, int warn_if_slow
,
12175 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
12179 /* Implementation of to_fileio_pwrite. */
12182 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12183 ULONGEST offset
, int *remote_errno
)
12185 struct remote_state
*rs
= get_remote_state ();
12186 char *p
= rs
->buf
.data ();
12187 int left
= get_remote_packet_size ();
12190 rs
->readahead_cache
.invalidate_fd (fd
);
12192 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
12194 remote_buffer_add_int (&p
, &left
, fd
);
12195 remote_buffer_add_string (&p
, &left
, ",");
12197 remote_buffer_add_int (&p
, &left
, offset
);
12198 remote_buffer_add_string (&p
, &left
, ",");
12200 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
12201 (get_remote_packet_size ()
12202 - (p
- rs
->buf
.data ())));
12204 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
12205 remote_errno
, NULL
, NULL
);
12209 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12210 ULONGEST offset
, int *remote_errno
)
12212 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
12215 /* Helper for the implementation of to_fileio_pread. Read the file
12216 from the remote side with vFile:pread. */
12219 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
12220 ULONGEST offset
, int *remote_errno
)
12222 struct remote_state
*rs
= get_remote_state ();
12223 char *p
= rs
->buf
.data ();
12224 const char *attachment
;
12225 int left
= get_remote_packet_size ();
12226 int ret
, attachment_len
;
12229 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
12231 remote_buffer_add_int (&p
, &left
, fd
);
12232 remote_buffer_add_string (&p
, &left
, ",");
12234 remote_buffer_add_int (&p
, &left
, len
);
12235 remote_buffer_add_string (&p
, &left
, ",");
12237 remote_buffer_add_int (&p
, &left
, offset
);
12239 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
12240 remote_errno
, &attachment
,
12246 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12248 if (read_len
!= ret
)
12249 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
12254 /* See declaration.h. */
12257 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12261 && this->offset
<= offset
12262 && offset
< this->offset
+ this->bufsize
)
12264 ULONGEST max
= this->offset
+ this->bufsize
;
12266 if (offset
+ len
> max
)
12267 len
= max
- offset
;
12269 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12276 /* Implementation of to_fileio_pread. */
12279 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12280 ULONGEST offset
, int *remote_errno
)
12283 struct remote_state
*rs
= get_remote_state ();
12284 readahead_cache
*cache
= &rs
->readahead_cache
;
12286 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12289 cache
->hit_count
++;
12291 remote_debug_printf ("readahead cache hit %s",
12292 pulongest (cache
->hit_count
));
12296 cache
->miss_count
++;
12298 remote_debug_printf ("readahead cache miss %s",
12299 pulongest (cache
->miss_count
));
12302 cache
->offset
= offset
;
12303 cache
->bufsize
= get_remote_packet_size ();
12304 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12306 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12307 cache
->offset
, remote_errno
);
12310 cache
->invalidate_fd (fd
);
12314 cache
->bufsize
= ret
;
12315 return cache
->pread (fd
, read_buf
, len
, offset
);
12319 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12320 ULONGEST offset
, int *remote_errno
)
12322 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12325 /* Implementation of to_fileio_close. */
12328 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12330 struct remote_state
*rs
= get_remote_state ();
12331 char *p
= rs
->buf
.data ();
12332 int left
= get_remote_packet_size () - 1;
12334 rs
->readahead_cache
.invalidate_fd (fd
);
12336 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12338 remote_buffer_add_int (&p
, &left
, fd
);
12340 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12341 remote_errno
, NULL
, NULL
);
12345 remote_target::fileio_close (int fd
, int *remote_errno
)
12347 return remote_hostio_close (fd
, remote_errno
);
12350 /* Implementation of to_fileio_unlink. */
12353 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12356 struct remote_state
*rs
= get_remote_state ();
12357 char *p
= rs
->buf
.data ();
12358 int left
= get_remote_packet_size () - 1;
12360 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12363 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12365 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12366 strlen (filename
));
12368 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12369 remote_errno
, NULL
, NULL
);
12373 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12376 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12379 /* Implementation of to_fileio_readlink. */
12381 gdb::optional
<std::string
>
12382 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12385 struct remote_state
*rs
= get_remote_state ();
12386 char *p
= rs
->buf
.data ();
12387 const char *attachment
;
12388 int left
= get_remote_packet_size ();
12389 int len
, attachment_len
;
12392 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12395 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12397 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12398 strlen (filename
));
12400 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12401 remote_errno
, &attachment
,
12407 std::string
ret (len
, '\0');
12409 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12410 (gdb_byte
*) &ret
[0], len
);
12411 if (read_len
!= len
)
12412 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12417 /* Implementation of to_fileio_fstat. */
12420 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12422 struct remote_state
*rs
= get_remote_state ();
12423 char *p
= rs
->buf
.data ();
12424 int left
= get_remote_packet_size ();
12425 int attachment_len
, ret
;
12426 const char *attachment
;
12427 struct fio_stat fst
;
12430 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12432 remote_buffer_add_int (&p
, &left
, fd
);
12434 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12435 remote_errno
, &attachment
,
12439 if (*remote_errno
!= FILEIO_ENOSYS
)
12442 /* Strictly we should return -1, ENOSYS here, but when
12443 "set sysroot remote:" was implemented in August 2008
12444 BFD's need for a stat function was sidestepped with
12445 this hack. This was not remedied until March 2015
12446 so we retain the previous behavior to avoid breaking
12449 Note that the memset is a March 2015 addition; older
12450 GDBs set st_size *and nothing else* so the structure
12451 would have garbage in all other fields. This might
12452 break something but retaining the previous behavior
12453 here would be just too wrong. */
12455 memset (st
, 0, sizeof (struct stat
));
12456 st
->st_size
= INT_MAX
;
12460 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12461 (gdb_byte
*) &fst
, sizeof (fst
));
12463 if (read_len
!= ret
)
12464 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12466 if (read_len
!= sizeof (fst
))
12467 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12468 read_len
, (int) sizeof (fst
));
12470 remote_fileio_to_host_stat (&fst
, st
);
12475 /* Implementation of to_filesystem_is_local. */
12478 remote_target::filesystem_is_local ()
12480 /* Valgrind GDB presents itself as a remote target but works
12481 on the local filesystem: it does not implement remote get
12482 and users are not expected to set a sysroot. To handle
12483 this case we treat the remote filesystem as local if the
12484 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12485 does not support vFile:open. */
12486 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12488 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12490 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12492 int fd
, remote_errno
;
12494 /* Try opening a file to probe support. The supplied
12495 filename is irrelevant, we only care about whether
12496 the stub recognizes the packet or not. */
12497 fd
= remote_hostio_open (NULL
, "just probing",
12498 FILEIO_O_RDONLY
, 0700, 0,
12502 remote_hostio_close (fd
, &remote_errno
);
12504 ps
= packet_support (PACKET_vFile_open
);
12507 if (ps
== PACKET_DISABLE
)
12509 static int warning_issued
= 0;
12511 if (!warning_issued
)
12513 warning (_("remote target does not support file"
12514 " transfer, attempting to access files"
12515 " from local filesystem."));
12516 warning_issued
= 1;
12527 remote_fileio_errno_to_host (int errnum
)
12533 case FILEIO_ENOENT
:
12541 case FILEIO_EACCES
:
12543 case FILEIO_EFAULT
:
12547 case FILEIO_EEXIST
:
12549 case FILEIO_ENODEV
:
12551 case FILEIO_ENOTDIR
:
12553 case FILEIO_EISDIR
:
12555 case FILEIO_EINVAL
:
12557 case FILEIO_ENFILE
:
12559 case FILEIO_EMFILE
:
12563 case FILEIO_ENOSPC
:
12565 case FILEIO_ESPIPE
:
12569 case FILEIO_ENOSYS
:
12571 case FILEIO_ENAMETOOLONG
:
12572 return ENAMETOOLONG
;
12578 remote_hostio_error (int errnum
)
12580 int host_error
= remote_fileio_errno_to_host (errnum
);
12582 if (host_error
== -1)
12583 error (_("Unknown remote I/O error %d"), errnum
);
12585 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12588 /* A RAII wrapper around a remote file descriptor. */
12590 class scoped_remote_fd
12593 scoped_remote_fd (remote_target
*remote
, int fd
)
12594 : m_remote (remote
), m_fd (fd
)
12598 ~scoped_remote_fd ()
12605 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12609 /* Swallow exception before it escapes the dtor. If
12610 something goes wrong, likely the connection is gone,
12611 and there's nothing else that can be done. */
12616 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12618 /* Release ownership of the file descriptor, and return it. */
12619 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12626 /* Return the owned file descriptor. */
12627 int get () const noexcept
12633 /* The remote target. */
12634 remote_target
*m_remote
;
12636 /* The owned remote I/O file descriptor. */
12641 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12643 remote_target
*remote
= get_current_remote_target ();
12645 if (remote
== nullptr)
12646 error (_("command can only be used with remote target"));
12648 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12652 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12655 int retcode
, remote_errno
, bytes
, io_size
;
12656 int bytes_in_buffer
;
12660 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12662 perror_with_name (local_file
);
12664 scoped_remote_fd fd
12665 (this, remote_hostio_open (NULL
,
12666 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12668 0700, 0, &remote_errno
));
12669 if (fd
.get () == -1)
12670 remote_hostio_error (remote_errno
);
12672 /* Send up to this many bytes at once. They won't all fit in the
12673 remote packet limit, so we'll transfer slightly fewer. */
12674 io_size
= get_remote_packet_size ();
12675 gdb::byte_vector
buffer (io_size
);
12677 bytes_in_buffer
= 0;
12680 while (bytes_in_buffer
|| !saw_eof
)
12684 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12685 io_size
- bytes_in_buffer
,
12689 if (ferror (file
.get ()))
12690 error (_("Error reading %s."), local_file
);
12693 /* EOF. Unless there is something still in the
12694 buffer from the last iteration, we are done. */
12696 if (bytes_in_buffer
== 0)
12704 bytes
+= bytes_in_buffer
;
12705 bytes_in_buffer
= 0;
12707 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12708 offset
, &remote_errno
);
12711 remote_hostio_error (remote_errno
);
12712 else if (retcode
== 0)
12713 error (_("Remote write of %d bytes returned 0!"), bytes
);
12714 else if (retcode
< bytes
)
12716 /* Short write. Save the rest of the read data for the next
12718 bytes_in_buffer
= bytes
- retcode
;
12719 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12725 if (remote_hostio_close (fd
.release (), &remote_errno
))
12726 remote_hostio_error (remote_errno
);
12729 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12733 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12735 remote_target
*remote
= get_current_remote_target ();
12737 if (remote
== nullptr)
12738 error (_("command can only be used with remote target"));
12740 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12744 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12747 int remote_errno
, bytes
, io_size
;
12750 scoped_remote_fd fd
12751 (this, remote_hostio_open (NULL
,
12752 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12754 if (fd
.get () == -1)
12755 remote_hostio_error (remote_errno
);
12757 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12759 perror_with_name (local_file
);
12761 /* Send up to this many bytes at once. They won't all fit in the
12762 remote packet limit, so we'll transfer slightly fewer. */
12763 io_size
= get_remote_packet_size ();
12764 gdb::byte_vector
buffer (io_size
);
12769 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12772 /* Success, but no bytes, means end-of-file. */
12775 remote_hostio_error (remote_errno
);
12779 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12781 perror_with_name (local_file
);
12784 if (remote_hostio_close (fd
.release (), &remote_errno
))
12785 remote_hostio_error (remote_errno
);
12788 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12792 remote_file_delete (const char *remote_file
, int from_tty
)
12794 remote_target
*remote
= get_current_remote_target ();
12796 if (remote
== nullptr)
12797 error (_("command can only be used with remote target"));
12799 remote
->remote_file_delete (remote_file
, from_tty
);
12803 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12805 int retcode
, remote_errno
;
12807 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12809 remote_hostio_error (remote_errno
);
12812 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12816 remote_put_command (const char *args
, int from_tty
)
12819 error_no_arg (_("file to put"));
12821 gdb_argv
argv (args
);
12822 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12823 error (_("Invalid parameters to remote put"));
12825 remote_file_put (argv
[0], argv
[1], from_tty
);
12829 remote_get_command (const char *args
, int from_tty
)
12832 error_no_arg (_("file to get"));
12834 gdb_argv
argv (args
);
12835 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12836 error (_("Invalid parameters to remote get"));
12838 remote_file_get (argv
[0], argv
[1], from_tty
);
12842 remote_delete_command (const char *args
, int from_tty
)
12845 error_no_arg (_("file to delete"));
12847 gdb_argv
argv (args
);
12848 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12849 error (_("Invalid parameters to remote delete"));
12851 remote_file_delete (argv
[0], from_tty
);
12855 remote_target::can_execute_reverse ()
12857 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12858 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12865 remote_target::supports_non_stop ()
12871 remote_target::supports_disable_randomization ()
12873 /* Only supported in extended mode. */
12878 remote_target::supports_multi_process ()
12880 struct remote_state
*rs
= get_remote_state ();
12882 return remote_multi_process_p (rs
);
12886 remote_supports_cond_tracepoints ()
12888 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12892 remote_target::supports_evaluation_of_breakpoint_conditions ()
12894 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12898 remote_supports_fast_tracepoints ()
12900 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12904 remote_supports_static_tracepoints ()
12906 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12910 remote_supports_install_in_trace ()
12912 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12916 remote_target::supports_enable_disable_tracepoint ()
12918 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12923 remote_target::supports_string_tracing ()
12925 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12929 remote_target::can_run_breakpoint_commands ()
12931 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12935 remote_target::trace_init ()
12937 struct remote_state
*rs
= get_remote_state ();
12940 remote_get_noisy_reply ();
12941 if (strcmp (rs
->buf
.data (), "OK") != 0)
12942 error (_("Target does not support this command."));
12945 /* Recursive routine to walk through command list including loops, and
12946 download packets for each command. */
12949 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12950 struct command_line
*cmds
)
12952 struct remote_state
*rs
= get_remote_state ();
12953 struct command_line
*cmd
;
12955 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12957 QUIT
; /* Allow user to bail out with ^C. */
12958 strcpy (rs
->buf
.data (), "QTDPsrc:");
12959 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12960 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12961 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12963 remote_get_noisy_reply ();
12964 if (strcmp (rs
->buf
.data (), "OK"))
12965 warning (_("Target does not support source download."));
12967 if (cmd
->control_type
== while_control
12968 || cmd
->control_type
== while_stepping_control
)
12970 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12972 QUIT
; /* Allow user to bail out with ^C. */
12973 strcpy (rs
->buf
.data (), "QTDPsrc:");
12974 encode_source_string (num
, addr
, "cmd", "end",
12975 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12976 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12978 remote_get_noisy_reply ();
12979 if (strcmp (rs
->buf
.data (), "OK"))
12980 warning (_("Target does not support source download."));
12986 remote_target::download_tracepoint (struct bp_location
*loc
)
12990 std::vector
<std::string
> tdp_actions
;
12991 std::vector
<std::string
> stepping_actions
;
12993 struct breakpoint
*b
= loc
->owner
;
12994 struct tracepoint
*t
= (struct tracepoint
*) b
;
12995 struct remote_state
*rs
= get_remote_state ();
12997 const char *err_msg
= _("Tracepoint packet too large for target.");
13000 /* We use a buffer other than rs->buf because we'll build strings
13001 across multiple statements, and other statements in between could
13003 gdb::char_vector
buf (get_remote_packet_size ());
13005 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
13007 tpaddr
= loc
->address
;
13008 strcpy (addrbuf
, phex (tpaddr
, sizeof (CORE_ADDR
)));
13009 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
13010 b
->number
, addrbuf
, /* address */
13011 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
13012 t
->step_count
, t
->pass_count
);
13014 if (ret
< 0 || ret
>= buf
.size ())
13015 error ("%s", err_msg
);
13017 /* Fast tracepoints are mostly handled by the target, but we can
13018 tell the target how big of an instruction block should be moved
13020 if (b
->type
== bp_fast_tracepoint
)
13022 /* Only test for support at download time; we may not know
13023 target capabilities at definition time. */
13024 if (remote_supports_fast_tracepoints ())
13026 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
13029 size_left
= buf
.size () - strlen (buf
.data ());
13030 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13032 gdb_insn_length (loc
->gdbarch
, tpaddr
));
13034 if (ret
< 0 || ret
>= size_left
)
13035 error ("%s", err_msg
);
13038 /* If it passed validation at definition but fails now,
13039 something is very wrong. */
13040 internal_error (__FILE__
, __LINE__
,
13041 _("Fast tracepoint not "
13042 "valid during download"));
13045 /* Fast tracepoints are functionally identical to regular
13046 tracepoints, so don't take lack of support as a reason to
13047 give up on the trace run. */
13048 warning (_("Target does not support fast tracepoints, "
13049 "downloading %d as regular tracepoint"), b
->number
);
13051 else if (b
->type
== bp_static_tracepoint
)
13053 /* Only test for support at download time; we may not know
13054 target capabilities at definition time. */
13055 if (remote_supports_static_tracepoints ())
13057 struct static_tracepoint_marker marker
;
13059 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
13061 size_left
= buf
.size () - strlen (buf
.data ());
13062 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13065 if (ret
< 0 || ret
>= size_left
)
13066 error ("%s", err_msg
);
13069 error (_("Static tracepoint not valid during download"));
13072 /* Fast tracepoints are functionally identical to regular
13073 tracepoints, so don't take lack of support as a reason
13074 to give up on the trace run. */
13075 error (_("Target does not support static tracepoints"));
13077 /* If the tracepoint has a conditional, make it into an agent
13078 expression and append to the definition. */
13081 /* Only test support at download time, we may not know target
13082 capabilities at definition time. */
13083 if (remote_supports_cond_tracepoints ())
13085 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
13088 size_left
= buf
.size () - strlen (buf
.data ());
13090 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13091 size_left
, ":X%x,", aexpr
->len
);
13093 if (ret
< 0 || ret
>= size_left
)
13094 error ("%s", err_msg
);
13096 size_left
= buf
.size () - strlen (buf
.data ());
13098 /* Two bytes to encode each aexpr byte, plus the terminating
13100 if (aexpr
->len
* 2 + 1 > size_left
)
13101 error ("%s", err_msg
);
13103 pkt
= buf
.data () + strlen (buf
.data ());
13105 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
13106 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
13110 warning (_("Target does not support conditional tracepoints, "
13111 "ignoring tp %d cond"), b
->number
);
13114 if (b
->commands
|| *default_collect
)
13116 size_left
= buf
.size () - strlen (buf
.data ());
13118 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13121 if (ret
< 0 || ret
>= size_left
)
13122 error ("%s", err_msg
);
13125 putpkt (buf
.data ());
13126 remote_get_noisy_reply ();
13127 if (strcmp (rs
->buf
.data (), "OK"))
13128 error (_("Target does not support tracepoints."));
13130 /* do_single_steps (t); */
13131 for (auto action_it
= tdp_actions
.begin ();
13132 action_it
!= tdp_actions
.end (); action_it
++)
13134 QUIT
; /* Allow user to bail out with ^C. */
13136 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
13137 || !stepping_actions
.empty ());
13139 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
13140 b
->number
, addrbuf
, /* address */
13141 action_it
->c_str (),
13142 has_more
? '-' : 0);
13144 if (ret
< 0 || ret
>= buf
.size ())
13145 error ("%s", err_msg
);
13147 putpkt (buf
.data ());
13148 remote_get_noisy_reply ();
13149 if (strcmp (rs
->buf
.data (), "OK"))
13150 error (_("Error on target while setting tracepoints."));
13153 for (auto action_it
= stepping_actions
.begin ();
13154 action_it
!= stepping_actions
.end (); action_it
++)
13156 QUIT
; /* Allow user to bail out with ^C. */
13158 bool is_first
= action_it
== stepping_actions
.begin ();
13159 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
13161 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
13162 b
->number
, addrbuf
, /* address */
13163 is_first
? "S" : "",
13164 action_it
->c_str (),
13165 has_more
? "-" : "");
13167 if (ret
< 0 || ret
>= buf
.size ())
13168 error ("%s", err_msg
);
13170 putpkt (buf
.data ());
13171 remote_get_noisy_reply ();
13172 if (strcmp (rs
->buf
.data (), "OK"))
13173 error (_("Error on target while setting tracepoints."));
13176 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
13178 if (b
->location
!= NULL
)
13180 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13182 if (ret
< 0 || ret
>= buf
.size ())
13183 error ("%s", err_msg
);
13185 encode_source_string (b
->number
, loc
->address
, "at",
13186 event_location_to_string (b
->location
.get ()),
13187 buf
.data () + strlen (buf
.data ()),
13188 buf
.size () - strlen (buf
.data ()));
13189 putpkt (buf
.data ());
13190 remote_get_noisy_reply ();
13191 if (strcmp (rs
->buf
.data (), "OK"))
13192 warning (_("Target does not support source download."));
13194 if (b
->cond_string
)
13196 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13198 if (ret
< 0 || ret
>= buf
.size ())
13199 error ("%s", err_msg
);
13201 encode_source_string (b
->number
, loc
->address
,
13202 "cond", b
->cond_string
,
13203 buf
.data () + strlen (buf
.data ()),
13204 buf
.size () - strlen (buf
.data ()));
13205 putpkt (buf
.data ());
13206 remote_get_noisy_reply ();
13207 if (strcmp (rs
->buf
.data (), "OK"))
13208 warning (_("Target does not support source download."));
13210 remote_download_command_source (b
->number
, loc
->address
,
13211 breakpoint_commands (b
));
13216 remote_target::can_download_tracepoint ()
13218 struct remote_state
*rs
= get_remote_state ();
13219 struct trace_status
*ts
;
13222 /* Don't try to install tracepoints until we've relocated our
13223 symbols, and fetched and merged the target's tracepoint list with
13225 if (rs
->starting_up
)
13228 ts
= current_trace_status ();
13229 status
= get_trace_status (ts
);
13231 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
13234 /* If we are in a tracing experiment, but remote stub doesn't support
13235 installing tracepoint in trace, we have to return. */
13236 if (!remote_supports_install_in_trace ())
13244 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
13246 struct remote_state
*rs
= get_remote_state ();
13249 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13250 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13252 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13253 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13254 >= get_remote_packet_size ())
13255 error (_("Trace state variable name too long for tsv definition packet"));
13256 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13259 remote_get_noisy_reply ();
13260 if (rs
->buf
[0] == '\0')
13261 error (_("Target does not support this command."));
13262 if (strcmp (rs
->buf
.data (), "OK") != 0)
13263 error (_("Error on target while downloading trace state variable."));
13267 remote_target::enable_tracepoint (struct bp_location
*location
)
13269 struct remote_state
*rs
= get_remote_state ();
13271 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13272 location
->owner
->number
,
13273 phex (location
->address
, sizeof (CORE_ADDR
)));
13275 remote_get_noisy_reply ();
13276 if (rs
->buf
[0] == '\0')
13277 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13278 if (strcmp (rs
->buf
.data (), "OK") != 0)
13279 error (_("Error on target while enabling tracepoint."));
13283 remote_target::disable_tracepoint (struct bp_location
*location
)
13285 struct remote_state
*rs
= get_remote_state ();
13287 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13288 location
->owner
->number
,
13289 phex (location
->address
, sizeof (CORE_ADDR
)));
13291 remote_get_noisy_reply ();
13292 if (rs
->buf
[0] == '\0')
13293 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13294 if (strcmp (rs
->buf
.data (), "OK") != 0)
13295 error (_("Error on target while disabling tracepoint."));
13299 remote_target::trace_set_readonly_regions ()
13302 bfd_size_type size
;
13307 if (!current_program_space
->exec_bfd ())
13308 return; /* No information to give. */
13310 struct remote_state
*rs
= get_remote_state ();
13312 strcpy (rs
->buf
.data (), "QTro");
13313 offset
= strlen (rs
->buf
.data ());
13314 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
13316 char tmp1
[40], tmp2
[40];
13319 if ((s
->flags
& SEC_LOAD
) == 0 ||
13320 /* (s->flags & SEC_CODE) == 0 || */
13321 (s
->flags
& SEC_READONLY
) == 0)
13325 vma
= bfd_section_vma (s
);
13326 size
= bfd_section_size (s
);
13327 sprintf_vma (tmp1
, vma
);
13328 sprintf_vma (tmp2
, vma
+ size
);
13329 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13330 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13332 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13334 Too many sections for read-only sections definition packet."));
13337 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13339 offset
+= sec_length
;
13344 getpkt (&rs
->buf
, 0);
13349 remote_target::trace_start ()
13351 struct remote_state
*rs
= get_remote_state ();
13353 putpkt ("QTStart");
13354 remote_get_noisy_reply ();
13355 if (rs
->buf
[0] == '\0')
13356 error (_("Target does not support this command."));
13357 if (strcmp (rs
->buf
.data (), "OK") != 0)
13358 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13362 remote_target::get_trace_status (struct trace_status
*ts
)
13364 /* Initialize it just to avoid a GCC false warning. */
13366 enum packet_result result
;
13367 struct remote_state
*rs
= get_remote_state ();
13369 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13372 /* FIXME we need to get register block size some other way. */
13373 trace_regblock_size
13374 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13376 putpkt ("qTStatus");
13380 p
= remote_get_noisy_reply ();
13382 catch (const gdb_exception_error
&ex
)
13384 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13386 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13392 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13394 /* If the remote target doesn't do tracing, flag it. */
13395 if (result
== PACKET_UNKNOWN
)
13398 /* We're working with a live target. */
13399 ts
->filename
= NULL
;
13402 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13404 /* Function 'parse_trace_status' sets default value of each field of
13405 'ts' at first, so we don't have to do it here. */
13406 parse_trace_status (p
, ts
);
13408 return ts
->running
;
13412 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13413 struct uploaded_tp
*utp
)
13415 struct remote_state
*rs
= get_remote_state ();
13417 struct bp_location
*loc
;
13418 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13419 size_t size
= get_remote_packet_size ();
13424 tp
->traceframe_usage
= 0;
13425 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13427 /* If the tracepoint was never downloaded, don't go asking for
13429 if (tp
->number_on_target
== 0)
13431 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13432 phex_nz (loc
->address
, 0));
13434 reply
= remote_get_noisy_reply ();
13435 if (reply
&& *reply
)
13438 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13444 utp
->hit_count
= 0;
13445 utp
->traceframe_usage
= 0;
13446 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13447 phex_nz (utp
->addr
, 0));
13449 reply
= remote_get_noisy_reply ();
13450 if (reply
&& *reply
)
13453 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13459 remote_target::trace_stop ()
13461 struct remote_state
*rs
= get_remote_state ();
13464 remote_get_noisy_reply ();
13465 if (rs
->buf
[0] == '\0')
13466 error (_("Target does not support this command."));
13467 if (strcmp (rs
->buf
.data (), "OK") != 0)
13468 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13472 remote_target::trace_find (enum trace_find_type type
, int num
,
13473 CORE_ADDR addr1
, CORE_ADDR addr2
,
13476 struct remote_state
*rs
= get_remote_state ();
13477 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13479 int target_frameno
= -1, target_tracept
= -1;
13481 /* Lookups other than by absolute frame number depend on the current
13482 trace selected, so make sure it is correct on the remote end
13484 if (type
!= tfind_number
)
13485 set_remote_traceframe ();
13487 p
= rs
->buf
.data ();
13488 strcpy (p
, "QTFrame:");
13489 p
= strchr (p
, '\0');
13493 xsnprintf (p
, endbuf
- p
, "%x", num
);
13496 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13499 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13502 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13503 phex_nz (addr2
, 0));
13505 case tfind_outside
:
13506 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13507 phex_nz (addr2
, 0));
13510 error (_("Unknown trace find type %d"), type
);
13514 reply
= remote_get_noisy_reply ();
13515 if (*reply
== '\0')
13516 error (_("Target does not support this command."));
13518 while (reply
&& *reply
)
13523 target_frameno
= (int) strtol (p
, &reply
, 16);
13525 error (_("Unable to parse trace frame number"));
13526 /* Don't update our remote traceframe number cache on failure
13527 to select a remote traceframe. */
13528 if (target_frameno
== -1)
13533 target_tracept
= (int) strtol (p
, &reply
, 16);
13535 error (_("Unable to parse tracepoint number"));
13537 case 'O': /* "OK"? */
13538 if (reply
[1] == 'K' && reply
[2] == '\0')
13541 error (_("Bogus reply from target: %s"), reply
);
13544 error (_("Bogus reply from target: %s"), reply
);
13547 *tpp
= target_tracept
;
13549 rs
->remote_traceframe_number
= target_frameno
;
13550 return target_frameno
;
13554 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13556 struct remote_state
*rs
= get_remote_state ();
13560 set_remote_traceframe ();
13562 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13564 reply
= remote_get_noisy_reply ();
13565 if (reply
&& *reply
)
13569 unpack_varlen_hex (reply
+ 1, &uval
);
13570 *val
= (LONGEST
) uval
;
13578 remote_target::save_trace_data (const char *filename
)
13580 struct remote_state
*rs
= get_remote_state ();
13583 p
= rs
->buf
.data ();
13584 strcpy (p
, "QTSave:");
13586 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13587 >= get_remote_packet_size ())
13588 error (_("Remote file name too long for trace save packet"));
13589 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13592 reply
= remote_get_noisy_reply ();
13593 if (*reply
== '\0')
13594 error (_("Target does not support this command."));
13595 if (strcmp (reply
, "OK") != 0)
13596 error (_("Bogus reply from target: %s"), reply
);
13600 /* This is basically a memory transfer, but needs to be its own packet
13601 because we don't know how the target actually organizes its trace
13602 memory, plus we want to be able to ask for as much as possible, but
13603 not be unhappy if we don't get as much as we ask for. */
13606 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13608 struct remote_state
*rs
= get_remote_state ();
13613 p
= rs
->buf
.data ();
13614 strcpy (p
, "qTBuffer:");
13616 p
+= hexnumstr (p
, offset
);
13618 p
+= hexnumstr (p
, len
);
13622 reply
= remote_get_noisy_reply ();
13623 if (reply
&& *reply
)
13625 /* 'l' by itself means we're at the end of the buffer and
13626 there is nothing more to get. */
13630 /* Convert the reply into binary. Limit the number of bytes to
13631 convert according to our passed-in buffer size, rather than
13632 what was returned in the packet; if the target is
13633 unexpectedly generous and gives us a bigger reply than we
13634 asked for, we don't want to crash. */
13635 rslt
= hex2bin (reply
, buf
, len
);
13639 /* Something went wrong, flag as an error. */
13644 remote_target::set_disconnected_tracing (int val
)
13646 struct remote_state
*rs
= get_remote_state ();
13648 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13652 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13653 "QTDisconnected:%x", val
);
13655 reply
= remote_get_noisy_reply ();
13656 if (*reply
== '\0')
13657 error (_("Target does not support this command."));
13658 if (strcmp (reply
, "OK") != 0)
13659 error (_("Bogus reply from target: %s"), reply
);
13662 warning (_("Target does not support disconnected tracing."));
13666 remote_target::core_of_thread (ptid_t ptid
)
13668 thread_info
*info
= find_thread_ptid (this, ptid
);
13670 if (info
!= NULL
&& info
->priv
!= NULL
)
13671 return get_remote_thread_info (info
)->core
;
13677 remote_target::set_circular_trace_buffer (int val
)
13679 struct remote_state
*rs
= get_remote_state ();
13682 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13683 "QTBuffer:circular:%x", val
);
13685 reply
= remote_get_noisy_reply ();
13686 if (*reply
== '\0')
13687 error (_("Target does not support this command."));
13688 if (strcmp (reply
, "OK") != 0)
13689 error (_("Bogus reply from target: %s"), reply
);
13693 remote_target::traceframe_info ()
13695 gdb::optional
<gdb::char_vector
> text
13696 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13699 return parse_traceframe_info (text
->data ());
13704 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13705 instruction on which a fast tracepoint may be placed. Returns -1
13706 if the packet is not supported, and 0 if the minimum instruction
13707 length is unknown. */
13710 remote_target::get_min_fast_tracepoint_insn_len ()
13712 struct remote_state
*rs
= get_remote_state ();
13715 /* If we're not debugging a process yet, the IPA can't be
13717 if (!target_has_execution ())
13720 /* Make sure the remote is pointing at the right process. */
13721 set_general_process ();
13723 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13725 reply
= remote_get_noisy_reply ();
13726 if (*reply
== '\0')
13730 ULONGEST min_insn_len
;
13732 unpack_varlen_hex (reply
, &min_insn_len
);
13734 return (int) min_insn_len
;
13739 remote_target::set_trace_buffer_size (LONGEST val
)
13741 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13743 struct remote_state
*rs
= get_remote_state ();
13744 char *buf
= rs
->buf
.data ();
13745 char *endbuf
= buf
+ get_remote_packet_size ();
13746 enum packet_result result
;
13748 gdb_assert (val
>= 0 || val
== -1);
13749 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13750 /* Send -1 as literal "-1" to avoid host size dependency. */
13754 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13757 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13760 remote_get_noisy_reply ();
13761 result
= packet_ok (rs
->buf
,
13762 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13764 if (result
!= PACKET_OK
)
13765 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13770 remote_target::set_trace_notes (const char *user
, const char *notes
,
13771 const char *stop_notes
)
13773 struct remote_state
*rs
= get_remote_state ();
13775 char *buf
= rs
->buf
.data ();
13776 char *endbuf
= buf
+ get_remote_packet_size ();
13779 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13782 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13783 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13789 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13790 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13796 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13797 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13801 /* Ensure the buffer is terminated. */
13805 reply
= remote_get_noisy_reply ();
13806 if (*reply
== '\0')
13809 if (strcmp (reply
, "OK") != 0)
13810 error (_("Bogus reply from target: %s"), reply
);
13816 remote_target::use_agent (bool use
)
13818 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13820 struct remote_state
*rs
= get_remote_state ();
13822 /* If the stub supports QAgent. */
13823 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13825 getpkt (&rs
->buf
, 0);
13827 if (strcmp (rs
->buf
.data (), "OK") == 0)
13838 remote_target::can_use_agent ()
13840 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13843 struct btrace_target_info
13845 /* The ptid of the traced thread. */
13848 /* The obtained branch trace configuration. */
13849 struct btrace_config conf
;
13852 /* Reset our idea of our target's btrace configuration. */
13855 remote_btrace_reset (remote_state
*rs
)
13857 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13860 /* Synchronize the configuration with the target. */
13863 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13865 struct packet_config
*packet
;
13866 struct remote_state
*rs
;
13867 char *buf
, *pos
, *endbuf
;
13869 rs
= get_remote_state ();
13870 buf
= rs
->buf
.data ();
13871 endbuf
= buf
+ get_remote_packet_size ();
13873 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13874 if (packet_config_support (packet
) == PACKET_ENABLE
13875 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13878 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13882 getpkt (&rs
->buf
, 0);
13884 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13886 if (buf
[0] == 'E' && buf
[1] == '.')
13887 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13889 error (_("Failed to configure the BTS buffer size."));
13892 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13895 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13896 if (packet_config_support (packet
) == PACKET_ENABLE
13897 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13900 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13904 getpkt (&rs
->buf
, 0);
13906 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13908 if (buf
[0] == 'E' && buf
[1] == '.')
13909 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13911 error (_("Failed to configure the trace buffer size."));
13914 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13918 /* Read the current thread's btrace configuration from the target and
13919 store it into CONF. */
13922 btrace_read_config (struct btrace_config
*conf
)
13924 gdb::optional
<gdb::char_vector
> xml
13925 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13927 parse_xml_btrace_conf (conf
, xml
->data ());
13930 /* Maybe reopen target btrace. */
13933 remote_target::remote_btrace_maybe_reopen ()
13935 struct remote_state
*rs
= get_remote_state ();
13936 int btrace_target_pushed
= 0;
13937 #if !defined (HAVE_LIBIPT)
13941 /* Don't bother walking the entirety of the remote thread list when
13942 we know the feature isn't supported by the remote. */
13943 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13946 scoped_restore_current_thread restore_thread
;
13948 for (thread_info
*tp
: all_non_exited_threads (this))
13950 set_general_thread (tp
->ptid
);
13952 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13953 btrace_read_config (&rs
->btrace_config
);
13955 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13958 #if !defined (HAVE_LIBIPT)
13959 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13964 warning (_("Target is recording using Intel Processor Trace "
13965 "but support was disabled at compile time."));
13970 #endif /* !defined (HAVE_LIBIPT) */
13972 /* Push target, once, but before anything else happens. This way our
13973 changes to the threads will be cleaned up by unpushing the target
13974 in case btrace_read_config () throws. */
13975 if (!btrace_target_pushed
)
13977 btrace_target_pushed
= 1;
13978 record_btrace_push_target ();
13979 printf_filtered (_("Target is recording using %s.\n"),
13980 btrace_format_string (rs
->btrace_config
.format
));
13983 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13984 tp
->btrace
.target
->ptid
= tp
->ptid
;
13985 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13989 /* Enable branch tracing. */
13991 struct btrace_target_info
*
13992 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13994 struct btrace_target_info
*tinfo
= NULL
;
13995 struct packet_config
*packet
= NULL
;
13996 struct remote_state
*rs
= get_remote_state ();
13997 char *buf
= rs
->buf
.data ();
13998 char *endbuf
= buf
+ get_remote_packet_size ();
14000 switch (conf
->format
)
14002 case BTRACE_FORMAT_BTS
:
14003 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
14006 case BTRACE_FORMAT_PT
:
14007 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
14011 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
14012 error (_("Target does not support branch tracing."));
14014 btrace_sync_conf (conf
);
14016 set_general_thread (ptid
);
14018 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
14020 getpkt (&rs
->buf
, 0);
14022 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
14024 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
14025 error (_("Could not enable branch tracing for %s: %s"),
14026 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
14028 error (_("Could not enable branch tracing for %s."),
14029 target_pid_to_str (ptid
).c_str ());
14032 tinfo
= XCNEW (struct btrace_target_info
);
14033 tinfo
->ptid
= ptid
;
14035 /* If we fail to read the configuration, we lose some information, but the
14036 tracing itself is not impacted. */
14039 btrace_read_config (&tinfo
->conf
);
14041 catch (const gdb_exception_error
&err
)
14043 if (err
.message
!= NULL
)
14044 warning ("%s", err
.what ());
14050 /* Disable branch tracing. */
14053 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
14055 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
14056 struct remote_state
*rs
= get_remote_state ();
14057 char *buf
= rs
->buf
.data ();
14058 char *endbuf
= buf
+ get_remote_packet_size ();
14060 if (packet_config_support (packet
) != PACKET_ENABLE
)
14061 error (_("Target does not support branch tracing."));
14063 set_general_thread (tinfo
->ptid
);
14065 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
14067 getpkt (&rs
->buf
, 0);
14069 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
14071 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
14072 error (_("Could not disable branch tracing for %s: %s"),
14073 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
14075 error (_("Could not disable branch tracing for %s."),
14076 target_pid_to_str (tinfo
->ptid
).c_str ());
14082 /* Teardown branch tracing. */
14085 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
14087 /* We must not talk to the target during teardown. */
14091 /* Read the branch trace. */
14094 remote_target::read_btrace (struct btrace_data
*btrace
,
14095 struct btrace_target_info
*tinfo
,
14096 enum btrace_read_type type
)
14098 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
14101 if (packet_config_support (packet
) != PACKET_ENABLE
)
14102 error (_("Target does not support branch tracing."));
14104 #if !defined(HAVE_LIBEXPAT)
14105 error (_("Cannot process branch tracing result. XML parsing not supported."));
14110 case BTRACE_READ_ALL
:
14113 case BTRACE_READ_NEW
:
14116 case BTRACE_READ_DELTA
:
14120 internal_error (__FILE__
, __LINE__
,
14121 _("Bad branch tracing read type: %u."),
14122 (unsigned int) type
);
14125 gdb::optional
<gdb::char_vector
> xml
14126 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
14128 return BTRACE_ERR_UNKNOWN
;
14130 parse_xml_btrace (btrace
, xml
->data ());
14132 return BTRACE_ERR_NONE
;
14135 const struct btrace_config
*
14136 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
14138 return &tinfo
->conf
;
14142 remote_target::augmented_libraries_svr4_read ()
14144 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
14148 /* Implementation of to_load. */
14151 remote_target::load (const char *name
, int from_tty
)
14153 generic_load (name
, from_tty
);
14156 /* Accepts an integer PID; returns a string representing a file that
14157 can be opened on the remote side to get the symbols for the child
14158 process. Returns NULL if the operation is not supported. */
14161 remote_target::pid_to_exec_file (int pid
)
14163 static gdb::optional
<gdb::char_vector
> filename
;
14164 char *annex
= NULL
;
14166 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
14169 inferior
*inf
= find_inferior_pid (this, pid
);
14171 internal_error (__FILE__
, __LINE__
,
14172 _("not currently attached to process %d"), pid
);
14174 if (!inf
->fake_pid_p
)
14176 const int annex_size
= 9;
14178 annex
= (char *) alloca (annex_size
);
14179 xsnprintf (annex
, annex_size
, "%x", pid
);
14182 filename
= target_read_stralloc (current_top_target (),
14183 TARGET_OBJECT_EXEC_FILE
, annex
);
14185 return filename
? filename
->data () : nullptr;
14188 /* Implement the to_can_do_single_step target_ops method. */
14191 remote_target::can_do_single_step ()
14193 /* We can only tell whether target supports single step or not by
14194 supported s and S vCont actions if the stub supports vContSupported
14195 feature. If the stub doesn't support vContSupported feature,
14196 we have conservatively to think target doesn't supports single
14198 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
14200 struct remote_state
*rs
= get_remote_state ();
14202 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14203 remote_vcont_probe ();
14205 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
14211 /* Implementation of the to_execution_direction method for the remote
14214 enum exec_direction_kind
14215 remote_target::execution_direction ()
14217 struct remote_state
*rs
= get_remote_state ();
14219 return rs
->last_resume_exec_dir
;
14222 /* Return pointer to the thread_info struct which corresponds to
14223 THREAD_HANDLE (having length HANDLE_LEN). */
14226 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
14230 for (thread_info
*tp
: all_non_exited_threads (this))
14232 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14234 if (tp
->inf
== inf
&& priv
!= NULL
)
14236 if (handle_len
!= priv
->thread_handle
.size ())
14237 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14238 handle_len
, priv
->thread_handle
.size ());
14239 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14249 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
14251 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14252 return priv
->thread_handle
;
14256 remote_target::can_async_p ()
14258 struct remote_state
*rs
= get_remote_state ();
14260 /* We don't go async if the user has explicitly prevented it with the
14261 "maint set target-async" command. */
14262 if (!target_async_permitted
)
14265 /* We're async whenever the serial device is. */
14266 return serial_can_async_p (rs
->remote_desc
);
14270 remote_target::is_async_p ()
14272 struct remote_state
*rs
= get_remote_state ();
14274 if (!target_async_permitted
)
14275 /* We only enable async when the user specifically asks for it. */
14278 /* We're async whenever the serial device is. */
14279 return serial_is_async_p (rs
->remote_desc
);
14282 /* Pass the SERIAL event on and up to the client. One day this code
14283 will be able to delay notifying the client of an event until the
14284 point where an entire packet has been received. */
14286 static serial_event_ftype remote_async_serial_handler
;
14289 remote_async_serial_handler (struct serial
*scb
, void *context
)
14291 /* Don't propogate error information up to the client. Instead let
14292 the client find out about the error by querying the target. */
14293 inferior_event_handler (INF_REG_EVENT
);
14297 remote_async_inferior_event_handler (gdb_client_data data
)
14299 inferior_event_handler (INF_REG_EVENT
);
14303 remote_target::async_wait_fd ()
14305 struct remote_state
*rs
= get_remote_state ();
14306 return rs
->remote_desc
->fd
;
14310 remote_target::async (int enable
)
14312 struct remote_state
*rs
= get_remote_state ();
14316 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14318 /* If there are pending events in the stop reply queue tell the
14319 event loop to process them. */
14320 if (!rs
->stop_reply_queue
.empty ())
14321 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14322 /* For simplicity, below we clear the pending events token
14323 without remembering whether it is marked, so here we always
14324 mark it. If there's actually no pending notification to
14325 process, this ends up being a no-op (other than a spurious
14326 event-loop wakeup). */
14327 if (target_is_non_stop_p ())
14328 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14332 serial_async (rs
->remote_desc
, NULL
, NULL
);
14333 /* If the core is disabling async, it doesn't want to be
14334 disturbed with target events. Clear all async event sources
14336 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14337 if (target_is_non_stop_p ())
14338 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14342 /* Implementation of the to_thread_events method. */
14345 remote_target::thread_events (int enable
)
14347 struct remote_state
*rs
= get_remote_state ();
14348 size_t size
= get_remote_packet_size ();
14350 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14353 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14355 getpkt (&rs
->buf
, 0);
14357 switch (packet_ok (rs
->buf
,
14358 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14361 if (strcmp (rs
->buf
.data (), "OK") != 0)
14362 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14365 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14367 case PACKET_UNKNOWN
:
14373 show_remote_cmd (const char *args
, int from_tty
)
14375 /* We can't just use cmd_show_list here, because we want to skip
14376 the redundant "show remote Z-packet" and the legacy aliases. */
14377 struct cmd_list_element
*list
= remote_show_cmdlist
;
14378 struct ui_out
*uiout
= current_uiout
;
14380 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14381 for (; list
!= NULL
; list
= list
->next
)
14382 if (strcmp (list
->name
, "Z-packet") == 0)
14384 else if (list
->type
== not_set_cmd
)
14385 /* Alias commands are exactly like the original, except they
14386 don't have the normal type. */
14390 ui_out_emit_tuple
option_emitter (uiout
, "option");
14392 uiout
->field_string ("name", list
->name
);
14393 uiout
->text (": ");
14394 if (list
->type
== show_cmd
)
14395 do_show_command (NULL
, from_tty
, list
);
14397 cmd_func (list
, NULL
, from_tty
);
14402 /* Function to be called whenever a new objfile (shlib) is detected. */
14404 remote_new_objfile (struct objfile
*objfile
)
14406 remote_target
*remote
= get_current_remote_target ();
14408 if (remote
!= NULL
) /* Have a remote connection. */
14409 remote
->remote_check_symbols ();
14412 /* Pull all the tracepoints defined on the target and create local
14413 data structures representing them. We don't want to create real
14414 tracepoints yet, we don't want to mess up the user's existing
14418 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14420 struct remote_state
*rs
= get_remote_state ();
14423 /* Ask for a first packet of tracepoint definition. */
14425 getpkt (&rs
->buf
, 0);
14426 p
= rs
->buf
.data ();
14427 while (*p
&& *p
!= 'l')
14429 parse_tracepoint_definition (p
, utpp
);
14430 /* Ask for another packet of tracepoint definition. */
14432 getpkt (&rs
->buf
, 0);
14433 p
= rs
->buf
.data ();
14439 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14441 struct remote_state
*rs
= get_remote_state ();
14444 /* Ask for a first packet of variable definition. */
14446 getpkt (&rs
->buf
, 0);
14447 p
= rs
->buf
.data ();
14448 while (*p
&& *p
!= 'l')
14450 parse_tsv_definition (p
, utsvp
);
14451 /* Ask for another packet of variable definition. */
14453 getpkt (&rs
->buf
, 0);
14454 p
= rs
->buf
.data ();
14459 /* The "set/show range-stepping" show hook. */
14462 show_range_stepping (struct ui_file
*file
, int from_tty
,
14463 struct cmd_list_element
*c
,
14466 fprintf_filtered (file
,
14467 _("Debugger's willingness to use range stepping "
14468 "is %s.\n"), value
);
14471 /* Return true if the vCont;r action is supported by the remote
14475 remote_target::vcont_r_supported ()
14477 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14478 remote_vcont_probe ();
14480 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14481 && get_remote_state ()->supports_vCont
.r
);
14484 /* The "set/show range-stepping" set hook. */
14487 set_range_stepping (const char *ignore_args
, int from_tty
,
14488 struct cmd_list_element
*c
)
14490 /* When enabling, check whether range stepping is actually supported
14491 by the target, and warn if not. */
14492 if (use_range_stepping
)
14494 remote_target
*remote
= get_current_remote_target ();
14496 || !remote
->vcont_r_supported ())
14497 warning (_("Range stepping is not supported by the current target"));
14502 show_remote_debug (struct ui_file
*file
, int from_tty
,
14503 struct cmd_list_element
*c
, const char *value
)
14505 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
14510 show_remote_timeout (struct ui_file
*file
, int from_tty
,
14511 struct cmd_list_element
*c
, const char *value
)
14513 fprintf_filtered (file
,
14514 _("Timeout limit to wait for target to respond is %s.\n"),
14518 /* Implement the "supports_memory_tagging" target_ops method. */
14521 remote_target::supports_memory_tagging ()
14523 return remote_memory_tagging_p ();
14526 /* Create the qMemTags packet given ADDRESS, LEN and TYPE. */
14529 create_fetch_memtags_request (gdb::char_vector
&packet
, CORE_ADDR address
,
14530 size_t len
, int type
)
14532 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
14534 std::string request
= string_printf ("qMemTags:%s,%s:%s",
14535 phex_nz (address
, addr_size
),
14536 phex_nz (len
, sizeof (len
)),
14537 phex_nz (type
, sizeof (type
)));
14539 strcpy (packet
.data (), request
.c_str ());
14542 /* Parse the qMemTags packet reply into TAGS.
14544 Return true if successful, false otherwise. */
14547 parse_fetch_memtags_reply (const gdb::char_vector
&reply
,
14548 gdb::byte_vector
&tags
)
14550 if (reply
.empty () || reply
[0] == 'E' || reply
[0] != 'm')
14553 /* Copy the tag data. */
14554 tags
= hex2bin (reply
.data () + 1);
14559 /* Create the QMemTags packet given ADDRESS, LEN, TYPE and TAGS. */
14562 create_store_memtags_request (gdb::char_vector
&packet
, CORE_ADDR address
,
14563 size_t len
, int type
,
14564 const gdb::byte_vector
&tags
)
14566 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
14568 /* Put together the main packet, address and length. */
14569 std::string request
= string_printf ("QMemTags:%s,%s:%s:",
14570 phex_nz (address
, addr_size
),
14571 phex_nz (len
, sizeof (len
)),
14572 phex_nz (type
, sizeof (type
)));
14573 request
+= bin2hex (tags
.data (), tags
.size ());
14575 /* Check if we have exceeded the maximum packet size. */
14576 if (packet
.size () < request
.length ())
14577 error (_("Contents too big for packet QMemTags."));
14579 strcpy (packet
.data (), request
.c_str ());
14582 /* Implement the "fetch_memtags" target_ops method. */
14585 remote_target::fetch_memtags (CORE_ADDR address
, size_t len
,
14586 gdb::byte_vector
&tags
, int type
)
14588 /* Make sure the qMemTags packet is supported. */
14589 if (!remote_memory_tagging_p ())
14590 gdb_assert_not_reached ("remote fetch_memtags called with packet disabled");
14592 struct remote_state
*rs
= get_remote_state ();
14594 create_fetch_memtags_request (rs
->buf
, address
, len
, type
);
14597 getpkt (&rs
->buf
, 0);
14599 return parse_fetch_memtags_reply (rs
->buf
, tags
);
14602 /* Implement the "store_memtags" target_ops method. */
14605 remote_target::store_memtags (CORE_ADDR address
, size_t len
,
14606 const gdb::byte_vector
&tags
, int type
)
14608 /* Make sure the QMemTags packet is supported. */
14609 if (!remote_memory_tagging_p ())
14610 gdb_assert_not_reached ("remote store_memtags called with packet disabled");
14612 struct remote_state
*rs
= get_remote_state ();
14614 create_store_memtags_request (rs
->buf
, address
, len
, type
, tags
);
14617 getpkt (&rs
->buf
, 0);
14619 /* Verify if the request was successful. */
14620 return packet_check_result (rs
->buf
.data ()) == PACKET_OK
;
14623 void _initialize_remote ();
14625 _initialize_remote ()
14627 struct cmd_list_element
*cmd
;
14628 const char *cmd_name
;
14630 /* architecture specific data */
14631 remote_g_packet_data_handle
=
14632 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14634 add_target (remote_target_info
, remote_target::open
);
14635 add_target (extended_remote_target_info
, extended_remote_target::open
);
14637 /* Hook into new objfile notification. */
14638 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14641 init_remote_threadtests ();
14644 /* set/show remote ... */
14646 add_basic_prefix_cmd ("remote", class_maintenance
, _("\
14647 Remote protocol specific variables.\n\
14648 Configure various remote-protocol specific variables such as\n\
14649 the packets being used."),
14650 &remote_set_cmdlist
, "set remote ",
14651 0 /* allow-unknown */, &setlist
);
14652 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14653 Remote protocol specific variables.\n\
14654 Configure various remote-protocol specific variables such as\n\
14655 the packets being used."),
14656 &remote_show_cmdlist
, "show remote ",
14657 0 /* allow-unknown */, &showlist
);
14659 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14660 Compare section data on target to the exec file.\n\
14661 Argument is a single section name (default: all loaded sections).\n\
14662 To compare only read-only loaded sections, specify the -r option."),
14665 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14666 Send an arbitrary packet to a remote target.\n\
14667 maintenance packet TEXT\n\
14668 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14669 this command sends the string TEXT to the inferior, and displays the\n\
14670 response packet. GDB supplies the initial `$' character, and the\n\
14671 terminating `#' character and checksum."),
14674 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14675 Set whether to send break if interrupted."), _("\
14676 Show whether to send break if interrupted."), _("\
14677 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14678 set_remotebreak
, show_remotebreak
,
14679 &setlist
, &showlist
);
14680 cmd_name
= "remotebreak";
14681 cmd
= lookup_cmd (&cmd_name
, setlist
, "", NULL
, -1, 1);
14682 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14683 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14684 cmd
= lookup_cmd (&cmd_name
, showlist
, "", NULL
, -1, 1);
14685 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14687 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14688 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14690 Set interrupt sequence to remote target."), _("\
14691 Show interrupt sequence to remote target."), _("\
14692 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14693 NULL
, show_interrupt_sequence
,
14694 &remote_set_cmdlist
,
14695 &remote_show_cmdlist
);
14697 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14698 &interrupt_on_connect
, _("\
14699 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14700 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14701 If set, interrupt sequence is sent to remote target."),
14703 &remote_set_cmdlist
, &remote_show_cmdlist
);
14705 /* Install commands for configuring memory read/write packets. */
14707 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14708 Set the maximum number of bytes per memory write packet (deprecated)."),
14710 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14711 Show the maximum number of bytes per memory write packet (deprecated)."),
14713 add_cmd ("memory-write-packet-size", no_class
,
14714 set_memory_write_packet_size
, _("\
14715 Set the maximum number of bytes per memory-write packet.\n\
14716 Specify the number of bytes in a packet or 0 (zero) for the\n\
14717 default packet size. The actual limit is further reduced\n\
14718 dependent on the target. Specify ``fixed'' to disable the\n\
14719 further restriction and ``limit'' to enable that restriction."),
14720 &remote_set_cmdlist
);
14721 add_cmd ("memory-read-packet-size", no_class
,
14722 set_memory_read_packet_size
, _("\
14723 Set the maximum number of bytes per memory-read packet.\n\
14724 Specify the number of bytes in a packet or 0 (zero) for the\n\
14725 default packet size. The actual limit is further reduced\n\
14726 dependent on the target. Specify ``fixed'' to disable the\n\
14727 further restriction and ``limit'' to enable that restriction."),
14728 &remote_set_cmdlist
);
14729 add_cmd ("memory-write-packet-size", no_class
,
14730 show_memory_write_packet_size
,
14731 _("Show the maximum number of bytes per memory-write packet."),
14732 &remote_show_cmdlist
);
14733 add_cmd ("memory-read-packet-size", no_class
,
14734 show_memory_read_packet_size
,
14735 _("Show the maximum number of bytes per memory-read packet."),
14736 &remote_show_cmdlist
);
14738 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14739 &remote_hw_watchpoint_limit
, _("\
14740 Set the maximum number of target hardware watchpoints."), _("\
14741 Show the maximum number of target hardware watchpoints."), _("\
14742 Specify \"unlimited\" for unlimited hardware watchpoints."),
14743 NULL
, show_hardware_watchpoint_limit
,
14744 &remote_set_cmdlist
,
14745 &remote_show_cmdlist
);
14746 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14748 &remote_hw_watchpoint_length_limit
, _("\
14749 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14750 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14751 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14752 NULL
, show_hardware_watchpoint_length_limit
,
14753 &remote_set_cmdlist
, &remote_show_cmdlist
);
14754 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14755 &remote_hw_breakpoint_limit
, _("\
14756 Set the maximum number of target hardware breakpoints."), _("\
14757 Show the maximum number of target hardware breakpoints."), _("\
14758 Specify \"unlimited\" for unlimited hardware breakpoints."),
14759 NULL
, show_hardware_breakpoint_limit
,
14760 &remote_set_cmdlist
, &remote_show_cmdlist
);
14762 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14763 &remote_address_size
, _("\
14764 Set the maximum size of the address (in bits) in a memory packet."), _("\
14765 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14767 NULL
, /* FIXME: i18n: */
14768 &setlist
, &showlist
);
14770 init_all_packet_configs ();
14772 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14773 "X", "binary-download", 1);
14775 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14776 "vCont", "verbose-resume", 0);
14778 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14779 "QPassSignals", "pass-signals", 0);
14781 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14782 "QCatchSyscalls", "catch-syscalls", 0);
14784 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14785 "QProgramSignals", "program-signals", 0);
14787 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14788 "QSetWorkingDir", "set-working-dir", 0);
14790 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14791 "QStartupWithShell", "startup-with-shell", 0);
14793 add_packet_config_cmd (&remote_protocol_packets
14794 [PACKET_QEnvironmentHexEncoded
],
14795 "QEnvironmentHexEncoded", "environment-hex-encoded",
14798 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14799 "QEnvironmentReset", "environment-reset",
14802 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14803 "QEnvironmentUnset", "environment-unset",
14806 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14807 "qSymbol", "symbol-lookup", 0);
14809 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14810 "P", "set-register", 1);
14812 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14813 "p", "fetch-register", 1);
14815 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14816 "Z0", "software-breakpoint", 0);
14818 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14819 "Z1", "hardware-breakpoint", 0);
14821 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14822 "Z2", "write-watchpoint", 0);
14824 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14825 "Z3", "read-watchpoint", 0);
14827 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14828 "Z4", "access-watchpoint", 0);
14830 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14831 "qXfer:auxv:read", "read-aux-vector", 0);
14833 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14834 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14836 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14837 "qXfer:features:read", "target-features", 0);
14839 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14840 "qXfer:libraries:read", "library-info", 0);
14842 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14843 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14845 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14846 "qXfer:memory-map:read", "memory-map", 0);
14848 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14849 "qXfer:osdata:read", "osdata", 0);
14851 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14852 "qXfer:threads:read", "threads", 0);
14854 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14855 "qXfer:siginfo:read", "read-siginfo-object", 0);
14857 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14858 "qXfer:siginfo:write", "write-siginfo-object", 0);
14860 add_packet_config_cmd
14861 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14862 "qXfer:traceframe-info:read", "traceframe-info", 0);
14864 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14865 "qXfer:uib:read", "unwind-info-block", 0);
14867 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14868 "qGetTLSAddr", "get-thread-local-storage-address",
14871 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14872 "qGetTIBAddr", "get-thread-information-block-address",
14875 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14876 "bc", "reverse-continue", 0);
14878 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14879 "bs", "reverse-step", 0);
14881 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14882 "qSupported", "supported-packets", 0);
14884 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14885 "qSearch:memory", "search-memory", 0);
14887 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14888 "qTStatus", "trace-status", 0);
14890 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14891 "vFile:setfs", "hostio-setfs", 0);
14893 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14894 "vFile:open", "hostio-open", 0);
14896 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14897 "vFile:pread", "hostio-pread", 0);
14899 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14900 "vFile:pwrite", "hostio-pwrite", 0);
14902 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14903 "vFile:close", "hostio-close", 0);
14905 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14906 "vFile:unlink", "hostio-unlink", 0);
14908 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14909 "vFile:readlink", "hostio-readlink", 0);
14911 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14912 "vFile:fstat", "hostio-fstat", 0);
14914 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14915 "vAttach", "attach", 0);
14917 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14920 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14921 "QStartNoAckMode", "noack", 0);
14923 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14924 "vKill", "kill", 0);
14926 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14927 "qAttached", "query-attached", 0);
14929 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14930 "ConditionalTracepoints",
14931 "conditional-tracepoints", 0);
14933 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14934 "ConditionalBreakpoints",
14935 "conditional-breakpoints", 0);
14937 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14938 "BreakpointCommands",
14939 "breakpoint-commands", 0);
14941 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14942 "FastTracepoints", "fast-tracepoints", 0);
14944 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14945 "TracepointSource", "TracepointSource", 0);
14947 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14948 "QAllow", "allow", 0);
14950 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14951 "StaticTracepoints", "static-tracepoints", 0);
14953 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14954 "InstallInTrace", "install-in-trace", 0);
14956 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14957 "qXfer:statictrace:read", "read-sdata-object", 0);
14959 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14960 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14962 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14963 "QDisableRandomization", "disable-randomization", 0);
14965 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14966 "QAgent", "agent", 0);
14968 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14969 "QTBuffer:size", "trace-buffer-size", 0);
14971 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14972 "Qbtrace:off", "disable-btrace", 0);
14974 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14975 "Qbtrace:bts", "enable-btrace-bts", 0);
14977 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14978 "Qbtrace:pt", "enable-btrace-pt", 0);
14980 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14981 "qXfer:btrace", "read-btrace", 0);
14983 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14984 "qXfer:btrace-conf", "read-btrace-conf", 0);
14986 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14987 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14989 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14990 "multiprocess-feature", "multiprocess-feature", 0);
14992 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14993 "swbreak-feature", "swbreak-feature", 0);
14995 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14996 "hwbreak-feature", "hwbreak-feature", 0);
14998 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14999 "fork-event-feature", "fork-event-feature", 0);
15001 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
15002 "vfork-event-feature", "vfork-event-feature", 0);
15004 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
15005 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
15007 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
15008 "vContSupported", "verbose-resume-supported", 0);
15010 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
15011 "exec-event-feature", "exec-event-feature", 0);
15013 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
15014 "vCtrlC", "ctrl-c", 0);
15016 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
15017 "QThreadEvents", "thread-events", 0);
15019 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
15020 "N stop reply", "no-resumed-stop-reply", 0);
15022 add_packet_config_cmd (&remote_protocol_packets
[PACKET_memory_tagging_feature
],
15023 "memory-tagging-feature", "memory-tagging-feature", 0);
15025 /* Assert that we've registered "set remote foo-packet" commands
15026 for all packet configs. */
15030 for (i
= 0; i
< PACKET_MAX
; i
++)
15032 /* Ideally all configs would have a command associated. Some
15033 still don't though. */
15038 case PACKET_QNonStop
:
15039 case PACKET_EnableDisableTracepoints_feature
:
15040 case PACKET_tracenz_feature
:
15041 case PACKET_DisconnectedTracing_feature
:
15042 case PACKET_augmented_libraries_svr4_read_feature
:
15044 /* Additions to this list need to be well justified:
15045 pre-existing packets are OK; new packets are not. */
15053 /* This catches both forgetting to add a config command, and
15054 forgetting to remove a packet from the exception list. */
15055 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
15059 /* Keep the old ``set remote Z-packet ...'' working. Each individual
15060 Z sub-packet has its own set and show commands, but users may
15061 have sets to this variable in their .gdbinit files (or in their
15063 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
15064 &remote_Z_packet_detect
, _("\
15065 Set use of remote protocol `Z' packets."), _("\
15066 Show use of remote protocol `Z' packets."), _("\
15067 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
15069 set_remote_protocol_Z_packet_cmd
,
15070 show_remote_protocol_Z_packet_cmd
,
15071 /* FIXME: i18n: Use of remote protocol
15072 `Z' packets is %s. */
15073 &remote_set_cmdlist
, &remote_show_cmdlist
);
15075 add_basic_prefix_cmd ("remote", class_files
, _("\
15076 Manipulate files on the remote system.\n\
15077 Transfer files to and from the remote target system."),
15078 &remote_cmdlist
, "remote ",
15079 0 /* allow-unknown */, &cmdlist
);
15081 add_cmd ("put", class_files
, remote_put_command
,
15082 _("Copy a local file to the remote system."),
15085 add_cmd ("get", class_files
, remote_get_command
,
15086 _("Copy a remote file to the local system."),
15089 add_cmd ("delete", class_files
, remote_delete_command
,
15090 _("Delete a remote file."),
15093 add_setshow_string_noescape_cmd ("exec-file", class_files
,
15094 &remote_exec_file_var
, _("\
15095 Set the remote pathname for \"run\"."), _("\
15096 Show the remote pathname for \"run\"."), NULL
,
15097 set_remote_exec_file
,
15098 show_remote_exec_file
,
15099 &remote_set_cmdlist
,
15100 &remote_show_cmdlist
);
15102 add_setshow_boolean_cmd ("range-stepping", class_run
,
15103 &use_range_stepping
, _("\
15104 Enable or disable range stepping."), _("\
15105 Show whether target-assisted range stepping is enabled."), _("\
15106 If on, and the target supports it, when stepping a source line, GDB\n\
15107 tells the target to step the corresponding range of addresses itself instead\n\
15108 of issuing multiple single-steps. This speeds up source level\n\
15109 stepping. If off, GDB always issues single-steps, even if range\n\
15110 stepping is supported by the target. The default is on."),
15111 set_range_stepping
,
15112 show_range_stepping
,
15116 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
15117 Set watchdog timer."), _("\
15118 Show watchdog timer."), _("\
15119 When non-zero, this timeout is used instead of waiting forever for a target\n\
15120 to finish a low-level step or continue operation. If the specified amount\n\
15121 of time passes without a response from the target, an error occurs."),
15124 &setlist
, &showlist
);
15126 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
15127 &remote_packet_max_chars
, _("\
15128 Set the maximum number of characters to display for each remote packet."), _("\
15129 Show the maximum number of characters to display for each remote packet."), _("\
15130 Specify \"unlimited\" to display all the characters."),
15131 NULL
, show_remote_packet_max_chars
,
15132 &setdebuglist
, &showdebuglist
);
15134 add_setshow_boolean_cmd ("remote", no_class
, &remote_debug
,
15135 _("Set debugging of remote protocol."),
15136 _("Show debugging of remote protocol."),
15138 When enabled, each packet sent or received with the remote target\n\
15142 &setdebuglist
, &showdebuglist
);
15144 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
15145 &remote_timeout
, _("\
15146 Set timeout limit to wait for target to respond."), _("\
15147 Show timeout limit to wait for target to respond."), _("\
15148 This value is used to set the time limit for gdb to wait for a response\n\
15149 from the target."),
15151 show_remote_timeout
,
15152 &setlist
, &showlist
);
15154 /* Eventually initialize fileio. See fileio.c */
15155 initialize_remote_fileio (&remote_set_cmdlist
, &remote_show_cmdlist
);