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 public: /* Remote specific methods. */
695 void remote_download_command_source (int num
, ULONGEST addr
,
696 struct command_line
*cmds
);
698 void remote_file_put (const char *local_file
, const char *remote_file
,
700 void remote_file_get (const char *remote_file
, const char *local_file
,
702 void remote_file_delete (const char *remote_file
, int from_tty
);
704 int remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
705 ULONGEST offset
, int *remote_errno
);
706 int remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
707 ULONGEST offset
, int *remote_errno
);
708 int remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
709 ULONGEST offset
, int *remote_errno
);
711 int remote_hostio_send_command (int command_bytes
, int which_packet
,
712 int *remote_errno
, const char **attachment
,
713 int *attachment_len
);
714 int remote_hostio_set_filesystem (struct inferior
*inf
,
716 /* We should get rid of this and use fileio_open directly. */
717 int remote_hostio_open (struct inferior
*inf
, const char *filename
,
718 int flags
, int mode
, int warn_if_slow
,
720 int remote_hostio_close (int fd
, int *remote_errno
);
722 int remote_hostio_unlink (inferior
*inf
, const char *filename
,
725 struct remote_state
*get_remote_state ();
727 long get_remote_packet_size (void);
728 long get_memory_packet_size (struct memory_packet_config
*config
);
730 long get_memory_write_packet_size ();
731 long get_memory_read_packet_size ();
733 char *append_pending_thread_resumptions (char *p
, char *endp
,
735 static void open_1 (const char *name
, int from_tty
, int extended_p
);
736 void start_remote (int from_tty
, int extended_p
);
737 void remote_detach_1 (struct inferior
*inf
, int from_tty
);
739 char *append_resumption (char *p
, char *endp
,
740 ptid_t ptid
, int step
, gdb_signal siggnal
);
741 int remote_resume_with_vcont (ptid_t ptid
, int step
,
744 thread_info
*add_current_inferior_and_thread (const char *wait_status
);
746 ptid_t
wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
747 target_wait_flags options
);
748 ptid_t
wait_as (ptid_t ptid
, target_waitstatus
*status
,
749 target_wait_flags options
);
751 ptid_t
process_stop_reply (struct stop_reply
*stop_reply
,
752 target_waitstatus
*status
);
754 ptid_t select_thread_for_ambiguous_stop_reply
755 (const struct target_waitstatus
*status
);
757 void remote_notice_new_inferior (ptid_t currthread
, int executing
);
759 void process_initial_stop_replies (int from_tty
);
761 thread_info
*remote_add_thread (ptid_t ptid
, bool running
, bool executing
);
763 void btrace_sync_conf (const btrace_config
*conf
);
765 void remote_btrace_maybe_reopen ();
767 void remove_new_fork_children (threads_listing_context
*context
);
768 void kill_new_fork_children (int pid
);
769 void discard_pending_stop_replies (struct inferior
*inf
);
770 int stop_reply_queue_length ();
772 void check_pending_events_prevent_wildcard_vcont
773 (int *may_global_wildcard_vcont
);
775 void discard_pending_stop_replies_in_queue ();
776 struct stop_reply
*remote_notif_remove_queued_reply (ptid_t ptid
);
777 struct stop_reply
*queued_stop_reply (ptid_t ptid
);
778 int peek_stop_reply (ptid_t ptid
);
779 void remote_parse_stop_reply (const char *buf
, stop_reply
*event
);
781 void remote_stop_ns (ptid_t ptid
);
782 void remote_interrupt_as ();
783 void remote_interrupt_ns ();
785 char *remote_get_noisy_reply ();
786 int remote_query_attached (int pid
);
787 inferior
*remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
790 ptid_t
remote_current_thread (ptid_t oldpid
);
791 ptid_t
get_current_thread (const char *wait_status
);
793 void set_thread (ptid_t ptid
, int gen
);
794 void set_general_thread (ptid_t ptid
);
795 void set_continue_thread (ptid_t ptid
);
796 void set_general_process ();
798 char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
800 int remote_unpack_thread_info_response (const char *pkt
, threadref
*expectedref
,
801 gdb_ext_thread_info
*info
);
802 int remote_get_threadinfo (threadref
*threadid
, int fieldset
,
803 gdb_ext_thread_info
*info
);
805 int parse_threadlist_response (const char *pkt
, int result_limit
,
806 threadref
*original_echo
,
807 threadref
*resultlist
,
809 int remote_get_threadlist (int startflag
, threadref
*nextthread
,
810 int result_limit
, int *done
, int *result_count
,
811 threadref
*threadlist
);
813 int remote_threadlist_iterator (rmt_thread_action stepfunction
,
814 void *context
, int looplimit
);
816 int remote_get_threads_with_ql (threads_listing_context
*context
);
817 int remote_get_threads_with_qxfer (threads_listing_context
*context
);
818 int remote_get_threads_with_qthreadinfo (threads_listing_context
*context
);
820 void extended_remote_restart ();
824 void remote_check_symbols ();
826 void remote_supported_packet (const struct protocol_feature
*feature
,
827 enum packet_support support
,
828 const char *argument
);
830 void remote_query_supported ();
832 void remote_packet_size (const protocol_feature
*feature
,
833 packet_support support
, const char *value
);
835 void remote_serial_quit_handler ();
837 void remote_detach_pid (int pid
);
839 void remote_vcont_probe ();
841 void remote_resume_with_hc (ptid_t ptid
, int step
,
844 void send_interrupt_sequence ();
845 void interrupt_query ();
847 void remote_notif_get_pending_events (notif_client
*nc
);
849 int fetch_register_using_p (struct regcache
*regcache
,
851 int send_g_packet ();
852 void process_g_packet (struct regcache
*regcache
);
853 void fetch_registers_using_g (struct regcache
*regcache
);
854 int store_register_using_P (const struct regcache
*regcache
,
856 void store_registers_using_G (const struct regcache
*regcache
);
858 void set_remote_traceframe ();
860 void check_binary_download (CORE_ADDR addr
);
862 target_xfer_status
remote_write_bytes_aux (const char *header
,
864 const gdb_byte
*myaddr
,
867 ULONGEST
*xfered_len_units
,
871 target_xfer_status
remote_write_bytes (CORE_ADDR memaddr
,
872 const gdb_byte
*myaddr
, ULONGEST len
,
873 int unit_size
, ULONGEST
*xfered_len
);
875 target_xfer_status
remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
877 int unit_size
, ULONGEST
*xfered_len_units
);
879 target_xfer_status
remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
883 ULONGEST
*xfered_len
);
885 target_xfer_status
remote_read_bytes (CORE_ADDR memaddr
,
886 gdb_byte
*myaddr
, ULONGEST len
,
888 ULONGEST
*xfered_len
);
890 packet_result
remote_send_printf (const char *format
, ...)
891 ATTRIBUTE_PRINTF (2, 3);
893 target_xfer_status
remote_flash_write (ULONGEST address
,
894 ULONGEST length
, ULONGEST
*xfered_len
,
895 const gdb_byte
*data
);
897 int readchar (int timeout
);
899 void remote_serial_write (const char *str
, int len
);
901 int putpkt (const char *buf
);
902 int putpkt_binary (const char *buf
, int cnt
);
904 int putpkt (const gdb::char_vector
&buf
)
906 return putpkt (buf
.data ());
910 long read_frame (gdb::char_vector
*buf_p
);
911 void getpkt (gdb::char_vector
*buf
, int forever
);
912 int getpkt_or_notif_sane_1 (gdb::char_vector
*buf
, int forever
,
913 int expecting_notif
, int *is_notif
);
914 int getpkt_sane (gdb::char_vector
*buf
, int forever
);
915 int getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
917 int remote_vkill (int pid
);
918 void remote_kill_k ();
920 void extended_remote_disable_randomization (int val
);
921 int extended_remote_run (const std::string
&args
);
923 void send_environment_packet (const char *action
,
927 void extended_remote_environment_support ();
928 void extended_remote_set_inferior_cwd ();
930 target_xfer_status
remote_write_qxfer (const char *object_name
,
932 const gdb_byte
*writebuf
,
933 ULONGEST offset
, LONGEST len
,
934 ULONGEST
*xfered_len
,
935 struct packet_config
*packet
);
937 target_xfer_status
remote_read_qxfer (const char *object_name
,
939 gdb_byte
*readbuf
, ULONGEST offset
,
941 ULONGEST
*xfered_len
,
942 struct packet_config
*packet
);
944 void push_stop_reply (struct stop_reply
*new_event
);
946 bool vcont_r_supported ();
948 void packet_command (const char *args
, int from_tty
);
950 private: /* data fields */
952 /* The remote state. Don't reference this directly. Use the
953 get_remote_state method instead. */
954 remote_state m_remote_state
;
957 static const target_info extended_remote_target_info
= {
959 N_("Extended remote serial target in gdb-specific protocol"),
963 /* Set up the extended remote target by extending the standard remote
964 target and adding to it. */
966 class extended_remote_target final
: public remote_target
969 const target_info
&info () const override
970 { return extended_remote_target_info
; }
972 /* Open an extended-remote connection. */
973 static void open (const char *, int);
975 bool can_create_inferior () override
{ return true; }
976 void create_inferior (const char *, const std::string
&,
977 char **, int) override
;
979 void detach (inferior
*, int) override
;
981 bool can_attach () override
{ return true; }
982 void attach (const char *, int) override
;
984 void post_attach (int) override
;
985 bool supports_disable_randomization () override
;
988 /* Per-program-space data key. */
989 static const struct program_space_key
<char, gdb::xfree_deleter
<char>>
992 /* The variable registered as the control variable used by the
993 remote exec-file commands. While the remote exec-file setting is
994 per-program-space, the set/show machinery uses this as the
995 location of the remote exec-file value. */
996 static char *remote_exec_file_var
;
998 /* The size to align memory write packets, when practical. The protocol
999 does not guarantee any alignment, and gdb will generate short
1000 writes and unaligned writes, but even as a best-effort attempt this
1001 can improve bulk transfers. For instance, if a write is misaligned
1002 relative to the target's data bus, the stub may need to make an extra
1003 round trip fetching data from the target. This doesn't make a
1004 huge difference, but it's easy to do, so we try to be helpful.
1006 The alignment chosen is arbitrary; usually data bus width is
1007 important here, not the possibly larger cache line size. */
1008 enum { REMOTE_ALIGN_WRITES
= 16 };
1010 /* Prototypes for local functions. */
1012 static int hexnumlen (ULONGEST num
);
1014 static int stubhex (int ch
);
1016 static int hexnumstr (char *, ULONGEST
);
1018 static int hexnumnstr (char *, ULONGEST
, int);
1020 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
1022 static void print_packet (const char *);
1024 static int stub_unpack_int (const char *buff
, int fieldlength
);
1026 struct packet_config
;
1028 static void show_packet_config_cmd (struct packet_config
*config
);
1030 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
1032 struct cmd_list_element
*c
,
1035 static ptid_t
read_ptid (const char *buf
, const char **obuf
);
1037 static void remote_async_inferior_event_handler (gdb_client_data
);
1039 static bool remote_read_description_p (struct target_ops
*target
);
1041 static void remote_console_output (const char *msg
);
1043 static void remote_btrace_reset (remote_state
*rs
);
1045 static void remote_unpush_and_throw (remote_target
*target
);
1049 static struct cmd_list_element
*remote_cmdlist
;
1051 /* For "set remote" and "show remote". */
1053 static struct cmd_list_element
*remote_set_cmdlist
;
1054 static struct cmd_list_element
*remote_show_cmdlist
;
1056 /* Controls whether GDB is willing to use range stepping. */
1058 static bool use_range_stepping
= true;
1060 /* From the remote target's point of view, each thread is in one of these three
1062 enum class resume_state
1064 /* Not resumed - we haven't been asked to resume this thread. */
1067 /* We have been asked to resume this thread, but haven't sent a vCont action
1068 for it yet. We'll need to consider it next time commit_resume is
1070 RESUMED_PENDING_VCONT
,
1072 /* We have been asked to resume this thread, and we have sent a vCont action
1077 /* Information about a thread's pending vCont-resume. Used when a thread is in
1078 the remote_resume_state::RESUMED_PENDING_VCONT state. remote_target::resume
1079 stores this information which is then picked up by
1080 remote_target::commit_resume to know which is the proper action for this
1081 thread to include in the vCont packet. */
1082 struct resumed_pending_vcont_info
1084 /* True if the last resume call for this thread was a step request, false
1085 if a continue request. */
1088 /* The signal specified in the last resume call for this thread. */
1092 /* Private data that we'll store in (struct thread_info)->priv. */
1093 struct remote_thread_info
: public private_thread_info
1099 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1100 sequence of bytes. */
1101 gdb::byte_vector thread_handle
;
1103 /* Whether the target stopped for a breakpoint/watchpoint. */
1104 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1106 /* This is set to the data address of the access causing the target
1107 to stop for a watchpoint. */
1108 CORE_ADDR watch_data_address
= 0;
1110 /* Get the thread's resume state. */
1111 enum resume_state
get_resume_state () const
1113 return m_resume_state
;
1116 /* Put the thread in the NOT_RESUMED state. */
1117 void set_not_resumed ()
1119 m_resume_state
= resume_state::NOT_RESUMED
;
1122 /* Put the thread in the RESUMED_PENDING_VCONT state. */
1123 void set_resumed_pending_vcont (bool step
, gdb_signal sig
)
1125 m_resume_state
= resume_state::RESUMED_PENDING_VCONT
;
1126 m_resumed_pending_vcont_info
.step
= step
;
1127 m_resumed_pending_vcont_info
.sig
= sig
;
1130 /* Get the information this thread's pending vCont-resumption.
1132 Must only be called if the thread is in the RESUMED_PENDING_VCONT resume
1134 const struct resumed_pending_vcont_info
&resumed_pending_vcont_info () const
1136 gdb_assert (m_resume_state
== resume_state::RESUMED_PENDING_VCONT
);
1138 return m_resumed_pending_vcont_info
;
1141 /* Put the thread in the VCONT_RESUMED state. */
1144 m_resume_state
= resume_state::RESUMED
;
1148 /* Resume state for this thread. This is used to implement vCont action
1149 coalescing (only when the target operates in non-stop mode).
1151 remote_target::resume moves the thread to the RESUMED_PENDING_VCONT state,
1152 which notes that this thread must be considered in the next commit_resume
1155 remote_target::commit_resume sends a vCont packet with actions for the
1156 threads in the RESUMED_PENDING_VCONT state and moves them to the
1157 VCONT_RESUMED state.
1159 When reporting a stop to the core for a thread, that thread is moved back
1160 to the NOT_RESUMED state. */
1161 enum resume_state m_resume_state
= resume_state::NOT_RESUMED
;
1163 /* Extra info used if the thread is in the RESUMED_PENDING_VCONT state. */
1164 struct resumed_pending_vcont_info m_resumed_pending_vcont_info
;
1167 remote_state::remote_state ()
1172 remote_state::~remote_state ()
1174 xfree (this->last_pass_packet
);
1175 xfree (this->last_program_signals_packet
);
1176 xfree (this->finished_object
);
1177 xfree (this->finished_annex
);
1180 /* Utility: generate error from an incoming stub packet. */
1182 trace_error (char *buf
)
1185 return; /* not an error msg */
1188 case '1': /* malformed packet error */
1189 if (*++buf
== '0') /* general case: */
1190 error (_("remote.c: error in outgoing packet."));
1192 error (_("remote.c: error in outgoing packet at field #%ld."),
1193 strtol (buf
, NULL
, 16));
1195 error (_("Target returns error code '%s'."), buf
);
1199 /* Utility: wait for reply from stub, while accepting "O" packets. */
1202 remote_target::remote_get_noisy_reply ()
1204 struct remote_state
*rs
= get_remote_state ();
1206 do /* Loop on reply from remote stub. */
1210 QUIT
; /* Allow user to bail out with ^C. */
1211 getpkt (&rs
->buf
, 0);
1212 buf
= rs
->buf
.data ();
1215 else if (startswith (buf
, "qRelocInsn:"))
1218 CORE_ADDR from
, to
, org_to
;
1220 int adjusted_size
= 0;
1223 p
= buf
+ strlen ("qRelocInsn:");
1224 pp
= unpack_varlen_hex (p
, &ul
);
1226 error (_("invalid qRelocInsn packet: %s"), buf
);
1230 unpack_varlen_hex (p
, &ul
);
1237 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1240 catch (const gdb_exception
&ex
)
1242 if (ex
.error
== MEMORY_ERROR
)
1244 /* Propagate memory errors silently back to the
1245 target. The stub may have limited the range of
1246 addresses we can write to, for example. */
1250 /* Something unexpectedly bad happened. Be verbose
1251 so we can tell what, and propagate the error back
1252 to the stub, so it doesn't get stuck waiting for
1254 exception_fprintf (gdb_stderr
, ex
,
1255 _("warning: relocating instruction: "));
1262 adjusted_size
= to
- org_to
;
1264 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1268 else if (buf
[0] == 'O' && buf
[1] != 'K')
1269 remote_console_output (buf
+ 1); /* 'O' message from stub */
1271 return buf
; /* Here's the actual reply. */
1276 struct remote_arch_state
*
1277 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1279 remote_arch_state
*rsa
;
1281 auto it
= this->m_arch_states
.find (gdbarch
);
1282 if (it
== this->m_arch_states
.end ())
1284 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1285 std::forward_as_tuple (gdbarch
),
1286 std::forward_as_tuple (gdbarch
));
1287 rsa
= &p
.first
->second
;
1289 /* Make sure that the packet buffer is plenty big enough for
1290 this architecture. */
1291 if (this->buf
.size () < rsa
->remote_packet_size
)
1292 this->buf
.resize (2 * rsa
->remote_packet_size
);
1300 /* Fetch the global remote target state. */
1303 remote_target::get_remote_state ()
1305 /* Make sure that the remote architecture state has been
1306 initialized, because doing so might reallocate rs->buf. Any
1307 function which calls getpkt also needs to be mindful of changes
1308 to rs->buf, but this call limits the number of places which run
1310 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1312 return &m_remote_state
;
1315 /* Fetch the remote exec-file from the current program space. */
1318 get_remote_exec_file (void)
1320 char *remote_exec_file
;
1322 remote_exec_file
= remote_pspace_data
.get (current_program_space
);
1323 if (remote_exec_file
== NULL
)
1326 return remote_exec_file
;
1329 /* Set the remote exec file for PSPACE. */
1332 set_pspace_remote_exec_file (struct program_space
*pspace
,
1333 const char *remote_exec_file
)
1335 char *old_file
= remote_pspace_data
.get (pspace
);
1338 remote_pspace_data
.set (pspace
, xstrdup (remote_exec_file
));
1341 /* The "set/show remote exec-file" set command hook. */
1344 set_remote_exec_file (const char *ignored
, int from_tty
,
1345 struct cmd_list_element
*c
)
1347 gdb_assert (remote_exec_file_var
!= NULL
);
1348 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
1351 /* The "set/show remote exec-file" show command hook. */
1354 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1355 struct cmd_list_element
*cmd
, const char *value
)
1357 fprintf_filtered (file
, "%s\n", get_remote_exec_file ());
1361 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1363 int regnum
, num_remote_regs
, offset
;
1364 struct packet_reg
**remote_regs
;
1366 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1368 struct packet_reg
*r
= ®s
[regnum
];
1370 if (register_size (gdbarch
, regnum
) == 0)
1371 /* Do not try to fetch zero-sized (placeholder) registers. */
1374 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1379 /* Define the g/G packet format as the contents of each register
1380 with a remote protocol number, in order of ascending protocol
1383 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1384 for (num_remote_regs
= 0, regnum
= 0;
1385 regnum
< gdbarch_num_regs (gdbarch
);
1387 if (regs
[regnum
].pnum
!= -1)
1388 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1390 std::sort (remote_regs
, remote_regs
+ num_remote_regs
,
1391 [] (const packet_reg
*a
, const packet_reg
*b
)
1392 { return a
->pnum
< b
->pnum
; });
1394 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1396 remote_regs
[regnum
]->in_g_packet
= 1;
1397 remote_regs
[regnum
]->offset
= offset
;
1398 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1404 /* Given the architecture described by GDBARCH, return the remote
1405 protocol register's number and the register's offset in the g/G
1406 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1407 If the target does not have a mapping for REGNUM, return false,
1408 otherwise, return true. */
1411 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1412 int *pnum
, int *poffset
)
1414 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1416 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1418 map_regcache_remote_table (gdbarch
, regs
.data ());
1420 *pnum
= regs
[regnum
].pnum
;
1421 *poffset
= regs
[regnum
].offset
;
1426 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1428 /* Use the architecture to build a regnum<->pnum table, which will be
1429 1:1 unless a feature set specifies otherwise. */
1430 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1432 /* Record the maximum possible size of the g packet - it may turn out
1434 this->sizeof_g_packet
1435 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1437 /* Default maximum number of characters in a packet body. Many
1438 remote stubs have a hardwired buffer size of 400 bytes
1439 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1440 as the maximum packet-size to ensure that the packet and an extra
1441 NUL character can always fit in the buffer. This stops GDB
1442 trashing stubs that try to squeeze an extra NUL into what is
1443 already a full buffer (As of 1999-12-04 that was most stubs). */
1444 this->remote_packet_size
= 400 - 1;
1446 /* This one is filled in when a ``g'' packet is received. */
1447 this->actual_register_packet_size
= 0;
1449 /* Should rsa->sizeof_g_packet needs more space than the
1450 default, adjust the size accordingly. Remember that each byte is
1451 encoded as two characters. 32 is the overhead for the packet
1452 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1453 (``$NN:G...#NN'') is a better guess, the below has been padded a
1455 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1456 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1459 /* Get a pointer to the current remote target. If not connected to a
1460 remote target, return NULL. */
1462 static remote_target
*
1463 get_current_remote_target ()
1465 target_ops
*proc_target
= current_inferior ()->process_target ();
1466 return dynamic_cast<remote_target
*> (proc_target
);
1469 /* Return the current allowed size of a remote packet. This is
1470 inferred from the current architecture, and should be used to
1471 limit the length of outgoing packets. */
1473 remote_target::get_remote_packet_size ()
1475 struct remote_state
*rs
= get_remote_state ();
1476 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1478 if (rs
->explicit_packet_size
)
1479 return rs
->explicit_packet_size
;
1481 return rsa
->remote_packet_size
;
1484 static struct packet_reg
*
1485 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1488 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1492 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1494 gdb_assert (r
->regnum
== regnum
);
1499 static struct packet_reg
*
1500 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1505 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1507 struct packet_reg
*r
= &rsa
->regs
[i
];
1509 if (r
->pnum
== pnum
)
1515 /* Allow the user to specify what sequence to send to the remote
1516 when he requests a program interruption: Although ^C is usually
1517 what remote systems expect (this is the default, here), it is
1518 sometimes preferable to send a break. On other systems such
1519 as the Linux kernel, a break followed by g, which is Magic SysRq g
1520 is required in order to interrupt the execution. */
1521 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1522 const char interrupt_sequence_break
[] = "BREAK";
1523 const char interrupt_sequence_break_g
[] = "BREAK-g";
1524 static const char *const interrupt_sequence_modes
[] =
1526 interrupt_sequence_control_c
,
1527 interrupt_sequence_break
,
1528 interrupt_sequence_break_g
,
1531 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1534 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1535 struct cmd_list_element
*c
,
1538 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1539 fprintf_filtered (file
,
1540 _("Send the ASCII ETX character (Ctrl-c) "
1541 "to the remote target to interrupt the "
1542 "execution of the program.\n"));
1543 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1544 fprintf_filtered (file
,
1545 _("send a break signal to the remote target "
1546 "to interrupt the execution of the program.\n"));
1547 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1548 fprintf_filtered (file
,
1549 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1550 "the remote target to interrupt the execution "
1551 "of Linux kernel.\n"));
1553 internal_error (__FILE__
, __LINE__
,
1554 _("Invalid value for interrupt_sequence_mode: %s."),
1555 interrupt_sequence_mode
);
1558 /* This boolean variable specifies whether interrupt_sequence is sent
1559 to the remote target when gdb connects to it.
1560 This is mostly needed when you debug the Linux kernel: The Linux kernel
1561 expects BREAK g which is Magic SysRq g for connecting gdb. */
1562 static bool interrupt_on_connect
= false;
1564 /* This variable is used to implement the "set/show remotebreak" commands.
1565 Since these commands are now deprecated in favor of "set/show remote
1566 interrupt-sequence", it no longer has any effect on the code. */
1567 static bool remote_break
;
1570 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1573 interrupt_sequence_mode
= interrupt_sequence_break
;
1575 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1579 show_remotebreak (struct ui_file
*file
, int from_tty
,
1580 struct cmd_list_element
*c
,
1585 /* This variable sets the number of bits in an address that are to be
1586 sent in a memory ("M" or "m") packet. Normally, after stripping
1587 leading zeros, the entire address would be sent. This variable
1588 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1589 initial implementation of remote.c restricted the address sent in
1590 memory packets to ``host::sizeof long'' bytes - (typically 32
1591 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1592 address was never sent. Since fixing this bug may cause a break in
1593 some remote targets this variable is principally provided to
1594 facilitate backward compatibility. */
1596 static unsigned int remote_address_size
;
1599 /* User configurable variables for the number of characters in a
1600 memory read/write packet. MIN (rsa->remote_packet_size,
1601 rsa->sizeof_g_packet) is the default. Some targets need smaller
1602 values (fifo overruns, et.al.) and some users need larger values
1603 (speed up transfers). The variables ``preferred_*'' (the user
1604 request), ``current_*'' (what was actually set) and ``forced_*''
1605 (Positive - a soft limit, negative - a hard limit). */
1607 struct memory_packet_config
1614 /* The default max memory-write-packet-size, when the setting is
1615 "fixed". The 16k is historical. (It came from older GDB's using
1616 alloca for buffers and the knowledge (folklore?) that some hosts
1617 don't cope very well with large alloca calls.) */
1618 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1620 /* The minimum remote packet size for memory transfers. Ensures we
1621 can write at least one byte. */
1622 #define MIN_MEMORY_PACKET_SIZE 20
1624 /* Get the memory packet size, assuming it is fixed. */
1627 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1629 gdb_assert (config
->fixed_p
);
1631 if (config
->size
<= 0)
1632 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1634 return config
->size
;
1637 /* Compute the current size of a read/write packet. Since this makes
1638 use of ``actual_register_packet_size'' the computation is dynamic. */
1641 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1643 struct remote_state
*rs
= get_remote_state ();
1644 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1647 if (config
->fixed_p
)
1648 what_they_get
= get_fixed_memory_packet_size (config
);
1651 what_they_get
= get_remote_packet_size ();
1652 /* Limit the packet to the size specified by the user. */
1653 if (config
->size
> 0
1654 && what_they_get
> config
->size
)
1655 what_they_get
= config
->size
;
1657 /* Limit it to the size of the targets ``g'' response unless we have
1658 permission from the stub to use a larger packet size. */
1659 if (rs
->explicit_packet_size
== 0
1660 && rsa
->actual_register_packet_size
> 0
1661 && what_they_get
> rsa
->actual_register_packet_size
)
1662 what_they_get
= rsa
->actual_register_packet_size
;
1664 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1665 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1667 /* Make sure there is room in the global buffer for this packet
1668 (including its trailing NUL byte). */
1669 if (rs
->buf
.size () < what_they_get
+ 1)
1670 rs
->buf
.resize (2 * what_they_get
);
1672 return what_they_get
;
1675 /* Update the size of a read/write packet. If they user wants
1676 something really big then do a sanity check. */
1679 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1681 int fixed_p
= config
->fixed_p
;
1682 long size
= config
->size
;
1685 error (_("Argument required (integer, `fixed' or `limited')."));
1686 else if (strcmp (args
, "hard") == 0
1687 || strcmp (args
, "fixed") == 0)
1689 else if (strcmp (args
, "soft") == 0
1690 || strcmp (args
, "limit") == 0)
1696 size
= strtoul (args
, &end
, 0);
1698 error (_("Invalid %s (bad syntax)."), config
->name
);
1700 /* Instead of explicitly capping the size of a packet to or
1701 disallowing it, the user is allowed to set the size to
1702 something arbitrarily large. */
1706 if (fixed_p
&& !config
->fixed_p
)
1708 /* So that the query shows the correct value. */
1709 long query_size
= (size
<= 0
1710 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1713 if (! query (_("The target may not be able to correctly handle a %s\n"
1714 "of %ld bytes. Change the packet size? "),
1715 config
->name
, query_size
))
1716 error (_("Packet size not changed."));
1718 /* Update the config. */
1719 config
->fixed_p
= fixed_p
;
1720 config
->size
= size
;
1724 show_memory_packet_size (struct memory_packet_config
*config
)
1726 if (config
->size
== 0)
1727 printf_filtered (_("The %s is 0 (default). "), config
->name
);
1729 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1730 if (config
->fixed_p
)
1731 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1732 get_fixed_memory_packet_size (config
));
1735 remote_target
*remote
= get_current_remote_target ();
1738 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1739 remote
->get_memory_packet_size (config
));
1741 puts_filtered ("The actual limit will be further reduced "
1742 "dependent on the target.\n");
1746 /* FIXME: needs to be per-remote-target. */
1747 static struct memory_packet_config memory_write_packet_config
=
1749 "memory-write-packet-size",
1753 set_memory_write_packet_size (const char *args
, int from_tty
)
1755 set_memory_packet_size (args
, &memory_write_packet_config
);
1759 show_memory_write_packet_size (const char *args
, int from_tty
)
1761 show_memory_packet_size (&memory_write_packet_config
);
1764 /* Show the number of hardware watchpoints that can be used. */
1767 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1768 struct cmd_list_element
*c
,
1771 fprintf_filtered (file
, _("The maximum number of target hardware "
1772 "watchpoints is %s.\n"), value
);
1775 /* Show the length limit (in bytes) for hardware watchpoints. */
1778 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1779 struct cmd_list_element
*c
,
1782 fprintf_filtered (file
, _("The maximum length (in bytes) of a target "
1783 "hardware watchpoint is %s.\n"), value
);
1786 /* Show the number of hardware breakpoints that can be used. */
1789 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1790 struct cmd_list_element
*c
,
1793 fprintf_filtered (file
, _("The maximum number of target hardware "
1794 "breakpoints is %s.\n"), value
);
1797 /* Controls the maximum number of characters to display in the debug output
1798 for each remote packet. The remaining characters are omitted. */
1800 static int remote_packet_max_chars
= 512;
1802 /* Show the maximum number of characters to display for each remote packet
1803 when remote debugging is enabled. */
1806 show_remote_packet_max_chars (struct ui_file
*file
, int from_tty
,
1807 struct cmd_list_element
*c
,
1810 fprintf_filtered (file
, _("Number of remote packet characters to "
1811 "display is %s.\n"), value
);
1815 remote_target::get_memory_write_packet_size ()
1817 return get_memory_packet_size (&memory_write_packet_config
);
1820 /* FIXME: needs to be per-remote-target. */
1821 static struct memory_packet_config memory_read_packet_config
=
1823 "memory-read-packet-size",
1827 set_memory_read_packet_size (const char *args
, int from_tty
)
1829 set_memory_packet_size (args
, &memory_read_packet_config
);
1833 show_memory_read_packet_size (const char *args
, int from_tty
)
1835 show_memory_packet_size (&memory_read_packet_config
);
1839 remote_target::get_memory_read_packet_size ()
1841 long size
= get_memory_packet_size (&memory_read_packet_config
);
1843 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1844 extra buffer size argument before the memory read size can be
1845 increased beyond this. */
1846 if (size
> get_remote_packet_size ())
1847 size
= get_remote_packet_size ();
1853 struct packet_config
1858 /* If auto, GDB auto-detects support for this packet or feature,
1859 either through qSupported, or by trying the packet and looking
1860 at the response. If true, GDB assumes the target supports this
1861 packet. If false, the packet is disabled. Configs that don't
1862 have an associated command always have this set to auto. */
1863 enum auto_boolean detect
;
1865 /* Does the target support this packet? */
1866 enum packet_support support
;
1869 static enum packet_support
packet_config_support (struct packet_config
*config
);
1870 static enum packet_support
packet_support (int packet
);
1873 show_packet_config_cmd (struct packet_config
*config
)
1875 const char *support
= "internal-error";
1877 switch (packet_config_support (config
))
1880 support
= "enabled";
1882 case PACKET_DISABLE
:
1883 support
= "disabled";
1885 case PACKET_SUPPORT_UNKNOWN
:
1886 support
= "unknown";
1889 switch (config
->detect
)
1891 case AUTO_BOOLEAN_AUTO
:
1892 printf_filtered (_("Support for the `%s' packet "
1893 "is auto-detected, currently %s.\n"),
1894 config
->name
, support
);
1896 case AUTO_BOOLEAN_TRUE
:
1897 case AUTO_BOOLEAN_FALSE
:
1898 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1899 config
->name
, support
);
1905 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1906 const char *title
, int legacy
)
1912 config
->name
= name
;
1913 config
->title
= title
;
1914 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1916 show_doc
= xstrprintf ("Show current use of remote "
1917 "protocol `%s' (%s) packet.",
1919 /* set/show TITLE-packet {auto,on,off} */
1920 cmd_name
= xstrprintf ("%s-packet", title
);
1921 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1922 &config
->detect
, set_doc
,
1923 show_doc
, NULL
, /* help_doc */
1925 show_remote_protocol_packet_cmd
,
1926 &remote_set_cmdlist
, &remote_show_cmdlist
);
1927 /* The command code copies the documentation strings. */
1930 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1935 legacy_name
= xstrprintf ("%s-packet", name
);
1936 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1937 &remote_set_cmdlist
);
1938 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1939 &remote_show_cmdlist
);
1943 static enum packet_result
1944 packet_check_result (const char *buf
)
1948 /* The stub recognized the packet request. Check that the
1949 operation succeeded. */
1951 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1953 /* "Enn" - definitely an error. */
1954 return PACKET_ERROR
;
1956 /* Always treat "E." as an error. This will be used for
1957 more verbose error messages, such as E.memtypes. */
1958 if (buf
[0] == 'E' && buf
[1] == '.')
1959 return PACKET_ERROR
;
1961 /* The packet may or may not be OK. Just assume it is. */
1965 /* The stub does not support the packet. */
1966 return PACKET_UNKNOWN
;
1969 static enum packet_result
1970 packet_check_result (const gdb::char_vector
&buf
)
1972 return packet_check_result (buf
.data ());
1975 static enum packet_result
1976 packet_ok (const char *buf
, struct packet_config
*config
)
1978 enum packet_result result
;
1980 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1981 && config
->support
== PACKET_DISABLE
)
1982 internal_error (__FILE__
, __LINE__
,
1983 _("packet_ok: attempt to use a disabled packet"));
1985 result
= packet_check_result (buf
);
1990 /* The stub recognized the packet request. */
1991 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1993 remote_debug_printf ("Packet %s (%s) is supported",
1994 config
->name
, config
->title
);
1995 config
->support
= PACKET_ENABLE
;
1998 case PACKET_UNKNOWN
:
1999 /* The stub does not support the packet. */
2000 if (config
->detect
== AUTO_BOOLEAN_AUTO
2001 && config
->support
== PACKET_ENABLE
)
2003 /* If the stub previously indicated that the packet was
2004 supported then there is a protocol error. */
2005 error (_("Protocol error: %s (%s) conflicting enabled responses."),
2006 config
->name
, config
->title
);
2008 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
2010 /* The user set it wrong. */
2011 error (_("Enabled packet %s (%s) not recognized by stub"),
2012 config
->name
, config
->title
);
2015 remote_debug_printf ("Packet %s (%s) is NOT supported",
2016 config
->name
, config
->title
);
2017 config
->support
= PACKET_DISABLE
;
2024 static enum packet_result
2025 packet_ok (const gdb::char_vector
&buf
, struct packet_config
*config
)
2027 return packet_ok (buf
.data (), config
);
2044 PACKET_vFile_pwrite
,
2046 PACKET_vFile_unlink
,
2047 PACKET_vFile_readlink
,
2050 PACKET_qXfer_features
,
2051 PACKET_qXfer_exec_file
,
2052 PACKET_qXfer_libraries
,
2053 PACKET_qXfer_libraries_svr4
,
2054 PACKET_qXfer_memory_map
,
2055 PACKET_qXfer_osdata
,
2056 PACKET_qXfer_threads
,
2057 PACKET_qXfer_statictrace_read
,
2058 PACKET_qXfer_traceframe_info
,
2064 PACKET_QPassSignals
,
2065 PACKET_QCatchSyscalls
,
2066 PACKET_QProgramSignals
,
2067 PACKET_QSetWorkingDir
,
2068 PACKET_QStartupWithShell
,
2069 PACKET_QEnvironmentHexEncoded
,
2070 PACKET_QEnvironmentReset
,
2071 PACKET_QEnvironmentUnset
,
2073 PACKET_qSearch_memory
,
2076 PACKET_QStartNoAckMode
,
2078 PACKET_qXfer_siginfo_read
,
2079 PACKET_qXfer_siginfo_write
,
2082 /* Support for conditional tracepoints. */
2083 PACKET_ConditionalTracepoints
,
2085 /* Support for target-side breakpoint conditions. */
2086 PACKET_ConditionalBreakpoints
,
2088 /* Support for target-side breakpoint commands. */
2089 PACKET_BreakpointCommands
,
2091 /* Support for fast tracepoints. */
2092 PACKET_FastTracepoints
,
2094 /* Support for static tracepoints. */
2095 PACKET_StaticTracepoints
,
2097 /* Support for installing tracepoints while a trace experiment is
2099 PACKET_InstallInTrace
,
2103 PACKET_TracepointSource
,
2106 PACKET_QDisableRandomization
,
2108 PACKET_QTBuffer_size
,
2112 PACKET_qXfer_btrace
,
2114 /* Support for the QNonStop packet. */
2117 /* Support for the QThreadEvents packet. */
2118 PACKET_QThreadEvents
,
2120 /* Support for multi-process extensions. */
2121 PACKET_multiprocess_feature
,
2123 /* Support for enabling and disabling tracepoints while a trace
2124 experiment is running. */
2125 PACKET_EnableDisableTracepoints_feature
,
2127 /* Support for collecting strings using the tracenz bytecode. */
2128 PACKET_tracenz_feature
,
2130 /* Support for continuing to run a trace experiment while GDB is
2132 PACKET_DisconnectedTracing_feature
,
2134 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2135 PACKET_augmented_libraries_svr4_read_feature
,
2137 /* Support for the qXfer:btrace-conf:read packet. */
2138 PACKET_qXfer_btrace_conf
,
2140 /* Support for the Qbtrace-conf:bts:size packet. */
2141 PACKET_Qbtrace_conf_bts_size
,
2143 /* Support for swbreak+ feature. */
2144 PACKET_swbreak_feature
,
2146 /* Support for hwbreak+ feature. */
2147 PACKET_hwbreak_feature
,
2149 /* Support for fork events. */
2150 PACKET_fork_event_feature
,
2152 /* Support for vfork events. */
2153 PACKET_vfork_event_feature
,
2155 /* Support for the Qbtrace-conf:pt:size packet. */
2156 PACKET_Qbtrace_conf_pt_size
,
2158 /* Support for exec events. */
2159 PACKET_exec_event_feature
,
2161 /* Support for query supported vCont actions. */
2162 PACKET_vContSupported
,
2164 /* Support remote CTRL-C. */
2167 /* Support TARGET_WAITKIND_NO_RESUMED. */
2173 /* FIXME: needs to be per-remote-target. Ignoring this for now,
2174 assuming all remote targets are the same server (thus all support
2175 the same packets). */
2176 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
2178 /* Returns the packet's corresponding "set remote foo-packet" command
2179 state. See struct packet_config for more details. */
2181 static enum auto_boolean
2182 packet_set_cmd_state (int packet
)
2184 return remote_protocol_packets
[packet
].detect
;
2187 /* Returns whether a given packet or feature is supported. This takes
2188 into account the state of the corresponding "set remote foo-packet"
2189 command, which may be used to bypass auto-detection. */
2191 static enum packet_support
2192 packet_config_support (struct packet_config
*config
)
2194 switch (config
->detect
)
2196 case AUTO_BOOLEAN_TRUE
:
2197 return PACKET_ENABLE
;
2198 case AUTO_BOOLEAN_FALSE
:
2199 return PACKET_DISABLE
;
2200 case AUTO_BOOLEAN_AUTO
:
2201 return config
->support
;
2203 gdb_assert_not_reached (_("bad switch"));
2207 /* Same as packet_config_support, but takes the packet's enum value as
2210 static enum packet_support
2211 packet_support (int packet
)
2213 struct packet_config
*config
= &remote_protocol_packets
[packet
];
2215 return packet_config_support (config
);
2219 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
2220 struct cmd_list_element
*c
,
2223 struct packet_config
*packet
;
2225 for (packet
= remote_protocol_packets
;
2226 packet
< &remote_protocol_packets
[PACKET_MAX
];
2229 if (&packet
->detect
== c
->var
)
2231 show_packet_config_cmd (packet
);
2235 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
2239 /* Should we try one of the 'Z' requests? */
2243 Z_PACKET_SOFTWARE_BP
,
2244 Z_PACKET_HARDWARE_BP
,
2251 /* For compatibility with older distributions. Provide a ``set remote
2252 Z-packet ...'' command that updates all the Z packet types. */
2254 static enum auto_boolean remote_Z_packet_detect
;
2257 set_remote_protocol_Z_packet_cmd (const char *args
, int from_tty
,
2258 struct cmd_list_element
*c
)
2262 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2263 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
2267 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
2268 struct cmd_list_element
*c
,
2273 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2275 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
2279 /* Returns true if the multi-process extensions are in effect. */
2282 remote_multi_process_p (struct remote_state
*rs
)
2284 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
2287 /* Returns true if fork events are supported. */
2290 remote_fork_event_p (struct remote_state
*rs
)
2292 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
2295 /* Returns true if vfork events are supported. */
2298 remote_vfork_event_p (struct remote_state
*rs
)
2300 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
2303 /* Returns true if exec events are supported. */
2306 remote_exec_event_p (struct remote_state
*rs
)
2308 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
2311 /* Insert fork catchpoint target routine. If fork events are enabled
2312 then return success, nothing more to do. */
2315 remote_target::insert_fork_catchpoint (int pid
)
2317 struct remote_state
*rs
= get_remote_state ();
2319 return !remote_fork_event_p (rs
);
2322 /* Remove fork catchpoint target routine. Nothing to do, just
2326 remote_target::remove_fork_catchpoint (int pid
)
2331 /* Insert vfork catchpoint target routine. If vfork events are enabled
2332 then return success, nothing more to do. */
2335 remote_target::insert_vfork_catchpoint (int pid
)
2337 struct remote_state
*rs
= get_remote_state ();
2339 return !remote_vfork_event_p (rs
);
2342 /* Remove vfork catchpoint target routine. Nothing to do, just
2346 remote_target::remove_vfork_catchpoint (int pid
)
2351 /* Insert exec catchpoint target routine. If exec events are
2352 enabled, just return success. */
2355 remote_target::insert_exec_catchpoint (int pid
)
2357 struct remote_state
*rs
= get_remote_state ();
2359 return !remote_exec_event_p (rs
);
2362 /* Remove exec catchpoint target routine. Nothing to do, just
2366 remote_target::remove_exec_catchpoint (int pid
)
2373 /* Take advantage of the fact that the TID field is not used, to tag
2374 special ptids with it set to != 0. */
2375 static const ptid_t
magic_null_ptid (42000, -1, 1);
2376 static const ptid_t
not_sent_ptid (42000, -2, 1);
2377 static const ptid_t
any_thread_ptid (42000, 0, 1);
2379 /* Find out if the stub attached to PID (and hence GDB should offer to
2380 detach instead of killing it when bailing out). */
2383 remote_target::remote_query_attached (int pid
)
2385 struct remote_state
*rs
= get_remote_state ();
2386 size_t size
= get_remote_packet_size ();
2388 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
2391 if (remote_multi_process_p (rs
))
2392 xsnprintf (rs
->buf
.data (), size
, "qAttached:%x", pid
);
2394 xsnprintf (rs
->buf
.data (), size
, "qAttached");
2397 getpkt (&rs
->buf
, 0);
2399 switch (packet_ok (rs
->buf
,
2400 &remote_protocol_packets
[PACKET_qAttached
]))
2403 if (strcmp (rs
->buf
.data (), "1") == 0)
2407 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
2409 case PACKET_UNKNOWN
:
2416 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2417 has been invented by GDB, instead of reported by the target. Since
2418 we can be connected to a remote system before before knowing about
2419 any inferior, mark the target with execution when we find the first
2420 inferior. If ATTACHED is 1, then we had just attached to this
2421 inferior. If it is 0, then we just created this inferior. If it
2422 is -1, then try querying the remote stub to find out if it had
2423 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2424 attempt to open this inferior's executable as the main executable
2425 if no main executable is open already. */
2428 remote_target::remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
2431 struct inferior
*inf
;
2433 /* Check whether this process we're learning about is to be
2434 considered attached, or if is to be considered to have been
2435 spawned by the stub. */
2437 attached
= remote_query_attached (pid
);
2439 if (gdbarch_has_global_solist (target_gdbarch ()))
2441 /* If the target shares code across all inferiors, then every
2442 attach adds a new inferior. */
2443 inf
= add_inferior (pid
);
2445 /* ... and every inferior is bound to the same program space.
2446 However, each inferior may still have its own address
2448 inf
->aspace
= maybe_new_address_space ();
2449 inf
->pspace
= current_program_space
;
2453 /* In the traditional debugging scenario, there's a 1-1 match
2454 between program/address spaces. We simply bind the inferior
2455 to the program space's address space. */
2456 inf
= current_inferior ();
2458 /* However, if the current inferior is already bound to a
2459 process, find some other empty inferior. */
2463 for (inferior
*it
: all_inferiors ())
2472 /* Since all inferiors were already bound to a process, add
2474 inf
= add_inferior_with_spaces ();
2476 switch_to_inferior_no_thread (inf
);
2478 inferior_appeared (inf
, pid
);
2481 inf
->attach_flag
= attached
;
2482 inf
->fake_pid_p
= fake_pid_p
;
2484 /* If no main executable is currently open then attempt to
2485 open the file that was executed to create this inferior. */
2486 if (try_open_exec
&& get_exec_file (0) == NULL
)
2487 exec_file_locate_attach (pid
, 0, 1);
2489 /* Check for exec file mismatch, and let the user solve it. */
2490 validate_exec_file (1);
2495 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2496 static remote_thread_info
*get_remote_thread_info (remote_target
*target
,
2499 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2500 according to RUNNING. */
2503 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
)
2505 struct remote_state
*rs
= get_remote_state ();
2506 struct thread_info
*thread
;
2508 /* GDB historically didn't pull threads in the initial connection
2509 setup. If the remote target doesn't even have a concept of
2510 threads (e.g., a bare-metal target), even if internally we
2511 consider that a single-threaded target, mentioning a new thread
2512 might be confusing to the user. Be silent then, preserving the
2513 age old behavior. */
2514 if (rs
->starting_up
)
2515 thread
= add_thread_silent (this, ptid
);
2517 thread
= add_thread (this, ptid
);
2519 /* We start by assuming threads are resumed. That state then gets updated
2520 when we process a matching stop reply. */
2521 get_remote_thread_info (thread
)->set_resumed ();
2523 set_executing (this, ptid
, executing
);
2524 set_running (this, ptid
, running
);
2529 /* Come here when we learn about a thread id from the remote target.
2530 It may be the first time we hear about such thread, so take the
2531 opportunity to add it to GDB's thread list. In case this is the
2532 first time we're noticing its corresponding inferior, add it to
2533 GDB's inferior list as well. EXECUTING indicates whether the
2534 thread is (internally) executing or stopped. */
2537 remote_target::remote_notice_new_inferior (ptid_t currthread
, int executing
)
2539 /* In non-stop mode, we assume new found threads are (externally)
2540 running until proven otherwise with a stop reply. In all-stop,
2541 we can only get here if all threads are stopped. */
2542 int running
= target_is_non_stop_p () ? 1 : 0;
2544 /* If this is a new thread, add it to GDB's thread list.
2545 If we leave it up to WFI to do this, bad things will happen. */
2547 thread_info
*tp
= find_thread_ptid (this, currthread
);
2548 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2550 /* We're seeing an event on a thread id we knew had exited.
2551 This has to be a new thread reusing the old id. Add it. */
2552 remote_add_thread (currthread
, running
, executing
);
2556 if (!in_thread_list (this, currthread
))
2558 struct inferior
*inf
= NULL
;
2559 int pid
= currthread
.pid ();
2561 if (inferior_ptid
.is_pid ()
2562 && pid
== inferior_ptid
.pid ())
2564 /* inferior_ptid has no thread member yet. This can happen
2565 with the vAttach -> remote_wait,"TAAthread:" path if the
2566 stub doesn't support qC. This is the first stop reported
2567 after an attach, so this is the main thread. Update the
2568 ptid in the thread list. */
2569 if (in_thread_list (this, ptid_t (pid
)))
2570 thread_change_ptid (this, inferior_ptid
, currthread
);
2574 = remote_add_thread (currthread
, running
, executing
);
2575 switch_to_thread (thr
);
2580 if (magic_null_ptid
== inferior_ptid
)
2582 /* inferior_ptid is not set yet. This can happen with the
2583 vRun -> remote_wait,"TAAthread:" path if the stub
2584 doesn't support qC. This is the first stop reported
2585 after an attach, so this is the main thread. Update the
2586 ptid in the thread list. */
2587 thread_change_ptid (this, inferior_ptid
, currthread
);
2591 /* When connecting to a target remote, or to a target
2592 extended-remote which already was debugging an inferior, we
2593 may not know about it yet. Add it before adding its child
2594 thread, so notifications are emitted in a sensible order. */
2595 if (find_inferior_pid (this, currthread
.pid ()) == NULL
)
2597 struct remote_state
*rs
= get_remote_state ();
2598 bool fake_pid_p
= !remote_multi_process_p (rs
);
2600 inf
= remote_add_inferior (fake_pid_p
,
2601 currthread
.pid (), -1, 1);
2604 /* This is really a new thread. Add it. */
2605 thread_info
*new_thr
2606 = remote_add_thread (currthread
, running
, executing
);
2608 /* If we found a new inferior, let the common code do whatever
2609 it needs to with it (e.g., read shared libraries, insert
2610 breakpoints), unless we're just setting up an all-stop
2614 struct remote_state
*rs
= get_remote_state ();
2616 if (!rs
->starting_up
)
2617 notice_new_inferior (new_thr
, executing
, 0);
2622 /* Return THREAD's private thread data, creating it if necessary. */
2624 static remote_thread_info
*
2625 get_remote_thread_info (thread_info
*thread
)
2627 gdb_assert (thread
!= NULL
);
2629 if (thread
->priv
== NULL
)
2630 thread
->priv
.reset (new remote_thread_info
);
2632 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2635 /* Return PTID's private thread data, creating it if necessary. */
2637 static remote_thread_info
*
2638 get_remote_thread_info (remote_target
*target
, ptid_t ptid
)
2640 thread_info
*thr
= find_thread_ptid (target
, ptid
);
2641 return get_remote_thread_info (thr
);
2644 /* Call this function as a result of
2645 1) A halt indication (T packet) containing a thread id
2646 2) A direct query of currthread
2647 3) Successful execution of set thread */
2650 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2652 rs
->general_thread
= currthread
;
2655 /* If 'QPassSignals' is supported, tell the remote stub what signals
2656 it can simply pass through to the inferior without reporting. */
2659 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2661 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2663 char *pass_packet
, *p
;
2665 struct remote_state
*rs
= get_remote_state ();
2667 gdb_assert (pass_signals
.size () < 256);
2668 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2670 if (pass_signals
[i
])
2673 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2674 strcpy (pass_packet
, "QPassSignals:");
2675 p
= pass_packet
+ strlen (pass_packet
);
2676 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2678 if (pass_signals
[i
])
2681 *p
++ = tohex (i
>> 4);
2682 *p
++ = tohex (i
& 15);
2691 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2693 putpkt (pass_packet
);
2694 getpkt (&rs
->buf
, 0);
2695 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2696 xfree (rs
->last_pass_packet
);
2697 rs
->last_pass_packet
= pass_packet
;
2700 xfree (pass_packet
);
2704 /* If 'QCatchSyscalls' is supported, tell the remote stub
2705 to report syscalls to GDB. */
2708 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2709 gdb::array_view
<const int> syscall_counts
)
2711 const char *catch_packet
;
2712 enum packet_result result
;
2715 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2717 /* Not supported. */
2721 if (needed
&& any_count
== 0)
2723 /* Count how many syscalls are to be caught. */
2724 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2726 if (syscall_counts
[i
] != 0)
2731 remote_debug_printf ("pid %d needed %d any_count %d n_sysno %d",
2732 pid
, needed
, any_count
, n_sysno
);
2734 std::string built_packet
;
2737 /* Prepare a packet with the sysno list, assuming max 8+1
2738 characters for a sysno. If the resulting packet size is too
2739 big, fallback on the non-selective packet. */
2740 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2741 built_packet
.reserve (maxpktsz
);
2742 built_packet
= "QCatchSyscalls:1";
2745 /* Add in each syscall to be caught. */
2746 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2748 if (syscall_counts
[i
] != 0)
2749 string_appendf (built_packet
, ";%zx", i
);
2752 if (built_packet
.size () > get_remote_packet_size ())
2754 /* catch_packet too big. Fallback to less efficient
2755 non selective mode, with GDB doing the filtering. */
2756 catch_packet
= "QCatchSyscalls:1";
2759 catch_packet
= built_packet
.c_str ();
2762 catch_packet
= "QCatchSyscalls:0";
2764 struct remote_state
*rs
= get_remote_state ();
2766 putpkt (catch_packet
);
2767 getpkt (&rs
->buf
, 0);
2768 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2769 if (result
== PACKET_OK
)
2775 /* If 'QProgramSignals' is supported, tell the remote stub what
2776 signals it should pass through to the inferior when detaching. */
2779 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2781 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2785 struct remote_state
*rs
= get_remote_state ();
2787 gdb_assert (signals
.size () < 256);
2788 for (size_t i
= 0; i
< signals
.size (); i
++)
2793 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2794 strcpy (packet
, "QProgramSignals:");
2795 p
= packet
+ strlen (packet
);
2796 for (size_t i
= 0; i
< signals
.size (); i
++)
2798 if (signal_pass_state (i
))
2801 *p
++ = tohex (i
>> 4);
2802 *p
++ = tohex (i
& 15);
2811 if (!rs
->last_program_signals_packet
2812 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2815 getpkt (&rs
->buf
, 0);
2816 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2817 xfree (rs
->last_program_signals_packet
);
2818 rs
->last_program_signals_packet
= packet
;
2825 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2826 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2827 thread. If GEN is set, set the general thread, if not, then set
2828 the step/continue thread. */
2830 remote_target::set_thread (ptid_t ptid
, int gen
)
2832 struct remote_state
*rs
= get_remote_state ();
2833 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2834 char *buf
= rs
->buf
.data ();
2835 char *endbuf
= buf
+ get_remote_packet_size ();
2841 *buf
++ = gen
? 'g' : 'c';
2842 if (ptid
== magic_null_ptid
)
2843 xsnprintf (buf
, endbuf
- buf
, "0");
2844 else if (ptid
== any_thread_ptid
)
2845 xsnprintf (buf
, endbuf
- buf
, "0");
2846 else if (ptid
== minus_one_ptid
)
2847 xsnprintf (buf
, endbuf
- buf
, "-1");
2849 write_ptid (buf
, endbuf
, ptid
);
2851 getpkt (&rs
->buf
, 0);
2853 rs
->general_thread
= ptid
;
2855 rs
->continue_thread
= ptid
;
2859 remote_target::set_general_thread (ptid_t ptid
)
2861 set_thread (ptid
, 1);
2865 remote_target::set_continue_thread (ptid_t ptid
)
2867 set_thread (ptid
, 0);
2870 /* Change the remote current process. Which thread within the process
2871 ends up selected isn't important, as long as it is the same process
2872 as what INFERIOR_PTID points to.
2874 This comes from that fact that there is no explicit notion of
2875 "selected process" in the protocol. The selected process for
2876 general operations is the process the selected general thread
2880 remote_target::set_general_process ()
2882 struct remote_state
*rs
= get_remote_state ();
2884 /* If the remote can't handle multiple processes, don't bother. */
2885 if (!remote_multi_process_p (rs
))
2888 /* We only need to change the remote current thread if it's pointing
2889 at some other process. */
2890 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2891 set_general_thread (inferior_ptid
);
2895 /* Return nonzero if this is the main thread that we made up ourselves
2896 to model non-threaded targets as single-threaded. */
2899 remote_thread_always_alive (ptid_t ptid
)
2901 if (ptid
== magic_null_ptid
)
2902 /* The main thread is always alive. */
2905 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2906 /* The main thread is always alive. This can happen after a
2907 vAttach, if the remote side doesn't support
2914 /* Return nonzero if the thread PTID is still alive on the remote
2918 remote_target::thread_alive (ptid_t ptid
)
2920 struct remote_state
*rs
= get_remote_state ();
2923 /* Check if this is a thread that we made up ourselves to model
2924 non-threaded targets as single-threaded. */
2925 if (remote_thread_always_alive (ptid
))
2928 p
= rs
->buf
.data ();
2929 endp
= p
+ get_remote_packet_size ();
2932 write_ptid (p
, endp
, ptid
);
2935 getpkt (&rs
->buf
, 0);
2936 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2939 /* Return a pointer to a thread name if we know it and NULL otherwise.
2940 The thread_info object owns the memory for the name. */
2943 remote_target::thread_name (struct thread_info
*info
)
2945 if (info
->priv
!= NULL
)
2947 const std::string
&name
= get_remote_thread_info (info
)->name
;
2948 return !name
.empty () ? name
.c_str () : NULL
;
2954 /* About these extended threadlist and threadinfo packets. They are
2955 variable length packets but, the fields within them are often fixed
2956 length. They are redundant enough to send over UDP as is the
2957 remote protocol in general. There is a matching unit test module
2960 /* WARNING: This threadref data structure comes from the remote O.S.,
2961 libstub protocol encoding, and remote.c. It is not particularly
2964 /* Right now, the internal structure is int. We want it to be bigger.
2965 Plan to fix this. */
2967 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2969 /* gdb_ext_thread_info is an internal GDB data structure which is
2970 equivalent to the reply of the remote threadinfo packet. */
2972 struct gdb_ext_thread_info
2974 threadref threadid
; /* External form of thread reference. */
2975 int active
; /* Has state interesting to GDB?
2977 char display
[256]; /* Brief state display, name,
2978 blocked/suspended. */
2979 char shortname
[32]; /* To be used to name threads. */
2980 char more_display
[256]; /* Long info, statistics, queue depth,
2984 /* The volume of remote transfers can be limited by submitting
2985 a mask containing bits specifying the desired information.
2986 Use a union of these values as the 'selection' parameter to
2987 get_thread_info. FIXME: Make these TAG names more thread specific. */
2989 #define TAG_THREADID 1
2990 #define TAG_EXISTS 2
2991 #define TAG_DISPLAY 4
2992 #define TAG_THREADNAME 8
2993 #define TAG_MOREDISPLAY 16
2995 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2997 static const char *unpack_nibble (const char *buf
, int *val
);
2999 static const char *unpack_byte (const char *buf
, int *value
);
3001 static char *pack_int (char *buf
, int value
);
3003 static const char *unpack_int (const char *buf
, int *value
);
3005 static const char *unpack_string (const char *src
, char *dest
, int length
);
3007 static char *pack_threadid (char *pkt
, threadref
*id
);
3009 static const char *unpack_threadid (const char *inbuf
, threadref
*id
);
3011 void int_to_threadref (threadref
*id
, int value
);
3013 static int threadref_to_int (threadref
*ref
);
3015 static void copy_threadref (threadref
*dest
, threadref
*src
);
3017 static int threadmatch (threadref
*dest
, threadref
*src
);
3019 static char *pack_threadinfo_request (char *pkt
, int mode
,
3022 static char *pack_threadlist_request (char *pkt
, int startflag
,
3024 threadref
*nextthread
);
3026 static int remote_newthread_step (threadref
*ref
, void *context
);
3029 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
3030 buffer we're allowed to write to. Returns
3031 BUF+CHARACTERS_WRITTEN. */
3034 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
3037 struct remote_state
*rs
= get_remote_state ();
3039 if (remote_multi_process_p (rs
))
3043 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
3045 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
3049 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
3051 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
3056 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
3057 last parsed char. Returns null_ptid if no thread id is found, and
3058 throws an error if the thread id has an invalid format. */
3061 read_ptid (const char *buf
, const char **obuf
)
3063 const char *p
= buf
;
3065 ULONGEST pid
= 0, tid
= 0;
3069 /* Multi-process ptid. */
3070 pp
= unpack_varlen_hex (p
+ 1, &pid
);
3072 error (_("invalid remote ptid: %s"), p
);
3075 pp
= unpack_varlen_hex (p
+ 1, &tid
);
3078 return ptid_t (pid
, tid
, 0);
3081 /* No multi-process. Just a tid. */
3082 pp
= unpack_varlen_hex (p
, &tid
);
3084 /* Return null_ptid when no thread id is found. */
3092 /* Since the stub is not sending a process id, then default to
3093 what's in inferior_ptid, unless it's null at this point. If so,
3094 then since there's no way to know the pid of the reported
3095 threads, use the magic number. */
3096 if (inferior_ptid
== null_ptid
)
3097 pid
= magic_null_ptid
.pid ();
3099 pid
= inferior_ptid
.pid ();
3103 return ptid_t (pid
, tid
, 0);
3109 if (ch
>= 'a' && ch
<= 'f')
3110 return ch
- 'a' + 10;
3111 if (ch
>= '0' && ch
<= '9')
3113 if (ch
>= 'A' && ch
<= 'F')
3114 return ch
- 'A' + 10;
3119 stub_unpack_int (const char *buff
, int fieldlength
)
3126 nibble
= stubhex (*buff
++);
3130 retval
= retval
<< 4;
3136 unpack_nibble (const char *buf
, int *val
)
3138 *val
= fromhex (*buf
++);
3143 unpack_byte (const char *buf
, int *value
)
3145 *value
= stub_unpack_int (buf
, 2);
3150 pack_int (char *buf
, int value
)
3152 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3153 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3154 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3155 buf
= pack_hex_byte (buf
, (value
& 0xff));
3160 unpack_int (const char *buf
, int *value
)
3162 *value
= stub_unpack_int (buf
, 8);
3166 #if 0 /* Currently unused, uncomment when needed. */
3167 static char *pack_string (char *pkt
, char *string
);
3170 pack_string (char *pkt
, char *string
)
3175 len
= strlen (string
);
3177 len
= 200; /* Bigger than most GDB packets, junk??? */
3178 pkt
= pack_hex_byte (pkt
, len
);
3182 if ((ch
== '\0') || (ch
== '#'))
3183 ch
= '*'; /* Protect encapsulation. */
3188 #endif /* 0 (unused) */
3191 unpack_string (const char *src
, char *dest
, int length
)
3200 pack_threadid (char *pkt
, threadref
*id
)
3203 unsigned char *altid
;
3205 altid
= (unsigned char *) id
;
3206 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3208 pkt
= pack_hex_byte (pkt
, *altid
++);
3214 unpack_threadid (const char *inbuf
, threadref
*id
)
3217 const char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3220 altref
= (char *) id
;
3222 while (inbuf
< limit
)
3224 x
= stubhex (*inbuf
++);
3225 y
= stubhex (*inbuf
++);
3226 *altref
++ = (x
<< 4) | y
;
3231 /* Externally, threadrefs are 64 bits but internally, they are still
3232 ints. This is due to a mismatch of specifications. We would like
3233 to use 64bit thread references internally. This is an adapter
3237 int_to_threadref (threadref
*id
, int value
)
3239 unsigned char *scan
;
3241 scan
= (unsigned char *) id
;
3247 *scan
++ = (value
>> 24) & 0xff;
3248 *scan
++ = (value
>> 16) & 0xff;
3249 *scan
++ = (value
>> 8) & 0xff;
3250 *scan
++ = (value
& 0xff);
3254 threadref_to_int (threadref
*ref
)
3257 unsigned char *scan
;
3263 value
= (value
<< 8) | ((*scan
++) & 0xff);
3268 copy_threadref (threadref
*dest
, threadref
*src
)
3271 unsigned char *csrc
, *cdest
;
3273 csrc
= (unsigned char *) src
;
3274 cdest
= (unsigned char *) dest
;
3281 threadmatch (threadref
*dest
, threadref
*src
)
3283 /* Things are broken right now, so just assume we got a match. */
3285 unsigned char *srcp
, *destp
;
3287 srcp
= (char *) src
;
3288 destp
= (char *) dest
;
3292 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3299 threadid:1, # always request threadid
3306 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3309 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3311 *pkt
++ = 'q'; /* Info Query */
3312 *pkt
++ = 'P'; /* process or thread info */
3313 pkt
= pack_int (pkt
, mode
); /* mode */
3314 pkt
= pack_threadid (pkt
, id
); /* threadid */
3315 *pkt
= '\0'; /* terminate */
3319 /* These values tag the fields in a thread info response packet. */
3320 /* Tagging the fields allows us to request specific fields and to
3321 add more fields as time goes by. */
3323 #define TAG_THREADID 1 /* Echo the thread identifier. */
3324 #define TAG_EXISTS 2 /* Is this process defined enough to
3325 fetch registers and its stack? */
3326 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3327 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3328 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3332 remote_target::remote_unpack_thread_info_response (const char *pkt
,
3333 threadref
*expectedref
,
3334 gdb_ext_thread_info
*info
)
3336 struct remote_state
*rs
= get_remote_state ();
3340 const char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3343 /* info->threadid = 0; FIXME: implement zero_threadref. */
3345 info
->display
[0] = '\0';
3346 info
->shortname
[0] = '\0';
3347 info
->more_display
[0] = '\0';
3349 /* Assume the characters indicating the packet type have been
3351 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3352 pkt
= unpack_threadid (pkt
, &ref
);
3355 warning (_("Incomplete response to threadinfo request."));
3356 if (!threadmatch (&ref
, expectedref
))
3357 { /* This is an answer to a different request. */
3358 warning (_("ERROR RMT Thread info mismatch."));
3361 copy_threadref (&info
->threadid
, &ref
);
3363 /* Loop on tagged fields , try to bail if something goes wrong. */
3365 /* Packets are terminated with nulls. */
3366 while ((pkt
< limit
) && mask
&& *pkt
)
3368 pkt
= unpack_int (pkt
, &tag
); /* tag */
3369 pkt
= unpack_byte (pkt
, &length
); /* length */
3370 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3372 warning (_("ERROR RMT: threadinfo tag mismatch."));
3376 if (tag
== TAG_THREADID
)
3380 warning (_("ERROR RMT: length of threadid is not 16."));
3384 pkt
= unpack_threadid (pkt
, &ref
);
3385 mask
= mask
& ~TAG_THREADID
;
3388 if (tag
== TAG_EXISTS
)
3390 info
->active
= stub_unpack_int (pkt
, length
);
3392 mask
= mask
& ~(TAG_EXISTS
);
3395 warning (_("ERROR RMT: 'exists' length too long."));
3401 if (tag
== TAG_THREADNAME
)
3403 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3404 mask
= mask
& ~TAG_THREADNAME
;
3407 if (tag
== TAG_DISPLAY
)
3409 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3410 mask
= mask
& ~TAG_DISPLAY
;
3413 if (tag
== TAG_MOREDISPLAY
)
3415 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3416 mask
= mask
& ~TAG_MOREDISPLAY
;
3419 warning (_("ERROR RMT: unknown thread info tag."));
3420 break; /* Not a tag we know about. */
3426 remote_target::remote_get_threadinfo (threadref
*threadid
,
3428 gdb_ext_thread_info
*info
)
3430 struct remote_state
*rs
= get_remote_state ();
3433 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3435 getpkt (&rs
->buf
, 0);
3437 if (rs
->buf
[0] == '\0')
3440 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3445 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3448 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3449 threadref
*nextthread
)
3451 *pkt
++ = 'q'; /* info query packet */
3452 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3453 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3454 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3455 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3460 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3463 remote_target::parse_threadlist_response (const char *pkt
, int result_limit
,
3464 threadref
*original_echo
,
3465 threadref
*resultlist
,
3468 struct remote_state
*rs
= get_remote_state ();
3469 int count
, resultcount
, done
;
3472 /* Assume the 'q' and 'M chars have been stripped. */
3473 const char *limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3474 /* done parse past here */
3475 pkt
= unpack_byte (pkt
, &count
); /* count field */
3476 pkt
= unpack_nibble (pkt
, &done
);
3477 /* The first threadid is the argument threadid. */
3478 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3479 while ((count
-- > 0) && (pkt
< limit
))
3481 pkt
= unpack_threadid (pkt
, resultlist
++);
3482 if (resultcount
++ >= result_limit
)
3490 /* Fetch the next batch of threads from the remote. Returns -1 if the
3491 qL packet is not supported, 0 on error and 1 on success. */
3494 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3495 int result_limit
, int *done
, int *result_count
,
3496 threadref
*threadlist
)
3498 struct remote_state
*rs
= get_remote_state ();
3501 /* Truncate result limit to be smaller than the packet size. */
3502 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3503 >= get_remote_packet_size ())
3504 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3506 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3509 getpkt (&rs
->buf
, 0);
3510 if (rs
->buf
[0] == '\0')
3512 /* Packet not supported. */
3517 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3518 &rs
->echo_nextthread
, threadlist
, done
);
3520 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3522 /* FIXME: This is a good reason to drop the packet. */
3523 /* Possibly, there is a duplicate response. */
3525 retransmit immediatly - race conditions
3526 retransmit after timeout - yes
3528 wait for packet, then exit
3530 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3531 return 0; /* I choose simply exiting. */
3533 if (*result_count
<= 0)
3537 warning (_("RMT ERROR : failed to get remote thread list."));
3540 return result
; /* break; */
3542 if (*result_count
> result_limit
)
3545 warning (_("RMT ERROR: threadlist response longer than requested."));
3551 /* Fetch the list of remote threads, with the qL packet, and call
3552 STEPFUNCTION for each thread found. Stops iterating and returns 1
3553 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3554 STEPFUNCTION returns false. If the packet is not supported,
3558 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3559 void *context
, int looplimit
)
3561 struct remote_state
*rs
= get_remote_state ();
3562 int done
, i
, result_count
;
3570 if (loopcount
++ > looplimit
)
3573 warning (_("Remote fetch threadlist -infinite loop-."));
3576 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3577 MAXTHREADLISTRESULTS
,
3578 &done
, &result_count
,
3579 rs
->resultthreadlist
);
3582 /* Clear for later iterations. */
3584 /* Setup to resume next batch of thread references, set nextthread. */
3585 if (result_count
>= 1)
3586 copy_threadref (&rs
->nextthread
,
3587 &rs
->resultthreadlist
[result_count
- 1]);
3589 while (result_count
--)
3591 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3601 /* A thread found on the remote target. */
3605 explicit thread_item (ptid_t ptid_
)
3609 thread_item (thread_item
&&other
) = default;
3610 thread_item
&operator= (thread_item
&&other
) = default;
3612 DISABLE_COPY_AND_ASSIGN (thread_item
);
3614 /* The thread's PTID. */
3617 /* The thread's extra info. */
3620 /* The thread's name. */
3623 /* The core the thread was running on. -1 if not known. */
3626 /* The thread handle associated with the thread. */
3627 gdb::byte_vector thread_handle
;
3630 /* Context passed around to the various methods listing remote
3631 threads. As new threads are found, they're added to the ITEMS
3634 struct threads_listing_context
3636 /* Return true if this object contains an entry for a thread with ptid
3639 bool contains_thread (ptid_t ptid
) const
3641 auto match_ptid
= [&] (const thread_item
&item
)
3643 return item
.ptid
== ptid
;
3646 auto it
= std::find_if (this->items
.begin (),
3650 return it
!= this->items
.end ();
3653 /* Remove the thread with ptid PTID. */
3655 void remove_thread (ptid_t ptid
)
3657 auto match_ptid
= [&] (const thread_item
&item
)
3659 return item
.ptid
== ptid
;
3662 auto it
= std::remove_if (this->items
.begin (),
3666 if (it
!= this->items
.end ())
3667 this->items
.erase (it
);
3670 /* The threads found on the remote target. */
3671 std::vector
<thread_item
> items
;
3675 remote_newthread_step (threadref
*ref
, void *data
)
3677 struct threads_listing_context
*context
3678 = (struct threads_listing_context
*) data
;
3679 int pid
= inferior_ptid
.pid ();
3680 int lwp
= threadref_to_int (ref
);
3681 ptid_t
ptid (pid
, lwp
);
3683 context
->items
.emplace_back (ptid
);
3685 return 1; /* continue iterator */
3688 #define CRAZY_MAX_THREADS 1000
3691 remote_target::remote_current_thread (ptid_t oldpid
)
3693 struct remote_state
*rs
= get_remote_state ();
3696 getpkt (&rs
->buf
, 0);
3697 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3702 result
= read_ptid (&rs
->buf
[2], &obuf
);
3704 remote_debug_printf ("warning: garbage in qC reply");
3712 /* List remote threads using the deprecated qL packet. */
3715 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3717 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3718 CRAZY_MAX_THREADS
) >= 0)
3724 #if defined(HAVE_LIBEXPAT)
3727 start_thread (struct gdb_xml_parser
*parser
,
3728 const struct gdb_xml_element
*element
,
3730 std::vector
<gdb_xml_value
> &attributes
)
3732 struct threads_listing_context
*data
3733 = (struct threads_listing_context
*) user_data
;
3734 struct gdb_xml_value
*attr
;
3736 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3737 ptid_t ptid
= read_ptid (id
, NULL
);
3739 data
->items
.emplace_back (ptid
);
3740 thread_item
&item
= data
->items
.back ();
3742 attr
= xml_find_attribute (attributes
, "core");
3744 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3746 attr
= xml_find_attribute (attributes
, "name");
3748 item
.name
= (const char *) attr
->value
.get ();
3750 attr
= xml_find_attribute (attributes
, "handle");
3752 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3756 end_thread (struct gdb_xml_parser
*parser
,
3757 const struct gdb_xml_element
*element
,
3758 void *user_data
, const char *body_text
)
3760 struct threads_listing_context
*data
3761 = (struct threads_listing_context
*) user_data
;
3763 if (body_text
!= NULL
&& *body_text
!= '\0')
3764 data
->items
.back ().extra
= body_text
;
3767 const struct gdb_xml_attribute thread_attributes
[] = {
3768 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3769 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3770 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3771 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3772 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3775 const struct gdb_xml_element thread_children
[] = {
3776 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3779 const struct gdb_xml_element threads_children
[] = {
3780 { "thread", thread_attributes
, thread_children
,
3781 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3782 start_thread
, end_thread
},
3783 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3786 const struct gdb_xml_element threads_elements
[] = {
3787 { "threads", NULL
, threads_children
,
3788 GDB_XML_EF_NONE
, NULL
, NULL
},
3789 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3794 /* List remote threads using qXfer:threads:read. */
3797 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3799 #if defined(HAVE_LIBEXPAT)
3800 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3802 gdb::optional
<gdb::char_vector
> xml
3803 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3805 if (xml
&& (*xml
)[0] != '\0')
3807 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3808 threads_elements
, xml
->data (), context
);
3818 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3821 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3823 struct remote_state
*rs
= get_remote_state ();
3825 if (rs
->use_threadinfo_query
)
3829 putpkt ("qfThreadInfo");
3830 getpkt (&rs
->buf
, 0);
3831 bufp
= rs
->buf
.data ();
3832 if (bufp
[0] != '\0') /* q packet recognized */
3834 while (*bufp
++ == 'm') /* reply contains one or more TID */
3838 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3839 context
->items
.emplace_back (ptid
);
3841 while (*bufp
++ == ','); /* comma-separated list */
3842 putpkt ("qsThreadInfo");
3843 getpkt (&rs
->buf
, 0);
3844 bufp
= rs
->buf
.data ();
3850 /* Packet not recognized. */
3851 rs
->use_threadinfo_query
= 0;
3858 /* Return true if INF only has one non-exited thread. */
3861 has_single_non_exited_thread (inferior
*inf
)
3864 for (thread_info
*tp ATTRIBUTE_UNUSED
: inf
->non_exited_threads ())
3870 /* Implement the to_update_thread_list function for the remote
3874 remote_target::update_thread_list ()
3876 struct threads_listing_context context
;
3879 /* We have a few different mechanisms to fetch the thread list. Try
3880 them all, starting with the most preferred one first, falling
3881 back to older methods. */
3882 if (remote_get_threads_with_qxfer (&context
)
3883 || remote_get_threads_with_qthreadinfo (&context
)
3884 || remote_get_threads_with_ql (&context
))
3888 if (context
.items
.empty ()
3889 && remote_thread_always_alive (inferior_ptid
))
3891 /* Some targets don't really support threads, but still
3892 reply an (empty) thread list in response to the thread
3893 listing packets, instead of replying "packet not
3894 supported". Exit early so we don't delete the main
3899 /* CONTEXT now holds the current thread list on the remote
3900 target end. Delete GDB-side threads no longer found on the
3902 for (thread_info
*tp
: all_threads_safe ())
3904 if (tp
->inf
->process_target () != this)
3907 if (!context
.contains_thread (tp
->ptid
))
3909 /* Do not remove the thread if it is the last thread in
3910 the inferior. This situation happens when we have a
3911 pending exit process status to process. Otherwise we
3912 may end up with a seemingly live inferior (i.e. pid
3913 != 0) that has no threads. */
3914 if (has_single_non_exited_thread (tp
->inf
))
3922 /* Remove any unreported fork child threads from CONTEXT so
3923 that we don't interfere with follow fork, which is where
3924 creation of such threads is handled. */
3925 remove_new_fork_children (&context
);
3927 /* And now add threads we don't know about yet to our list. */
3928 for (thread_item
&item
: context
.items
)
3930 if (item
.ptid
!= null_ptid
)
3932 /* In non-stop mode, we assume new found threads are
3933 executing until proven otherwise with a stop reply.
3934 In all-stop, we can only get here if all threads are
3936 int executing
= target_is_non_stop_p () ? 1 : 0;
3938 remote_notice_new_inferior (item
.ptid
, executing
);
3940 thread_info
*tp
= find_thread_ptid (this, item
.ptid
);
3941 remote_thread_info
*info
= get_remote_thread_info (tp
);
3942 info
->core
= item
.core
;
3943 info
->extra
= std::move (item
.extra
);
3944 info
->name
= std::move (item
.name
);
3945 info
->thread_handle
= std::move (item
.thread_handle
);
3952 /* If no thread listing method is supported, then query whether
3953 each known thread is alive, one by one, with the T packet.
3954 If the target doesn't support threads at all, then this is a
3955 no-op. See remote_thread_alive. */
3961 * Collect a descriptive string about the given thread.
3962 * The target may say anything it wants to about the thread
3963 * (typically info about its blocked / runnable state, name, etc.).
3964 * This string will appear in the info threads display.
3966 * Optional: targets are not required to implement this function.
3970 remote_target::extra_thread_info (thread_info
*tp
)
3972 struct remote_state
*rs
= get_remote_state ();
3975 struct gdb_ext_thread_info threadinfo
;
3977 if (rs
->remote_desc
== 0) /* paranoia */
3978 internal_error (__FILE__
, __LINE__
,
3979 _("remote_threads_extra_info"));
3981 if (tp
->ptid
== magic_null_ptid
3982 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
3983 /* This is the main thread which was added by GDB. The remote
3984 server doesn't know about it. */
3987 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
3989 /* If already have cached info, use it. */
3990 if (!extra
.empty ())
3991 return extra
.c_str ();
3993 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3995 /* If we're using qXfer:threads:read, then the extra info is
3996 included in the XML. So if we didn't have anything cached,
3997 it's because there's really no extra info. */
4001 if (rs
->use_threadextra_query
)
4003 char *b
= rs
->buf
.data ();
4004 char *endb
= b
+ get_remote_packet_size ();
4006 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
4008 write_ptid (b
, endb
, tp
->ptid
);
4011 getpkt (&rs
->buf
, 0);
4012 if (rs
->buf
[0] != 0)
4014 extra
.resize (strlen (rs
->buf
.data ()) / 2);
4015 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
4016 return extra
.c_str ();
4020 /* If the above query fails, fall back to the old method. */
4021 rs
->use_threadextra_query
= 0;
4022 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
4023 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
4024 int_to_threadref (&id
, tp
->ptid
.lwp ());
4025 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
4026 if (threadinfo
.active
)
4028 if (*threadinfo
.shortname
)
4029 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
4030 if (*threadinfo
.display
)
4032 if (!extra
.empty ())
4034 string_appendf (extra
, " State: %s", threadinfo
.display
);
4036 if (*threadinfo
.more_display
)
4038 if (!extra
.empty ())
4040 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
4042 return extra
.c_str ();
4049 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
4050 struct static_tracepoint_marker
*marker
)
4052 struct remote_state
*rs
= get_remote_state ();
4053 char *p
= rs
->buf
.data ();
4055 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
4057 p
+= hexnumstr (p
, addr
);
4059 getpkt (&rs
->buf
, 0);
4060 p
= rs
->buf
.data ();
4063 error (_("Remote failure reply: %s"), p
);
4067 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
4074 std::vector
<static_tracepoint_marker
>
4075 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
4077 struct remote_state
*rs
= get_remote_state ();
4078 std::vector
<static_tracepoint_marker
> markers
;
4080 static_tracepoint_marker marker
;
4082 /* Ask for a first packet of static tracepoint marker
4085 getpkt (&rs
->buf
, 0);
4086 p
= rs
->buf
.data ();
4088 error (_("Remote failure reply: %s"), p
);
4094 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
4096 if (strid
== NULL
|| marker
.str_id
== strid
)
4097 markers
.push_back (std::move (marker
));
4099 while (*p
++ == ','); /* comma-separated list */
4100 /* Ask for another packet of static tracepoint definition. */
4102 getpkt (&rs
->buf
, 0);
4103 p
= rs
->buf
.data ();
4110 /* Implement the to_get_ada_task_ptid function for the remote targets. */
4113 remote_target::get_ada_task_ptid (long lwp
, long thread
)
4115 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
4119 /* Restart the remote side; this is an extended protocol operation. */
4122 remote_target::extended_remote_restart ()
4124 struct remote_state
*rs
= get_remote_state ();
4126 /* Send the restart command; for reasons I don't understand the
4127 remote side really expects a number after the "R". */
4128 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
4131 remote_fileio_reset ();
4134 /* Clean up connection to a remote debugger. */
4137 remote_target::close ()
4139 /* Make sure we leave stdin registered in the event loop. */
4142 trace_reset_local_state ();
4147 remote_target::~remote_target ()
4149 struct remote_state
*rs
= get_remote_state ();
4151 /* Check for NULL because we may get here with a partially
4152 constructed target/connection. */
4153 if (rs
->remote_desc
== nullptr)
4156 serial_close (rs
->remote_desc
);
4158 /* We are destroying the remote target, so we should discard
4159 everything of this target. */
4160 discard_pending_stop_replies_in_queue ();
4162 if (rs
->remote_async_inferior_event_token
)
4163 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4165 delete rs
->notif_state
;
4168 /* Query the remote side for the text, data and bss offsets. */
4171 remote_target::get_offsets ()
4173 struct remote_state
*rs
= get_remote_state ();
4176 int lose
, num_segments
= 0, do_sections
, do_segments
;
4177 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4179 if (current_program_space
->symfile_object_file
== NULL
)
4182 putpkt ("qOffsets");
4183 getpkt (&rs
->buf
, 0);
4184 buf
= rs
->buf
.data ();
4186 if (buf
[0] == '\000')
4187 return; /* Return silently. Stub doesn't support
4191 warning (_("Remote failure reply: %s"), buf
);
4195 /* Pick up each field in turn. This used to be done with scanf, but
4196 scanf will make trouble if CORE_ADDR size doesn't match
4197 conversion directives correctly. The following code will work
4198 with any size of CORE_ADDR. */
4199 text_addr
= data_addr
= bss_addr
= 0;
4203 if (startswith (ptr
, "Text="))
4206 /* Don't use strtol, could lose on big values. */
4207 while (*ptr
&& *ptr
!= ';')
4208 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4210 if (startswith (ptr
, ";Data="))
4213 while (*ptr
&& *ptr
!= ';')
4214 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4219 if (!lose
&& startswith (ptr
, ";Bss="))
4222 while (*ptr
&& *ptr
!= ';')
4223 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4225 if (bss_addr
!= data_addr
)
4226 warning (_("Target reported unsupported offsets: %s"), buf
);
4231 else if (startswith (ptr
, "TextSeg="))
4234 /* Don't use strtol, could lose on big values. */
4235 while (*ptr
&& *ptr
!= ';')
4236 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4239 if (startswith (ptr
, ";DataSeg="))
4242 while (*ptr
&& *ptr
!= ';')
4243 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4251 error (_("Malformed response to offset query, %s"), buf
);
4252 else if (*ptr
!= '\0')
4253 warning (_("Target reported unsupported offsets: %s"), buf
);
4255 objfile
*objf
= current_program_space
->symfile_object_file
;
4256 section_offsets offs
= objf
->section_offsets
;
4258 symfile_segment_data_up data
= get_symfile_segment_data (objf
->obfd
);
4259 do_segments
= (data
!= NULL
);
4260 do_sections
= num_segments
== 0;
4262 if (num_segments
> 0)
4264 segments
[0] = text_addr
;
4265 segments
[1] = data_addr
;
4267 /* If we have two segments, we can still try to relocate everything
4268 by assuming that the .text and .data offsets apply to the whole
4269 text and data segments. Convert the offsets given in the packet
4270 to base addresses for symfile_map_offsets_to_segments. */
4271 else if (data
!= nullptr && data
->segments
.size () == 2)
4273 segments
[0] = data
->segments
[0].base
+ text_addr
;
4274 segments
[1] = data
->segments
[1].base
+ data_addr
;
4277 /* If the object file has only one segment, assume that it is text
4278 rather than data; main programs with no writable data are rare,
4279 but programs with no code are useless. Of course the code might
4280 have ended up in the data segment... to detect that we would need
4281 the permissions here. */
4282 else if (data
&& data
->segments
.size () == 1)
4284 segments
[0] = data
->segments
[0].base
+ text_addr
;
4287 /* There's no way to relocate by segment. */
4293 int ret
= symfile_map_offsets_to_segments (objf
->obfd
,
4295 num_segments
, segments
);
4297 if (ret
== 0 && !do_sections
)
4298 error (_("Can not handle qOffsets TextSeg "
4299 "response with this symbol file"));
4307 offs
[SECT_OFF_TEXT (objf
)] = text_addr
;
4309 /* This is a temporary kludge to force data and bss to use the
4310 same offsets because that's what nlmconv does now. The real
4311 solution requires changes to the stub and remote.c that I
4312 don't have time to do right now. */
4314 offs
[SECT_OFF_DATA (objf
)] = data_addr
;
4315 offs
[SECT_OFF_BSS (objf
)] = data_addr
;
4318 objfile_relocate (objf
, offs
);
4321 /* Send interrupt_sequence to remote target. */
4324 remote_target::send_interrupt_sequence ()
4326 struct remote_state
*rs
= get_remote_state ();
4328 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4329 remote_serial_write ("\x03", 1);
4330 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4331 serial_send_break (rs
->remote_desc
);
4332 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4334 serial_send_break (rs
->remote_desc
);
4335 remote_serial_write ("g", 1);
4338 internal_error (__FILE__
, __LINE__
,
4339 _("Invalid value for interrupt_sequence_mode: %s."),
4340 interrupt_sequence_mode
);
4344 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4345 and extract the PTID. Returns NULL_PTID if not found. */
4348 stop_reply_extract_thread (const char *stop_reply
)
4350 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4354 /* Txx r:val ; r:val (...) */
4357 /* Look for "register" named "thread". */
4362 p1
= strchr (p
, ':');
4366 if (strncmp (p
, "thread", p1
- p
) == 0)
4367 return read_ptid (++p1
, &p
);
4369 p1
= strchr (p
, ';');
4381 /* Determine the remote side's current thread. If we have a stop
4382 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4383 "thread" register we can extract the current thread from. If not,
4384 ask the remote which is the current thread with qC. The former
4385 method avoids a roundtrip. */
4388 remote_target::get_current_thread (const char *wait_status
)
4390 ptid_t ptid
= null_ptid
;
4392 /* Note we don't use remote_parse_stop_reply as that makes use of
4393 the target architecture, which we haven't yet fully determined at
4395 if (wait_status
!= NULL
)
4396 ptid
= stop_reply_extract_thread (wait_status
);
4397 if (ptid
== null_ptid
)
4398 ptid
= remote_current_thread (inferior_ptid
);
4403 /* Query the remote target for which is the current thread/process,
4404 add it to our tables, and update INFERIOR_PTID. The caller is
4405 responsible for setting the state such that the remote end is ready
4406 to return the current thread.
4408 This function is called after handling the '?' or 'vRun' packets,
4409 whose response is a stop reply from which we can also try
4410 extracting the thread. If the target doesn't support the explicit
4411 qC query, we infer the current thread from that stop reply, passed
4412 in in WAIT_STATUS, which may be NULL.
4414 The function returns pointer to the main thread of the inferior. */
4417 remote_target::add_current_inferior_and_thread (const char *wait_status
)
4419 struct remote_state
*rs
= get_remote_state ();
4420 bool fake_pid_p
= false;
4422 switch_to_no_thread ();
4424 /* Now, if we have thread information, update the current thread's
4426 ptid_t curr_ptid
= get_current_thread (wait_status
);
4428 if (curr_ptid
!= null_ptid
)
4430 if (!remote_multi_process_p (rs
))
4435 /* Without this, some commands which require an active target
4436 (such as kill) won't work. This variable serves (at least)
4437 double duty as both the pid of the target process (if it has
4438 such), and as a flag indicating that a target is active. */
4439 curr_ptid
= magic_null_ptid
;
4443 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4445 /* Add the main thread and switch to it. Don't try reading
4446 registers yet, since we haven't fetched the target description
4448 thread_info
*tp
= add_thread_silent (this, curr_ptid
);
4449 switch_to_thread_no_regs (tp
);
4454 /* Print info about a thread that was found already stopped on
4458 print_one_stopped_thread (struct thread_info
*thread
)
4460 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4462 switch_to_thread (thread
);
4463 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4464 set_current_sal_from_frame (get_current_frame ());
4466 thread
->suspend
.waitstatus_pending_p
= 0;
4468 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4470 enum gdb_signal sig
= ws
->value
.sig
;
4472 if (signal_print_state (sig
))
4473 gdb::observers::signal_received
.notify (sig
);
4475 gdb::observers::normal_stop
.notify (NULL
, 1);
4478 /* Process all initial stop replies the remote side sent in response
4479 to the ? packet. These indicate threads that were already stopped
4480 on initial connection. We mark these threads as stopped and print
4481 their current frame before giving the user the prompt. */
4484 remote_target::process_initial_stop_replies (int from_tty
)
4486 int pending_stop_replies
= stop_reply_queue_length ();
4487 struct thread_info
*selected
= NULL
;
4488 struct thread_info
*lowest_stopped
= NULL
;
4489 struct thread_info
*first
= NULL
;
4491 /* Consume the initial pending events. */
4492 while (pending_stop_replies
-- > 0)
4494 ptid_t waiton_ptid
= minus_one_ptid
;
4496 struct target_waitstatus ws
;
4497 int ignore_event
= 0;
4499 memset (&ws
, 0, sizeof (ws
));
4500 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4502 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4506 case TARGET_WAITKIND_IGNORE
:
4507 case TARGET_WAITKIND_NO_RESUMED
:
4508 case TARGET_WAITKIND_SIGNALLED
:
4509 case TARGET_WAITKIND_EXITED
:
4510 /* We shouldn't see these, but if we do, just ignore. */
4511 remote_debug_printf ("event ignored");
4515 case TARGET_WAITKIND_EXECD
:
4516 xfree (ws
.value
.execd_pathname
);
4525 thread_info
*evthread
= find_thread_ptid (this, event_ptid
);
4527 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4529 enum gdb_signal sig
= ws
.value
.sig
;
4531 /* Stubs traditionally report SIGTRAP as initial signal,
4532 instead of signal 0. Suppress it. */
4533 if (sig
== GDB_SIGNAL_TRAP
)
4535 evthread
->suspend
.stop_signal
= sig
;
4539 evthread
->suspend
.waitstatus
= ws
;
4541 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4542 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4543 evthread
->suspend
.waitstatus_pending_p
= 1;
4545 set_executing (this, event_ptid
, false);
4546 set_running (this, event_ptid
, false);
4547 get_remote_thread_info (evthread
)->set_not_resumed ();
4550 /* "Notice" the new inferiors before anything related to
4551 registers/memory. */
4552 for (inferior
*inf
: all_non_exited_inferiors (this))
4554 inf
->needs_setup
= 1;
4558 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4559 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4564 /* If all-stop on top of non-stop, pause all threads. Note this
4565 records the threads' stop pc, so must be done after "noticing"
4569 stop_all_threads ();
4571 /* If all threads of an inferior were already stopped, we
4572 haven't setup the inferior yet. */
4573 for (inferior
*inf
: all_non_exited_inferiors (this))
4575 if (inf
->needs_setup
)
4577 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4578 switch_to_thread_no_regs (thread
);
4584 /* Now go over all threads that are stopped, and print their current
4585 frame. If all-stop, then if there's a signalled thread, pick
4587 for (thread_info
*thread
: all_non_exited_threads (this))
4593 thread
->set_running (false);
4594 else if (thread
->state
!= THREAD_STOPPED
)
4597 if (selected
== NULL
4598 && thread
->suspend
.waitstatus_pending_p
)
4601 if (lowest_stopped
== NULL
4602 || thread
->inf
->num
< lowest_stopped
->inf
->num
4603 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4604 lowest_stopped
= thread
;
4607 print_one_stopped_thread (thread
);
4610 /* In all-stop, we only print the status of one thread, and leave
4611 others with their status pending. */
4614 thread_info
*thread
= selected
;
4616 thread
= lowest_stopped
;
4620 print_one_stopped_thread (thread
);
4623 /* For "info program". */
4624 thread_info
*thread
= inferior_thread ();
4625 if (thread
->state
== THREAD_STOPPED
)
4626 set_last_target_status (this, inferior_ptid
, thread
->suspend
.waitstatus
);
4629 /* Start the remote connection and sync state. */
4632 remote_target::start_remote (int from_tty
, int extended_p
)
4634 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
4636 struct remote_state
*rs
= get_remote_state ();
4637 struct packet_config
*noack_config
;
4639 /* Signal other parts that we're going through the initial setup,
4640 and so things may not be stable yet. E.g., we don't try to
4641 install tracepoints until we've relocated symbols. Also, a
4642 Ctrl-C before we're connected and synced up can't interrupt the
4643 target. Instead, it offers to drop the (potentially wedged)
4645 rs
->starting_up
= 1;
4649 if (interrupt_on_connect
)
4650 send_interrupt_sequence ();
4652 /* Ack any packet which the remote side has already sent. */
4653 remote_serial_write ("+", 1);
4655 /* The first packet we send to the target is the optional "supported
4656 packets" request. If the target can answer this, it will tell us
4657 which later probes to skip. */
4658 remote_query_supported ();
4660 /* If the stub wants to get a QAllow, compose one and send it. */
4661 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4664 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4665 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4666 as a reply to known packet. For packet "vFile:setfs:" it is an
4667 invalid reply and GDB would return error in
4668 remote_hostio_set_filesystem, making remote files access impossible.
4669 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4670 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4672 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4674 putpkt (v_mustreplyempty
);
4675 getpkt (&rs
->buf
, 0);
4676 if (strcmp (rs
->buf
.data (), "OK") == 0)
4677 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4678 else if (strcmp (rs
->buf
.data (), "") != 0)
4679 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4683 /* Next, we possibly activate noack mode.
4685 If the QStartNoAckMode packet configuration is set to AUTO,
4686 enable noack mode if the stub reported a wish for it with
4689 If set to TRUE, then enable noack mode even if the stub didn't
4690 report it in qSupported. If the stub doesn't reply OK, the
4691 session ends with an error.
4693 If FALSE, then don't activate noack mode, regardless of what the
4694 stub claimed should be the default with qSupported. */
4696 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4697 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4699 putpkt ("QStartNoAckMode");
4700 getpkt (&rs
->buf
, 0);
4701 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4707 /* Tell the remote that we are using the extended protocol. */
4709 getpkt (&rs
->buf
, 0);
4712 /* Let the target know which signals it is allowed to pass down to
4714 update_signals_program_target ();
4716 /* Next, if the target can specify a description, read it. We do
4717 this before anything involving memory or registers. */
4718 target_find_description ();
4720 /* Next, now that we know something about the target, update the
4721 address spaces in the program spaces. */
4722 update_address_spaces ();
4724 /* On OSs where the list of libraries is global to all
4725 processes, we fetch them early. */
4726 if (gdbarch_has_global_solist (target_gdbarch ()))
4727 solib_add (NULL
, from_tty
, auto_solib_add
);
4729 if (target_is_non_stop_p ())
4731 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4732 error (_("Non-stop mode requested, but remote "
4733 "does not support non-stop"));
4735 putpkt ("QNonStop:1");
4736 getpkt (&rs
->buf
, 0);
4738 if (strcmp (rs
->buf
.data (), "OK") != 0)
4739 error (_("Remote refused setting non-stop mode with: %s"),
4742 /* Find about threads and processes the stub is already
4743 controlling. We default to adding them in the running state.
4744 The '?' query below will then tell us about which threads are
4746 this->update_thread_list ();
4748 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4750 /* Don't assume that the stub can operate in all-stop mode.
4751 Request it explicitly. */
4752 putpkt ("QNonStop:0");
4753 getpkt (&rs
->buf
, 0);
4755 if (strcmp (rs
->buf
.data (), "OK") != 0)
4756 error (_("Remote refused setting all-stop mode with: %s"),
4760 /* Upload TSVs regardless of whether the target is running or not. The
4761 remote stub, such as GDBserver, may have some predefined or builtin
4762 TSVs, even if the target is not running. */
4763 if (get_trace_status (current_trace_status ()) != -1)
4765 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4767 upload_trace_state_variables (&uploaded_tsvs
);
4768 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4771 /* Check whether the target is running now. */
4773 getpkt (&rs
->buf
, 0);
4775 if (!target_is_non_stop_p ())
4777 char *wait_status
= NULL
;
4779 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4782 error (_("The target is not running (try extended-remote?)"));
4784 /* We're connected, but not running. Drop out before we
4785 call start_remote. */
4786 rs
->starting_up
= 0;
4791 /* Save the reply for later. */
4792 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4793 strcpy (wait_status
, rs
->buf
.data ());
4796 /* Fetch thread list. */
4797 target_update_thread_list ();
4799 /* Let the stub know that we want it to return the thread. */
4800 set_continue_thread (minus_one_ptid
);
4802 if (thread_count (this) == 0)
4804 /* Target has no concept of threads at all. GDB treats
4805 non-threaded target as single-threaded; add a main
4807 thread_info
*tp
= add_current_inferior_and_thread (wait_status
);
4808 get_remote_thread_info (tp
)->set_resumed ();
4812 /* We have thread information; select the thread the target
4813 says should be current. If we're reconnecting to a
4814 multi-threaded program, this will ideally be the thread
4815 that last reported an event before GDB disconnected. */
4816 ptid_t curr_thread
= get_current_thread (wait_status
);
4817 if (curr_thread
== null_ptid
)
4819 /* Odd... The target was able to list threads, but not
4820 tell us which thread was current (no "thread"
4821 register in T stop reply?). Just pick the first
4822 thread in the thread list then. */
4824 remote_debug_printf ("warning: couldn't determine remote "
4825 "current thread; picking first in list.");
4827 for (thread_info
*tp
: all_non_exited_threads (this,
4830 switch_to_thread (tp
);
4835 switch_to_thread (find_thread_ptid (this, curr_thread
));
4838 /* init_wait_for_inferior should be called before get_offsets in order
4839 to manage `inserted' flag in bp loc in a correct state.
4840 breakpoint_init_inferior, called from init_wait_for_inferior, set
4841 `inserted' flag to 0, while before breakpoint_re_set, called from
4842 start_remote, set `inserted' flag to 1. In the initialization of
4843 inferior, breakpoint_init_inferior should be called first, and then
4844 breakpoint_re_set can be called. If this order is broken, state of
4845 `inserted' flag is wrong, and cause some problems on breakpoint
4847 init_wait_for_inferior ();
4849 get_offsets (); /* Get text, data & bss offsets. */
4851 /* If we could not find a description using qXfer, and we know
4852 how to do it some other way, try again. This is not
4853 supported for non-stop; it could be, but it is tricky if
4854 there are no stopped threads when we connect. */
4855 if (remote_read_description_p (this)
4856 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4858 target_clear_description ();
4859 target_find_description ();
4862 /* Use the previously fetched status. */
4863 gdb_assert (wait_status
!= NULL
);
4864 strcpy (rs
->buf
.data (), wait_status
);
4865 rs
->cached_wait_status
= 1;
4867 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4871 /* Clear WFI global state. Do this before finding about new
4872 threads and inferiors, and setting the current inferior.
4873 Otherwise we would clear the proceed status of the current
4874 inferior when we want its stop_soon state to be preserved
4875 (see notice_new_inferior). */
4876 init_wait_for_inferior ();
4878 /* In non-stop, we will either get an "OK", meaning that there
4879 are no stopped threads at this time; or, a regular stop
4880 reply. In the latter case, there may be more than one thread
4881 stopped --- we pull them all out using the vStopped
4883 if (strcmp (rs
->buf
.data (), "OK") != 0)
4885 struct notif_client
*notif
= ¬if_client_stop
;
4887 /* remote_notif_get_pending_replies acks this one, and gets
4889 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4890 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4891 remote_notif_get_pending_events (notif
);
4894 if (thread_count (this) == 0)
4897 error (_("The target is not running (try extended-remote?)"));
4899 /* We're connected, but not running. Drop out before we
4900 call start_remote. */
4901 rs
->starting_up
= 0;
4905 /* Report all signals during attach/startup. */
4908 /* If there are already stopped threads, mark them stopped and
4909 report their stops before giving the prompt to the user. */
4910 process_initial_stop_replies (from_tty
);
4912 if (target_can_async_p ())
4916 /* If we connected to a live target, do some additional setup. */
4917 if (target_has_execution ())
4919 /* No use without a symbol-file. */
4920 if (current_program_space
->symfile_object_file
)
4921 remote_check_symbols ();
4924 /* Possibly the target has been engaged in a trace run started
4925 previously; find out where things are at. */
4926 if (get_trace_status (current_trace_status ()) != -1)
4928 struct uploaded_tp
*uploaded_tps
= NULL
;
4930 if (current_trace_status ()->running
)
4931 printf_filtered (_("Trace is already running on the target.\n"));
4933 upload_tracepoints (&uploaded_tps
);
4935 merge_uploaded_tracepoints (&uploaded_tps
);
4938 /* Possibly the target has been engaged in a btrace record started
4939 previously; find out where things are at. */
4940 remote_btrace_maybe_reopen ();
4942 /* The thread and inferior lists are now synchronized with the
4943 target, our symbols have been relocated, and we're merged the
4944 target's tracepoints with ours. We're done with basic start
4946 rs
->starting_up
= 0;
4948 /* Maybe breakpoints are global and need to be inserted now. */
4949 if (breakpoints_should_be_inserted_now ())
4950 insert_breakpoints ();
4954 remote_target::connection_string ()
4956 remote_state
*rs
= get_remote_state ();
4958 if (rs
->remote_desc
->name
!= NULL
)
4959 return rs
->remote_desc
->name
;
4964 /* Open a connection to a remote debugger.
4965 NAME is the filename used for communication. */
4968 remote_target::open (const char *name
, int from_tty
)
4970 open_1 (name
, from_tty
, 0);
4973 /* Open a connection to a remote debugger using the extended
4974 remote gdb protocol. NAME is the filename used for communication. */
4977 extended_remote_target::open (const char *name
, int from_tty
)
4979 open_1 (name
, from_tty
, 1 /*extended_p */);
4982 /* Reset all packets back to "unknown support". Called when opening a
4983 new connection to a remote target. */
4986 reset_all_packet_configs_support (void)
4990 for (i
= 0; i
< PACKET_MAX
; i
++)
4991 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4994 /* Initialize all packet configs. */
4997 init_all_packet_configs (void)
5001 for (i
= 0; i
< PACKET_MAX
; i
++)
5003 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
5004 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
5008 /* Symbol look-up. */
5011 remote_target::remote_check_symbols ()
5016 /* The remote side has no concept of inferiors that aren't running
5017 yet, it only knows about running processes. If we're connected
5018 but our current inferior is not running, we should not invite the
5019 remote target to request symbol lookups related to its
5020 (unrelated) current process. */
5021 if (!target_has_execution ())
5024 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
5027 /* Make sure the remote is pointing at the right process. Note
5028 there's no way to select "no process". */
5029 set_general_process ();
5031 /* Allocate a message buffer. We can't reuse the input buffer in RS,
5032 because we need both at the same time. */
5033 gdb::char_vector
msg (get_remote_packet_size ());
5034 gdb::char_vector
reply (get_remote_packet_size ());
5036 /* Invite target to request symbol lookups. */
5038 putpkt ("qSymbol::");
5040 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
5042 while (startswith (reply
.data (), "qSymbol:"))
5044 struct bound_minimal_symbol sym
;
5047 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
5050 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
5051 if (sym
.minsym
== NULL
)
5052 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
5056 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
5057 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
5059 /* If this is a function address, return the start of code
5060 instead of any data function descriptor. */
5061 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
5063 current_top_target ());
5065 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
5066 phex_nz (sym_addr
, addr_size
), &reply
[8]);
5069 putpkt (msg
.data ());
5074 static struct serial
*
5075 remote_serial_open (const char *name
)
5077 static int udp_warning
= 0;
5079 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
5080 of in ser-tcp.c, because it is the remote protocol assuming that the
5081 serial connection is reliable and not the serial connection promising
5083 if (!udp_warning
&& startswith (name
, "udp:"))
5085 warning (_("The remote protocol may be unreliable over UDP.\n"
5086 "Some events may be lost, rendering further debugging "
5091 return serial_open (name
);
5094 /* Inform the target of our permission settings. The permission flags
5095 work without this, but if the target knows the settings, it can do
5096 a couple things. First, it can add its own check, to catch cases
5097 that somehow manage to get by the permissions checks in target
5098 methods. Second, if the target is wired to disallow particular
5099 settings (for instance, a system in the field that is not set up to
5100 be able to stop at a breakpoint), it can object to any unavailable
5104 remote_target::set_permissions ()
5106 struct remote_state
*rs
= get_remote_state ();
5108 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
5109 "WriteReg:%x;WriteMem:%x;"
5110 "InsertBreak:%x;InsertTrace:%x;"
5111 "InsertFastTrace:%x;Stop:%x",
5112 may_write_registers
, may_write_memory
,
5113 may_insert_breakpoints
, may_insert_tracepoints
,
5114 may_insert_fast_tracepoints
, may_stop
);
5116 getpkt (&rs
->buf
, 0);
5118 /* If the target didn't like the packet, warn the user. Do not try
5119 to undo the user's settings, that would just be maddening. */
5120 if (strcmp (rs
->buf
.data (), "OK") != 0)
5121 warning (_("Remote refused setting permissions with: %s"),
5125 /* This type describes each known response to the qSupported
5127 struct protocol_feature
5129 /* The name of this protocol feature. */
5132 /* The default for this protocol feature. */
5133 enum packet_support default_support
;
5135 /* The function to call when this feature is reported, or after
5136 qSupported processing if the feature is not supported.
5137 The first argument points to this structure. The second
5138 argument indicates whether the packet requested support be
5139 enabled, disabled, or probed (or the default, if this function
5140 is being called at the end of processing and this feature was
5141 not reported). The third argument may be NULL; if not NULL, it
5142 is a NUL-terminated string taken from the packet following
5143 this feature's name and an equals sign. */
5144 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5145 enum packet_support
, const char *);
5147 /* The corresponding packet for this feature. Only used if
5148 FUNC is remote_supported_packet. */
5153 remote_supported_packet (remote_target
*remote
,
5154 const struct protocol_feature
*feature
,
5155 enum packet_support support
,
5156 const char *argument
)
5160 warning (_("Remote qSupported response supplied an unexpected value for"
5161 " \"%s\"."), feature
->name
);
5165 remote_protocol_packets
[feature
->packet
].support
= support
;
5169 remote_target::remote_packet_size (const protocol_feature
*feature
,
5170 enum packet_support support
, const char *value
)
5172 struct remote_state
*rs
= get_remote_state ();
5177 if (support
!= PACKET_ENABLE
)
5180 if (value
== NULL
|| *value
== '\0')
5182 warning (_("Remote target reported \"%s\" without a size."),
5188 packet_size
= strtol (value
, &value_end
, 16);
5189 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5191 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5192 feature
->name
, value
);
5196 /* Record the new maximum packet size. */
5197 rs
->explicit_packet_size
= packet_size
;
5201 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5202 enum packet_support support
, const char *value
)
5204 remote
->remote_packet_size (feature
, support
, value
);
5207 static const struct protocol_feature remote_protocol_features
[] = {
5208 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5209 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5210 PACKET_qXfer_auxv
},
5211 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5212 PACKET_qXfer_exec_file
},
5213 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5214 PACKET_qXfer_features
},
5215 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5216 PACKET_qXfer_libraries
},
5217 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5218 PACKET_qXfer_libraries_svr4
},
5219 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5220 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5221 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5222 PACKET_qXfer_memory_map
},
5223 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5224 PACKET_qXfer_osdata
},
5225 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5226 PACKET_qXfer_threads
},
5227 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5228 PACKET_qXfer_traceframe_info
},
5229 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5230 PACKET_QPassSignals
},
5231 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5232 PACKET_QCatchSyscalls
},
5233 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5234 PACKET_QProgramSignals
},
5235 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5236 PACKET_QSetWorkingDir
},
5237 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5238 PACKET_QStartupWithShell
},
5239 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5240 PACKET_QEnvironmentHexEncoded
},
5241 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5242 PACKET_QEnvironmentReset
},
5243 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5244 PACKET_QEnvironmentUnset
},
5245 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5246 PACKET_QStartNoAckMode
},
5247 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5248 PACKET_multiprocess_feature
},
5249 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5250 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5251 PACKET_qXfer_siginfo_read
},
5252 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5253 PACKET_qXfer_siginfo_write
},
5254 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5255 PACKET_ConditionalTracepoints
},
5256 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5257 PACKET_ConditionalBreakpoints
},
5258 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5259 PACKET_BreakpointCommands
},
5260 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5261 PACKET_FastTracepoints
},
5262 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5263 PACKET_StaticTracepoints
},
5264 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5265 PACKET_InstallInTrace
},
5266 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5267 PACKET_DisconnectedTracing_feature
},
5268 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5270 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5272 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5273 PACKET_TracepointSource
},
5274 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5276 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5277 PACKET_EnableDisableTracepoints_feature
},
5278 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5279 PACKET_qXfer_fdpic
},
5280 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5282 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5283 PACKET_QDisableRandomization
},
5284 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5285 { "QTBuffer:size", PACKET_DISABLE
,
5286 remote_supported_packet
, PACKET_QTBuffer_size
},
5287 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5288 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5289 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5290 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5291 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5292 PACKET_qXfer_btrace
},
5293 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5294 PACKET_qXfer_btrace_conf
},
5295 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5296 PACKET_Qbtrace_conf_bts_size
},
5297 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5298 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5299 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5300 PACKET_fork_event_feature
},
5301 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5302 PACKET_vfork_event_feature
},
5303 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5304 PACKET_exec_event_feature
},
5305 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5306 PACKET_Qbtrace_conf_pt_size
},
5307 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5308 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5309 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5312 static char *remote_support_xml
;
5314 /* Register string appended to "xmlRegisters=" in qSupported query. */
5317 register_remote_support_xml (const char *xml
)
5319 #if defined(HAVE_LIBEXPAT)
5320 if (remote_support_xml
== NULL
)
5321 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5324 char *copy
= xstrdup (remote_support_xml
+ 13);
5326 char *p
= strtok_r (copy
, ",", &saveptr
);
5330 if (strcmp (p
, xml
) == 0)
5337 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5340 remote_support_xml
= reconcat (remote_support_xml
,
5341 remote_support_xml
, ",", xml
,
5348 remote_query_supported_append (std::string
*msg
, const char *append
)
5352 msg
->append (append
);
5356 remote_target::remote_query_supported ()
5358 struct remote_state
*rs
= get_remote_state ();
5361 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5363 /* The packet support flags are handled differently for this packet
5364 than for most others. We treat an error, a disabled packet, and
5365 an empty response identically: any features which must be reported
5366 to be used will be automatically disabled. An empty buffer
5367 accomplishes this, since that is also the representation for a list
5368 containing no features. */
5371 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5375 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5376 remote_query_supported_append (&q
, "multiprocess+");
5378 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5379 remote_query_supported_append (&q
, "swbreak+");
5380 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5381 remote_query_supported_append (&q
, "hwbreak+");
5383 remote_query_supported_append (&q
, "qRelocInsn+");
5385 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5386 != AUTO_BOOLEAN_FALSE
)
5387 remote_query_supported_append (&q
, "fork-events+");
5388 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5389 != AUTO_BOOLEAN_FALSE
)
5390 remote_query_supported_append (&q
, "vfork-events+");
5391 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5392 != AUTO_BOOLEAN_FALSE
)
5393 remote_query_supported_append (&q
, "exec-events+");
5395 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5396 remote_query_supported_append (&q
, "vContSupported+");
5398 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5399 remote_query_supported_append (&q
, "QThreadEvents+");
5401 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5402 remote_query_supported_append (&q
, "no-resumed+");
5404 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5405 the qSupported:xmlRegisters=i386 handling. */
5406 if (remote_support_xml
!= NULL
5407 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5408 remote_query_supported_append (&q
, remote_support_xml
);
5410 q
= "qSupported:" + q
;
5411 putpkt (q
.c_str ());
5413 getpkt (&rs
->buf
, 0);
5415 /* If an error occured, warn, but do not return - just reset the
5416 buffer to empty and go on to disable features. */
5417 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5420 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5425 memset (seen
, 0, sizeof (seen
));
5427 next
= rs
->buf
.data ();
5430 enum packet_support is_supported
;
5431 char *p
, *end
, *name_end
, *value
;
5433 /* First separate out this item from the rest of the packet. If
5434 there's another item after this, we overwrite the separator
5435 (terminated strings are much easier to work with). */
5437 end
= strchr (p
, ';');
5440 end
= p
+ strlen (p
);
5450 warning (_("empty item in \"qSupported\" response"));
5455 name_end
= strchr (p
, '=');
5458 /* This is a name=value entry. */
5459 is_supported
= PACKET_ENABLE
;
5460 value
= name_end
+ 1;
5469 is_supported
= PACKET_ENABLE
;
5473 is_supported
= PACKET_DISABLE
;
5477 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5481 warning (_("unrecognized item \"%s\" "
5482 "in \"qSupported\" response"), p
);
5488 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5489 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5491 const struct protocol_feature
*feature
;
5494 feature
= &remote_protocol_features
[i
];
5495 feature
->func (this, feature
, is_supported
, value
);
5500 /* If we increased the packet size, make sure to increase the global
5501 buffer size also. We delay this until after parsing the entire
5502 qSupported packet, because this is the same buffer we were
5504 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5505 rs
->buf
.resize (rs
->explicit_packet_size
);
5507 /* Handle the defaults for unmentioned features. */
5508 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5511 const struct protocol_feature
*feature
;
5513 feature
= &remote_protocol_features
[i
];
5514 feature
->func (this, feature
, feature
->default_support
, NULL
);
5518 /* Serial QUIT handler for the remote serial descriptor.
5520 Defers handling a Ctrl-C until we're done with the current
5521 command/response packet sequence, unless:
5523 - We're setting up the connection. Don't send a remote interrupt
5524 request, as we're not fully synced yet. Quit immediately
5527 - The target has been resumed in the foreground
5528 (target_terminal::is_ours is false) with a synchronous resume
5529 packet, and we're blocked waiting for the stop reply, thus a
5530 Ctrl-C should be immediately sent to the target.
5532 - We get a second Ctrl-C while still within the same serial read or
5533 write. In that case the serial is seemingly wedged --- offer to
5536 - We see a second Ctrl-C without target response, after having
5537 previously interrupted the target. In that case the target/stub
5538 is probably wedged --- offer to quit/disconnect.
5542 remote_target::remote_serial_quit_handler ()
5544 struct remote_state
*rs
= get_remote_state ();
5546 if (check_quit_flag ())
5548 /* If we're starting up, we're not fully synced yet. Quit
5550 if (rs
->starting_up
)
5552 else if (rs
->got_ctrlc_during_io
)
5554 if (query (_("The target is not responding to GDB commands.\n"
5555 "Stop debugging it? ")))
5556 remote_unpush_and_throw (this);
5558 /* If ^C has already been sent once, offer to disconnect. */
5559 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5561 /* All-stop protocol, and blocked waiting for stop reply. Send
5562 an interrupt request. */
5563 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5564 target_interrupt ();
5566 rs
->got_ctrlc_during_io
= 1;
5570 /* The remote_target that is current while the quit handler is
5571 overridden with remote_serial_quit_handler. */
5572 static remote_target
*curr_quit_handler_target
;
5575 remote_serial_quit_handler ()
5577 curr_quit_handler_target
->remote_serial_quit_handler ();
5580 /* Remove the remote target from the target stack of each inferior
5581 that is using it. Upper targets depend on it so remove them
5585 remote_unpush_target (remote_target
*target
)
5587 /* We have to unpush the target from all inferiors, even those that
5589 scoped_restore_current_inferior restore_current_inferior
;
5591 for (inferior
*inf
: all_inferiors (target
))
5593 switch_to_inferior_no_thread (inf
);
5594 pop_all_targets_at_and_above (process_stratum
);
5595 generic_mourn_inferior ();
5600 remote_unpush_and_throw (remote_target
*target
)
5602 remote_unpush_target (target
);
5603 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5607 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5609 remote_target
*curr_remote
= get_current_remote_target ();
5612 error (_("To open a remote debug connection, you need to specify what\n"
5613 "serial device is attached to the remote system\n"
5614 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5616 /* If we're connected to a running target, target_preopen will kill it.
5617 Ask this question first, before target_preopen has a chance to kill
5619 if (curr_remote
!= NULL
&& !target_has_execution ())
5622 && !query (_("Already connected to a remote target. Disconnect? ")))
5623 error (_("Still connected."));
5626 /* Here the possibly existing remote target gets unpushed. */
5627 target_preopen (from_tty
);
5629 remote_fileio_reset ();
5630 reopen_exec_file ();
5633 remote_target
*remote
5634 = (extended_p
? new extended_remote_target () : new remote_target ());
5635 target_ops_up
target_holder (remote
);
5637 remote_state
*rs
= remote
->get_remote_state ();
5639 /* See FIXME above. */
5640 if (!target_async_permitted
)
5641 rs
->wait_forever_enabled_p
= 1;
5643 rs
->remote_desc
= remote_serial_open (name
);
5644 if (!rs
->remote_desc
)
5645 perror_with_name (name
);
5647 if (baud_rate
!= -1)
5649 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5651 /* The requested speed could not be set. Error out to
5652 top level after closing remote_desc. Take care to
5653 set remote_desc to NULL to avoid closing remote_desc
5655 serial_close (rs
->remote_desc
);
5656 rs
->remote_desc
= NULL
;
5657 perror_with_name (name
);
5661 serial_setparity (rs
->remote_desc
, serial_parity
);
5662 serial_raw (rs
->remote_desc
);
5664 /* If there is something sitting in the buffer we might take it as a
5665 response to a command, which would be bad. */
5666 serial_flush_input (rs
->remote_desc
);
5670 puts_filtered ("Remote debugging using ");
5671 puts_filtered (name
);
5672 puts_filtered ("\n");
5675 /* Switch to using the remote target now. */
5676 push_target (std::move (target_holder
));
5678 /* Register extra event sources in the event loop. */
5679 rs
->remote_async_inferior_event_token
5680 = create_async_event_handler (remote_async_inferior_event_handler
, nullptr,
5682 rs
->notif_state
= remote_notif_state_allocate (remote
);
5684 /* Reset the target state; these things will be queried either by
5685 remote_query_supported or as they are needed. */
5686 reset_all_packet_configs_support ();
5687 rs
->cached_wait_status
= 0;
5688 rs
->explicit_packet_size
= 0;
5690 rs
->extended
= extended_p
;
5691 rs
->waiting_for_stop_reply
= 0;
5692 rs
->ctrlc_pending_p
= 0;
5693 rs
->got_ctrlc_during_io
= 0;
5695 rs
->general_thread
= not_sent_ptid
;
5696 rs
->continue_thread
= not_sent_ptid
;
5697 rs
->remote_traceframe_number
= -1;
5699 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5701 /* Probe for ability to use "ThreadInfo" query, as required. */
5702 rs
->use_threadinfo_query
= 1;
5703 rs
->use_threadextra_query
= 1;
5705 rs
->readahead_cache
.invalidate ();
5707 if (target_async_permitted
)
5709 /* FIXME: cagney/1999-09-23: During the initial connection it is
5710 assumed that the target is already ready and able to respond to
5711 requests. Unfortunately remote_start_remote() eventually calls
5712 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5713 around this. Eventually a mechanism that allows
5714 wait_for_inferior() to expect/get timeouts will be
5716 rs
->wait_forever_enabled_p
= 0;
5719 /* First delete any symbols previously loaded from shared libraries. */
5720 no_shared_libraries (NULL
, 0);
5722 /* Start the remote connection. If error() or QUIT, discard this
5723 target (we'd otherwise be in an inconsistent state) and then
5724 propogate the error on up the exception chain. This ensures that
5725 the caller doesn't stumble along blindly assuming that the
5726 function succeeded. The CLI doesn't have this problem but other
5727 UI's, such as MI do.
5729 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5730 this function should return an error indication letting the
5731 caller restore the previous state. Unfortunately the command
5732 ``target remote'' is directly wired to this function making that
5733 impossible. On a positive note, the CLI side of this problem has
5734 been fixed - the function set_cmd_context() makes it possible for
5735 all the ``target ....'' commands to share a common callback
5736 function. See cli-dump.c. */
5741 remote
->start_remote (from_tty
, extended_p
);
5743 catch (const gdb_exception
&ex
)
5745 /* Pop the partially set up target - unless something else did
5746 already before throwing the exception. */
5747 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5748 remote_unpush_target (remote
);
5753 remote_btrace_reset (rs
);
5755 if (target_async_permitted
)
5756 rs
->wait_forever_enabled_p
= 1;
5759 /* Detach the specified process. */
5762 remote_target::remote_detach_pid (int pid
)
5764 struct remote_state
*rs
= get_remote_state ();
5766 /* This should not be necessary, but the handling for D;PID in
5767 GDBserver versions prior to 8.2 incorrectly assumes that the
5768 selected process points to the same process we're detaching,
5769 leading to misbehavior (and possibly GDBserver crashing) when it
5770 does not. Since it's easy and cheap, work around it by forcing
5771 GDBserver to select GDB's current process. */
5772 set_general_process ();
5774 if (remote_multi_process_p (rs
))
5775 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5777 strcpy (rs
->buf
.data (), "D");
5780 getpkt (&rs
->buf
, 0);
5782 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5784 else if (rs
->buf
[0] == '\0')
5785 error (_("Remote doesn't know how to detach"));
5787 error (_("Can't detach process."));
5790 /* This detaches a program to which we previously attached, using
5791 inferior_ptid to identify the process. After this is done, GDB
5792 can be used to debug some other program. We better not have left
5793 any breakpoints in the target program or it'll die when it hits
5797 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5799 int pid
= inferior_ptid
.pid ();
5800 struct remote_state
*rs
= get_remote_state ();
5803 if (!target_has_execution ())
5804 error (_("No process to detach from."));
5806 target_announce_detach (from_tty
);
5808 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
5810 /* If we're in breakpoints-always-inserted mode, or the inferior
5811 is running, we have to remove breakpoints before detaching.
5812 We don't do this in common code instead because not all
5813 targets support removing breakpoints while the target is
5814 running. The remote target / gdbserver does, though. */
5815 remove_breakpoints_inf (current_inferior ());
5818 /* Tell the remote target to detach. */
5819 remote_detach_pid (pid
);
5821 /* Exit only if this is the only active inferior. */
5822 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors (this) == 1)
5823 puts_filtered (_("Ending remote debugging.\n"));
5825 thread_info
*tp
= find_thread_ptid (this, inferior_ptid
);
5827 /* Check to see if we are detaching a fork parent. Note that if we
5828 are detaching a fork child, tp == NULL. */
5829 is_fork_parent
= (tp
!= NULL
5830 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5832 /* If doing detach-on-fork, we don't mourn, because that will delete
5833 breakpoints that should be available for the followed inferior. */
5834 if (!is_fork_parent
)
5836 /* Save the pid as a string before mourning, since that will
5837 unpush the remote target, and we need the string after. */
5838 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5840 target_mourn_inferior (inferior_ptid
);
5841 if (print_inferior_events
)
5842 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5843 inf
->num
, infpid
.c_str ());
5847 switch_to_no_thread ();
5848 detach_inferior (current_inferior ());
5853 remote_target::detach (inferior
*inf
, int from_tty
)
5855 remote_detach_1 (inf
, from_tty
);
5859 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5861 remote_detach_1 (inf
, from_tty
);
5864 /* Target follow-fork function for remote targets. On entry, and
5865 at return, the current inferior is the fork parent.
5867 Note that although this is currently only used for extended-remote,
5868 it is named remote_follow_fork in anticipation of using it for the
5869 remote target as well. */
5872 remote_target::follow_fork (bool follow_child
, bool detach_fork
)
5874 struct remote_state
*rs
= get_remote_state ();
5875 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5877 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5878 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5880 /* When following the parent and detaching the child, we detach
5881 the child here. For the case of following the child and
5882 detaching the parent, the detach is done in the target-
5883 independent follow fork code in infrun.c. We can't use
5884 target_detach when detaching an unfollowed child because
5885 the client side doesn't know anything about the child. */
5886 if (detach_fork
&& !follow_child
)
5888 /* Detach the fork child. */
5892 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5893 child_pid
= child_ptid
.pid ();
5895 remote_detach_pid (child_pid
);
5902 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5903 in the program space of the new inferior. On entry and at return the
5904 current inferior is the exec'ing inferior. INF is the new exec'd
5905 inferior, which may be the same as the exec'ing inferior unless
5906 follow-exec-mode is "new". */
5909 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5911 /* We know that this is a target file name, so if it has the "target:"
5912 prefix we strip it off before saving it in the program space. */
5913 if (is_target_filename (execd_pathname
))
5914 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5916 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5919 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5922 remote_target::disconnect (const char *args
, int from_tty
)
5925 error (_("Argument given to \"disconnect\" when remotely debugging."));
5927 /* Make sure we unpush even the extended remote targets. Calling
5928 target_mourn_inferior won't unpush, and
5929 remote_target::mourn_inferior won't unpush if there is more than
5930 one inferior left. */
5931 remote_unpush_target (this);
5934 puts_filtered ("Ending remote debugging.\n");
5937 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5938 be chatty about it. */
5941 extended_remote_target::attach (const char *args
, int from_tty
)
5943 struct remote_state
*rs
= get_remote_state ();
5945 char *wait_status
= NULL
;
5947 pid
= parse_pid_to_attach (args
);
5949 /* Remote PID can be freely equal to getpid, do not check it here the same
5950 way as in other targets. */
5952 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5953 error (_("This target does not support attaching to a process"));
5957 const char *exec_file
= get_exec_file (0);
5960 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5961 target_pid_to_str (ptid_t (pid
)).c_str ());
5963 printf_unfiltered (_("Attaching to %s\n"),
5964 target_pid_to_str (ptid_t (pid
)).c_str ());
5967 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5969 getpkt (&rs
->buf
, 0);
5971 switch (packet_ok (rs
->buf
,
5972 &remote_protocol_packets
[PACKET_vAttach
]))
5975 if (!target_is_non_stop_p ())
5977 /* Save the reply for later. */
5978 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5979 strcpy (wait_status
, rs
->buf
.data ());
5981 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5982 error (_("Attaching to %s failed with: %s"),
5983 target_pid_to_str (ptid_t (pid
)).c_str (),
5986 case PACKET_UNKNOWN
:
5987 error (_("This target does not support attaching to a process"));
5989 error (_("Attaching to %s failed"),
5990 target_pid_to_str (ptid_t (pid
)).c_str ());
5993 switch_to_inferior_no_thread (remote_add_inferior (false, pid
, 1, 0));
5995 inferior_ptid
= ptid_t (pid
);
5997 if (target_is_non_stop_p ())
5999 /* Get list of threads. */
6000 update_thread_list ();
6002 thread_info
*thread
= first_thread_of_inferior (current_inferior ());
6003 if (thread
!= nullptr)
6004 switch_to_thread (thread
);
6006 /* Invalidate our notion of the remote current thread. */
6007 record_currthread (rs
, minus_one_ptid
);
6011 /* Now, if we have thread information, update the main thread's
6013 ptid_t curr_ptid
= remote_current_thread (ptid_t (pid
));
6015 /* Add the main thread to the thread list. */
6016 thread_info
*thr
= add_thread_silent (this, curr_ptid
);
6018 switch_to_thread (thr
);
6020 /* Don't consider the thread stopped until we've processed the
6021 saved stop reply. */
6022 set_executing (this, thr
->ptid
, true);
6025 /* Next, if the target can specify a description, read it. We do
6026 this before anything involving memory or registers. */
6027 target_find_description ();
6029 if (!target_is_non_stop_p ())
6031 /* Use the previously fetched status. */
6032 gdb_assert (wait_status
!= NULL
);
6034 if (target_can_async_p ())
6036 struct notif_event
*reply
6037 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
6039 push_stop_reply ((struct stop_reply
*) reply
);
6045 gdb_assert (wait_status
!= NULL
);
6046 strcpy (rs
->buf
.data (), wait_status
);
6047 rs
->cached_wait_status
= 1;
6052 gdb_assert (wait_status
== NULL
);
6054 gdb_assert (target_can_async_p ());
6059 /* Implementation of the to_post_attach method. */
6062 extended_remote_target::post_attach (int pid
)
6064 /* Get text, data & bss offsets. */
6067 /* In certain cases GDB might not have had the chance to start
6068 symbol lookup up until now. This could happen if the debugged
6069 binary is not using shared libraries, the vsyscall page is not
6070 present (on Linux) and the binary itself hadn't changed since the
6071 debugging process was started. */
6072 if (current_program_space
->symfile_object_file
!= NULL
)
6073 remote_check_symbols();
6077 /* Check for the availability of vCont. This function should also check
6081 remote_target::remote_vcont_probe ()
6083 remote_state
*rs
= get_remote_state ();
6086 strcpy (rs
->buf
.data (), "vCont?");
6088 getpkt (&rs
->buf
, 0);
6089 buf
= rs
->buf
.data ();
6091 /* Make sure that the features we assume are supported. */
6092 if (startswith (buf
, "vCont"))
6095 int support_c
, support_C
;
6097 rs
->supports_vCont
.s
= 0;
6098 rs
->supports_vCont
.S
= 0;
6101 rs
->supports_vCont
.t
= 0;
6102 rs
->supports_vCont
.r
= 0;
6103 while (p
&& *p
== ';')
6106 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6107 rs
->supports_vCont
.s
= 1;
6108 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6109 rs
->supports_vCont
.S
= 1;
6110 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6112 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6114 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6115 rs
->supports_vCont
.t
= 1;
6116 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6117 rs
->supports_vCont
.r
= 1;
6119 p
= strchr (p
, ';');
6122 /* If c, and C are not all supported, we can't use vCont. Clearing
6123 BUF will make packet_ok disable the packet. */
6124 if (!support_c
|| !support_C
)
6128 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
6129 rs
->supports_vCont_probed
= true;
6132 /* Helper function for building "vCont" resumptions. Write a
6133 resumption to P. ENDP points to one-passed-the-end of the buffer
6134 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
6135 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
6136 resumed thread should be single-stepped and/or signalled. If PTID
6137 equals minus_one_ptid, then all threads are resumed; if PTID
6138 represents a process, then all threads of the process are resumed;
6139 the thread to be stepped and/or signalled is given in the global
6143 remote_target::append_resumption (char *p
, char *endp
,
6144 ptid_t ptid
, int step
, gdb_signal siggnal
)
6146 struct remote_state
*rs
= get_remote_state ();
6148 if (step
&& siggnal
!= GDB_SIGNAL_0
)
6149 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
6151 /* GDB is willing to range step. */
6152 && use_range_stepping
6153 /* Target supports range stepping. */
6154 && rs
->supports_vCont
.r
6155 /* We don't currently support range stepping multiple
6156 threads with a wildcard (though the protocol allows it,
6157 so stubs shouldn't make an active effort to forbid
6159 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6161 struct thread_info
*tp
;
6163 if (ptid
== minus_one_ptid
)
6165 /* If we don't know about the target thread's tid, then
6166 we're resuming magic_null_ptid (see caller). */
6167 tp
= find_thread_ptid (this, magic_null_ptid
);
6170 tp
= find_thread_ptid (this, ptid
);
6171 gdb_assert (tp
!= NULL
);
6173 if (tp
->control
.may_range_step
)
6175 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6177 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6178 phex_nz (tp
->control
.step_range_start
,
6180 phex_nz (tp
->control
.step_range_end
,
6184 p
+= xsnprintf (p
, endp
- p
, ";s");
6187 p
+= xsnprintf (p
, endp
- p
, ";s");
6188 else if (siggnal
!= GDB_SIGNAL_0
)
6189 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6191 p
+= xsnprintf (p
, endp
- p
, ";c");
6193 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6197 /* All (-1) threads of process. */
6198 nptid
= ptid_t (ptid
.pid (), -1, 0);
6200 p
+= xsnprintf (p
, endp
- p
, ":");
6201 p
= write_ptid (p
, endp
, nptid
);
6203 else if (ptid
!= minus_one_ptid
)
6205 p
+= xsnprintf (p
, endp
- p
, ":");
6206 p
= write_ptid (p
, endp
, ptid
);
6212 /* Clear the thread's private info on resume. */
6215 resume_clear_thread_private_info (struct thread_info
*thread
)
6217 if (thread
->priv
!= NULL
)
6219 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6221 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6222 priv
->watch_data_address
= 0;
6226 /* Append a vCont continue-with-signal action for threads that have a
6227 non-zero stop signal. */
6230 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6233 for (thread_info
*thread
: all_non_exited_threads (this, ptid
))
6234 if (inferior_ptid
!= thread
->ptid
6235 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6237 p
= append_resumption (p
, endp
, thread
->ptid
,
6238 0, thread
->suspend
.stop_signal
);
6239 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6240 resume_clear_thread_private_info (thread
);
6246 /* Set the target running, using the packets that use Hc
6250 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6253 struct remote_state
*rs
= get_remote_state ();
6256 rs
->last_sent_signal
= siggnal
;
6257 rs
->last_sent_step
= step
;
6259 /* The c/s/C/S resume packets use Hc, so set the continue
6261 if (ptid
== minus_one_ptid
)
6262 set_continue_thread (any_thread_ptid
);
6264 set_continue_thread (ptid
);
6266 for (thread_info
*thread
: all_non_exited_threads (this))
6267 resume_clear_thread_private_info (thread
);
6269 buf
= rs
->buf
.data ();
6270 if (::execution_direction
== EXEC_REVERSE
)
6272 /* We don't pass signals to the target in reverse exec mode. */
6273 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6274 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6277 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6278 error (_("Remote reverse-step not supported."));
6279 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6280 error (_("Remote reverse-continue not supported."));
6282 strcpy (buf
, step
? "bs" : "bc");
6284 else if (siggnal
!= GDB_SIGNAL_0
)
6286 buf
[0] = step
? 'S' : 'C';
6287 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6288 buf
[2] = tohex (((int) siggnal
) & 0xf);
6292 strcpy (buf
, step
? "s" : "c");
6297 /* Resume the remote inferior by using a "vCont" packet. The thread
6298 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6299 resumed thread should be single-stepped and/or signalled. If PTID
6300 equals minus_one_ptid, then all threads are resumed; the thread to
6301 be stepped and/or signalled is given in the global INFERIOR_PTID.
6302 This function returns non-zero iff it resumes the inferior.
6304 This function issues a strict subset of all possible vCont commands
6308 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6309 enum gdb_signal siggnal
)
6311 struct remote_state
*rs
= get_remote_state ();
6315 /* No reverse execution actions defined for vCont. */
6316 if (::execution_direction
== EXEC_REVERSE
)
6319 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6320 remote_vcont_probe ();
6322 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6325 p
= rs
->buf
.data ();
6326 endp
= p
+ get_remote_packet_size ();
6328 /* If we could generate a wider range of packets, we'd have to worry
6329 about overflowing BUF. Should there be a generic
6330 "multi-part-packet" packet? */
6332 p
+= xsnprintf (p
, endp
- p
, "vCont");
6334 if (ptid
== magic_null_ptid
)
6336 /* MAGIC_NULL_PTID means that we don't have any active threads,
6337 so we don't have any TID numbers the inferior will
6338 understand. Make sure to only send forms that do not specify
6340 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6342 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6344 /* Resume all threads (of all processes, or of a single
6345 process), with preference for INFERIOR_PTID. This assumes
6346 inferior_ptid belongs to the set of all threads we are about
6348 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6350 /* Step inferior_ptid, with or without signal. */
6351 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6354 /* Also pass down any pending signaled resumption for other
6355 threads not the current. */
6356 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6358 /* And continue others without a signal. */
6359 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6363 /* Scheduler locking; resume only PTID. */
6364 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6367 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6370 if (target_is_non_stop_p ())
6372 /* In non-stop, the stub replies to vCont with "OK". The stop
6373 reply will be reported asynchronously by means of a `%Stop'
6375 getpkt (&rs
->buf
, 0);
6376 if (strcmp (rs
->buf
.data (), "OK") != 0)
6377 error (_("Unexpected vCont reply in non-stop mode: %s"),
6384 /* Tell the remote machine to resume. */
6387 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6389 struct remote_state
*rs
= get_remote_state ();
6391 /* When connected in non-stop mode, the core resumes threads
6392 individually. Resuming remote threads directly in target_resume
6393 would thus result in sending one packet per thread. Instead, to
6394 minimize roundtrip latency, here we just store the resume
6395 request (put the thread in RESUMED_PENDING_VCONT state); the actual remote
6396 resumption will be done in remote_target::commit_resume, where we'll be
6397 able to do vCont action coalescing. */
6398 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6400 remote_thread_info
*remote_thr
;
6402 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6403 remote_thr
= get_remote_thread_info (this, inferior_ptid
);
6405 remote_thr
= get_remote_thread_info (this, ptid
);
6407 /* We don't expect the core to ask to resume an already resumed (from
6408 its point of view) thread. */
6409 gdb_assert (remote_thr
->get_resume_state () == resume_state::NOT_RESUMED
);
6411 remote_thr
->set_resumed_pending_vcont (step
, siggnal
);
6415 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6416 (explained in remote-notif.c:handle_notification) so
6417 remote_notif_process is not called. We need find a place where
6418 it is safe to start a 'vNotif' sequence. It is good to do it
6419 before resuming inferior, because inferior was stopped and no RSP
6420 traffic at that moment. */
6421 if (!target_is_non_stop_p ())
6422 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6424 rs
->last_resume_exec_dir
= ::execution_direction
;
6426 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6427 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6428 remote_resume_with_hc (ptid
, step
, siggnal
);
6430 /* Update resumed state tracked by the remote target. */
6431 for (thread_info
*tp
: all_non_exited_threads (this, ptid
))
6432 get_remote_thread_info (tp
)->set_resumed ();
6434 /* We are about to start executing the inferior, let's register it
6435 with the event loop. NOTE: this is the one place where all the
6436 execution commands end up. We could alternatively do this in each
6437 of the execution commands in infcmd.c. */
6438 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6439 into infcmd.c in order to allow inferior function calls to work
6440 NOT asynchronously. */
6441 if (target_can_async_p ())
6444 /* We've just told the target to resume. The remote server will
6445 wait for the inferior to stop, and then send a stop reply. In
6446 the mean time, we can't start another command/query ourselves
6447 because the stub wouldn't be ready to process it. This applies
6448 only to the base all-stop protocol, however. In non-stop (which
6449 only supports vCont), the stub replies with an "OK", and is
6450 immediate able to process further serial input. */
6451 if (!target_is_non_stop_p ())
6452 rs
->waiting_for_stop_reply
= 1;
6455 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6457 /* Private per-inferior info for target remote processes. */
6459 struct remote_inferior
: public private_inferior
6461 /* Whether we can send a wildcard vCont for this process. */
6462 bool may_wildcard_vcont
= true;
6465 /* Get the remote private inferior data associated to INF. */
6467 static remote_inferior
*
6468 get_remote_inferior (inferior
*inf
)
6470 if (inf
->priv
== NULL
)
6471 inf
->priv
.reset (new remote_inferior
);
6473 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6476 /* Class used to track the construction of a vCont packet in the
6477 outgoing packet buffer. This is used to send multiple vCont
6478 packets if we have more actions than would fit a single packet. */
6483 explicit vcont_builder (remote_target
*remote
)
6490 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6495 /* The remote target. */
6496 remote_target
*m_remote
;
6498 /* Pointer to the first action. P points here if no action has been
6500 char *m_first_action
;
6502 /* Where the next action will be appended. */
6505 /* The end of the buffer. Must never write past this. */
6509 /* Prepare the outgoing buffer for a new vCont packet. */
6512 vcont_builder::restart ()
6514 struct remote_state
*rs
= m_remote
->get_remote_state ();
6516 m_p
= rs
->buf
.data ();
6517 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6518 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6519 m_first_action
= m_p
;
6522 /* If the vCont packet being built has any action, send it to the
6526 vcont_builder::flush ()
6528 struct remote_state
*rs
;
6530 if (m_p
== m_first_action
)
6533 rs
= m_remote
->get_remote_state ();
6534 m_remote
->putpkt (rs
->buf
);
6535 m_remote
->getpkt (&rs
->buf
, 0);
6536 if (strcmp (rs
->buf
.data (), "OK") != 0)
6537 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6540 /* The largest action is range-stepping, with its two addresses. This
6541 is more than sufficient. If a new, bigger action is created, it'll
6542 quickly trigger a failed assertion in append_resumption (and we'll
6544 #define MAX_ACTION_SIZE 200
6546 /* Append a new vCont action in the outgoing packet being built. If
6547 the action doesn't fit the packet along with previous actions, push
6548 what we've got so far to the remote end and start over a new vCont
6549 packet (with the new action). */
6552 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6554 char buf
[MAX_ACTION_SIZE
+ 1];
6556 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6557 ptid
, step
, siggnal
);
6559 /* Check whether this new action would fit in the vCont packet along
6560 with previous actions. If not, send what we've got so far and
6561 start a new vCont packet. */
6562 size_t rsize
= endp
- buf
;
6563 if (rsize
> m_endp
- m_p
)
6568 /* Should now fit. */
6569 gdb_assert (rsize
<= m_endp
- m_p
);
6572 memcpy (m_p
, buf
, rsize
);
6577 /* to_commit_resume implementation. */
6580 remote_target::commit_resume ()
6582 int any_process_wildcard
;
6583 int may_global_wildcard_vcont
;
6585 /* If connected in all-stop mode, we'd send the remote resume
6586 request directly from remote_resume. Likewise if
6587 reverse-debugging, as there are no defined vCont actions for
6588 reverse execution. */
6589 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6592 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6593 instead of resuming all threads of each process individually.
6594 However, if any thread of a process must remain halted, we can't
6595 send wildcard resumes and must send one action per thread.
6597 Care must be taken to not resume threads/processes the server
6598 side already told us are stopped, but the core doesn't know about
6599 yet, because the events are still in the vStopped notification
6602 #1 => vCont s:p1.1;c
6604 #3 <= %Stopped T05 p1.1
6609 #8 (infrun handles the stop for p1.1 and continues stepping)
6610 #9 => vCont s:p1.1;c
6612 The last vCont above would resume thread p1.2 by mistake, because
6613 the server has no idea that the event for p1.2 had not been
6616 The server side must similarly ignore resume actions for the
6617 thread that has a pending %Stopped notification (and any other
6618 threads with events pending), until GDB acks the notification
6619 with vStopped. Otherwise, e.g., the following case is
6622 #1 => g (or any other packet)
6624 #3 <= %Stopped T05 p1.2
6625 #4 => vCont s:p1.1;c
6628 Above, the server must not resume thread p1.2. GDB can't know
6629 that p1.2 stopped until it acks the %Stopped notification, and
6630 since from GDB's perspective all threads should be running, it
6633 Finally, special care must also be given to handling fork/vfork
6634 events. A (v)fork event actually tells us that two processes
6635 stopped -- the parent and the child. Until we follow the fork,
6636 we must not resume the child. Therefore, if we have a pending
6637 fork follow, we must not send a global wildcard resume action
6638 (vCont;c). We can still send process-wide wildcards though. */
6640 /* Start by assuming a global wildcard (vCont;c) is possible. */
6641 may_global_wildcard_vcont
= 1;
6643 /* And assume every process is individually wildcard-able too. */
6644 for (inferior
*inf
: all_non_exited_inferiors (this))
6646 remote_inferior
*priv
= get_remote_inferior (inf
);
6648 priv
->may_wildcard_vcont
= true;
6651 /* Check for any pending events (not reported or processed yet) and
6652 disable process and global wildcard resumes appropriately. */
6653 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6655 for (thread_info
*tp
: all_non_exited_threads (this))
6657 remote_thread_info
*priv
= get_remote_thread_info (tp
);
6659 /* If a thread of a process is not meant to be resumed, then we
6660 can't wildcard that process. */
6661 if (priv
->get_resume_state () == resume_state::NOT_RESUMED
)
6663 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6665 /* And if we can't wildcard a process, we can't wildcard
6666 everything either. */
6667 may_global_wildcard_vcont
= 0;
6671 /* If a thread is the parent of an unfollowed fork, then we
6672 can't do a global wildcard, as that would resume the fork
6674 if (is_pending_fork_parent_thread (tp
))
6675 may_global_wildcard_vcont
= 0;
6678 /* Now let's build the vCont packet(s). Actions must be appended
6679 from narrower to wider scopes (thread -> process -> global). If
6680 we end up with too many actions for a single packet vcont_builder
6681 flushes the current vCont packet to the remote side and starts a
6683 struct vcont_builder
vcont_builder (this);
6685 /* Threads first. */
6686 for (thread_info
*tp
: all_non_exited_threads (this))
6688 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6690 /* If the thread was previously vCont-resumed, no need to send a specific
6691 action for it. If we didn't receive a resume request for it, don't
6692 send an action for it either. */
6693 if (remote_thr
->get_resume_state () != resume_state::RESUMED_PENDING_VCONT
)
6696 gdb_assert (!thread_is_in_step_over_chain (tp
));
6698 const resumed_pending_vcont_info
&info
6699 = remote_thr
->resumed_pending_vcont_info ();
6701 /* Check if we need to send a specific action for this thread. If not,
6702 it will be included in a wildcard resume instead. */
6703 if (info
.step
|| info
.sig
!= GDB_SIGNAL_0
6704 || !get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6705 vcont_builder
.push_action (tp
->ptid
, info
.step
, info
.sig
);
6707 remote_thr
->set_resumed ();
6710 /* Now check whether we can send any process-wide wildcard. This is
6711 to avoid sending a global wildcard in the case nothing is
6712 supposed to be resumed. */
6713 any_process_wildcard
= 0;
6715 for (inferior
*inf
: all_non_exited_inferiors (this))
6717 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6719 any_process_wildcard
= 1;
6724 if (any_process_wildcard
)
6726 /* If all processes are wildcard-able, then send a single "c"
6727 action, otherwise, send an "all (-1) threads of process"
6728 continue action for each running process, if any. */
6729 if (may_global_wildcard_vcont
)
6731 vcont_builder
.push_action (minus_one_ptid
,
6732 false, GDB_SIGNAL_0
);
6736 for (inferior
*inf
: all_non_exited_inferiors (this))
6738 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6740 vcont_builder
.push_action (ptid_t (inf
->pid
),
6741 false, GDB_SIGNAL_0
);
6747 vcont_builder
.flush ();
6752 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6753 thread, all threads of a remote process, or all threads of all
6757 remote_target::remote_stop_ns (ptid_t ptid
)
6759 struct remote_state
*rs
= get_remote_state ();
6760 char *p
= rs
->buf
.data ();
6761 char *endp
= p
+ get_remote_packet_size ();
6763 /* FIXME: This supports_vCont_probed check is a workaround until
6764 packet_support is per-connection. */
6765 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
6766 || !rs
->supports_vCont_probed
)
6767 remote_vcont_probe ();
6769 if (!rs
->supports_vCont
.t
)
6770 error (_("Remote server does not support stopping threads"));
6772 if (ptid
== minus_one_ptid
6773 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6774 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6779 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6782 /* All (-1) threads of process. */
6783 nptid
= ptid_t (ptid
.pid (), -1, 0);
6786 /* Small optimization: if we already have a stop reply for
6787 this thread, no use in telling the stub we want this
6789 if (peek_stop_reply (ptid
))
6795 write_ptid (p
, endp
, nptid
);
6798 /* In non-stop, we get an immediate OK reply. The stop reply will
6799 come in asynchronously by notification. */
6801 getpkt (&rs
->buf
, 0);
6802 if (strcmp (rs
->buf
.data (), "OK") != 0)
6803 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6807 /* All-stop version of target_interrupt. Sends a break or a ^C to
6808 interrupt the remote target. It is undefined which thread of which
6809 process reports the interrupt. */
6812 remote_target::remote_interrupt_as ()
6814 struct remote_state
*rs
= get_remote_state ();
6816 rs
->ctrlc_pending_p
= 1;
6818 /* If the inferior is stopped already, but the core didn't know
6819 about it yet, just ignore the request. The cached wait status
6820 will be collected in remote_wait. */
6821 if (rs
->cached_wait_status
)
6824 /* Send interrupt_sequence to remote target. */
6825 send_interrupt_sequence ();
6828 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6829 the remote target. It is undefined which thread of which process
6830 reports the interrupt. Throws an error if the packet is not
6831 supported by the server. */
6834 remote_target::remote_interrupt_ns ()
6836 struct remote_state
*rs
= get_remote_state ();
6837 char *p
= rs
->buf
.data ();
6838 char *endp
= p
+ get_remote_packet_size ();
6840 xsnprintf (p
, endp
- p
, "vCtrlC");
6842 /* In non-stop, we get an immediate OK reply. The stop reply will
6843 come in asynchronously by notification. */
6845 getpkt (&rs
->buf
, 0);
6847 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6851 case PACKET_UNKNOWN
:
6852 error (_("No support for interrupting the remote target."));
6854 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6858 /* Implement the to_stop function for the remote targets. */
6861 remote_target::stop (ptid_t ptid
)
6863 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
6865 if (target_is_non_stop_p ())
6866 remote_stop_ns (ptid
);
6869 /* We don't currently have a way to transparently pause the
6870 remote target in all-stop mode. Interrupt it instead. */
6871 remote_interrupt_as ();
6875 /* Implement the to_interrupt function for the remote targets. */
6878 remote_target::interrupt ()
6880 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
6882 if (target_is_non_stop_p ())
6883 remote_interrupt_ns ();
6885 remote_interrupt_as ();
6888 /* Implement the to_pass_ctrlc function for the remote targets. */
6891 remote_target::pass_ctrlc ()
6893 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
6895 struct remote_state
*rs
= get_remote_state ();
6897 /* If we're starting up, we're not fully synced yet. Quit
6899 if (rs
->starting_up
)
6901 /* If ^C has already been sent once, offer to disconnect. */
6902 else if (rs
->ctrlc_pending_p
)
6905 target_interrupt ();
6908 /* Ask the user what to do when an interrupt is received. */
6911 remote_target::interrupt_query ()
6913 struct remote_state
*rs
= get_remote_state ();
6915 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6917 if (query (_("The target is not responding to interrupt requests.\n"
6918 "Stop debugging it? ")))
6920 remote_unpush_target (this);
6921 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6926 if (query (_("Interrupted while waiting for the program.\n"
6927 "Give up waiting? ")))
6932 /* Enable/disable target terminal ownership. Most targets can use
6933 terminal groups to control terminal ownership. Remote targets are
6934 different in that explicit transfer of ownership to/from GDB/target
6938 remote_target::terminal_inferior ()
6940 /* NOTE: At this point we could also register our selves as the
6941 recipient of all input. Any characters typed could then be
6942 passed on down to the target. */
6946 remote_target::terminal_ours ()
6951 remote_console_output (const char *msg
)
6955 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6958 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6962 gdb_stdtarg
->puts (tb
);
6964 gdb_stdtarg
->flush ();
6967 struct stop_reply
: public notif_event
6971 /* The identifier of the thread about this event */
6974 /* The remote state this event is associated with. When the remote
6975 connection, represented by a remote_state object, is closed,
6976 all the associated stop_reply events should be released. */
6977 struct remote_state
*rs
;
6979 struct target_waitstatus ws
;
6981 /* The architecture associated with the expedited registers. */
6984 /* Expedited registers. This makes remote debugging a bit more
6985 efficient for those targets that provide critical registers as
6986 part of their normal status mechanism (as another roundtrip to
6987 fetch them is avoided). */
6988 std::vector
<cached_reg_t
> regcache
;
6990 enum target_stop_reason stop_reason
;
6992 CORE_ADDR watch_data_address
;
6997 /* Return the length of the stop reply queue. */
7000 remote_target::stop_reply_queue_length ()
7002 remote_state
*rs
= get_remote_state ();
7003 return rs
->stop_reply_queue
.size ();
7007 remote_notif_stop_parse (remote_target
*remote
,
7008 struct notif_client
*self
, const char *buf
,
7009 struct notif_event
*event
)
7011 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
7015 remote_notif_stop_ack (remote_target
*remote
,
7016 struct notif_client
*self
, const char *buf
,
7017 struct notif_event
*event
)
7019 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
7022 putpkt (remote
, self
->ack_command
);
7024 /* Kind can be TARGET_WAITKIND_IGNORE if we have meanwhile discarded
7025 the notification. It was left in the queue because we need to
7026 acknowledge it and pull the rest of the notifications out. */
7027 if (stop_reply
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7028 remote
->push_stop_reply (stop_reply
);
7032 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
7033 struct notif_client
*self
)
7035 /* We can't get pending events in remote_notif_process for
7036 notification stop, and we have to do this in remote_wait_ns
7037 instead. If we fetch all queued events from stub, remote stub
7038 may exit and we have no chance to process them back in
7040 remote_state
*rs
= remote
->get_remote_state ();
7041 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7045 stop_reply::~stop_reply ()
7047 for (cached_reg_t
®
: regcache
)
7051 static notif_event_up
7052 remote_notif_stop_alloc_reply ()
7054 return notif_event_up (new struct stop_reply ());
7057 /* A client of notification Stop. */
7059 struct notif_client notif_client_stop
=
7063 remote_notif_stop_parse
,
7064 remote_notif_stop_ack
,
7065 remote_notif_stop_can_get_pending_events
,
7066 remote_notif_stop_alloc_reply
,
7070 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
7071 the pid of the process that owns the threads we want to check, or
7072 -1 if we want to check all threads. */
7075 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
7078 if (ws
->kind
== TARGET_WAITKIND_FORKED
7079 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
7081 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
7088 /* Return the thread's pending status used to determine whether the
7089 thread is a fork parent stopped at a fork event. */
7091 static struct target_waitstatus
*
7092 thread_pending_fork_status (struct thread_info
*thread
)
7094 if (thread
->suspend
.waitstatus_pending_p
)
7095 return &thread
->suspend
.waitstatus
;
7097 return &thread
->pending_follow
;
7100 /* Determine if THREAD is a pending fork parent thread. */
7103 is_pending_fork_parent_thread (struct thread_info
*thread
)
7105 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
7108 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
7111 /* If CONTEXT contains any fork child threads that have not been
7112 reported yet, remove them from the CONTEXT list. If such a
7113 thread exists it is because we are stopped at a fork catchpoint
7114 and have not yet called follow_fork, which will set up the
7115 host-side data structures for the new process. */
7118 remote_target::remove_new_fork_children (threads_listing_context
*context
)
7121 struct notif_client
*notif
= ¬if_client_stop
;
7123 /* For any threads stopped at a fork event, remove the corresponding
7124 fork child threads from the CONTEXT list. */
7125 for (thread_info
*thread
: all_non_exited_threads (this))
7127 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
7129 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
7130 context
->remove_thread (ws
->value
.related_pid
);
7133 /* Check for any pending fork events (not reported or processed yet)
7134 in process PID and remove those fork child threads from the
7135 CONTEXT list as well. */
7136 remote_notif_get_pending_events (notif
);
7137 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7138 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7139 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
7140 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
7141 context
->remove_thread (event
->ws
.value
.related_pid
);
7144 /* Check whether any event pending in the vStopped queue would prevent
7145 a global or process wildcard vCont action. Clear
7146 *may_global_wildcard if we can't do a global wildcard (vCont;c),
7147 and clear the event inferior's may_wildcard_vcont flag if we can't
7148 do a process-wide wildcard resume (vCont;c:pPID.-1). */
7151 remote_target::check_pending_events_prevent_wildcard_vcont
7152 (int *may_global_wildcard
)
7154 struct notif_client
*notif
= ¬if_client_stop
;
7156 remote_notif_get_pending_events (notif
);
7157 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7159 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
7160 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
7163 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7164 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
7165 *may_global_wildcard
= 0;
7167 struct inferior
*inf
= find_inferior_ptid (this, event
->ptid
);
7169 /* This may be the first time we heard about this process.
7170 Regardless, we must not do a global wildcard resume, otherwise
7171 we'd resume this process too. */
7172 *may_global_wildcard
= 0;
7174 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7178 /* Discard all pending stop replies of inferior INF. */
7181 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7183 struct stop_reply
*reply
;
7184 struct remote_state
*rs
= get_remote_state ();
7185 struct remote_notif_state
*rns
= rs
->notif_state
;
7187 /* This function can be notified when an inferior exists. When the
7188 target is not remote, the notification state is NULL. */
7189 if (rs
->remote_desc
== NULL
)
7192 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7194 /* Discard the in-flight notification. */
7195 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7197 /* Leave the notification pending, since the server expects that
7198 we acknowledge it with vStopped. But clear its contents, so
7199 that later on when we acknowledge it, we also discard it. */
7200 reply
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7203 fprintf_unfiltered (gdb_stdlog
,
7204 "discarded in-flight notification\n");
7207 /* Discard the stop replies we have already pulled with
7209 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7210 rs
->stop_reply_queue
.end (),
7211 [=] (const stop_reply_up
&event
)
7213 return event
->ptid
.pid () == inf
->pid
;
7215 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7218 /* Discard the stop replies for RS in stop_reply_queue. */
7221 remote_target::discard_pending_stop_replies_in_queue ()
7223 remote_state
*rs
= get_remote_state ();
7225 /* Discard the stop replies we have already pulled with
7227 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7228 rs
->stop_reply_queue
.end (),
7229 [=] (const stop_reply_up
&event
)
7231 return event
->rs
== rs
;
7233 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7236 /* Remove the first reply in 'stop_reply_queue' which matches
7240 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7242 remote_state
*rs
= get_remote_state ();
7244 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7245 rs
->stop_reply_queue
.end (),
7246 [=] (const stop_reply_up
&event
)
7248 return event
->ptid
.matches (ptid
);
7250 struct stop_reply
*result
;
7251 if (iter
== rs
->stop_reply_queue
.end ())
7255 result
= iter
->release ();
7256 rs
->stop_reply_queue
.erase (iter
);
7260 fprintf_unfiltered (gdb_stdlog
,
7261 "notif: discard queued event: 'Stop' in %s\n",
7262 target_pid_to_str (ptid
).c_str ());
7267 /* Look for a queued stop reply belonging to PTID. If one is found,
7268 remove it from the queue, and return it. Returns NULL if none is
7269 found. If there are still queued events left to process, tell the
7270 event loop to get back to target_wait soon. */
7273 remote_target::queued_stop_reply (ptid_t ptid
)
7275 remote_state
*rs
= get_remote_state ();
7276 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7278 if (!rs
->stop_reply_queue
.empty ())
7280 /* There's still at least an event left. */
7281 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7287 /* Push a fully parsed stop reply in the stop reply queue. Since we
7288 know that we now have at least one queued event left to pass to the
7289 core side, tell the event loop to get back to target_wait soon. */
7292 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7294 remote_state
*rs
= get_remote_state ();
7295 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7298 fprintf_unfiltered (gdb_stdlog
,
7299 "notif: push 'Stop' %s to queue %d\n",
7300 target_pid_to_str (new_event
->ptid
).c_str (),
7301 int (rs
->stop_reply_queue
.size ()));
7303 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7306 /* Returns true if we have a stop reply for PTID. */
7309 remote_target::peek_stop_reply (ptid_t ptid
)
7311 remote_state
*rs
= get_remote_state ();
7312 for (auto &event
: rs
->stop_reply_queue
)
7313 if (ptid
== event
->ptid
7314 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7319 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7320 starting with P and ending with PEND matches PREFIX. */
7323 strprefix (const char *p
, const char *pend
, const char *prefix
)
7325 for ( ; p
< pend
; p
++, prefix
++)
7328 return *prefix
== '\0';
7331 /* Parse the stop reply in BUF. Either the function succeeds, and the
7332 result is stored in EVENT, or throws an error. */
7335 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7337 remote_arch_state
*rsa
= NULL
;
7342 event
->ptid
= null_ptid
;
7343 event
->rs
= get_remote_state ();
7344 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7345 event
->ws
.value
.integer
= 0;
7346 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7347 event
->regcache
.clear ();
7352 case 'T': /* Status with PC, SP, FP, ... */
7353 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7354 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7356 n... = register number
7357 r... = register contents
7360 p
= &buf
[3]; /* after Txx */
7366 p1
= strchr (p
, ':');
7368 error (_("Malformed packet(a) (missing colon): %s\n\
7372 error (_("Malformed packet(a) (missing register number): %s\n\
7376 /* Some "registers" are actually extended stop information.
7377 Note if you're adding a new entry here: GDB 7.9 and
7378 earlier assume that all register "numbers" that start
7379 with an hex digit are real register numbers. Make sure
7380 the server only sends such a packet if it knows the
7381 client understands it. */
7383 if (strprefix (p
, p1
, "thread"))
7384 event
->ptid
= read_ptid (++p1
, &p
);
7385 else if (strprefix (p
, p1
, "syscall_entry"))
7389 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7390 p
= unpack_varlen_hex (++p1
, &sysno
);
7391 event
->ws
.value
.syscall_number
= (int) sysno
;
7393 else if (strprefix (p
, p1
, "syscall_return"))
7397 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7398 p
= unpack_varlen_hex (++p1
, &sysno
);
7399 event
->ws
.value
.syscall_number
= (int) sysno
;
7401 else if (strprefix (p
, p1
, "watch")
7402 || strprefix (p
, p1
, "rwatch")
7403 || strprefix (p
, p1
, "awatch"))
7405 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7406 p
= unpack_varlen_hex (++p1
, &addr
);
7407 event
->watch_data_address
= (CORE_ADDR
) addr
;
7409 else if (strprefix (p
, p1
, "swbreak"))
7411 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7413 /* Make sure the stub doesn't forget to indicate support
7415 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7416 error (_("Unexpected swbreak stop reason"));
7418 /* The value part is documented as "must be empty",
7419 though we ignore it, in case we ever decide to make
7420 use of it in a backward compatible way. */
7421 p
= strchrnul (p1
+ 1, ';');
7423 else if (strprefix (p
, p1
, "hwbreak"))
7425 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7427 /* Make sure the stub doesn't forget to indicate support
7429 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7430 error (_("Unexpected hwbreak stop reason"));
7433 p
= strchrnul (p1
+ 1, ';');
7435 else if (strprefix (p
, p1
, "library"))
7437 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7438 p
= strchrnul (p1
+ 1, ';');
7440 else if (strprefix (p
, p1
, "replaylog"))
7442 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7443 /* p1 will indicate "begin" or "end", but it makes
7444 no difference for now, so ignore it. */
7445 p
= strchrnul (p1
+ 1, ';');
7447 else if (strprefix (p
, p1
, "core"))
7451 p
= unpack_varlen_hex (++p1
, &c
);
7454 else if (strprefix (p
, p1
, "fork"))
7456 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7457 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7459 else if (strprefix (p
, p1
, "vfork"))
7461 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7462 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7464 else if (strprefix (p
, p1
, "vforkdone"))
7466 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7467 p
= strchrnul (p1
+ 1, ';');
7469 else if (strprefix (p
, p1
, "exec"))
7474 /* Determine the length of the execd pathname. */
7475 p
= unpack_varlen_hex (++p1
, &ignored
);
7476 pathlen
= (p
- p1
) / 2;
7478 /* Save the pathname for event reporting and for
7479 the next run command. */
7480 gdb::unique_xmalloc_ptr
<char[]> pathname
7481 ((char *) xmalloc (pathlen
+ 1));
7482 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7483 pathname
[pathlen
] = '\0';
7485 /* This is freed during event handling. */
7486 event
->ws
.value
.execd_pathname
= pathname
.release ();
7487 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7489 /* Skip the registers included in this packet, since
7490 they may be for an architecture different from the
7491 one used by the original program. */
7494 else if (strprefix (p
, p1
, "create"))
7496 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7497 p
= strchrnul (p1
+ 1, ';');
7506 p
= strchrnul (p1
+ 1, ';');
7511 /* Maybe a real ``P'' register number. */
7512 p_temp
= unpack_varlen_hex (p
, &pnum
);
7513 /* If the first invalid character is the colon, we got a
7514 register number. Otherwise, it's an unknown stop
7518 /* If we haven't parsed the event's thread yet, find
7519 it now, in order to find the architecture of the
7520 reported expedited registers. */
7521 if (event
->ptid
== null_ptid
)
7523 /* If there is no thread-id information then leave
7524 the event->ptid as null_ptid. Later in
7525 process_stop_reply we will pick a suitable
7527 const char *thr
= strstr (p1
+ 1, ";thread:");
7529 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7536 = (event
->ptid
== null_ptid
7538 : find_inferior_ptid (this, event
->ptid
));
7539 /* If this is the first time we learn anything
7540 about this process, skip the registers
7541 included in this packet, since we don't yet
7542 know which architecture to use to parse them.
7543 We'll determine the architecture later when
7544 we process the stop reply and retrieve the
7545 target description, via
7546 remote_notice_new_inferior ->
7547 post_create_inferior. */
7550 p
= strchrnul (p1
+ 1, ';');
7555 event
->arch
= inf
->gdbarch
;
7556 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7560 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7561 cached_reg_t cached_reg
;
7564 error (_("Remote sent bad register number %s: %s\n\
7566 hex_string (pnum
), p
, buf
);
7568 cached_reg
.num
= reg
->regnum
;
7569 cached_reg
.data
= (gdb_byte
*)
7570 xmalloc (register_size (event
->arch
, reg
->regnum
));
7573 fieldsize
= hex2bin (p
, cached_reg
.data
,
7574 register_size (event
->arch
, reg
->regnum
));
7576 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7577 warning (_("Remote reply is too short: %s"), buf
);
7579 event
->regcache
.push_back (cached_reg
);
7583 /* Not a number. Silently skip unknown optional
7585 p
= strchrnul (p1
+ 1, ';');
7590 error (_("Remote register badly formatted: %s\nhere: %s"),
7595 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7599 case 'S': /* Old style status, just signal only. */
7603 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7604 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7605 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7606 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7608 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7611 case 'w': /* Thread exited. */
7615 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7616 p
= unpack_varlen_hex (&buf
[1], &value
);
7617 event
->ws
.value
.integer
= value
;
7619 error (_("stop reply packet badly formatted: %s"), buf
);
7620 event
->ptid
= read_ptid (++p
, NULL
);
7623 case 'W': /* Target exited. */
7628 /* GDB used to accept only 2 hex chars here. Stubs should
7629 only send more if they detect GDB supports multi-process
7631 p
= unpack_varlen_hex (&buf
[1], &value
);
7635 /* The remote process exited. */
7636 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7637 event
->ws
.value
.integer
= value
;
7641 /* The remote process exited with a signal. */
7642 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7643 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7644 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7646 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7649 /* If no process is specified, return null_ptid, and let the
7650 caller figure out the right process to use. */
7660 else if (startswith (p
, "process:"))
7664 p
+= sizeof ("process:") - 1;
7665 unpack_varlen_hex (p
, &upid
);
7669 error (_("unknown stop reply packet: %s"), buf
);
7672 error (_("unknown stop reply packet: %s"), buf
);
7673 event
->ptid
= ptid_t (pid
);
7677 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7678 event
->ptid
= minus_one_ptid
;
7683 /* When the stub wants to tell GDB about a new notification reply, it
7684 sends a notification (%Stop, for example). Those can come it at
7685 any time, hence, we have to make sure that any pending
7686 putpkt/getpkt sequence we're making is finished, before querying
7687 the stub for more events with the corresponding ack command
7688 (vStopped, for example). E.g., if we started a vStopped sequence
7689 immediately upon receiving the notification, something like this
7697 1.6) <-- (registers reply to step #1.3)
7699 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7702 To solve this, whenever we parse a %Stop notification successfully,
7703 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7704 doing whatever we were doing:
7710 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7711 2.5) <-- (registers reply to step #2.3)
7713 Eventually after step #2.5, we return to the event loop, which
7714 notices there's an event on the
7715 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7716 associated callback --- the function below. At this point, we're
7717 always safe to start a vStopped sequence. :
7720 2.7) <-- T05 thread:2
7726 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7728 struct remote_state
*rs
= get_remote_state ();
7730 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7733 fprintf_unfiltered (gdb_stdlog
,
7734 "notif: process: '%s' ack pending event\n",
7738 nc
->ack (this, nc
, rs
->buf
.data (),
7739 rs
->notif_state
->pending_event
[nc
->id
]);
7740 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7744 getpkt (&rs
->buf
, 0);
7745 if (strcmp (rs
->buf
.data (), "OK") == 0)
7748 remote_notif_ack (this, nc
, rs
->buf
.data ());
7754 fprintf_unfiltered (gdb_stdlog
,
7755 "notif: process: '%s' no pending reply\n",
7760 /* Wrapper around remote_target::remote_notif_get_pending_events to
7761 avoid having to export the whole remote_target class. */
7764 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7766 remote
->remote_notif_get_pending_events (nc
);
7769 /* Called from process_stop_reply when the stop packet we are responding
7770 to didn't include a process-id or thread-id. STATUS is the stop event
7771 we are responding to.
7773 It is the task of this function to select a suitable thread (or process)
7774 and return its ptid, this is the thread (or process) we will assume the
7775 stop event came from.
7777 In some cases there isn't really any choice about which thread (or
7778 process) is selected, a basic remote with a single process containing a
7779 single thread might choose not to send any process-id or thread-id in
7780 its stop packets, this function will select and return the one and only
7783 However, if a target supports multiple threads (or processes) and still
7784 doesn't include a thread-id (or process-id) in its stop packet then
7785 first, this is a badly behaving target, and second, we're going to have
7786 to select a thread (or process) at random and use that. This function
7787 will print a warning to the user if it detects that there is the
7788 possibility that GDB is guessing which thread (or process) to
7791 Note that this is called before GDB fetches the updated thread list from the
7792 target. So it's possible for the stop reply to be ambiguous and for GDB to
7793 not realize it. For example, if there's initially one thread, the target
7794 spawns a second thread, and then sends a stop reply without an id that
7795 concerns the first thread. GDB will assume the stop reply is about the
7796 first thread - the only thread it knows about - without printing a warning.
7797 Anyway, if the remote meant for the stop reply to be about the second thread,
7798 then it would be really broken, because GDB doesn't know about that thread
7802 remote_target::select_thread_for_ambiguous_stop_reply
7803 (const struct target_waitstatus
*status
)
7805 /* Some stop events apply to all threads in an inferior, while others
7806 only apply to a single thread. */
7807 bool process_wide_stop
7808 = (status
->kind
== TARGET_WAITKIND_EXITED
7809 || status
->kind
== TARGET_WAITKIND_SIGNALLED
);
7811 thread_info
*first_resumed_thread
= nullptr;
7812 bool ambiguous
= false;
7814 /* Consider all non-exited threads of the target, find the first resumed
7816 for (thread_info
*thr
: all_non_exited_threads (this))
7818 remote_thread_info
*remote_thr
= get_remote_thread_info (thr
);
7820 if (remote_thr
->get_resume_state () != resume_state::RESUMED
)
7823 if (first_resumed_thread
== nullptr)
7824 first_resumed_thread
= thr
;
7825 else if (!process_wide_stop
7826 || first_resumed_thread
->ptid
.pid () != thr
->ptid
.pid ())
7830 gdb_assert (first_resumed_thread
!= nullptr);
7832 /* Warn if the remote target is sending ambiguous stop replies. */
7835 static bool warned
= false;
7839 /* If you are seeing this warning then the remote target has
7840 stopped without specifying a thread-id, but the target
7841 does have multiple threads (or inferiors), and so GDB is
7842 having to guess which thread stopped.
7844 Examples of what might cause this are the target sending
7845 and 'S' stop packet, or a 'T' stop packet and not
7846 including a thread-id.
7848 Additionally, the target might send a 'W' or 'X packet
7849 without including a process-id, when the target has
7850 multiple running inferiors. */
7851 if (process_wide_stop
)
7852 warning (_("multi-inferior target stopped without "
7853 "sending a process-id, using first "
7854 "non-exited inferior"));
7856 warning (_("multi-threaded target stopped without "
7857 "sending a thread-id, using first "
7858 "non-exited thread"));
7863 /* If this is a stop for all threads then don't use a particular threads
7864 ptid, instead create a new ptid where only the pid field is set. */
7865 if (process_wide_stop
)
7866 return ptid_t (first_resumed_thread
->ptid
.pid ());
7868 return first_resumed_thread
->ptid
;
7871 /* Called when it is decided that STOP_REPLY holds the info of the
7872 event that is to be returned to the core. This function always
7873 destroys STOP_REPLY. */
7876 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7877 struct target_waitstatus
*status
)
7879 *status
= stop_reply
->ws
;
7880 ptid_t ptid
= stop_reply
->ptid
;
7882 /* If no thread/process was reported by the stub then select a suitable
7884 if (ptid
== null_ptid
)
7885 ptid
= select_thread_for_ambiguous_stop_reply (status
);
7886 gdb_assert (ptid
!= null_ptid
);
7888 if (status
->kind
!= TARGET_WAITKIND_EXITED
7889 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7890 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7892 /* Expedited registers. */
7893 if (!stop_reply
->regcache
.empty ())
7895 struct regcache
*regcache
7896 = get_thread_arch_regcache (this, ptid
, stop_reply
->arch
);
7898 for (cached_reg_t
®
: stop_reply
->regcache
)
7900 regcache
->raw_supply (reg
.num
, reg
.data
);
7904 stop_reply
->regcache
.clear ();
7907 remote_notice_new_inferior (ptid
, 0);
7908 remote_thread_info
*remote_thr
= get_remote_thread_info (this, ptid
);
7909 remote_thr
->core
= stop_reply
->core
;
7910 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7911 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7913 if (target_is_non_stop_p ())
7915 /* If the target works in non-stop mode, a stop-reply indicates that
7916 only this thread stopped. */
7917 remote_thr
->set_not_resumed ();
7921 /* If the target works in all-stop mode, a stop-reply indicates that
7922 all the target's threads stopped. */
7923 for (thread_info
*tp
: all_non_exited_threads (this))
7924 get_remote_thread_info (tp
)->set_not_resumed ();
7932 /* The non-stop mode version of target_wait. */
7935 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
7936 target_wait_flags options
)
7938 struct remote_state
*rs
= get_remote_state ();
7939 struct stop_reply
*stop_reply
;
7943 /* If in non-stop mode, get out of getpkt even if a
7944 notification is received. */
7946 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7949 if (ret
!= -1 && !is_notif
)
7952 case 'E': /* Error of some sort. */
7953 /* We're out of sync with the target now. Did it continue
7954 or not? We can't tell which thread it was in non-stop,
7955 so just ignore this. */
7956 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7958 case 'O': /* Console output. */
7959 remote_console_output (&rs
->buf
[1]);
7962 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7966 /* Acknowledge a pending stop reply that may have arrived in the
7968 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7969 remote_notif_get_pending_events (¬if_client_stop
);
7971 /* If indeed we noticed a stop reply, we're done. */
7972 stop_reply
= queued_stop_reply (ptid
);
7973 if (stop_reply
!= NULL
)
7974 return process_stop_reply (stop_reply
, status
);
7976 /* Still no event. If we're just polling for an event, then
7977 return to the event loop. */
7978 if (options
& TARGET_WNOHANG
)
7980 status
->kind
= TARGET_WAITKIND_IGNORE
;
7981 return minus_one_ptid
;
7984 /* Otherwise do a blocking wait. */
7985 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7989 /* Return the first resumed thread. */
7992 first_remote_resumed_thread (remote_target
*target
)
7994 for (thread_info
*tp
: all_non_exited_threads (target
, minus_one_ptid
))
8000 /* Wait until the remote machine stops, then return, storing status in
8001 STATUS just as `wait' would. */
8004 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
,
8005 target_wait_flags options
)
8007 struct remote_state
*rs
= get_remote_state ();
8008 ptid_t event_ptid
= null_ptid
;
8010 struct stop_reply
*stop_reply
;
8014 status
->kind
= TARGET_WAITKIND_IGNORE
;
8015 status
->value
.integer
= 0;
8017 stop_reply
= queued_stop_reply (ptid
);
8018 if (stop_reply
!= NULL
)
8019 return process_stop_reply (stop_reply
, status
);
8021 if (rs
->cached_wait_status
)
8022 /* Use the cached wait status, but only once. */
8023 rs
->cached_wait_status
= 0;
8028 int forever
= ((options
& TARGET_WNOHANG
) == 0
8029 && rs
->wait_forever_enabled_p
);
8031 if (!rs
->waiting_for_stop_reply
)
8033 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
8034 return minus_one_ptid
;
8037 /* FIXME: cagney/1999-09-27: If we're in async mode we should
8038 _never_ wait for ever -> test on target_is_async_p().
8039 However, before we do that we need to ensure that the caller
8040 knows how to take the target into/out of async mode. */
8041 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
8043 /* GDB gets a notification. Return to core as this event is
8045 if (ret
!= -1 && is_notif
)
8046 return minus_one_ptid
;
8048 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
8049 return minus_one_ptid
;
8052 buf
= rs
->buf
.data ();
8054 /* Assume that the target has acknowledged Ctrl-C unless we receive
8055 an 'F' or 'O' packet. */
8056 if (buf
[0] != 'F' && buf
[0] != 'O')
8057 rs
->ctrlc_pending_p
= 0;
8061 case 'E': /* Error of some sort. */
8062 /* We're out of sync with the target now. Did it continue or
8063 not? Not is more likely, so report a stop. */
8064 rs
->waiting_for_stop_reply
= 0;
8066 warning (_("Remote failure reply: %s"), buf
);
8067 status
->kind
= TARGET_WAITKIND_STOPPED
;
8068 status
->value
.sig
= GDB_SIGNAL_0
;
8070 case 'F': /* File-I/O request. */
8071 /* GDB may access the inferior memory while handling the File-I/O
8072 request, but we don't want GDB accessing memory while waiting
8073 for a stop reply. See the comments in putpkt_binary. Set
8074 waiting_for_stop_reply to 0 temporarily. */
8075 rs
->waiting_for_stop_reply
= 0;
8076 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
8077 rs
->ctrlc_pending_p
= 0;
8078 /* GDB handled the File-I/O request, and the target is running
8079 again. Keep waiting for events. */
8080 rs
->waiting_for_stop_reply
= 1;
8082 case 'N': case 'T': case 'S': case 'X': case 'W':
8084 /* There is a stop reply to handle. */
8085 rs
->waiting_for_stop_reply
= 0;
8088 = (struct stop_reply
*) remote_notif_parse (this,
8092 event_ptid
= process_stop_reply (stop_reply
, status
);
8095 case 'O': /* Console output. */
8096 remote_console_output (buf
+ 1);
8099 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
8101 /* Zero length reply means that we tried 'S' or 'C' and the
8102 remote system doesn't support it. */
8103 target_terminal::ours_for_output ();
8105 ("Can't send signals to this remote system. %s not sent.\n",
8106 gdb_signal_to_name (rs
->last_sent_signal
));
8107 rs
->last_sent_signal
= GDB_SIGNAL_0
;
8108 target_terminal::inferior ();
8110 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
8116 warning (_("Invalid remote reply: %s"), buf
);
8120 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
8121 return minus_one_ptid
;
8122 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
8124 /* Nothing interesting happened. If we're doing a non-blocking
8125 poll, we're done. Otherwise, go back to waiting. */
8126 if (options
& TARGET_WNOHANG
)
8127 return minus_one_ptid
;
8131 else if (status
->kind
!= TARGET_WAITKIND_EXITED
8132 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
8134 if (event_ptid
!= null_ptid
)
8135 record_currthread (rs
, event_ptid
);
8137 event_ptid
= first_remote_resumed_thread (this);
8141 /* A process exit. Invalidate our notion of current thread. */
8142 record_currthread (rs
, minus_one_ptid
);
8143 /* It's possible that the packet did not include a pid. */
8144 if (event_ptid
== null_ptid
)
8145 event_ptid
= first_remote_resumed_thread (this);
8146 /* EVENT_PTID could still be NULL_PTID. Double-check. */
8147 if (event_ptid
== null_ptid
)
8148 event_ptid
= magic_null_ptid
;
8154 /* Wait until the remote machine stops, then return, storing status in
8155 STATUS just as `wait' would. */
8158 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
8159 target_wait_flags options
)
8161 REMOTE_SCOPED_DEBUG_ENTER_EXIT
;
8163 remote_state
*rs
= get_remote_state ();
8165 /* Start by clearing the flag that asks for our wait method to be called,
8166 we'll mark it again at the end if needed. */
8167 if (target_is_async_p ())
8168 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
8172 if (target_is_non_stop_p ())
8173 event_ptid
= wait_ns (ptid
, status
, options
);
8175 event_ptid
= wait_as (ptid
, status
, options
);
8177 if (target_is_async_p ())
8179 /* If there are events left in the queue, or unacknowledged
8180 notifications, then tell the event loop to call us again. */
8181 if (!rs
->stop_reply_queue
.empty ()
8182 || rs
->notif_state
->pending_event
[notif_client_stop
.id
] != nullptr)
8183 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
8189 /* Fetch a single register using a 'p' packet. */
8192 remote_target::fetch_register_using_p (struct regcache
*regcache
,
8195 struct gdbarch
*gdbarch
= regcache
->arch ();
8196 struct remote_state
*rs
= get_remote_state ();
8198 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8201 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
8204 if (reg
->pnum
== -1)
8207 p
= rs
->buf
.data ();
8209 p
+= hexnumstr (p
, reg
->pnum
);
8212 getpkt (&rs
->buf
, 0);
8214 buf
= rs
->buf
.data ();
8216 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
8220 case PACKET_UNKNOWN
:
8223 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
8224 gdbarch_register_name (regcache
->arch (),
8229 /* If this register is unfetchable, tell the regcache. */
8232 regcache
->raw_supply (reg
->regnum
, NULL
);
8236 /* Otherwise, parse and supply the value. */
8242 error (_("fetch_register_using_p: early buf termination"));
8244 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8247 regcache
->raw_supply (reg
->regnum
, regp
);
8251 /* Fetch the registers included in the target's 'g' packet. */
8254 remote_target::send_g_packet ()
8256 struct remote_state
*rs
= get_remote_state ();
8259 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
8261 getpkt (&rs
->buf
, 0);
8262 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8263 error (_("Could not read registers; remote failure reply '%s'"),
8266 /* We can get out of synch in various cases. If the first character
8267 in the buffer is not a hex character, assume that has happened
8268 and try to fetch another packet to read. */
8269 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
8270 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
8271 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
8272 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
8274 remote_debug_printf ("Bad register packet; fetching a new packet");
8275 getpkt (&rs
->buf
, 0);
8278 buf_len
= strlen (rs
->buf
.data ());
8280 /* Sanity check the received packet. */
8281 if (buf_len
% 2 != 0)
8282 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
8288 remote_target::process_g_packet (struct regcache
*regcache
)
8290 struct gdbarch
*gdbarch
= regcache
->arch ();
8291 struct remote_state
*rs
= get_remote_state ();
8292 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8297 buf_len
= strlen (rs
->buf
.data ());
8299 /* Further sanity checks, with knowledge of the architecture. */
8300 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
8301 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8303 rsa
->sizeof_g_packet
, buf_len
/ 2,
8306 /* Save the size of the packet sent to us by the target. It is used
8307 as a heuristic when determining the max size of packets that the
8308 target can safely receive. */
8309 if (rsa
->actual_register_packet_size
== 0)
8310 rsa
->actual_register_packet_size
= buf_len
;
8312 /* If this is smaller than we guessed the 'g' packet would be,
8313 update our records. A 'g' reply that doesn't include a register's
8314 value implies either that the register is not available, or that
8315 the 'p' packet must be used. */
8316 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8318 long sizeof_g_packet
= buf_len
/ 2;
8320 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8322 long offset
= rsa
->regs
[i
].offset
;
8323 long reg_size
= register_size (gdbarch
, i
);
8325 if (rsa
->regs
[i
].pnum
== -1)
8328 if (offset
>= sizeof_g_packet
)
8329 rsa
->regs
[i
].in_g_packet
= 0;
8330 else if (offset
+ reg_size
> sizeof_g_packet
)
8331 error (_("Truncated register %d in remote 'g' packet"), i
);
8333 rsa
->regs
[i
].in_g_packet
= 1;
8336 /* Looks valid enough, we can assume this is the correct length
8337 for a 'g' packet. It's important not to adjust
8338 rsa->sizeof_g_packet if we have truncated registers otherwise
8339 this "if" won't be run the next time the method is called
8340 with a packet of the same size and one of the internal errors
8341 below will trigger instead. */
8342 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8345 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8347 /* Unimplemented registers read as all bits zero. */
8348 memset (regs
, 0, rsa
->sizeof_g_packet
);
8350 /* Reply describes registers byte by byte, each byte encoded as two
8351 hex characters. Suck them all up, then supply them to the
8352 register cacheing/storage mechanism. */
8354 p
= rs
->buf
.data ();
8355 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8357 if (p
[0] == 0 || p
[1] == 0)
8358 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8359 internal_error (__FILE__
, __LINE__
,
8360 _("unexpected end of 'g' packet reply"));
8362 if (p
[0] == 'x' && p
[1] == 'x')
8363 regs
[i
] = 0; /* 'x' */
8365 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8369 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8371 struct packet_reg
*r
= &rsa
->regs
[i
];
8372 long reg_size
= register_size (gdbarch
, i
);
8376 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8377 /* This shouldn't happen - we adjusted in_g_packet above. */
8378 internal_error (__FILE__
, __LINE__
,
8379 _("unexpected end of 'g' packet reply"));
8380 else if (rs
->buf
[r
->offset
* 2] == 'x')
8382 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8383 /* The register isn't available, mark it as such (at
8384 the same time setting the value to zero). */
8385 regcache
->raw_supply (r
->regnum
, NULL
);
8388 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8394 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8397 process_g_packet (regcache
);
8400 /* Make the remote selected traceframe match GDB's selected
8404 remote_target::set_remote_traceframe ()
8407 struct remote_state
*rs
= get_remote_state ();
8409 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8412 /* Avoid recursion, remote_trace_find calls us again. */
8413 rs
->remote_traceframe_number
= get_traceframe_number ();
8415 newnum
= target_trace_find (tfind_number
,
8416 get_traceframe_number (), 0, 0, NULL
);
8418 /* Should not happen. If it does, all bets are off. */
8419 if (newnum
!= get_traceframe_number ())
8420 warning (_("could not set remote traceframe"));
8424 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8426 struct gdbarch
*gdbarch
= regcache
->arch ();
8427 struct remote_state
*rs
= get_remote_state ();
8428 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8431 set_remote_traceframe ();
8432 set_general_thread (regcache
->ptid ());
8436 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8438 gdb_assert (reg
!= NULL
);
8440 /* If this register might be in the 'g' packet, try that first -
8441 we are likely to read more than one register. If this is the
8442 first 'g' packet, we might be overly optimistic about its
8443 contents, so fall back to 'p'. */
8444 if (reg
->in_g_packet
)
8446 fetch_registers_using_g (regcache
);
8447 if (reg
->in_g_packet
)
8451 if (fetch_register_using_p (regcache
, reg
))
8454 /* This register is not available. */
8455 regcache
->raw_supply (reg
->regnum
, NULL
);
8460 fetch_registers_using_g (regcache
);
8462 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8463 if (!rsa
->regs
[i
].in_g_packet
)
8464 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8466 /* This register is not available. */
8467 regcache
->raw_supply (i
, NULL
);
8471 /* Prepare to store registers. Since we may send them all (using a
8472 'G' request), we have to read out the ones we don't want to change
8476 remote_target::prepare_to_store (struct regcache
*regcache
)
8478 struct remote_state
*rs
= get_remote_state ();
8479 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8482 /* Make sure the entire registers array is valid. */
8483 switch (packet_support (PACKET_P
))
8485 case PACKET_DISABLE
:
8486 case PACKET_SUPPORT_UNKNOWN
:
8487 /* Make sure all the necessary registers are cached. */
8488 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8489 if (rsa
->regs
[i
].in_g_packet
)
8490 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8497 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8498 packet was not recognized. */
8501 remote_target::store_register_using_P (const struct regcache
*regcache
,
8504 struct gdbarch
*gdbarch
= regcache
->arch ();
8505 struct remote_state
*rs
= get_remote_state ();
8506 /* Try storing a single register. */
8507 char *buf
= rs
->buf
.data ();
8508 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8511 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8514 if (reg
->pnum
== -1)
8517 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8518 p
= buf
+ strlen (buf
);
8519 regcache
->raw_collect (reg
->regnum
, regp
);
8520 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8522 getpkt (&rs
->buf
, 0);
8524 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8529 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8530 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8531 case PACKET_UNKNOWN
:
8534 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8538 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8539 contents of the register cache buffer. FIXME: ignores errors. */
8542 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8544 struct remote_state
*rs
= get_remote_state ();
8545 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8549 /* Extract all the registers in the regcache copying them into a
8554 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8555 memset (regs
, 0, rsa
->sizeof_g_packet
);
8556 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8558 struct packet_reg
*r
= &rsa
->regs
[i
];
8561 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8565 /* Command describes registers byte by byte,
8566 each byte encoded as two hex characters. */
8567 p
= rs
->buf
.data ();
8569 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8571 getpkt (&rs
->buf
, 0);
8572 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8573 error (_("Could not write registers; remote failure reply '%s'"),
8577 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8578 of the register cache buffer. FIXME: ignores errors. */
8581 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8583 struct gdbarch
*gdbarch
= regcache
->arch ();
8584 struct remote_state
*rs
= get_remote_state ();
8585 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8588 set_remote_traceframe ();
8589 set_general_thread (regcache
->ptid ());
8593 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8595 gdb_assert (reg
!= NULL
);
8597 /* Always prefer to store registers using the 'P' packet if
8598 possible; we often change only a small number of registers.
8599 Sometimes we change a larger number; we'd need help from a
8600 higher layer to know to use 'G'. */
8601 if (store_register_using_P (regcache
, reg
))
8604 /* For now, don't complain if we have no way to write the
8605 register. GDB loses track of unavailable registers too
8606 easily. Some day, this may be an error. We don't have
8607 any way to read the register, either... */
8608 if (!reg
->in_g_packet
)
8611 store_registers_using_G (regcache
);
8615 store_registers_using_G (regcache
);
8617 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8618 if (!rsa
->regs
[i
].in_g_packet
)
8619 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8620 /* See above for why we do not issue an error here. */
8625 /* Return the number of hex digits in num. */
8628 hexnumlen (ULONGEST num
)
8632 for (i
= 0; num
!= 0; i
++)
8635 return std::max (i
, 1);
8638 /* Set BUF to the minimum number of hex digits representing NUM. */
8641 hexnumstr (char *buf
, ULONGEST num
)
8643 int len
= hexnumlen (num
);
8645 return hexnumnstr (buf
, num
, len
);
8649 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8652 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8658 for (i
= width
- 1; i
>= 0; i
--)
8660 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8667 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8670 remote_address_masked (CORE_ADDR addr
)
8672 unsigned int address_size
= remote_address_size
;
8674 /* If "remoteaddresssize" was not set, default to target address size. */
8676 address_size
= gdbarch_addr_bit (target_gdbarch ());
8678 if (address_size
> 0
8679 && address_size
< (sizeof (ULONGEST
) * 8))
8681 /* Only create a mask when that mask can safely be constructed
8682 in a ULONGEST variable. */
8685 mask
= (mask
<< address_size
) - 1;
8691 /* Determine whether the remote target supports binary downloading.
8692 This is accomplished by sending a no-op memory write of zero length
8693 to the target at the specified address. It does not suffice to send
8694 the whole packet, since many stubs strip the eighth bit and
8695 subsequently compute a wrong checksum, which causes real havoc with
8698 NOTE: This can still lose if the serial line is not eight-bit
8699 clean. In cases like this, the user should clear "remote
8703 remote_target::check_binary_download (CORE_ADDR addr
)
8705 struct remote_state
*rs
= get_remote_state ();
8707 switch (packet_support (PACKET_X
))
8709 case PACKET_DISABLE
:
8713 case PACKET_SUPPORT_UNKNOWN
:
8717 p
= rs
->buf
.data ();
8719 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8721 p
+= hexnumstr (p
, (ULONGEST
) 0);
8725 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8726 getpkt (&rs
->buf
, 0);
8728 if (rs
->buf
[0] == '\0')
8730 remote_debug_printf ("binary downloading NOT supported by target");
8731 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8735 remote_debug_printf ("binary downloading supported by target");
8736 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8743 /* Helper function to resize the payload in order to try to get a good
8744 alignment. We try to write an amount of data such that the next write will
8745 start on an address aligned on REMOTE_ALIGN_WRITES. */
8748 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8750 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8753 /* Write memory data directly to the remote machine.
8754 This does not inform the data cache; the data cache uses this.
8755 HEADER is the starting part of the packet.
8756 MEMADDR is the address in the remote memory space.
8757 MYADDR is the address of the buffer in our space.
8758 LEN_UNITS is the number of addressable units to write.
8759 UNIT_SIZE is the length in bytes of an addressable unit.
8760 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8761 should send data as binary ('X'), or hex-encoded ('M').
8763 The function creates packet of the form
8764 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8766 where encoding of <DATA> is terminated by PACKET_FORMAT.
8768 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8771 Return the transferred status, error or OK (an
8772 'enum target_xfer_status' value). Save the number of addressable units
8773 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8775 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8776 exchange between gdb and the stub could look like (?? in place of the
8782 -> $M1000,3:eeeeffffeeee#??
8786 <- eeeeffffeeeedddd */
8789 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8790 const gdb_byte
*myaddr
,
8793 ULONGEST
*xfered_len_units
,
8794 char packet_format
, int use_length
)
8796 struct remote_state
*rs
= get_remote_state ();
8802 int payload_capacity_bytes
;
8803 int payload_length_bytes
;
8805 if (packet_format
!= 'X' && packet_format
!= 'M')
8806 internal_error (__FILE__
, __LINE__
,
8807 _("remote_write_bytes_aux: bad packet format"));
8810 return TARGET_XFER_EOF
;
8812 payload_capacity_bytes
= get_memory_write_packet_size ();
8814 /* The packet buffer will be large enough for the payload;
8815 get_memory_packet_size ensures this. */
8818 /* Compute the size of the actual payload by subtracting out the
8819 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8821 payload_capacity_bytes
-= strlen ("$,:#NN");
8823 /* The comma won't be used. */
8824 payload_capacity_bytes
+= 1;
8825 payload_capacity_bytes
-= strlen (header
);
8826 payload_capacity_bytes
-= hexnumlen (memaddr
);
8828 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8830 strcat (rs
->buf
.data (), header
);
8831 p
= rs
->buf
.data () + strlen (header
);
8833 /* Compute a best guess of the number of bytes actually transfered. */
8834 if (packet_format
== 'X')
8836 /* Best guess at number of bytes that will fit. */
8837 todo_units
= std::min (len_units
,
8838 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8840 payload_capacity_bytes
-= hexnumlen (todo_units
);
8841 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8845 /* Number of bytes that will fit. */
8847 = std::min (len_units
,
8848 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8850 payload_capacity_bytes
-= hexnumlen (todo_units
);
8851 todo_units
= std::min (todo_units
,
8852 (payload_capacity_bytes
/ unit_size
) / 2);
8855 if (todo_units
<= 0)
8856 internal_error (__FILE__
, __LINE__
,
8857 _("minimum packet size too small to write data"));
8859 /* If we already need another packet, then try to align the end
8860 of this packet to a useful boundary. */
8861 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8862 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8864 /* Append "<memaddr>". */
8865 memaddr
= remote_address_masked (memaddr
);
8866 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8873 /* Append the length and retain its location and size. It may need to be
8874 adjusted once the packet body has been created. */
8876 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8884 /* Append the packet body. */
8885 if (packet_format
== 'X')
8887 /* Binary mode. Send target system values byte by byte, in
8888 increasing byte addresses. Only escape certain critical
8890 payload_length_bytes
=
8891 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8892 &units_written
, payload_capacity_bytes
);
8894 /* If not all TODO units fit, then we'll need another packet. Make
8895 a second try to keep the end of the packet aligned. Don't do
8896 this if the packet is tiny. */
8897 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8901 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8903 if (new_todo_units
!= units_written
)
8904 payload_length_bytes
=
8905 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8906 (gdb_byte
*) p
, &units_written
,
8907 payload_capacity_bytes
);
8910 p
+= payload_length_bytes
;
8911 if (use_length
&& units_written
< todo_units
)
8913 /* Escape chars have filled up the buffer prematurely,
8914 and we have actually sent fewer units than planned.
8915 Fix-up the length field of the packet. Use the same
8916 number of characters as before. */
8917 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8919 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8924 /* Normal mode: Send target system values byte by byte, in
8925 increasing byte addresses. Each byte is encoded as a two hex
8927 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8928 units_written
= todo_units
;
8931 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8932 getpkt (&rs
->buf
, 0);
8934 if (rs
->buf
[0] == 'E')
8935 return TARGET_XFER_E_IO
;
8937 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8938 send fewer units than we'd planned. */
8939 *xfered_len_units
= (ULONGEST
) units_written
;
8940 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8943 /* Write memory data directly to the remote machine.
8944 This does not inform the data cache; the data cache uses this.
8945 MEMADDR is the address in the remote memory space.
8946 MYADDR is the address of the buffer in our space.
8947 LEN is the number of bytes.
8949 Return the transferred status, error or OK (an
8950 'enum target_xfer_status' value). Save the number of bytes
8951 transferred in *XFERED_LEN. Only transfer a single packet. */
8954 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8955 ULONGEST len
, int unit_size
,
8956 ULONGEST
*xfered_len
)
8958 const char *packet_format
= NULL
;
8960 /* Check whether the target supports binary download. */
8961 check_binary_download (memaddr
);
8963 switch (packet_support (PACKET_X
))
8966 packet_format
= "X";
8968 case PACKET_DISABLE
:
8969 packet_format
= "M";
8971 case PACKET_SUPPORT_UNKNOWN
:
8972 internal_error (__FILE__
, __LINE__
,
8973 _("remote_write_bytes: bad internal state"));
8975 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8978 return remote_write_bytes_aux (packet_format
,
8979 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8980 packet_format
[0], 1);
8983 /* Read memory data directly from the remote machine.
8984 This does not use the data cache; the data cache uses this.
8985 MEMADDR is the address in the remote memory space.
8986 MYADDR is the address of the buffer in our space.
8987 LEN_UNITS is the number of addressable memory units to read..
8988 UNIT_SIZE is the length in bytes of an addressable unit.
8990 Return the transferred status, error or OK (an
8991 'enum target_xfer_status' value). Save the number of bytes
8992 transferred in *XFERED_LEN_UNITS.
8994 See the comment of remote_write_bytes_aux for an example of
8995 memory read/write exchange between gdb and the stub. */
8998 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
9000 int unit_size
, ULONGEST
*xfered_len_units
)
9002 struct remote_state
*rs
= get_remote_state ();
9003 int buf_size_bytes
; /* Max size of packet output buffer. */
9008 buf_size_bytes
= get_memory_read_packet_size ();
9009 /* The packet buffer will be large enough for the payload;
9010 get_memory_packet_size ensures this. */
9012 /* Number of units that will fit. */
9013 todo_units
= std::min (len_units
,
9014 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
9016 /* Construct "m"<memaddr>","<len>". */
9017 memaddr
= remote_address_masked (memaddr
);
9018 p
= rs
->buf
.data ();
9020 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
9022 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
9025 getpkt (&rs
->buf
, 0);
9026 if (rs
->buf
[0] == 'E'
9027 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
9028 && rs
->buf
[3] == '\0')
9029 return TARGET_XFER_E_IO
;
9030 /* Reply describes memory byte by byte, each byte encoded as two hex
9032 p
= rs
->buf
.data ();
9033 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
9034 /* Return what we have. Let higher layers handle partial reads. */
9035 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
9036 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
9039 /* Using the set of read-only target sections of remote, read live
9042 For interface/parameters/return description see target.h,
9046 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
9050 ULONGEST
*xfered_len
)
9052 const struct target_section
*secp
;
9054 secp
= target_section_by_addr (this, memaddr
);
9056 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
9058 ULONGEST memend
= memaddr
+ len
;
9060 const target_section_table
*table
= target_get_section_table (this);
9061 for (const target_section
&p
: *table
)
9063 if (memaddr
>= p
.addr
)
9065 if (memend
<= p
.endaddr
)
9067 /* Entire transfer is within this section. */
9068 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
9071 else if (memaddr
>= p
.endaddr
)
9073 /* This section ends before the transfer starts. */
9078 /* This section overlaps the transfer. Just do half. */
9079 len
= p
.endaddr
- memaddr
;
9080 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
9087 return TARGET_XFER_EOF
;
9090 /* Similar to remote_read_bytes_1, but it reads from the remote stub
9091 first if the requested memory is unavailable in traceframe.
9092 Otherwise, fall back to remote_read_bytes_1. */
9095 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
9096 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
9097 ULONGEST
*xfered_len
)
9100 return TARGET_XFER_EOF
;
9102 if (get_traceframe_number () != -1)
9104 std::vector
<mem_range
> available
;
9106 /* If we fail to get the set of available memory, then the
9107 target does not support querying traceframe info, and so we
9108 attempt reading from the traceframe anyway (assuming the
9109 target implements the old QTro packet then). */
9110 if (traceframe_available_memory (&available
, memaddr
, len
))
9112 if (available
.empty () || available
[0].start
!= memaddr
)
9114 enum target_xfer_status res
;
9116 /* Don't read into the traceframe's available
9118 if (!available
.empty ())
9120 LONGEST oldlen
= len
;
9122 len
= available
[0].start
- memaddr
;
9123 gdb_assert (len
<= oldlen
);
9126 /* This goes through the topmost target again. */
9127 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
9128 len
, unit_size
, xfered_len
);
9129 if (res
== TARGET_XFER_OK
)
9130 return TARGET_XFER_OK
;
9133 /* No use trying further, we know some memory starting
9134 at MEMADDR isn't available. */
9136 return (*xfered_len
!= 0) ?
9137 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
9141 /* Don't try to read more than how much is available, in
9142 case the target implements the deprecated QTro packet to
9143 cater for older GDBs (the target's knowledge of read-only
9144 sections may be outdated by now). */
9145 len
= available
[0].length
;
9149 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
9154 /* Sends a packet with content determined by the printf format string
9155 FORMAT and the remaining arguments, then gets the reply. Returns
9156 whether the packet was a success, a failure, or unknown. */
9159 remote_target::remote_send_printf (const char *format
, ...)
9161 struct remote_state
*rs
= get_remote_state ();
9162 int max_size
= get_remote_packet_size ();
9165 va_start (ap
, format
);
9168 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
9172 if (size
>= max_size
)
9173 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
9175 if (putpkt (rs
->buf
) < 0)
9176 error (_("Communication problem with target."));
9179 getpkt (&rs
->buf
, 0);
9181 return packet_check_result (rs
->buf
);
9184 /* Flash writing can take quite some time. We'll set
9185 effectively infinite timeout for flash operations.
9186 In future, we'll need to decide on a better approach. */
9187 static const int remote_flash_timeout
= 1000;
9190 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
9192 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
9193 enum packet_result ret
;
9194 scoped_restore restore_timeout
9195 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9197 ret
= remote_send_printf ("vFlashErase:%s,%s",
9198 phex (address
, addr_size
),
9202 case PACKET_UNKNOWN
:
9203 error (_("Remote target does not support flash erase"));
9205 error (_("Error erasing flash with vFlashErase packet"));
9212 remote_target::remote_flash_write (ULONGEST address
,
9213 ULONGEST length
, ULONGEST
*xfered_len
,
9214 const gdb_byte
*data
)
9216 scoped_restore restore_timeout
9217 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9218 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
9223 remote_target::flash_done ()
9227 scoped_restore restore_timeout
9228 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9230 ret
= remote_send_printf ("vFlashDone");
9234 case PACKET_UNKNOWN
:
9235 error (_("Remote target does not support vFlashDone"));
9237 error (_("Error finishing flash operation"));
9244 remote_target::files_info ()
9246 puts_filtered ("Debugging a target over a serial line.\n");
9249 /* Stuff for dealing with the packets which are part of this protocol.
9250 See comment at top of file for details. */
9252 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
9253 error to higher layers. Called when a serial error is detected.
9254 The exception message is STRING, followed by a colon and a blank,
9255 the system error message for errno at function entry and final dot
9256 for output compatibility with throw_perror_with_name. */
9259 unpush_and_perror (remote_target
*target
, const char *string
)
9261 int saved_errno
= errno
;
9263 remote_unpush_target (target
);
9264 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
9265 safe_strerror (saved_errno
));
9268 /* Read a single character from the remote end. The current quit
9269 handler is overridden to avoid quitting in the middle of packet
9270 sequence, as that would break communication with the remote server.
9271 See remote_serial_quit_handler for more detail. */
9274 remote_target::readchar (int timeout
)
9277 struct remote_state
*rs
= get_remote_state ();
9280 scoped_restore restore_quit_target
9281 = make_scoped_restore (&curr_quit_handler_target
, this);
9282 scoped_restore restore_quit
9283 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9285 rs
->got_ctrlc_during_io
= 0;
9287 ch
= serial_readchar (rs
->remote_desc
, timeout
);
9289 if (rs
->got_ctrlc_during_io
)
9296 switch ((enum serial_rc
) ch
)
9299 remote_unpush_target (this);
9300 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9303 unpush_and_perror (this, _("Remote communication error. "
9304 "Target disconnected."));
9306 case SERIAL_TIMEOUT
:
9312 /* Wrapper for serial_write that closes the target and throws if
9313 writing fails. The current quit handler is overridden to avoid
9314 quitting in the middle of packet sequence, as that would break
9315 communication with the remote server. See
9316 remote_serial_quit_handler for more detail. */
9319 remote_target::remote_serial_write (const char *str
, int len
)
9321 struct remote_state
*rs
= get_remote_state ();
9323 scoped_restore restore_quit_target
9324 = make_scoped_restore (&curr_quit_handler_target
, this);
9325 scoped_restore restore_quit
9326 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9328 rs
->got_ctrlc_during_io
= 0;
9330 if (serial_write (rs
->remote_desc
, str
, len
))
9332 unpush_and_perror (this, _("Remote communication error. "
9333 "Target disconnected."));
9336 if (rs
->got_ctrlc_during_io
)
9340 /* Return a string representing an escaped version of BUF, of len N.
9341 E.g. \n is converted to \\n, \t to \\t, etc. */
9344 escape_buffer (const char *buf
, int n
)
9348 stb
.putstrn (buf
, n
, '\\');
9349 return std::move (stb
.string ());
9352 /* Display a null-terminated packet on stdout, for debugging, using C
9356 print_packet (const char *buf
)
9358 puts_filtered ("\"");
9359 fputstr_filtered (buf
, '"', gdb_stdout
);
9360 puts_filtered ("\"");
9364 remote_target::putpkt (const char *buf
)
9366 return putpkt_binary (buf
, strlen (buf
));
9369 /* Wrapper around remote_target::putpkt to avoid exporting
9373 putpkt (remote_target
*remote
, const char *buf
)
9375 return remote
->putpkt (buf
);
9378 /* Send a packet to the remote machine, with error checking. The data
9379 of the packet is in BUF. The string in BUF can be at most
9380 get_remote_packet_size () - 5 to account for the $, # and checksum,
9381 and for a possible /0 if we are debugging (remote_debug) and want
9382 to print the sent packet as a string. */
9385 remote_target::putpkt_binary (const char *buf
, int cnt
)
9387 struct remote_state
*rs
= get_remote_state ();
9389 unsigned char csum
= 0;
9390 gdb::def_vector
<char> data (cnt
+ 6);
9391 char *buf2
= data
.data ();
9397 /* Catch cases like trying to read memory or listing threads while
9398 we're waiting for a stop reply. The remote server wouldn't be
9399 ready to handle this request, so we'd hang and timeout. We don't
9400 have to worry about this in synchronous mode, because in that
9401 case it's not possible to issue a command while the target is
9402 running. This is not a problem in non-stop mode, because in that
9403 case, the stub is always ready to process serial input. */
9404 if (!target_is_non_stop_p ()
9405 && target_is_async_p ()
9406 && rs
->waiting_for_stop_reply
)
9408 error (_("Cannot execute this command while the target is running.\n"
9409 "Use the \"interrupt\" command to stop the target\n"
9410 "and then try again."));
9413 /* We're sending out a new packet. Make sure we don't look at a
9414 stale cached response. */
9415 rs
->cached_wait_status
= 0;
9417 /* Copy the packet into buffer BUF2, encapsulating it
9418 and giving it a checksum. */
9423 for (i
= 0; i
< cnt
; i
++)
9429 *p
++ = tohex ((csum
>> 4) & 0xf);
9430 *p
++ = tohex (csum
& 0xf);
9432 /* Send it over and over until we get a positive ack. */
9440 int len
= (int) (p
- buf2
);
9443 if (remote_packet_max_chars
< 0)
9446 max_chars
= remote_packet_max_chars
;
9449 = escape_buffer (buf2
, std::min (len
, max_chars
));
9451 if (len
> max_chars
)
9452 remote_debug_printf_nofunc
9453 ("Sending packet: %s [%d bytes omitted]", str
.c_str (),
9456 remote_debug_printf_nofunc ("Sending packet: %s", str
.c_str ());
9458 remote_serial_write (buf2
, p
- buf2
);
9460 /* If this is a no acks version of the remote protocol, send the
9461 packet and move on. */
9465 /* Read until either a timeout occurs (-2) or '+' is read.
9466 Handle any notification that arrives in the mean time. */
9469 ch
= readchar (remote_timeout
);
9474 remote_debug_printf_nofunc ("Received Ack");
9477 remote_debug_printf_nofunc ("Received Nak");
9479 case SERIAL_TIMEOUT
:
9483 break; /* Retransmit buffer. */
9486 remote_debug_printf ("Packet instead of Ack, ignoring it");
9487 /* It's probably an old response sent because an ACK
9488 was lost. Gobble up the packet and ack it so it
9489 doesn't get retransmitted when we resend this
9492 remote_serial_write ("+", 1);
9493 continue; /* Now, go look for +. */
9500 /* If we got a notification, handle it, and go back to looking
9502 /* We've found the start of a notification. Now
9503 collect the data. */
9504 val
= read_frame (&rs
->buf
);
9507 remote_debug_printf_nofunc
9508 (" Notification received: %s",
9509 escape_buffer (rs
->buf
.data (), val
).c_str ());
9511 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9512 /* We're in sync now, rewait for the ack. */
9516 remote_debug_printf_nofunc ("Junk: %c%s", ch
& 0177,
9522 remote_debug_printf_nofunc ("Junk: %c%s", ch
& 0177,
9526 break; /* Here to retransmit. */
9530 /* This is wrong. If doing a long backtrace, the user should be
9531 able to get out next time we call QUIT, without anything as
9532 violent as interrupt_query. If we want to provide a way out of
9533 here without getting to the next QUIT, it should be based on
9534 hitting ^C twice as in remote_wait. */
9546 /* Come here after finding the start of a frame when we expected an
9547 ack. Do our best to discard the rest of this packet. */
9550 remote_target::skip_frame ()
9556 c
= readchar (remote_timeout
);
9559 case SERIAL_TIMEOUT
:
9560 /* Nothing we can do. */
9563 /* Discard the two bytes of checksum and stop. */
9564 c
= readchar (remote_timeout
);
9566 c
= readchar (remote_timeout
);
9569 case '*': /* Run length encoding. */
9570 /* Discard the repeat count. */
9571 c
= readchar (remote_timeout
);
9576 /* A regular character. */
9582 /* Come here after finding the start of the frame. Collect the rest
9583 into *BUF, verifying the checksum, length, and handling run-length
9584 compression. NUL terminate the buffer. If there is not enough room,
9587 Returns -1 on error, number of characters in buffer (ignoring the
9588 trailing NULL) on success. (could be extended to return one of the
9589 SERIAL status indications). */
9592 remote_target::read_frame (gdb::char_vector
*buf_p
)
9597 char *buf
= buf_p
->data ();
9598 struct remote_state
*rs
= get_remote_state ();
9605 c
= readchar (remote_timeout
);
9608 case SERIAL_TIMEOUT
:
9609 remote_debug_printf ("Timeout in mid-packet, retrying");
9613 remote_debug_printf ("Saw new packet start in middle of old one");
9614 return -1; /* Start a new packet, count retries. */
9618 unsigned char pktcsum
;
9624 check_0
= readchar (remote_timeout
);
9626 check_1
= readchar (remote_timeout
);
9628 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9630 remote_debug_printf ("Timeout in checksum, retrying");
9633 else if (check_0
< 0 || check_1
< 0)
9635 remote_debug_printf ("Communication error in checksum");
9639 /* Don't recompute the checksum; with no ack packets we
9640 don't have any way to indicate a packet retransmission
9645 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9646 if (csum
== pktcsum
)
9650 ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s",
9651 pktcsum
, csum
, escape_buffer (buf
, bc
).c_str ());
9653 /* Number of characters in buffer ignoring trailing
9657 case '*': /* Run length encoding. */
9662 c
= readchar (remote_timeout
);
9664 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9666 /* The character before ``*'' is repeated. */
9668 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9670 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9672 /* Make some more room in the buffer. */
9673 buf_p
->resize (buf_p
->size () + repeat
);
9674 buf
= buf_p
->data ();
9677 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9683 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9687 if (bc
>= buf_p
->size () - 1)
9689 /* Make some more room in the buffer. */
9690 buf_p
->resize (buf_p
->size () * 2);
9691 buf
= buf_p
->data ();
9701 /* Set this to the maximum number of seconds to wait instead of waiting forever
9702 in target_wait(). If this timer times out, then it generates an error and
9703 the command is aborted. This replaces most of the need for timeouts in the
9704 GDB test suite, and makes it possible to distinguish between a hung target
9705 and one with slow communications. */
9707 static int watchdog
= 0;
9709 show_watchdog (struct ui_file
*file
, int from_tty
,
9710 struct cmd_list_element
*c
, const char *value
)
9712 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9715 /* Read a packet from the remote machine, with error checking, and
9716 store it in *BUF. Resize *BUF if necessary to hold the result. If
9717 FOREVER, wait forever rather than timing out; this is used (in
9718 synchronous mode) to wait for a target that is is executing user
9720 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9721 don't have to change all the calls to getpkt to deal with the
9722 return value, because at the moment I don't know what the right
9723 thing to do it for those. */
9726 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9728 getpkt_sane (buf
, forever
);
9732 /* Read a packet from the remote machine, with error checking, and
9733 store it in *BUF. Resize *BUF if necessary to hold the result. If
9734 FOREVER, wait forever rather than timing out; this is used (in
9735 synchronous mode) to wait for a target that is is executing user
9736 code to stop. If FOREVER == 0, this function is allowed to time
9737 out gracefully and return an indication of this to the caller.
9738 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9739 consider receiving a notification enough reason to return to the
9740 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9741 holds a notification or not (a regular packet). */
9744 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9745 int forever
, int expecting_notif
,
9748 struct remote_state
*rs
= get_remote_state ();
9754 /* We're reading a new response. Make sure we don't look at a
9755 previously cached response. */
9756 rs
->cached_wait_status
= 0;
9758 strcpy (buf
->data (), "timeout");
9761 timeout
= watchdog
> 0 ? watchdog
: -1;
9762 else if (expecting_notif
)
9763 timeout
= 0; /* There should already be a char in the buffer. If
9766 timeout
= remote_timeout
;
9770 /* Process any number of notifications, and then return when
9774 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9776 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9778 /* This can loop forever if the remote side sends us
9779 characters continuously, but if it pauses, we'll get
9780 SERIAL_TIMEOUT from readchar because of timeout. Then
9781 we'll count that as a retry.
9783 Note that even when forever is set, we will only wait
9784 forever prior to the start of a packet. After that, we
9785 expect characters to arrive at a brisk pace. They should
9786 show up within remote_timeout intervals. */
9788 c
= readchar (timeout
);
9789 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9791 if (c
== SERIAL_TIMEOUT
)
9793 if (expecting_notif
)
9794 return -1; /* Don't complain, it's normal to not get
9795 anything in this case. */
9797 if (forever
) /* Watchdog went off? Kill the target. */
9799 remote_unpush_target (this);
9800 throw_error (TARGET_CLOSE_ERROR
,
9801 _("Watchdog timeout has expired. "
9802 "Target detached."));
9805 remote_debug_printf ("Timed out.");
9809 /* We've found the start of a packet or notification.
9810 Now collect the data. */
9811 val
= read_frame (buf
);
9816 remote_serial_write ("-", 1);
9819 if (tries
> MAX_TRIES
)
9821 /* We have tried hard enough, and just can't receive the
9822 packet/notification. Give up. */
9823 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9825 /* Skip the ack char if we're in no-ack mode. */
9826 if (!rs
->noack_mode
)
9827 remote_serial_write ("+", 1);
9831 /* If we got an ordinary packet, return that to our caller. */
9838 if (remote_packet_max_chars
< 0)
9841 max_chars
= remote_packet_max_chars
;
9844 = escape_buffer (buf
->data (),
9845 std::min (val
, max_chars
));
9847 if (val
> max_chars
)
9848 remote_debug_printf_nofunc
9849 ("Packet received: %s [%d bytes omitted]", str
.c_str (),
9852 remote_debug_printf_nofunc ("Packet received: %s",
9856 /* Skip the ack char if we're in no-ack mode. */
9857 if (!rs
->noack_mode
)
9858 remote_serial_write ("+", 1);
9859 if (is_notif
!= NULL
)
9864 /* If we got a notification, handle it, and go back to looking
9868 gdb_assert (c
== '%');
9870 remote_debug_printf_nofunc
9871 (" Notification received: %s",
9872 escape_buffer (buf
->data (), val
).c_str ());
9874 if (is_notif
!= NULL
)
9877 handle_notification (rs
->notif_state
, buf
->data ());
9879 /* Notifications require no acknowledgement. */
9881 if (expecting_notif
)
9888 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9890 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9894 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9897 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9900 /* Kill any new fork children of process PID that haven't been
9901 processed by follow_fork. */
9904 remote_target::kill_new_fork_children (int pid
)
9906 remote_state
*rs
= get_remote_state ();
9907 struct notif_client
*notif
= ¬if_client_stop
;
9909 /* Kill the fork child threads of any threads in process PID
9910 that are stopped at a fork event. */
9911 for (thread_info
*thread
: all_non_exited_threads (this))
9913 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9915 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9917 int child_pid
= ws
->value
.related_pid
.pid ();
9920 res
= remote_vkill (child_pid
);
9922 error (_("Can't kill fork child process %d"), child_pid
);
9926 /* Check for any pending fork events (not reported or processed yet)
9927 in process PID and kill those fork child threads as well. */
9928 remote_notif_get_pending_events (notif
);
9929 for (auto &event
: rs
->stop_reply_queue
)
9930 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9932 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9935 res
= remote_vkill (child_pid
);
9937 error (_("Can't kill fork child process %d"), child_pid
);
9942 /* Target hook to kill the current inferior. */
9945 remote_target::kill ()
9948 int pid
= inferior_ptid
.pid ();
9949 struct remote_state
*rs
= get_remote_state ();
9951 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9953 /* If we're stopped while forking and we haven't followed yet,
9954 kill the child task. We need to do this before killing the
9955 parent task because if this is a vfork then the parent will
9957 kill_new_fork_children (pid
);
9959 res
= remote_vkill (pid
);
9962 target_mourn_inferior (inferior_ptid
);
9967 /* If we are in 'target remote' mode and we are killing the only
9968 inferior, then we will tell gdbserver to exit and unpush the
9970 if (res
== -1 && !remote_multi_process_p (rs
)
9971 && number_of_live_inferiors (this) == 1)
9975 /* We've killed the remote end, we get to mourn it. If we are
9976 not in extended mode, mourning the inferior also unpushes
9977 remote_ops from the target stack, which closes the remote
9979 target_mourn_inferior (inferior_ptid
);
9984 error (_("Can't kill process"));
9987 /* Send a kill request to the target using the 'vKill' packet. */
9990 remote_target::remote_vkill (int pid
)
9992 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9995 remote_state
*rs
= get_remote_state ();
9997 /* Tell the remote target to detach. */
9998 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
10000 getpkt (&rs
->buf
, 0);
10002 switch (packet_ok (rs
->buf
,
10003 &remote_protocol_packets
[PACKET_vKill
]))
10009 case PACKET_UNKNOWN
:
10012 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
10016 /* Send a kill request to the target using the 'k' packet. */
10019 remote_target::remote_kill_k ()
10021 /* Catch errors so the user can quit from gdb even when we
10022 aren't on speaking terms with the remote system. */
10027 catch (const gdb_exception_error
&ex
)
10029 if (ex
.error
== TARGET_CLOSE_ERROR
)
10031 /* If we got an (EOF) error that caused the target
10032 to go away, then we're done, that's what we wanted.
10033 "k" is susceptible to cause a premature EOF, given
10034 that the remote server isn't actually required to
10035 reply to "k", and it can happen that it doesn't
10036 even get to reply ACK to the "k". */
10040 /* Otherwise, something went wrong. We didn't actually kill
10041 the target. Just propagate the exception, and let the
10042 user or higher layers decide what to do. */
10048 remote_target::mourn_inferior ()
10050 struct remote_state
*rs
= get_remote_state ();
10052 /* We're no longer interested in notification events of an inferior
10053 that exited or was killed/detached. */
10054 discard_pending_stop_replies (current_inferior ());
10056 /* In 'target remote' mode with one inferior, we close the connection. */
10057 if (!rs
->extended
&& number_of_live_inferiors (this) <= 1)
10059 remote_unpush_target (this);
10063 /* In case we got here due to an error, but we're going to stay
10065 rs
->waiting_for_stop_reply
= 0;
10067 /* If the current general thread belonged to the process we just
10068 detached from or has exited, the remote side current general
10069 thread becomes undefined. Considering a case like this:
10071 - We just got here due to a detach.
10072 - The process that we're detaching from happens to immediately
10073 report a global breakpoint being hit in non-stop mode, in the
10074 same thread we had selected before.
10075 - GDB attaches to this process again.
10076 - This event happens to be the next event we handle.
10078 GDB would consider that the current general thread didn't need to
10079 be set on the stub side (with Hg), since for all it knew,
10080 GENERAL_THREAD hadn't changed.
10082 Notice that although in all-stop mode, the remote server always
10083 sets the current thread to the thread reporting the stop event,
10084 that doesn't happen in non-stop mode; in non-stop, the stub *must
10085 not* change the current thread when reporting a breakpoint hit,
10086 due to the decoupling of event reporting and event handling.
10088 To keep things simple, we always invalidate our notion of the
10090 record_currthread (rs
, minus_one_ptid
);
10092 /* Call common code to mark the inferior as not running. */
10093 generic_mourn_inferior ();
10097 extended_remote_target::supports_disable_randomization ()
10099 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
10103 remote_target::extended_remote_disable_randomization (int val
)
10105 struct remote_state
*rs
= get_remote_state ();
10108 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10109 "QDisableRandomization:%x", val
);
10111 reply
= remote_get_noisy_reply ();
10112 if (*reply
== '\0')
10113 error (_("Target does not support QDisableRandomization."));
10114 if (strcmp (reply
, "OK") != 0)
10115 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
10119 remote_target::extended_remote_run (const std::string
&args
)
10121 struct remote_state
*rs
= get_remote_state ();
10123 const char *remote_exec_file
= get_remote_exec_file ();
10125 /* If the user has disabled vRun support, or we have detected that
10126 support is not available, do not try it. */
10127 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
10130 strcpy (rs
->buf
.data (), "vRun;");
10131 len
= strlen (rs
->buf
.data ());
10133 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
10134 error (_("Remote file name too long for run packet"));
10135 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
10136 strlen (remote_exec_file
));
10138 if (!args
.empty ())
10142 gdb_argv
argv (args
.c_str ());
10143 for (i
= 0; argv
[i
] != NULL
; i
++)
10145 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
10146 error (_("Argument list too long for run packet"));
10147 rs
->buf
[len
++] = ';';
10148 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
10153 rs
->buf
[len
++] = '\0';
10156 getpkt (&rs
->buf
, 0);
10158 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
10161 /* We have a wait response. All is well. */
10163 case PACKET_UNKNOWN
:
10166 if (remote_exec_file
[0] == '\0')
10167 error (_("Running the default executable on the remote target failed; "
10168 "try \"set remote exec-file\"?"));
10170 error (_("Running \"%s\" on the remote target failed"),
10173 gdb_assert_not_reached (_("bad switch"));
10177 /* Helper function to send set/unset environment packets. ACTION is
10178 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
10179 or "QEnvironmentUnsetVariable". VALUE is the variable to be
10183 remote_target::send_environment_packet (const char *action
,
10184 const char *packet
,
10187 remote_state
*rs
= get_remote_state ();
10189 /* Convert the environment variable to an hex string, which
10190 is the best format to be transmitted over the wire. */
10191 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
10194 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10195 "%s:%s", packet
, encoded_value
.c_str ());
10198 getpkt (&rs
->buf
, 0);
10199 if (strcmp (rs
->buf
.data (), "OK") != 0)
10200 warning (_("Unable to %s environment variable '%s' on remote."),
10204 /* Helper function to handle the QEnvironment* packets. */
10207 remote_target::extended_remote_environment_support ()
10209 remote_state
*rs
= get_remote_state ();
10211 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
10213 putpkt ("QEnvironmentReset");
10214 getpkt (&rs
->buf
, 0);
10215 if (strcmp (rs
->buf
.data (), "OK") != 0)
10216 warning (_("Unable to reset environment on remote."));
10219 gdb_environ
*e
= ¤t_inferior ()->environment
;
10221 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
10222 for (const std::string
&el
: e
->user_set_env ())
10223 send_environment_packet ("set", "QEnvironmentHexEncoded",
10226 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
10227 for (const std::string
&el
: e
->user_unset_env ())
10228 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10231 /* Helper function to set the current working directory for the
10232 inferior in the remote target. */
10235 remote_target::extended_remote_set_inferior_cwd ()
10237 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10239 const char *inferior_cwd
= get_inferior_cwd ();
10240 remote_state
*rs
= get_remote_state ();
10242 if (inferior_cwd
!= NULL
)
10244 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10245 strlen (inferior_cwd
));
10247 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10248 "QSetWorkingDir:%s", hexpath
.c_str ());
10252 /* An empty inferior_cwd means that the user wants us to
10253 reset the remote server's inferior's cwd. */
10254 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10255 "QSetWorkingDir:");
10259 getpkt (&rs
->buf
, 0);
10260 if (packet_ok (rs
->buf
,
10261 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10264 Remote replied unexpectedly while setting the inferior's working\n\
10271 /* In the extended protocol we want to be able to do things like
10272 "run" and have them basically work as expected. So we need
10273 a special create_inferior function. We support changing the
10274 executable file and the command line arguments, but not the
10278 extended_remote_target::create_inferior (const char *exec_file
,
10279 const std::string
&args
,
10280 char **env
, int from_tty
)
10284 struct remote_state
*rs
= get_remote_state ();
10285 const char *remote_exec_file
= get_remote_exec_file ();
10287 /* If running asynchronously, register the target file descriptor
10288 with the event loop. */
10289 if (target_can_async_p ())
10292 /* Disable address space randomization if requested (and supported). */
10293 if (supports_disable_randomization ())
10294 extended_remote_disable_randomization (disable_randomization
);
10296 /* If startup-with-shell is on, we inform gdbserver to start the
10297 remote inferior using a shell. */
10298 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10300 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10301 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10303 getpkt (&rs
->buf
, 0);
10304 if (strcmp (rs
->buf
.data (), "OK") != 0)
10306 Remote replied unexpectedly while setting startup-with-shell: %s"),
10310 extended_remote_environment_support ();
10312 extended_remote_set_inferior_cwd ();
10314 /* Now restart the remote server. */
10315 run_worked
= extended_remote_run (args
) != -1;
10318 /* vRun was not supported. Fail if we need it to do what the
10320 if (remote_exec_file
[0])
10321 error (_("Remote target does not support \"set remote exec-file\""));
10322 if (!args
.empty ())
10323 error (_("Remote target does not support \"set args\" or run ARGS"));
10325 /* Fall back to "R". */
10326 extended_remote_restart ();
10329 /* vRun's success return is a stop reply. */
10330 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10331 add_current_inferior_and_thread (stop_reply
);
10333 /* Get updated offsets, if the stub uses qOffsets. */
10338 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10339 the list of conditions (in agent expression bytecode format), if any, the
10340 target needs to evaluate. The output is placed into the packet buffer
10341 started from BUF and ended at BUF_END. */
10344 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10345 struct bp_target_info
*bp_tgt
, char *buf
,
10348 if (bp_tgt
->conditions
.empty ())
10351 buf
+= strlen (buf
);
10352 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10355 /* Send conditions to the target. */
10356 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10358 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10359 buf
+= strlen (buf
);
10360 for (int i
= 0; i
< aexpr
->len
; ++i
)
10361 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10368 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10369 struct bp_target_info
*bp_tgt
, char *buf
)
10371 if (bp_tgt
->tcommands
.empty ())
10374 buf
+= strlen (buf
);
10376 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10377 buf
+= strlen (buf
);
10379 /* Concatenate all the agent expressions that are commands into the
10381 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10383 sprintf (buf
, "X%x,", aexpr
->len
);
10384 buf
+= strlen (buf
);
10385 for (int i
= 0; i
< aexpr
->len
; ++i
)
10386 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10391 /* Insert a breakpoint. On targets that have software breakpoint
10392 support, we ask the remote target to do the work; on targets
10393 which don't, we insert a traditional memory breakpoint. */
10396 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10397 struct bp_target_info
*bp_tgt
)
10399 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10400 If it succeeds, then set the support to PACKET_ENABLE. If it
10401 fails, and the user has explicitly requested the Z support then
10402 report an error, otherwise, mark it disabled and go on. */
10404 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10406 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10407 struct remote_state
*rs
;
10410 /* Make sure the remote is pointing at the right process, if
10412 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10413 set_general_process ();
10415 rs
= get_remote_state ();
10416 p
= rs
->buf
.data ();
10417 endbuf
= p
+ get_remote_packet_size ();
10422 addr
= (ULONGEST
) remote_address_masked (addr
);
10423 p
+= hexnumstr (p
, addr
);
10424 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10426 if (supports_evaluation_of_breakpoint_conditions ())
10427 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10429 if (can_run_breakpoint_commands ())
10430 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10433 getpkt (&rs
->buf
, 0);
10435 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10441 case PACKET_UNKNOWN
:
10446 /* If this breakpoint has target-side commands but this stub doesn't
10447 support Z0 packets, throw error. */
10448 if (!bp_tgt
->tcommands
.empty ())
10449 throw_error (NOT_SUPPORTED_ERROR
, _("\
10450 Target doesn't support breakpoints that have target side commands."));
10452 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10456 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10457 struct bp_target_info
*bp_tgt
,
10458 enum remove_bp_reason reason
)
10460 CORE_ADDR addr
= bp_tgt
->placed_address
;
10461 struct remote_state
*rs
= get_remote_state ();
10463 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10465 char *p
= rs
->buf
.data ();
10466 char *endbuf
= p
+ get_remote_packet_size ();
10468 /* Make sure the remote is pointing at the right process, if
10470 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10471 set_general_process ();
10477 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10478 p
+= hexnumstr (p
, addr
);
10479 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10482 getpkt (&rs
->buf
, 0);
10484 return (rs
->buf
[0] == 'E');
10487 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10490 static enum Z_packet_type
10491 watchpoint_to_Z_packet (int type
)
10496 return Z_PACKET_WRITE_WP
;
10499 return Z_PACKET_READ_WP
;
10502 return Z_PACKET_ACCESS_WP
;
10505 internal_error (__FILE__
, __LINE__
,
10506 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10511 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10512 enum target_hw_bp_type type
, struct expression
*cond
)
10514 struct remote_state
*rs
= get_remote_state ();
10515 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10517 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10519 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10522 /* Make sure the remote is pointing at the right process, if
10524 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10525 set_general_process ();
10527 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10528 p
= strchr (rs
->buf
.data (), '\0');
10529 addr
= remote_address_masked (addr
);
10530 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10531 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10534 getpkt (&rs
->buf
, 0);
10536 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10540 case PACKET_UNKNOWN
:
10545 internal_error (__FILE__
, __LINE__
,
10546 _("remote_insert_watchpoint: reached end of function"));
10550 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10551 CORE_ADDR start
, int length
)
10553 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10555 return diff
< length
;
10560 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10561 enum target_hw_bp_type type
, struct expression
*cond
)
10563 struct remote_state
*rs
= get_remote_state ();
10564 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10566 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10568 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10571 /* Make sure the remote is pointing at the right process, if
10573 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10574 set_general_process ();
10576 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10577 p
= strchr (rs
->buf
.data (), '\0');
10578 addr
= remote_address_masked (addr
);
10579 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10580 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10582 getpkt (&rs
->buf
, 0);
10584 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10587 case PACKET_UNKNOWN
:
10592 internal_error (__FILE__
, __LINE__
,
10593 _("remote_remove_watchpoint: reached end of function"));
10597 static int remote_hw_watchpoint_limit
= -1;
10598 static int remote_hw_watchpoint_length_limit
= -1;
10599 static int remote_hw_breakpoint_limit
= -1;
10602 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10604 if (remote_hw_watchpoint_length_limit
== 0)
10606 else if (remote_hw_watchpoint_length_limit
< 0)
10608 else if (len
<= remote_hw_watchpoint_length_limit
)
10615 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10617 if (type
== bp_hardware_breakpoint
)
10619 if (remote_hw_breakpoint_limit
== 0)
10621 else if (remote_hw_breakpoint_limit
< 0)
10623 else if (cnt
<= remote_hw_breakpoint_limit
)
10628 if (remote_hw_watchpoint_limit
== 0)
10630 else if (remote_hw_watchpoint_limit
< 0)
10634 else if (cnt
<= remote_hw_watchpoint_limit
)
10640 /* The to_stopped_by_sw_breakpoint method of target remote. */
10643 remote_target::stopped_by_sw_breakpoint ()
10645 struct thread_info
*thread
= inferior_thread ();
10647 return (thread
->priv
!= NULL
10648 && (get_remote_thread_info (thread
)->stop_reason
10649 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10652 /* The to_supports_stopped_by_sw_breakpoint method of target
10656 remote_target::supports_stopped_by_sw_breakpoint ()
10658 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10661 /* The to_stopped_by_hw_breakpoint method of target remote. */
10664 remote_target::stopped_by_hw_breakpoint ()
10666 struct thread_info
*thread
= inferior_thread ();
10668 return (thread
->priv
!= NULL
10669 && (get_remote_thread_info (thread
)->stop_reason
10670 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10673 /* The to_supports_stopped_by_hw_breakpoint method of target
10677 remote_target::supports_stopped_by_hw_breakpoint ()
10679 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10683 remote_target::stopped_by_watchpoint ()
10685 struct thread_info
*thread
= inferior_thread ();
10687 return (thread
->priv
!= NULL
10688 && (get_remote_thread_info (thread
)->stop_reason
10689 == TARGET_STOPPED_BY_WATCHPOINT
));
10693 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10695 struct thread_info
*thread
= inferior_thread ();
10697 if (thread
->priv
!= NULL
10698 && (get_remote_thread_info (thread
)->stop_reason
10699 == TARGET_STOPPED_BY_WATCHPOINT
))
10701 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10710 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10711 struct bp_target_info
*bp_tgt
)
10713 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10714 struct remote_state
*rs
;
10718 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10721 /* Make sure the remote is pointing at the right process, if
10723 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10724 set_general_process ();
10726 rs
= get_remote_state ();
10727 p
= rs
->buf
.data ();
10728 endbuf
= p
+ get_remote_packet_size ();
10734 addr
= remote_address_masked (addr
);
10735 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10736 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10738 if (supports_evaluation_of_breakpoint_conditions ())
10739 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10741 if (can_run_breakpoint_commands ())
10742 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10745 getpkt (&rs
->buf
, 0);
10747 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10750 if (rs
->buf
[1] == '.')
10752 message
= strchr (&rs
->buf
[2], '.');
10754 error (_("Remote failure reply: %s"), message
+ 1);
10757 case PACKET_UNKNOWN
:
10762 internal_error (__FILE__
, __LINE__
,
10763 _("remote_insert_hw_breakpoint: reached end of function"));
10768 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10769 struct bp_target_info
*bp_tgt
)
10772 struct remote_state
*rs
= get_remote_state ();
10773 char *p
= rs
->buf
.data ();
10774 char *endbuf
= p
+ get_remote_packet_size ();
10776 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10779 /* Make sure the remote is pointing at the right process, if
10781 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10782 set_general_process ();
10788 addr
= remote_address_masked (bp_tgt
->placed_address
);
10789 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10790 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10793 getpkt (&rs
->buf
, 0);
10795 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10798 case PACKET_UNKNOWN
:
10803 internal_error (__FILE__
, __LINE__
,
10804 _("remote_remove_hw_breakpoint: reached end of function"));
10807 /* Verify memory using the "qCRC:" request. */
10810 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10812 struct remote_state
*rs
= get_remote_state ();
10813 unsigned long host_crc
, target_crc
;
10816 /* It doesn't make sense to use qCRC if the remote target is
10817 connected but not running. */
10818 if (target_has_execution ()
10819 && packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10821 enum packet_result result
;
10823 /* Make sure the remote is pointing at the right process. */
10824 set_general_process ();
10826 /* FIXME: assumes lma can fit into long. */
10827 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10828 (long) lma
, (long) size
);
10831 /* Be clever; compute the host_crc before waiting for target
10833 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10835 getpkt (&rs
->buf
, 0);
10837 result
= packet_ok (rs
->buf
,
10838 &remote_protocol_packets
[PACKET_qCRC
]);
10839 if (result
== PACKET_ERROR
)
10841 else if (result
== PACKET_OK
)
10843 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10844 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10846 return (host_crc
== target_crc
);
10850 return simple_verify_memory (this, data
, lma
, size
);
10853 /* compare-sections command
10855 With no arguments, compares each loadable section in the exec bfd
10856 with the same memory range on the target, and reports mismatches.
10857 Useful for verifying the image on the target against the exec file. */
10860 compare_sections_command (const char *args
, int from_tty
)
10863 const char *sectname
;
10864 bfd_size_type size
;
10867 int mismatched
= 0;
10871 if (!current_program_space
->exec_bfd ())
10872 error (_("command cannot be used without an exec file"));
10874 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10880 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
10882 if (!(s
->flags
& SEC_LOAD
))
10883 continue; /* Skip non-loadable section. */
10885 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10886 continue; /* Skip writeable sections */
10888 size
= bfd_section_size (s
);
10890 continue; /* Skip zero-length section. */
10892 sectname
= bfd_section_name (s
);
10893 if (args
&& strcmp (args
, sectname
) != 0)
10894 continue; /* Not the section selected by user. */
10896 matched
= 1; /* Do this section. */
10899 gdb::byte_vector
sectdata (size
);
10900 bfd_get_section_contents (current_program_space
->exec_bfd (), s
,
10901 sectdata
.data (), 0, size
);
10903 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10906 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10907 paddress (target_gdbarch (), lma
),
10908 paddress (target_gdbarch (), lma
+ size
));
10910 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10911 paddress (target_gdbarch (), lma
),
10912 paddress (target_gdbarch (), lma
+ size
));
10914 printf_filtered ("matched.\n");
10917 printf_filtered ("MIS-MATCHED!\n");
10921 if (mismatched
> 0)
10922 warning (_("One or more sections of the target image does not match\n\
10923 the loaded file\n"));
10924 if (args
&& !matched
)
10925 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10928 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10929 into remote target. The number of bytes written to the remote
10930 target is returned, or -1 for error. */
10933 remote_target::remote_write_qxfer (const char *object_name
,
10934 const char *annex
, const gdb_byte
*writebuf
,
10935 ULONGEST offset
, LONGEST len
,
10936 ULONGEST
*xfered_len
,
10937 struct packet_config
*packet
)
10941 struct remote_state
*rs
= get_remote_state ();
10942 int max_size
= get_memory_write_packet_size ();
10944 if (packet_config_support (packet
) == PACKET_DISABLE
)
10945 return TARGET_XFER_E_IO
;
10947 /* Insert header. */
10948 i
= snprintf (rs
->buf
.data (), max_size
,
10949 "qXfer:%s:write:%s:%s:",
10950 object_name
, annex
? annex
: "",
10951 phex_nz (offset
, sizeof offset
));
10952 max_size
-= (i
+ 1);
10954 /* Escape as much data as fits into rs->buf. */
10955 buf_len
= remote_escape_output
10956 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10958 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10959 || getpkt_sane (&rs
->buf
, 0) < 0
10960 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10961 return TARGET_XFER_E_IO
;
10963 unpack_varlen_hex (rs
->buf
.data (), &n
);
10966 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10969 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10970 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10971 number of bytes read is returned, or 0 for EOF, or -1 for error.
10972 The number of bytes read may be less than LEN without indicating an
10973 EOF. PACKET is checked and updated to indicate whether the remote
10974 target supports this object. */
10977 remote_target::remote_read_qxfer (const char *object_name
,
10979 gdb_byte
*readbuf
, ULONGEST offset
,
10981 ULONGEST
*xfered_len
,
10982 struct packet_config
*packet
)
10984 struct remote_state
*rs
= get_remote_state ();
10985 LONGEST i
, n
, packet_len
;
10987 if (packet_config_support (packet
) == PACKET_DISABLE
)
10988 return TARGET_XFER_E_IO
;
10990 /* Check whether we've cached an end-of-object packet that matches
10992 if (rs
->finished_object
)
10994 if (strcmp (object_name
, rs
->finished_object
) == 0
10995 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10996 && offset
== rs
->finished_offset
)
10997 return TARGET_XFER_EOF
;
11000 /* Otherwise, we're now reading something different. Discard
11002 xfree (rs
->finished_object
);
11003 xfree (rs
->finished_annex
);
11004 rs
->finished_object
= NULL
;
11005 rs
->finished_annex
= NULL
;
11008 /* Request only enough to fit in a single packet. The actual data
11009 may not, since we don't know how much of it will need to be escaped;
11010 the target is free to respond with slightly less data. We subtract
11011 five to account for the response type and the protocol frame. */
11012 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
11013 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
11014 "qXfer:%s:read:%s:%s,%s",
11015 object_name
, annex
? annex
: "",
11016 phex_nz (offset
, sizeof offset
),
11017 phex_nz (n
, sizeof n
));
11018 i
= putpkt (rs
->buf
);
11020 return TARGET_XFER_E_IO
;
11023 packet_len
= getpkt_sane (&rs
->buf
, 0);
11024 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11025 return TARGET_XFER_E_IO
;
11027 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
11028 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
11030 /* 'm' means there is (or at least might be) more data after this
11031 batch. That does not make sense unless there's at least one byte
11032 of data in this reply. */
11033 if (rs
->buf
[0] == 'm' && packet_len
== 1)
11034 error (_("Remote qXfer reply contained no data."));
11036 /* Got some data. */
11037 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
11038 packet_len
- 1, readbuf
, n
);
11040 /* 'l' is an EOF marker, possibly including a final block of data,
11041 or possibly empty. If we have the final block of a non-empty
11042 object, record this fact to bypass a subsequent partial read. */
11043 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
11045 rs
->finished_object
= xstrdup (object_name
);
11046 rs
->finished_annex
= xstrdup (annex
? annex
: "");
11047 rs
->finished_offset
= offset
+ i
;
11051 return TARGET_XFER_EOF
;
11055 return TARGET_XFER_OK
;
11059 enum target_xfer_status
11060 remote_target::xfer_partial (enum target_object object
,
11061 const char *annex
, gdb_byte
*readbuf
,
11062 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
11063 ULONGEST
*xfered_len
)
11065 struct remote_state
*rs
;
11069 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
11071 set_remote_traceframe ();
11072 set_general_thread (inferior_ptid
);
11074 rs
= get_remote_state ();
11076 /* Handle memory using the standard memory routines. */
11077 if (object
== TARGET_OBJECT_MEMORY
)
11079 /* If the remote target is connected but not running, we should
11080 pass this request down to a lower stratum (e.g. the executable
11082 if (!target_has_execution ())
11083 return TARGET_XFER_EOF
;
11085 if (writebuf
!= NULL
)
11086 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
11089 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
11093 /* Handle extra signal info using qxfer packets. */
11094 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
11097 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
11098 xfered_len
, &remote_protocol_packets
11099 [PACKET_qXfer_siginfo_read
]);
11101 return remote_write_qxfer ("siginfo", annex
,
11102 writebuf
, offset
, len
, xfered_len
,
11103 &remote_protocol_packets
11104 [PACKET_qXfer_siginfo_write
]);
11107 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
11110 return remote_read_qxfer ("statictrace", annex
,
11111 readbuf
, offset
, len
, xfered_len
,
11112 &remote_protocol_packets
11113 [PACKET_qXfer_statictrace_read
]);
11115 return TARGET_XFER_E_IO
;
11118 /* Only handle flash writes. */
11119 if (writebuf
!= NULL
)
11123 case TARGET_OBJECT_FLASH
:
11124 return remote_flash_write (offset
, len
, xfered_len
,
11128 return TARGET_XFER_E_IO
;
11132 /* Map pre-existing objects onto letters. DO NOT do this for new
11133 objects!!! Instead specify new query packets. */
11136 case TARGET_OBJECT_AVR
:
11140 case TARGET_OBJECT_AUXV
:
11141 gdb_assert (annex
== NULL
);
11142 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
11144 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
11146 case TARGET_OBJECT_AVAILABLE_FEATURES
:
11147 return remote_read_qxfer
11148 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
11149 &remote_protocol_packets
[PACKET_qXfer_features
]);
11151 case TARGET_OBJECT_LIBRARIES
:
11152 return remote_read_qxfer
11153 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
11154 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
11156 case TARGET_OBJECT_LIBRARIES_SVR4
:
11157 return remote_read_qxfer
11158 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
11159 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
11161 case TARGET_OBJECT_MEMORY_MAP
:
11162 gdb_assert (annex
== NULL
);
11163 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
11165 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
11167 case TARGET_OBJECT_OSDATA
:
11168 /* Should only get here if we're connected. */
11169 gdb_assert (rs
->remote_desc
);
11170 return remote_read_qxfer
11171 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
11172 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
11174 case TARGET_OBJECT_THREADS
:
11175 gdb_assert (annex
== NULL
);
11176 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
11178 &remote_protocol_packets
[PACKET_qXfer_threads
]);
11180 case TARGET_OBJECT_TRACEFRAME_INFO
:
11181 gdb_assert (annex
== NULL
);
11182 return remote_read_qxfer
11183 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
11184 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
11186 case TARGET_OBJECT_FDPIC
:
11187 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
11189 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
11191 case TARGET_OBJECT_OPENVMS_UIB
:
11192 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
11194 &remote_protocol_packets
[PACKET_qXfer_uib
]);
11196 case TARGET_OBJECT_BTRACE
:
11197 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
11199 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
11201 case TARGET_OBJECT_BTRACE_CONF
:
11202 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
11204 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
11206 case TARGET_OBJECT_EXEC_FILE
:
11207 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
11209 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
11212 return TARGET_XFER_E_IO
;
11215 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
11216 large enough let the caller deal with it. */
11217 if (len
< get_remote_packet_size ())
11218 return TARGET_XFER_E_IO
;
11219 len
= get_remote_packet_size ();
11221 /* Except for querying the minimum buffer size, target must be open. */
11222 if (!rs
->remote_desc
)
11223 error (_("remote query is only available after target open"));
11225 gdb_assert (annex
!= NULL
);
11226 gdb_assert (readbuf
!= NULL
);
11228 p2
= rs
->buf
.data ();
11230 *p2
++ = query_type
;
11232 /* We used one buffer char for the remote protocol q command and
11233 another for the query type. As the remote protocol encapsulation
11234 uses 4 chars plus one extra in case we are debugging
11235 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11238 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11240 /* Bad caller may have sent forbidden characters. */
11241 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11246 gdb_assert (annex
[i
] == '\0');
11248 i
= putpkt (rs
->buf
);
11250 return TARGET_XFER_E_IO
;
11252 getpkt (&rs
->buf
, 0);
11253 strcpy ((char *) readbuf
, rs
->buf
.data ());
11255 *xfered_len
= strlen ((char *) readbuf
);
11256 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11259 /* Implementation of to_get_memory_xfer_limit. */
11262 remote_target::get_memory_xfer_limit ()
11264 return get_memory_write_packet_size ();
11268 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11269 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11270 CORE_ADDR
*found_addrp
)
11272 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11273 struct remote_state
*rs
= get_remote_state ();
11274 int max_size
= get_memory_write_packet_size ();
11275 struct packet_config
*packet
=
11276 &remote_protocol_packets
[PACKET_qSearch_memory
];
11277 /* Number of packet bytes used to encode the pattern;
11278 this could be more than PATTERN_LEN due to escape characters. */
11279 int escaped_pattern_len
;
11280 /* Amount of pattern that was encodable in the packet. */
11281 int used_pattern_len
;
11284 ULONGEST found_addr
;
11286 auto read_memory
= [=] (CORE_ADDR addr
, gdb_byte
*result
, size_t len
)
11288 return (target_read (this, TARGET_OBJECT_MEMORY
, NULL
, result
, addr
, len
)
11292 /* Don't go to the target if we don't have to. This is done before
11293 checking packet_config_support to avoid the possibility that a
11294 success for this edge case means the facility works in
11296 if (pattern_len
> search_space_len
)
11298 if (pattern_len
== 0)
11300 *found_addrp
= start_addr
;
11304 /* If we already know the packet isn't supported, fall back to the simple
11305 way of searching memory. */
11307 if (packet_config_support (packet
) == PACKET_DISABLE
)
11309 /* Target doesn't provided special support, fall back and use the
11310 standard support (copy memory and do the search here). */
11311 return simple_search_memory (read_memory
, start_addr
, search_space_len
,
11312 pattern
, pattern_len
, found_addrp
);
11315 /* Make sure the remote is pointing at the right process. */
11316 set_general_process ();
11318 /* Insert header. */
11319 i
= snprintf (rs
->buf
.data (), max_size
,
11320 "qSearch:memory:%s;%s;",
11321 phex_nz (start_addr
, addr_size
),
11322 phex_nz (search_space_len
, sizeof (search_space_len
)));
11323 max_size
-= (i
+ 1);
11325 /* Escape as much data as fits into rs->buf. */
11326 escaped_pattern_len
=
11327 remote_escape_output (pattern
, pattern_len
, 1,
11328 (gdb_byte
*) rs
->buf
.data () + i
,
11329 &used_pattern_len
, max_size
);
11331 /* Bail if the pattern is too large. */
11332 if (used_pattern_len
!= pattern_len
)
11333 error (_("Pattern is too large to transmit to remote target."));
11335 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11336 || getpkt_sane (&rs
->buf
, 0) < 0
11337 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11339 /* The request may not have worked because the command is not
11340 supported. If so, fall back to the simple way. */
11341 if (packet_config_support (packet
) == PACKET_DISABLE
)
11343 return simple_search_memory (read_memory
, start_addr
, search_space_len
,
11344 pattern
, pattern_len
, found_addrp
);
11349 if (rs
->buf
[0] == '0')
11351 else if (rs
->buf
[0] == '1')
11354 if (rs
->buf
[1] != ',')
11355 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11356 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11357 *found_addrp
= found_addr
;
11360 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11366 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11368 struct remote_state
*rs
= get_remote_state ();
11369 char *p
= rs
->buf
.data ();
11371 if (!rs
->remote_desc
)
11372 error (_("remote rcmd is only available after target open"));
11374 /* Send a NULL command across as an empty command. */
11375 if (command
== NULL
)
11378 /* The query prefix. */
11379 strcpy (rs
->buf
.data (), "qRcmd,");
11380 p
= strchr (rs
->buf
.data (), '\0');
11382 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11383 > get_remote_packet_size ())
11384 error (_("\"monitor\" command ``%s'' is too long."), command
);
11386 /* Encode the actual command. */
11387 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11389 if (putpkt (rs
->buf
) < 0)
11390 error (_("Communication problem with target."));
11392 /* get/display the response */
11397 /* XXX - see also remote_get_noisy_reply(). */
11398 QUIT
; /* Allow user to bail out with ^C. */
11400 if (getpkt_sane (&rs
->buf
, 0) == -1)
11402 /* Timeout. Continue to (try to) read responses.
11403 This is better than stopping with an error, assuming the stub
11404 is still executing the (long) monitor command.
11405 If needed, the user can interrupt gdb using C-c, obtaining
11406 an effect similar to stop on timeout. */
11409 buf
= rs
->buf
.data ();
11410 if (buf
[0] == '\0')
11411 error (_("Target does not support this command."));
11412 if (buf
[0] == 'O' && buf
[1] != 'K')
11414 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11417 if (strcmp (buf
, "OK") == 0)
11419 if (strlen (buf
) == 3 && buf
[0] == 'E'
11420 && isdigit (buf
[1]) && isdigit (buf
[2]))
11422 error (_("Protocol error with Rcmd"));
11424 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11426 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11428 fputc_unfiltered (c
, outbuf
);
11434 std::vector
<mem_region
>
11435 remote_target::memory_map ()
11437 std::vector
<mem_region
> result
;
11438 gdb::optional
<gdb::char_vector
> text
11439 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11442 result
= parse_memory_map (text
->data ());
11448 packet_command (const char *args
, int from_tty
)
11450 remote_target
*remote
= get_current_remote_target ();
11452 if (remote
== nullptr)
11453 error (_("command can only be used with remote target"));
11455 remote
->packet_command (args
, from_tty
);
11459 remote_target::packet_command (const char *args
, int from_tty
)
11462 error (_("remote-packet command requires packet text as argument"));
11464 puts_filtered ("sending: ");
11465 print_packet (args
);
11466 puts_filtered ("\n");
11469 remote_state
*rs
= get_remote_state ();
11471 getpkt (&rs
->buf
, 0);
11472 puts_filtered ("received: ");
11473 print_packet (rs
->buf
.data ());
11474 puts_filtered ("\n");
11478 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11480 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11482 static void threadset_test_cmd (char *cmd
, int tty
);
11484 static void threadalive_test (char *cmd
, int tty
);
11486 static void threadlist_test_cmd (char *cmd
, int tty
);
11488 int get_and_display_threadinfo (threadref
*ref
);
11490 static void threadinfo_test_cmd (char *cmd
, int tty
);
11492 static int thread_display_step (threadref
*ref
, void *context
);
11494 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11496 static void init_remote_threadtests (void);
11498 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11501 threadset_test_cmd (const char *cmd
, int tty
)
11503 int sample_thread
= SAMPLE_THREAD
;
11505 printf_filtered (_("Remote threadset test\n"));
11506 set_general_thread (sample_thread
);
11511 threadalive_test (const char *cmd
, int tty
)
11513 int sample_thread
= SAMPLE_THREAD
;
11514 int pid
= inferior_ptid
.pid ();
11515 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11517 if (remote_thread_alive (ptid
))
11518 printf_filtered ("PASS: Thread alive test\n");
11520 printf_filtered ("FAIL: Thread alive test\n");
11523 void output_threadid (char *title
, threadref
*ref
);
11526 output_threadid (char *title
, threadref
*ref
)
11530 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11532 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11536 threadlist_test_cmd (const char *cmd
, int tty
)
11539 threadref nextthread
;
11540 int done
, result_count
;
11541 threadref threadlist
[3];
11543 printf_filtered ("Remote Threadlist test\n");
11544 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11545 &result_count
, &threadlist
[0]))
11546 printf_filtered ("FAIL: threadlist test\n");
11549 threadref
*scan
= threadlist
;
11550 threadref
*limit
= scan
+ result_count
;
11552 while (scan
< limit
)
11553 output_threadid (" thread ", scan
++);
11558 display_thread_info (struct gdb_ext_thread_info
*info
)
11560 output_threadid ("Threadid: ", &info
->threadid
);
11561 printf_filtered ("Name: %s\n ", info
->shortname
);
11562 printf_filtered ("State: %s\n", info
->display
);
11563 printf_filtered ("other: %s\n\n", info
->more_display
);
11567 get_and_display_threadinfo (threadref
*ref
)
11571 struct gdb_ext_thread_info threadinfo
;
11573 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11574 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11575 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11576 display_thread_info (&threadinfo
);
11581 threadinfo_test_cmd (const char *cmd
, int tty
)
11583 int athread
= SAMPLE_THREAD
;
11587 int_to_threadref (&thread
, athread
);
11588 printf_filtered ("Remote Threadinfo test\n");
11589 if (!get_and_display_threadinfo (&thread
))
11590 printf_filtered ("FAIL cannot get thread info\n");
11594 thread_display_step (threadref
*ref
, void *context
)
11596 /* output_threadid(" threadstep ",ref); *//* simple test */
11597 return get_and_display_threadinfo (ref
);
11601 threadlist_update_test_cmd (const char *cmd
, int tty
)
11603 printf_filtered ("Remote Threadlist update test\n");
11604 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11608 init_remote_threadtests (void)
11610 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11611 _("Fetch and print the remote list of "
11612 "thread identifiers, one pkt only."));
11613 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11614 _("Fetch and display info about one thread."));
11615 add_com ("tset", class_obscure
, threadset_test_cmd
,
11616 _("Test setting to a different thread."));
11617 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11618 _("Iterate through updating all remote thread info."));
11619 add_com ("talive", class_obscure
, threadalive_test
,
11620 _("Remote thread alive test."));
11625 /* Convert a thread ID to a string. */
11628 remote_target::pid_to_str (ptid_t ptid
)
11630 struct remote_state
*rs
= get_remote_state ();
11632 if (ptid
== null_ptid
)
11633 return normal_pid_to_str (ptid
);
11634 else if (ptid
.is_pid ())
11636 /* Printing an inferior target id. */
11638 /* When multi-process extensions are off, there's no way in the
11639 remote protocol to know the remote process id, if there's any
11640 at all. There's one exception --- when we're connected with
11641 target extended-remote, and we manually attached to a process
11642 with "attach PID". We don't record anywhere a flag that
11643 allows us to distinguish that case from the case of
11644 connecting with extended-remote and the stub already being
11645 attached to a process, and reporting yes to qAttached, hence
11646 no smart special casing here. */
11647 if (!remote_multi_process_p (rs
))
11648 return "Remote target";
11650 return normal_pid_to_str (ptid
);
11654 if (magic_null_ptid
== ptid
)
11655 return "Thread <main>";
11656 else if (remote_multi_process_p (rs
))
11657 if (ptid
.lwp () == 0)
11658 return normal_pid_to_str (ptid
);
11660 return string_printf ("Thread %d.%ld",
11661 ptid
.pid (), ptid
.lwp ());
11663 return string_printf ("Thread %ld", ptid
.lwp ());
11667 /* Get the address of the thread local variable in OBJFILE which is
11668 stored at OFFSET within the thread local storage for thread PTID. */
11671 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11674 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11676 struct remote_state
*rs
= get_remote_state ();
11677 char *p
= rs
->buf
.data ();
11678 char *endp
= p
+ get_remote_packet_size ();
11679 enum packet_result result
;
11681 strcpy (p
, "qGetTLSAddr:");
11683 p
= write_ptid (p
, endp
, ptid
);
11685 p
+= hexnumstr (p
, offset
);
11687 p
+= hexnumstr (p
, lm
);
11691 getpkt (&rs
->buf
, 0);
11692 result
= packet_ok (rs
->buf
,
11693 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11694 if (result
== PACKET_OK
)
11698 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11701 else if (result
== PACKET_UNKNOWN
)
11702 throw_error (TLS_GENERIC_ERROR
,
11703 _("Remote target doesn't support qGetTLSAddr packet"));
11705 throw_error (TLS_GENERIC_ERROR
,
11706 _("Remote target failed to process qGetTLSAddr request"));
11709 throw_error (TLS_GENERIC_ERROR
,
11710 _("TLS not supported or disabled on this target"));
11715 /* Provide thread local base, i.e. Thread Information Block address.
11716 Returns 1 if ptid is found and thread_local_base is non zero. */
11719 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11721 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11723 struct remote_state
*rs
= get_remote_state ();
11724 char *p
= rs
->buf
.data ();
11725 char *endp
= p
+ get_remote_packet_size ();
11726 enum packet_result result
;
11728 strcpy (p
, "qGetTIBAddr:");
11730 p
= write_ptid (p
, endp
, ptid
);
11734 getpkt (&rs
->buf
, 0);
11735 result
= packet_ok (rs
->buf
,
11736 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11737 if (result
== PACKET_OK
)
11740 unpack_varlen_hex (rs
->buf
.data (), &val
);
11742 *addr
= (CORE_ADDR
) val
;
11745 else if (result
== PACKET_UNKNOWN
)
11746 error (_("Remote target doesn't support qGetTIBAddr packet"));
11748 error (_("Remote target failed to process qGetTIBAddr request"));
11751 error (_("qGetTIBAddr not supported or disabled on this target"));
11756 /* Support for inferring a target description based on the current
11757 architecture and the size of a 'g' packet. While the 'g' packet
11758 can have any size (since optional registers can be left off the
11759 end), some sizes are easily recognizable given knowledge of the
11760 approximate architecture. */
11762 struct remote_g_packet_guess
11764 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11771 const struct target_desc
*tdesc
;
11774 struct remote_g_packet_data
: public allocate_on_obstack
11776 std::vector
<remote_g_packet_guess
> guesses
;
11779 static struct gdbarch_data
*remote_g_packet_data_handle
;
11782 remote_g_packet_data_init (struct obstack
*obstack
)
11784 return new (obstack
) remote_g_packet_data
;
11788 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11789 const struct target_desc
*tdesc
)
11791 struct remote_g_packet_data
*data
11792 = ((struct remote_g_packet_data
*)
11793 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11795 gdb_assert (tdesc
!= NULL
);
11797 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11798 if (guess
.bytes
== bytes
)
11799 internal_error (__FILE__
, __LINE__
,
11800 _("Duplicate g packet description added for size %d"),
11803 data
->guesses
.emplace_back (bytes
, tdesc
);
11806 /* Return true if remote_read_description would do anything on this target
11807 and architecture, false otherwise. */
11810 remote_read_description_p (struct target_ops
*target
)
11812 struct remote_g_packet_data
*data
11813 = ((struct remote_g_packet_data
*)
11814 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11816 return !data
->guesses
.empty ();
11819 const struct target_desc
*
11820 remote_target::read_description ()
11822 struct remote_g_packet_data
*data
11823 = ((struct remote_g_packet_data
*)
11824 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11826 /* Do not try this during initial connection, when we do not know
11827 whether there is a running but stopped thread. */
11828 if (!target_has_execution () || inferior_ptid
== null_ptid
)
11829 return beneath ()->read_description ();
11831 if (!data
->guesses
.empty ())
11833 int bytes
= send_g_packet ();
11835 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11836 if (guess
.bytes
== bytes
)
11837 return guess
.tdesc
;
11839 /* We discard the g packet. A minor optimization would be to
11840 hold on to it, and fill the register cache once we have selected
11841 an architecture, but it's too tricky to do safely. */
11844 return beneath ()->read_description ();
11847 /* Remote file transfer support. This is host-initiated I/O, not
11848 target-initiated; for target-initiated, see remote-fileio.c. */
11850 /* If *LEFT is at least the length of STRING, copy STRING to
11851 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11852 decrease *LEFT. Otherwise raise an error. */
11855 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11857 int len
= strlen (string
);
11860 error (_("Packet too long for target."));
11862 memcpy (*buffer
, string
, len
);
11866 /* NUL-terminate the buffer as a convenience, if there is
11872 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11873 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11874 decrease *LEFT. Otherwise raise an error. */
11877 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11880 if (2 * len
> *left
)
11881 error (_("Packet too long for target."));
11883 bin2hex (bytes
, *buffer
, len
);
11884 *buffer
+= 2 * len
;
11887 /* NUL-terminate the buffer as a convenience, if there is
11893 /* If *LEFT is large enough, convert VALUE to hex and add it to
11894 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11895 decrease *LEFT. Otherwise raise an error. */
11898 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11900 int len
= hexnumlen (value
);
11903 error (_("Packet too long for target."));
11905 hexnumstr (*buffer
, value
);
11909 /* NUL-terminate the buffer as a convenience, if there is
11915 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11916 value, *REMOTE_ERRNO to the remote error number or zero if none
11917 was included, and *ATTACHMENT to point to the start of the annex
11918 if any. The length of the packet isn't needed here; there may
11919 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11921 Return 0 if the packet could be parsed, -1 if it could not. If
11922 -1 is returned, the other variables may not be initialized. */
11925 remote_hostio_parse_result (const char *buffer
, int *retcode
,
11926 int *remote_errno
, const char **attachment
)
11931 *attachment
= NULL
;
11933 if (buffer
[0] != 'F')
11937 *retcode
= strtol (&buffer
[1], &p
, 16);
11938 if (errno
!= 0 || p
== &buffer
[1])
11941 /* Check for ",errno". */
11945 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11946 if (errno
!= 0 || p
+ 1 == p2
)
11951 /* Check for ";attachment". If there is no attachment, the
11952 packet should end here. */
11955 *attachment
= p
+ 1;
11958 else if (*p
== '\0')
11964 /* Send a prepared I/O packet to the target and read its response.
11965 The prepared packet is in the global RS->BUF before this function
11966 is called, and the answer is there when we return.
11968 COMMAND_BYTES is the length of the request to send, which may include
11969 binary data. WHICH_PACKET is the packet configuration to check
11970 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11971 is set to the error number and -1 is returned. Otherwise the value
11972 returned by the function is returned.
11974 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11975 attachment is expected; an error will be reported if there's a
11976 mismatch. If one is found, *ATTACHMENT will be set to point into
11977 the packet buffer and *ATTACHMENT_LEN will be set to the
11978 attachment's length. */
11981 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11982 int *remote_errno
, const char **attachment
,
11983 int *attachment_len
)
11985 struct remote_state
*rs
= get_remote_state ();
11986 int ret
, bytes_read
;
11987 const char *attachment_tmp
;
11989 if (packet_support (which_packet
) == PACKET_DISABLE
)
11991 *remote_errno
= FILEIO_ENOSYS
;
11995 putpkt_binary (rs
->buf
.data (), command_bytes
);
11996 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11998 /* If it timed out, something is wrong. Don't try to parse the
12000 if (bytes_read
< 0)
12002 *remote_errno
= FILEIO_EINVAL
;
12006 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
12009 *remote_errno
= FILEIO_EINVAL
;
12011 case PACKET_UNKNOWN
:
12012 *remote_errno
= FILEIO_ENOSYS
;
12018 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
12021 *remote_errno
= FILEIO_EINVAL
;
12025 /* Make sure we saw an attachment if and only if we expected one. */
12026 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
12027 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
12029 *remote_errno
= FILEIO_EINVAL
;
12033 /* If an attachment was found, it must point into the packet buffer;
12034 work out how many bytes there were. */
12035 if (attachment_tmp
!= NULL
)
12037 *attachment
= attachment_tmp
;
12038 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
12044 /* See declaration.h. */
12047 readahead_cache::invalidate ()
12052 /* See declaration.h. */
12055 readahead_cache::invalidate_fd (int fd
)
12057 if (this->fd
== fd
)
12061 /* Set the filesystem remote_hostio functions that take FILENAME
12062 arguments will use. Return 0 on success, or -1 if an error
12063 occurs (and set *REMOTE_ERRNO). */
12066 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
12069 struct remote_state
*rs
= get_remote_state ();
12070 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
12071 char *p
= rs
->buf
.data ();
12072 int left
= get_remote_packet_size () - 1;
12076 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
12079 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
12082 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
12084 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
12085 remote_buffer_add_string (&p
, &left
, arg
);
12087 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
12088 remote_errno
, NULL
, NULL
);
12090 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
12094 rs
->fs_pid
= required_pid
;
12099 /* Implementation of to_fileio_open. */
12102 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
12103 int flags
, int mode
, int warn_if_slow
,
12106 struct remote_state
*rs
= get_remote_state ();
12107 char *p
= rs
->buf
.data ();
12108 int left
= get_remote_packet_size () - 1;
12112 static int warning_issued
= 0;
12114 printf_unfiltered (_("Reading %s from remote target...\n"),
12117 if (!warning_issued
)
12119 warning (_("File transfers from remote targets can be slow."
12120 " Use \"set sysroot\" to access files locally"
12122 warning_issued
= 1;
12126 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12129 remote_buffer_add_string (&p
, &left
, "vFile:open:");
12131 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12132 strlen (filename
));
12133 remote_buffer_add_string (&p
, &left
, ",");
12135 remote_buffer_add_int (&p
, &left
, flags
);
12136 remote_buffer_add_string (&p
, &left
, ",");
12138 remote_buffer_add_int (&p
, &left
, mode
);
12140 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
12141 remote_errno
, NULL
, NULL
);
12145 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
12146 int flags
, int mode
, int warn_if_slow
,
12149 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
12153 /* Implementation of to_fileio_pwrite. */
12156 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12157 ULONGEST offset
, int *remote_errno
)
12159 struct remote_state
*rs
= get_remote_state ();
12160 char *p
= rs
->buf
.data ();
12161 int left
= get_remote_packet_size ();
12164 rs
->readahead_cache
.invalidate_fd (fd
);
12166 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
12168 remote_buffer_add_int (&p
, &left
, fd
);
12169 remote_buffer_add_string (&p
, &left
, ",");
12171 remote_buffer_add_int (&p
, &left
, offset
);
12172 remote_buffer_add_string (&p
, &left
, ",");
12174 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
12175 (get_remote_packet_size ()
12176 - (p
- rs
->buf
.data ())));
12178 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
12179 remote_errno
, NULL
, NULL
);
12183 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12184 ULONGEST offset
, int *remote_errno
)
12186 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
12189 /* Helper for the implementation of to_fileio_pread. Read the file
12190 from the remote side with vFile:pread. */
12193 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
12194 ULONGEST offset
, int *remote_errno
)
12196 struct remote_state
*rs
= get_remote_state ();
12197 char *p
= rs
->buf
.data ();
12198 const char *attachment
;
12199 int left
= get_remote_packet_size ();
12200 int ret
, attachment_len
;
12203 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
12205 remote_buffer_add_int (&p
, &left
, fd
);
12206 remote_buffer_add_string (&p
, &left
, ",");
12208 remote_buffer_add_int (&p
, &left
, len
);
12209 remote_buffer_add_string (&p
, &left
, ",");
12211 remote_buffer_add_int (&p
, &left
, offset
);
12213 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
12214 remote_errno
, &attachment
,
12220 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12222 if (read_len
!= ret
)
12223 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
12228 /* See declaration.h. */
12231 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12235 && this->offset
<= offset
12236 && offset
< this->offset
+ this->bufsize
)
12238 ULONGEST max
= this->offset
+ this->bufsize
;
12240 if (offset
+ len
> max
)
12241 len
= max
- offset
;
12243 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12250 /* Implementation of to_fileio_pread. */
12253 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12254 ULONGEST offset
, int *remote_errno
)
12257 struct remote_state
*rs
= get_remote_state ();
12258 readahead_cache
*cache
= &rs
->readahead_cache
;
12260 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12263 cache
->hit_count
++;
12265 remote_debug_printf ("readahead cache hit %s",
12266 pulongest (cache
->hit_count
));
12270 cache
->miss_count
++;
12272 remote_debug_printf ("readahead cache miss %s",
12273 pulongest (cache
->miss_count
));
12276 cache
->offset
= offset
;
12277 cache
->bufsize
= get_remote_packet_size ();
12278 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12280 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12281 cache
->offset
, remote_errno
);
12284 cache
->invalidate_fd (fd
);
12288 cache
->bufsize
= ret
;
12289 return cache
->pread (fd
, read_buf
, len
, offset
);
12293 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12294 ULONGEST offset
, int *remote_errno
)
12296 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12299 /* Implementation of to_fileio_close. */
12302 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12304 struct remote_state
*rs
= get_remote_state ();
12305 char *p
= rs
->buf
.data ();
12306 int left
= get_remote_packet_size () - 1;
12308 rs
->readahead_cache
.invalidate_fd (fd
);
12310 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12312 remote_buffer_add_int (&p
, &left
, fd
);
12314 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12315 remote_errno
, NULL
, NULL
);
12319 remote_target::fileio_close (int fd
, int *remote_errno
)
12321 return remote_hostio_close (fd
, remote_errno
);
12324 /* Implementation of to_fileio_unlink. */
12327 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12330 struct remote_state
*rs
= get_remote_state ();
12331 char *p
= rs
->buf
.data ();
12332 int left
= get_remote_packet_size () - 1;
12334 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12337 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12339 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12340 strlen (filename
));
12342 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12343 remote_errno
, NULL
, NULL
);
12347 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12350 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12353 /* Implementation of to_fileio_readlink. */
12355 gdb::optional
<std::string
>
12356 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12359 struct remote_state
*rs
= get_remote_state ();
12360 char *p
= rs
->buf
.data ();
12361 const char *attachment
;
12362 int left
= get_remote_packet_size ();
12363 int len
, attachment_len
;
12366 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12369 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12371 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12372 strlen (filename
));
12374 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12375 remote_errno
, &attachment
,
12381 std::string
ret (len
, '\0');
12383 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12384 (gdb_byte
*) &ret
[0], len
);
12385 if (read_len
!= len
)
12386 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12391 /* Implementation of to_fileio_fstat. */
12394 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12396 struct remote_state
*rs
= get_remote_state ();
12397 char *p
= rs
->buf
.data ();
12398 int left
= get_remote_packet_size ();
12399 int attachment_len
, ret
;
12400 const char *attachment
;
12401 struct fio_stat fst
;
12404 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12406 remote_buffer_add_int (&p
, &left
, fd
);
12408 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12409 remote_errno
, &attachment
,
12413 if (*remote_errno
!= FILEIO_ENOSYS
)
12416 /* Strictly we should return -1, ENOSYS here, but when
12417 "set sysroot remote:" was implemented in August 2008
12418 BFD's need for a stat function was sidestepped with
12419 this hack. This was not remedied until March 2015
12420 so we retain the previous behavior to avoid breaking
12423 Note that the memset is a March 2015 addition; older
12424 GDBs set st_size *and nothing else* so the structure
12425 would have garbage in all other fields. This might
12426 break something but retaining the previous behavior
12427 here would be just too wrong. */
12429 memset (st
, 0, sizeof (struct stat
));
12430 st
->st_size
= INT_MAX
;
12434 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12435 (gdb_byte
*) &fst
, sizeof (fst
));
12437 if (read_len
!= ret
)
12438 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12440 if (read_len
!= sizeof (fst
))
12441 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12442 read_len
, (int) sizeof (fst
));
12444 remote_fileio_to_host_stat (&fst
, st
);
12449 /* Implementation of to_filesystem_is_local. */
12452 remote_target::filesystem_is_local ()
12454 /* Valgrind GDB presents itself as a remote target but works
12455 on the local filesystem: it does not implement remote get
12456 and users are not expected to set a sysroot. To handle
12457 this case we treat the remote filesystem as local if the
12458 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12459 does not support vFile:open. */
12460 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12462 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12464 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12466 int fd
, remote_errno
;
12468 /* Try opening a file to probe support. The supplied
12469 filename is irrelevant, we only care about whether
12470 the stub recognizes the packet or not. */
12471 fd
= remote_hostio_open (NULL
, "just probing",
12472 FILEIO_O_RDONLY
, 0700, 0,
12476 remote_hostio_close (fd
, &remote_errno
);
12478 ps
= packet_support (PACKET_vFile_open
);
12481 if (ps
== PACKET_DISABLE
)
12483 static int warning_issued
= 0;
12485 if (!warning_issued
)
12487 warning (_("remote target does not support file"
12488 " transfer, attempting to access files"
12489 " from local filesystem."));
12490 warning_issued
= 1;
12501 remote_fileio_errno_to_host (int errnum
)
12507 case FILEIO_ENOENT
:
12515 case FILEIO_EACCES
:
12517 case FILEIO_EFAULT
:
12521 case FILEIO_EEXIST
:
12523 case FILEIO_ENODEV
:
12525 case FILEIO_ENOTDIR
:
12527 case FILEIO_EISDIR
:
12529 case FILEIO_EINVAL
:
12531 case FILEIO_ENFILE
:
12533 case FILEIO_EMFILE
:
12537 case FILEIO_ENOSPC
:
12539 case FILEIO_ESPIPE
:
12543 case FILEIO_ENOSYS
:
12545 case FILEIO_ENAMETOOLONG
:
12546 return ENAMETOOLONG
;
12552 remote_hostio_error (int errnum
)
12554 int host_error
= remote_fileio_errno_to_host (errnum
);
12556 if (host_error
== -1)
12557 error (_("Unknown remote I/O error %d"), errnum
);
12559 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12562 /* A RAII wrapper around a remote file descriptor. */
12564 class scoped_remote_fd
12567 scoped_remote_fd (remote_target
*remote
, int fd
)
12568 : m_remote (remote
), m_fd (fd
)
12572 ~scoped_remote_fd ()
12579 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12583 /* Swallow exception before it escapes the dtor. If
12584 something goes wrong, likely the connection is gone,
12585 and there's nothing else that can be done. */
12590 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12592 /* Release ownership of the file descriptor, and return it. */
12593 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12600 /* Return the owned file descriptor. */
12601 int get () const noexcept
12607 /* The remote target. */
12608 remote_target
*m_remote
;
12610 /* The owned remote I/O file descriptor. */
12615 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12617 remote_target
*remote
= get_current_remote_target ();
12619 if (remote
== nullptr)
12620 error (_("command can only be used with remote target"));
12622 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12626 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12629 int retcode
, remote_errno
, bytes
, io_size
;
12630 int bytes_in_buffer
;
12634 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12636 perror_with_name (local_file
);
12638 scoped_remote_fd fd
12639 (this, remote_hostio_open (NULL
,
12640 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12642 0700, 0, &remote_errno
));
12643 if (fd
.get () == -1)
12644 remote_hostio_error (remote_errno
);
12646 /* Send up to this many bytes at once. They won't all fit in the
12647 remote packet limit, so we'll transfer slightly fewer. */
12648 io_size
= get_remote_packet_size ();
12649 gdb::byte_vector
buffer (io_size
);
12651 bytes_in_buffer
= 0;
12654 while (bytes_in_buffer
|| !saw_eof
)
12658 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12659 io_size
- bytes_in_buffer
,
12663 if (ferror (file
.get ()))
12664 error (_("Error reading %s."), local_file
);
12667 /* EOF. Unless there is something still in the
12668 buffer from the last iteration, we are done. */
12670 if (bytes_in_buffer
== 0)
12678 bytes
+= bytes_in_buffer
;
12679 bytes_in_buffer
= 0;
12681 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12682 offset
, &remote_errno
);
12685 remote_hostio_error (remote_errno
);
12686 else if (retcode
== 0)
12687 error (_("Remote write of %d bytes returned 0!"), bytes
);
12688 else if (retcode
< bytes
)
12690 /* Short write. Save the rest of the read data for the next
12692 bytes_in_buffer
= bytes
- retcode
;
12693 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12699 if (remote_hostio_close (fd
.release (), &remote_errno
))
12700 remote_hostio_error (remote_errno
);
12703 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12707 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12709 remote_target
*remote
= get_current_remote_target ();
12711 if (remote
== nullptr)
12712 error (_("command can only be used with remote target"));
12714 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12718 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12721 int remote_errno
, bytes
, io_size
;
12724 scoped_remote_fd fd
12725 (this, remote_hostio_open (NULL
,
12726 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12728 if (fd
.get () == -1)
12729 remote_hostio_error (remote_errno
);
12731 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12733 perror_with_name (local_file
);
12735 /* Send up to this many bytes at once. They won't all fit in the
12736 remote packet limit, so we'll transfer slightly fewer. */
12737 io_size
= get_remote_packet_size ();
12738 gdb::byte_vector
buffer (io_size
);
12743 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12746 /* Success, but no bytes, means end-of-file. */
12749 remote_hostio_error (remote_errno
);
12753 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12755 perror_with_name (local_file
);
12758 if (remote_hostio_close (fd
.release (), &remote_errno
))
12759 remote_hostio_error (remote_errno
);
12762 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12766 remote_file_delete (const char *remote_file
, int from_tty
)
12768 remote_target
*remote
= get_current_remote_target ();
12770 if (remote
== nullptr)
12771 error (_("command can only be used with remote target"));
12773 remote
->remote_file_delete (remote_file
, from_tty
);
12777 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12779 int retcode
, remote_errno
;
12781 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12783 remote_hostio_error (remote_errno
);
12786 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12790 remote_put_command (const char *args
, int from_tty
)
12793 error_no_arg (_("file to put"));
12795 gdb_argv
argv (args
);
12796 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12797 error (_("Invalid parameters to remote put"));
12799 remote_file_put (argv
[0], argv
[1], from_tty
);
12803 remote_get_command (const char *args
, int from_tty
)
12806 error_no_arg (_("file to get"));
12808 gdb_argv
argv (args
);
12809 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12810 error (_("Invalid parameters to remote get"));
12812 remote_file_get (argv
[0], argv
[1], from_tty
);
12816 remote_delete_command (const char *args
, int from_tty
)
12819 error_no_arg (_("file to delete"));
12821 gdb_argv
argv (args
);
12822 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12823 error (_("Invalid parameters to remote delete"));
12825 remote_file_delete (argv
[0], from_tty
);
12829 remote_target::can_execute_reverse ()
12831 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12832 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12839 remote_target::supports_non_stop ()
12845 remote_target::supports_disable_randomization ()
12847 /* Only supported in extended mode. */
12852 remote_target::supports_multi_process ()
12854 struct remote_state
*rs
= get_remote_state ();
12856 return remote_multi_process_p (rs
);
12860 remote_supports_cond_tracepoints ()
12862 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12866 remote_target::supports_evaluation_of_breakpoint_conditions ()
12868 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12872 remote_supports_fast_tracepoints ()
12874 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12878 remote_supports_static_tracepoints ()
12880 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12884 remote_supports_install_in_trace ()
12886 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12890 remote_target::supports_enable_disable_tracepoint ()
12892 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12897 remote_target::supports_string_tracing ()
12899 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12903 remote_target::can_run_breakpoint_commands ()
12905 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12909 remote_target::trace_init ()
12911 struct remote_state
*rs
= get_remote_state ();
12914 remote_get_noisy_reply ();
12915 if (strcmp (rs
->buf
.data (), "OK") != 0)
12916 error (_("Target does not support this command."));
12919 /* Recursive routine to walk through command list including loops, and
12920 download packets for each command. */
12923 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12924 struct command_line
*cmds
)
12926 struct remote_state
*rs
= get_remote_state ();
12927 struct command_line
*cmd
;
12929 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12931 QUIT
; /* Allow user to bail out with ^C. */
12932 strcpy (rs
->buf
.data (), "QTDPsrc:");
12933 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12934 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12935 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12937 remote_get_noisy_reply ();
12938 if (strcmp (rs
->buf
.data (), "OK"))
12939 warning (_("Target does not support source download."));
12941 if (cmd
->control_type
== while_control
12942 || cmd
->control_type
== while_stepping_control
)
12944 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12946 QUIT
; /* Allow user to bail out with ^C. */
12947 strcpy (rs
->buf
.data (), "QTDPsrc:");
12948 encode_source_string (num
, addr
, "cmd", "end",
12949 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12950 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12952 remote_get_noisy_reply ();
12953 if (strcmp (rs
->buf
.data (), "OK"))
12954 warning (_("Target does not support source download."));
12960 remote_target::download_tracepoint (struct bp_location
*loc
)
12964 std::vector
<std::string
> tdp_actions
;
12965 std::vector
<std::string
> stepping_actions
;
12967 struct breakpoint
*b
= loc
->owner
;
12968 struct tracepoint
*t
= (struct tracepoint
*) b
;
12969 struct remote_state
*rs
= get_remote_state ();
12971 const char *err_msg
= _("Tracepoint packet too large for target.");
12974 /* We use a buffer other than rs->buf because we'll build strings
12975 across multiple statements, and other statements in between could
12977 gdb::char_vector
buf (get_remote_packet_size ());
12979 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12981 tpaddr
= loc
->address
;
12982 strcpy (addrbuf
, phex (tpaddr
, sizeof (CORE_ADDR
)));
12983 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12984 b
->number
, addrbuf
, /* address */
12985 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12986 t
->step_count
, t
->pass_count
);
12988 if (ret
< 0 || ret
>= buf
.size ())
12989 error ("%s", err_msg
);
12991 /* Fast tracepoints are mostly handled by the target, but we can
12992 tell the target how big of an instruction block should be moved
12994 if (b
->type
== bp_fast_tracepoint
)
12996 /* Only test for support at download time; we may not know
12997 target capabilities at definition time. */
12998 if (remote_supports_fast_tracepoints ())
13000 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
13003 size_left
= buf
.size () - strlen (buf
.data ());
13004 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13006 gdb_insn_length (loc
->gdbarch
, tpaddr
));
13008 if (ret
< 0 || ret
>= size_left
)
13009 error ("%s", err_msg
);
13012 /* If it passed validation at definition but fails now,
13013 something is very wrong. */
13014 internal_error (__FILE__
, __LINE__
,
13015 _("Fast tracepoint not "
13016 "valid during download"));
13019 /* Fast tracepoints are functionally identical to regular
13020 tracepoints, so don't take lack of support as a reason to
13021 give up on the trace run. */
13022 warning (_("Target does not support fast tracepoints, "
13023 "downloading %d as regular tracepoint"), b
->number
);
13025 else if (b
->type
== bp_static_tracepoint
)
13027 /* Only test for support at download time; we may not know
13028 target capabilities at definition time. */
13029 if (remote_supports_static_tracepoints ())
13031 struct static_tracepoint_marker marker
;
13033 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
13035 size_left
= buf
.size () - strlen (buf
.data ());
13036 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13039 if (ret
< 0 || ret
>= size_left
)
13040 error ("%s", err_msg
);
13043 error (_("Static tracepoint not valid during download"));
13046 /* Fast tracepoints are functionally identical to regular
13047 tracepoints, so don't take lack of support as a reason
13048 to give up on the trace run. */
13049 error (_("Target does not support static tracepoints"));
13051 /* If the tracepoint has a conditional, make it into an agent
13052 expression and append to the definition. */
13055 /* Only test support at download time, we may not know target
13056 capabilities at definition time. */
13057 if (remote_supports_cond_tracepoints ())
13059 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
13062 size_left
= buf
.size () - strlen (buf
.data ());
13064 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13065 size_left
, ":X%x,", aexpr
->len
);
13067 if (ret
< 0 || ret
>= size_left
)
13068 error ("%s", err_msg
);
13070 size_left
= buf
.size () - strlen (buf
.data ());
13072 /* Two bytes to encode each aexpr byte, plus the terminating
13074 if (aexpr
->len
* 2 + 1 > size_left
)
13075 error ("%s", err_msg
);
13077 pkt
= buf
.data () + strlen (buf
.data ());
13079 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
13080 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
13084 warning (_("Target does not support conditional tracepoints, "
13085 "ignoring tp %d cond"), b
->number
);
13088 if (b
->commands
|| *default_collect
)
13090 size_left
= buf
.size () - strlen (buf
.data ());
13092 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13095 if (ret
< 0 || ret
>= size_left
)
13096 error ("%s", err_msg
);
13099 putpkt (buf
.data ());
13100 remote_get_noisy_reply ();
13101 if (strcmp (rs
->buf
.data (), "OK"))
13102 error (_("Target does not support tracepoints."));
13104 /* do_single_steps (t); */
13105 for (auto action_it
= tdp_actions
.begin ();
13106 action_it
!= tdp_actions
.end (); action_it
++)
13108 QUIT
; /* Allow user to bail out with ^C. */
13110 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
13111 || !stepping_actions
.empty ());
13113 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
13114 b
->number
, addrbuf
, /* address */
13115 action_it
->c_str (),
13116 has_more
? '-' : 0);
13118 if (ret
< 0 || ret
>= buf
.size ())
13119 error ("%s", err_msg
);
13121 putpkt (buf
.data ());
13122 remote_get_noisy_reply ();
13123 if (strcmp (rs
->buf
.data (), "OK"))
13124 error (_("Error on target while setting tracepoints."));
13127 for (auto action_it
= stepping_actions
.begin ();
13128 action_it
!= stepping_actions
.end (); action_it
++)
13130 QUIT
; /* Allow user to bail out with ^C. */
13132 bool is_first
= action_it
== stepping_actions
.begin ();
13133 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
13135 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
13136 b
->number
, addrbuf
, /* address */
13137 is_first
? "S" : "",
13138 action_it
->c_str (),
13139 has_more
? "-" : "");
13141 if (ret
< 0 || ret
>= buf
.size ())
13142 error ("%s", err_msg
);
13144 putpkt (buf
.data ());
13145 remote_get_noisy_reply ();
13146 if (strcmp (rs
->buf
.data (), "OK"))
13147 error (_("Error on target while setting tracepoints."));
13150 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
13152 if (b
->location
!= NULL
)
13154 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13156 if (ret
< 0 || ret
>= buf
.size ())
13157 error ("%s", err_msg
);
13159 encode_source_string (b
->number
, loc
->address
, "at",
13160 event_location_to_string (b
->location
.get ()),
13161 buf
.data () + strlen (buf
.data ()),
13162 buf
.size () - strlen (buf
.data ()));
13163 putpkt (buf
.data ());
13164 remote_get_noisy_reply ();
13165 if (strcmp (rs
->buf
.data (), "OK"))
13166 warning (_("Target does not support source download."));
13168 if (b
->cond_string
)
13170 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13172 if (ret
< 0 || ret
>= buf
.size ())
13173 error ("%s", err_msg
);
13175 encode_source_string (b
->number
, loc
->address
,
13176 "cond", b
->cond_string
,
13177 buf
.data () + strlen (buf
.data ()),
13178 buf
.size () - strlen (buf
.data ()));
13179 putpkt (buf
.data ());
13180 remote_get_noisy_reply ();
13181 if (strcmp (rs
->buf
.data (), "OK"))
13182 warning (_("Target does not support source download."));
13184 remote_download_command_source (b
->number
, loc
->address
,
13185 breakpoint_commands (b
));
13190 remote_target::can_download_tracepoint ()
13192 struct remote_state
*rs
= get_remote_state ();
13193 struct trace_status
*ts
;
13196 /* Don't try to install tracepoints until we've relocated our
13197 symbols, and fetched and merged the target's tracepoint list with
13199 if (rs
->starting_up
)
13202 ts
= current_trace_status ();
13203 status
= get_trace_status (ts
);
13205 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
13208 /* If we are in a tracing experiment, but remote stub doesn't support
13209 installing tracepoint in trace, we have to return. */
13210 if (!remote_supports_install_in_trace ())
13218 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
13220 struct remote_state
*rs
= get_remote_state ();
13223 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13224 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13226 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13227 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13228 >= get_remote_packet_size ())
13229 error (_("Trace state variable name too long for tsv definition packet"));
13230 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13233 remote_get_noisy_reply ();
13234 if (rs
->buf
[0] == '\0')
13235 error (_("Target does not support this command."));
13236 if (strcmp (rs
->buf
.data (), "OK") != 0)
13237 error (_("Error on target while downloading trace state variable."));
13241 remote_target::enable_tracepoint (struct bp_location
*location
)
13243 struct remote_state
*rs
= get_remote_state ();
13245 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13246 location
->owner
->number
,
13247 phex (location
->address
, sizeof (CORE_ADDR
)));
13249 remote_get_noisy_reply ();
13250 if (rs
->buf
[0] == '\0')
13251 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13252 if (strcmp (rs
->buf
.data (), "OK") != 0)
13253 error (_("Error on target while enabling tracepoint."));
13257 remote_target::disable_tracepoint (struct bp_location
*location
)
13259 struct remote_state
*rs
= get_remote_state ();
13261 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13262 location
->owner
->number
,
13263 phex (location
->address
, sizeof (CORE_ADDR
)));
13265 remote_get_noisy_reply ();
13266 if (rs
->buf
[0] == '\0')
13267 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13268 if (strcmp (rs
->buf
.data (), "OK") != 0)
13269 error (_("Error on target while disabling tracepoint."));
13273 remote_target::trace_set_readonly_regions ()
13276 bfd_size_type size
;
13281 if (!current_program_space
->exec_bfd ())
13282 return; /* No information to give. */
13284 struct remote_state
*rs
= get_remote_state ();
13286 strcpy (rs
->buf
.data (), "QTro");
13287 offset
= strlen (rs
->buf
.data ());
13288 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
13290 char tmp1
[40], tmp2
[40];
13293 if ((s
->flags
& SEC_LOAD
) == 0 ||
13294 /* (s->flags & SEC_CODE) == 0 || */
13295 (s
->flags
& SEC_READONLY
) == 0)
13299 vma
= bfd_section_vma (s
);
13300 size
= bfd_section_size (s
);
13301 sprintf_vma (tmp1
, vma
);
13302 sprintf_vma (tmp2
, vma
+ size
);
13303 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13304 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13306 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13308 Too many sections for read-only sections definition packet."));
13311 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13313 offset
+= sec_length
;
13318 getpkt (&rs
->buf
, 0);
13323 remote_target::trace_start ()
13325 struct remote_state
*rs
= get_remote_state ();
13327 putpkt ("QTStart");
13328 remote_get_noisy_reply ();
13329 if (rs
->buf
[0] == '\0')
13330 error (_("Target does not support this command."));
13331 if (strcmp (rs
->buf
.data (), "OK") != 0)
13332 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13336 remote_target::get_trace_status (struct trace_status
*ts
)
13338 /* Initialize it just to avoid a GCC false warning. */
13340 enum packet_result result
;
13341 struct remote_state
*rs
= get_remote_state ();
13343 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13346 /* FIXME we need to get register block size some other way. */
13347 trace_regblock_size
13348 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13350 putpkt ("qTStatus");
13354 p
= remote_get_noisy_reply ();
13356 catch (const gdb_exception_error
&ex
)
13358 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13360 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13366 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13368 /* If the remote target doesn't do tracing, flag it. */
13369 if (result
== PACKET_UNKNOWN
)
13372 /* We're working with a live target. */
13373 ts
->filename
= NULL
;
13376 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13378 /* Function 'parse_trace_status' sets default value of each field of
13379 'ts' at first, so we don't have to do it here. */
13380 parse_trace_status (p
, ts
);
13382 return ts
->running
;
13386 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13387 struct uploaded_tp
*utp
)
13389 struct remote_state
*rs
= get_remote_state ();
13391 struct bp_location
*loc
;
13392 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13393 size_t size
= get_remote_packet_size ();
13398 tp
->traceframe_usage
= 0;
13399 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13401 /* If the tracepoint was never downloaded, don't go asking for
13403 if (tp
->number_on_target
== 0)
13405 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13406 phex_nz (loc
->address
, 0));
13408 reply
= remote_get_noisy_reply ();
13409 if (reply
&& *reply
)
13412 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13418 utp
->hit_count
= 0;
13419 utp
->traceframe_usage
= 0;
13420 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13421 phex_nz (utp
->addr
, 0));
13423 reply
= remote_get_noisy_reply ();
13424 if (reply
&& *reply
)
13427 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13433 remote_target::trace_stop ()
13435 struct remote_state
*rs
= get_remote_state ();
13438 remote_get_noisy_reply ();
13439 if (rs
->buf
[0] == '\0')
13440 error (_("Target does not support this command."));
13441 if (strcmp (rs
->buf
.data (), "OK") != 0)
13442 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13446 remote_target::trace_find (enum trace_find_type type
, int num
,
13447 CORE_ADDR addr1
, CORE_ADDR addr2
,
13450 struct remote_state
*rs
= get_remote_state ();
13451 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13453 int target_frameno
= -1, target_tracept
= -1;
13455 /* Lookups other than by absolute frame number depend on the current
13456 trace selected, so make sure it is correct on the remote end
13458 if (type
!= tfind_number
)
13459 set_remote_traceframe ();
13461 p
= rs
->buf
.data ();
13462 strcpy (p
, "QTFrame:");
13463 p
= strchr (p
, '\0');
13467 xsnprintf (p
, endbuf
- p
, "%x", num
);
13470 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13473 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13476 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13477 phex_nz (addr2
, 0));
13479 case tfind_outside
:
13480 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13481 phex_nz (addr2
, 0));
13484 error (_("Unknown trace find type %d"), type
);
13488 reply
= remote_get_noisy_reply ();
13489 if (*reply
== '\0')
13490 error (_("Target does not support this command."));
13492 while (reply
&& *reply
)
13497 target_frameno
= (int) strtol (p
, &reply
, 16);
13499 error (_("Unable to parse trace frame number"));
13500 /* Don't update our remote traceframe number cache on failure
13501 to select a remote traceframe. */
13502 if (target_frameno
== -1)
13507 target_tracept
= (int) strtol (p
, &reply
, 16);
13509 error (_("Unable to parse tracepoint number"));
13511 case 'O': /* "OK"? */
13512 if (reply
[1] == 'K' && reply
[2] == '\0')
13515 error (_("Bogus reply from target: %s"), reply
);
13518 error (_("Bogus reply from target: %s"), reply
);
13521 *tpp
= target_tracept
;
13523 rs
->remote_traceframe_number
= target_frameno
;
13524 return target_frameno
;
13528 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13530 struct remote_state
*rs
= get_remote_state ();
13534 set_remote_traceframe ();
13536 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13538 reply
= remote_get_noisy_reply ();
13539 if (reply
&& *reply
)
13543 unpack_varlen_hex (reply
+ 1, &uval
);
13544 *val
= (LONGEST
) uval
;
13552 remote_target::save_trace_data (const char *filename
)
13554 struct remote_state
*rs
= get_remote_state ();
13557 p
= rs
->buf
.data ();
13558 strcpy (p
, "QTSave:");
13560 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13561 >= get_remote_packet_size ())
13562 error (_("Remote file name too long for trace save packet"));
13563 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13566 reply
= remote_get_noisy_reply ();
13567 if (*reply
== '\0')
13568 error (_("Target does not support this command."));
13569 if (strcmp (reply
, "OK") != 0)
13570 error (_("Bogus reply from target: %s"), reply
);
13574 /* This is basically a memory transfer, but needs to be its own packet
13575 because we don't know how the target actually organizes its trace
13576 memory, plus we want to be able to ask for as much as possible, but
13577 not be unhappy if we don't get as much as we ask for. */
13580 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13582 struct remote_state
*rs
= get_remote_state ();
13587 p
= rs
->buf
.data ();
13588 strcpy (p
, "qTBuffer:");
13590 p
+= hexnumstr (p
, offset
);
13592 p
+= hexnumstr (p
, len
);
13596 reply
= remote_get_noisy_reply ();
13597 if (reply
&& *reply
)
13599 /* 'l' by itself means we're at the end of the buffer and
13600 there is nothing more to get. */
13604 /* Convert the reply into binary. Limit the number of bytes to
13605 convert according to our passed-in buffer size, rather than
13606 what was returned in the packet; if the target is
13607 unexpectedly generous and gives us a bigger reply than we
13608 asked for, we don't want to crash. */
13609 rslt
= hex2bin (reply
, buf
, len
);
13613 /* Something went wrong, flag as an error. */
13618 remote_target::set_disconnected_tracing (int val
)
13620 struct remote_state
*rs
= get_remote_state ();
13622 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13626 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13627 "QTDisconnected:%x", val
);
13629 reply
= remote_get_noisy_reply ();
13630 if (*reply
== '\0')
13631 error (_("Target does not support this command."));
13632 if (strcmp (reply
, "OK") != 0)
13633 error (_("Bogus reply from target: %s"), reply
);
13636 warning (_("Target does not support disconnected tracing."));
13640 remote_target::core_of_thread (ptid_t ptid
)
13642 thread_info
*info
= find_thread_ptid (this, ptid
);
13644 if (info
!= NULL
&& info
->priv
!= NULL
)
13645 return get_remote_thread_info (info
)->core
;
13651 remote_target::set_circular_trace_buffer (int val
)
13653 struct remote_state
*rs
= get_remote_state ();
13656 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13657 "QTBuffer:circular:%x", val
);
13659 reply
= remote_get_noisy_reply ();
13660 if (*reply
== '\0')
13661 error (_("Target does not support this command."));
13662 if (strcmp (reply
, "OK") != 0)
13663 error (_("Bogus reply from target: %s"), reply
);
13667 remote_target::traceframe_info ()
13669 gdb::optional
<gdb::char_vector
> text
13670 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13673 return parse_traceframe_info (text
->data ());
13678 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13679 instruction on which a fast tracepoint may be placed. Returns -1
13680 if the packet is not supported, and 0 if the minimum instruction
13681 length is unknown. */
13684 remote_target::get_min_fast_tracepoint_insn_len ()
13686 struct remote_state
*rs
= get_remote_state ();
13689 /* If we're not debugging a process yet, the IPA can't be
13691 if (!target_has_execution ())
13694 /* Make sure the remote is pointing at the right process. */
13695 set_general_process ();
13697 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13699 reply
= remote_get_noisy_reply ();
13700 if (*reply
== '\0')
13704 ULONGEST min_insn_len
;
13706 unpack_varlen_hex (reply
, &min_insn_len
);
13708 return (int) min_insn_len
;
13713 remote_target::set_trace_buffer_size (LONGEST val
)
13715 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13717 struct remote_state
*rs
= get_remote_state ();
13718 char *buf
= rs
->buf
.data ();
13719 char *endbuf
= buf
+ get_remote_packet_size ();
13720 enum packet_result result
;
13722 gdb_assert (val
>= 0 || val
== -1);
13723 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13724 /* Send -1 as literal "-1" to avoid host size dependency. */
13728 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13731 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13734 remote_get_noisy_reply ();
13735 result
= packet_ok (rs
->buf
,
13736 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13738 if (result
!= PACKET_OK
)
13739 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13744 remote_target::set_trace_notes (const char *user
, const char *notes
,
13745 const char *stop_notes
)
13747 struct remote_state
*rs
= get_remote_state ();
13749 char *buf
= rs
->buf
.data ();
13750 char *endbuf
= buf
+ get_remote_packet_size ();
13753 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13756 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13757 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13763 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13764 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13770 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13771 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13775 /* Ensure the buffer is terminated. */
13779 reply
= remote_get_noisy_reply ();
13780 if (*reply
== '\0')
13783 if (strcmp (reply
, "OK") != 0)
13784 error (_("Bogus reply from target: %s"), reply
);
13790 remote_target::use_agent (bool use
)
13792 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13794 struct remote_state
*rs
= get_remote_state ();
13796 /* If the stub supports QAgent. */
13797 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13799 getpkt (&rs
->buf
, 0);
13801 if (strcmp (rs
->buf
.data (), "OK") == 0)
13812 remote_target::can_use_agent ()
13814 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13817 struct btrace_target_info
13819 /* The ptid of the traced thread. */
13822 /* The obtained branch trace configuration. */
13823 struct btrace_config conf
;
13826 /* Reset our idea of our target's btrace configuration. */
13829 remote_btrace_reset (remote_state
*rs
)
13831 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13834 /* Synchronize the configuration with the target. */
13837 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13839 struct packet_config
*packet
;
13840 struct remote_state
*rs
;
13841 char *buf
, *pos
, *endbuf
;
13843 rs
= get_remote_state ();
13844 buf
= rs
->buf
.data ();
13845 endbuf
= buf
+ get_remote_packet_size ();
13847 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13848 if (packet_config_support (packet
) == PACKET_ENABLE
13849 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13852 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13856 getpkt (&rs
->buf
, 0);
13858 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13860 if (buf
[0] == 'E' && buf
[1] == '.')
13861 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13863 error (_("Failed to configure the BTS buffer size."));
13866 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13869 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13870 if (packet_config_support (packet
) == PACKET_ENABLE
13871 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13874 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13878 getpkt (&rs
->buf
, 0);
13880 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13882 if (buf
[0] == 'E' && buf
[1] == '.')
13883 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13885 error (_("Failed to configure the trace buffer size."));
13888 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13892 /* Read the current thread's btrace configuration from the target and
13893 store it into CONF. */
13896 btrace_read_config (struct btrace_config
*conf
)
13898 gdb::optional
<gdb::char_vector
> xml
13899 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13901 parse_xml_btrace_conf (conf
, xml
->data ());
13904 /* Maybe reopen target btrace. */
13907 remote_target::remote_btrace_maybe_reopen ()
13909 struct remote_state
*rs
= get_remote_state ();
13910 int btrace_target_pushed
= 0;
13911 #if !defined (HAVE_LIBIPT)
13915 /* Don't bother walking the entirety of the remote thread list when
13916 we know the feature isn't supported by the remote. */
13917 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13920 scoped_restore_current_thread restore_thread
;
13922 for (thread_info
*tp
: all_non_exited_threads (this))
13924 set_general_thread (tp
->ptid
);
13926 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13927 btrace_read_config (&rs
->btrace_config
);
13929 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13932 #if !defined (HAVE_LIBIPT)
13933 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13938 warning (_("Target is recording using Intel Processor Trace "
13939 "but support was disabled at compile time."));
13944 #endif /* !defined (HAVE_LIBIPT) */
13946 /* Push target, once, but before anything else happens. This way our
13947 changes to the threads will be cleaned up by unpushing the target
13948 in case btrace_read_config () throws. */
13949 if (!btrace_target_pushed
)
13951 btrace_target_pushed
= 1;
13952 record_btrace_push_target ();
13953 printf_filtered (_("Target is recording using %s.\n"),
13954 btrace_format_string (rs
->btrace_config
.format
));
13957 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13958 tp
->btrace
.target
->ptid
= tp
->ptid
;
13959 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13963 /* Enable branch tracing. */
13965 struct btrace_target_info
*
13966 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13968 struct btrace_target_info
*tinfo
= NULL
;
13969 struct packet_config
*packet
= NULL
;
13970 struct remote_state
*rs
= get_remote_state ();
13971 char *buf
= rs
->buf
.data ();
13972 char *endbuf
= buf
+ get_remote_packet_size ();
13974 switch (conf
->format
)
13976 case BTRACE_FORMAT_BTS
:
13977 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13980 case BTRACE_FORMAT_PT
:
13981 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13985 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13986 error (_("Target does not support branch tracing."));
13988 btrace_sync_conf (conf
);
13990 set_general_thread (ptid
);
13992 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13994 getpkt (&rs
->buf
, 0);
13996 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13998 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13999 error (_("Could not enable branch tracing for %s: %s"),
14000 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
14002 error (_("Could not enable branch tracing for %s."),
14003 target_pid_to_str (ptid
).c_str ());
14006 tinfo
= XCNEW (struct btrace_target_info
);
14007 tinfo
->ptid
= ptid
;
14009 /* If we fail to read the configuration, we lose some information, but the
14010 tracing itself is not impacted. */
14013 btrace_read_config (&tinfo
->conf
);
14015 catch (const gdb_exception_error
&err
)
14017 if (err
.message
!= NULL
)
14018 warning ("%s", err
.what ());
14024 /* Disable branch tracing. */
14027 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
14029 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
14030 struct remote_state
*rs
= get_remote_state ();
14031 char *buf
= rs
->buf
.data ();
14032 char *endbuf
= buf
+ get_remote_packet_size ();
14034 if (packet_config_support (packet
) != PACKET_ENABLE
)
14035 error (_("Target does not support branch tracing."));
14037 set_general_thread (tinfo
->ptid
);
14039 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
14041 getpkt (&rs
->buf
, 0);
14043 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
14045 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
14046 error (_("Could not disable branch tracing for %s: %s"),
14047 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
14049 error (_("Could not disable branch tracing for %s."),
14050 target_pid_to_str (tinfo
->ptid
).c_str ());
14056 /* Teardown branch tracing. */
14059 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
14061 /* We must not talk to the target during teardown. */
14065 /* Read the branch trace. */
14068 remote_target::read_btrace (struct btrace_data
*btrace
,
14069 struct btrace_target_info
*tinfo
,
14070 enum btrace_read_type type
)
14072 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
14075 if (packet_config_support (packet
) != PACKET_ENABLE
)
14076 error (_("Target does not support branch tracing."));
14078 #if !defined(HAVE_LIBEXPAT)
14079 error (_("Cannot process branch tracing result. XML parsing not supported."));
14084 case BTRACE_READ_ALL
:
14087 case BTRACE_READ_NEW
:
14090 case BTRACE_READ_DELTA
:
14094 internal_error (__FILE__
, __LINE__
,
14095 _("Bad branch tracing read type: %u."),
14096 (unsigned int) type
);
14099 gdb::optional
<gdb::char_vector
> xml
14100 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
14102 return BTRACE_ERR_UNKNOWN
;
14104 parse_xml_btrace (btrace
, xml
->data ());
14106 return BTRACE_ERR_NONE
;
14109 const struct btrace_config
*
14110 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
14112 return &tinfo
->conf
;
14116 remote_target::augmented_libraries_svr4_read ()
14118 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
14122 /* Implementation of to_load. */
14125 remote_target::load (const char *name
, int from_tty
)
14127 generic_load (name
, from_tty
);
14130 /* Accepts an integer PID; returns a string representing a file that
14131 can be opened on the remote side to get the symbols for the child
14132 process. Returns NULL if the operation is not supported. */
14135 remote_target::pid_to_exec_file (int pid
)
14137 static gdb::optional
<gdb::char_vector
> filename
;
14138 char *annex
= NULL
;
14140 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
14143 inferior
*inf
= find_inferior_pid (this, pid
);
14145 internal_error (__FILE__
, __LINE__
,
14146 _("not currently attached to process %d"), pid
);
14148 if (!inf
->fake_pid_p
)
14150 const int annex_size
= 9;
14152 annex
= (char *) alloca (annex_size
);
14153 xsnprintf (annex
, annex_size
, "%x", pid
);
14156 filename
= target_read_stralloc (current_top_target (),
14157 TARGET_OBJECT_EXEC_FILE
, annex
);
14159 return filename
? filename
->data () : nullptr;
14162 /* Implement the to_can_do_single_step target_ops method. */
14165 remote_target::can_do_single_step ()
14167 /* We can only tell whether target supports single step or not by
14168 supported s and S vCont actions if the stub supports vContSupported
14169 feature. If the stub doesn't support vContSupported feature,
14170 we have conservatively to think target doesn't supports single
14172 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
14174 struct remote_state
*rs
= get_remote_state ();
14176 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14177 remote_vcont_probe ();
14179 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
14185 /* Implementation of the to_execution_direction method for the remote
14188 enum exec_direction_kind
14189 remote_target::execution_direction ()
14191 struct remote_state
*rs
= get_remote_state ();
14193 return rs
->last_resume_exec_dir
;
14196 /* Return pointer to the thread_info struct which corresponds to
14197 THREAD_HANDLE (having length HANDLE_LEN). */
14200 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
14204 for (thread_info
*tp
: all_non_exited_threads (this))
14206 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14208 if (tp
->inf
== inf
&& priv
!= NULL
)
14210 if (handle_len
!= priv
->thread_handle
.size ())
14211 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14212 handle_len
, priv
->thread_handle
.size ());
14213 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14223 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
14225 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14226 return priv
->thread_handle
;
14230 remote_target::can_async_p ()
14232 struct remote_state
*rs
= get_remote_state ();
14234 /* We don't go async if the user has explicitly prevented it with the
14235 "maint set target-async" command. */
14236 if (!target_async_permitted
)
14239 /* We're async whenever the serial device is. */
14240 return serial_can_async_p (rs
->remote_desc
);
14244 remote_target::is_async_p ()
14246 struct remote_state
*rs
= get_remote_state ();
14248 if (!target_async_permitted
)
14249 /* We only enable async when the user specifically asks for it. */
14252 /* We're async whenever the serial device is. */
14253 return serial_is_async_p (rs
->remote_desc
);
14256 /* Pass the SERIAL event on and up to the client. One day this code
14257 will be able to delay notifying the client of an event until the
14258 point where an entire packet has been received. */
14260 static serial_event_ftype remote_async_serial_handler
;
14263 remote_async_serial_handler (struct serial
*scb
, void *context
)
14265 /* Don't propogate error information up to the client. Instead let
14266 the client find out about the error by querying the target. */
14267 inferior_event_handler (INF_REG_EVENT
);
14271 remote_async_inferior_event_handler (gdb_client_data data
)
14273 inferior_event_handler (INF_REG_EVENT
);
14277 remote_target::async_wait_fd ()
14279 struct remote_state
*rs
= get_remote_state ();
14280 return rs
->remote_desc
->fd
;
14284 remote_target::async (int enable
)
14286 struct remote_state
*rs
= get_remote_state ();
14290 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14292 /* If there are pending events in the stop reply queue tell the
14293 event loop to process them. */
14294 if (!rs
->stop_reply_queue
.empty ())
14295 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14296 /* For simplicity, below we clear the pending events token
14297 without remembering whether it is marked, so here we always
14298 mark it. If there's actually no pending notification to
14299 process, this ends up being a no-op (other than a spurious
14300 event-loop wakeup). */
14301 if (target_is_non_stop_p ())
14302 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14306 serial_async (rs
->remote_desc
, NULL
, NULL
);
14307 /* If the core is disabling async, it doesn't want to be
14308 disturbed with target events. Clear all async event sources
14310 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14311 if (target_is_non_stop_p ())
14312 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14316 /* Implementation of the to_thread_events method. */
14319 remote_target::thread_events (int enable
)
14321 struct remote_state
*rs
= get_remote_state ();
14322 size_t size
= get_remote_packet_size ();
14324 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14327 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14329 getpkt (&rs
->buf
, 0);
14331 switch (packet_ok (rs
->buf
,
14332 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14335 if (strcmp (rs
->buf
.data (), "OK") != 0)
14336 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14339 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14341 case PACKET_UNKNOWN
:
14347 show_remote_cmd (const char *args
, int from_tty
)
14349 /* We can't just use cmd_show_list here, because we want to skip
14350 the redundant "show remote Z-packet" and the legacy aliases. */
14351 struct cmd_list_element
*list
= remote_show_cmdlist
;
14352 struct ui_out
*uiout
= current_uiout
;
14354 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14355 for (; list
!= NULL
; list
= list
->next
)
14356 if (strcmp (list
->name
, "Z-packet") == 0)
14358 else if (list
->type
== not_set_cmd
)
14359 /* Alias commands are exactly like the original, except they
14360 don't have the normal type. */
14364 ui_out_emit_tuple
option_emitter (uiout
, "option");
14366 uiout
->field_string ("name", list
->name
);
14367 uiout
->text (": ");
14368 if (list
->type
== show_cmd
)
14369 do_show_command (NULL
, from_tty
, list
);
14371 cmd_func (list
, NULL
, from_tty
);
14376 /* Function to be called whenever a new objfile (shlib) is detected. */
14378 remote_new_objfile (struct objfile
*objfile
)
14380 remote_target
*remote
= get_current_remote_target ();
14382 if (remote
!= NULL
) /* Have a remote connection. */
14383 remote
->remote_check_symbols ();
14386 /* Pull all the tracepoints defined on the target and create local
14387 data structures representing them. We don't want to create real
14388 tracepoints yet, we don't want to mess up the user's existing
14392 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14394 struct remote_state
*rs
= get_remote_state ();
14397 /* Ask for a first packet of tracepoint definition. */
14399 getpkt (&rs
->buf
, 0);
14400 p
= rs
->buf
.data ();
14401 while (*p
&& *p
!= 'l')
14403 parse_tracepoint_definition (p
, utpp
);
14404 /* Ask for another packet of tracepoint definition. */
14406 getpkt (&rs
->buf
, 0);
14407 p
= rs
->buf
.data ();
14413 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14415 struct remote_state
*rs
= get_remote_state ();
14418 /* Ask for a first packet of variable definition. */
14420 getpkt (&rs
->buf
, 0);
14421 p
= rs
->buf
.data ();
14422 while (*p
&& *p
!= 'l')
14424 parse_tsv_definition (p
, utsvp
);
14425 /* Ask for another packet of variable definition. */
14427 getpkt (&rs
->buf
, 0);
14428 p
= rs
->buf
.data ();
14433 /* The "set/show range-stepping" show hook. */
14436 show_range_stepping (struct ui_file
*file
, int from_tty
,
14437 struct cmd_list_element
*c
,
14440 fprintf_filtered (file
,
14441 _("Debugger's willingness to use range stepping "
14442 "is %s.\n"), value
);
14445 /* Return true if the vCont;r action is supported by the remote
14449 remote_target::vcont_r_supported ()
14451 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14452 remote_vcont_probe ();
14454 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14455 && get_remote_state ()->supports_vCont
.r
);
14458 /* The "set/show range-stepping" set hook. */
14461 set_range_stepping (const char *ignore_args
, int from_tty
,
14462 struct cmd_list_element
*c
)
14464 /* When enabling, check whether range stepping is actually supported
14465 by the target, and warn if not. */
14466 if (use_range_stepping
)
14468 remote_target
*remote
= get_current_remote_target ();
14470 || !remote
->vcont_r_supported ())
14471 warning (_("Range stepping is not supported by the current target"));
14476 show_remote_debug (struct ui_file
*file
, int from_tty
,
14477 struct cmd_list_element
*c
, const char *value
)
14479 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
14484 show_remote_timeout (struct ui_file
*file
, int from_tty
,
14485 struct cmd_list_element
*c
, const char *value
)
14487 fprintf_filtered (file
,
14488 _("Timeout limit to wait for target to respond is %s.\n"),
14492 void _initialize_remote ();
14494 _initialize_remote ()
14496 struct cmd_list_element
*cmd
;
14497 const char *cmd_name
;
14499 /* architecture specific data */
14500 remote_g_packet_data_handle
=
14501 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14503 add_target (remote_target_info
, remote_target::open
);
14504 add_target (extended_remote_target_info
, extended_remote_target::open
);
14506 /* Hook into new objfile notification. */
14507 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14510 init_remote_threadtests ();
14513 /* set/show remote ... */
14515 add_basic_prefix_cmd ("remote", class_maintenance
, _("\
14516 Remote protocol specific variables.\n\
14517 Configure various remote-protocol specific variables such as\n\
14518 the packets being used."),
14519 &remote_set_cmdlist
, "set remote ",
14520 0 /* allow-unknown */, &setlist
);
14521 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14522 Remote protocol specific variables.\n\
14523 Configure various remote-protocol specific variables such as\n\
14524 the packets being used."),
14525 &remote_show_cmdlist
, "show remote ",
14526 0 /* allow-unknown */, &showlist
);
14528 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14529 Compare section data on target to the exec file.\n\
14530 Argument is a single section name (default: all loaded sections).\n\
14531 To compare only read-only loaded sections, specify the -r option."),
14534 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14535 Send an arbitrary packet to a remote target.\n\
14536 maintenance packet TEXT\n\
14537 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14538 this command sends the string TEXT to the inferior, and displays the\n\
14539 response packet. GDB supplies the initial `$' character, and the\n\
14540 terminating `#' character and checksum."),
14543 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14544 Set whether to send break if interrupted."), _("\
14545 Show whether to send break if interrupted."), _("\
14546 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14547 set_remotebreak
, show_remotebreak
,
14548 &setlist
, &showlist
);
14549 cmd_name
= "remotebreak";
14550 cmd
= lookup_cmd (&cmd_name
, setlist
, "", NULL
, -1, 1);
14551 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14552 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14553 cmd
= lookup_cmd (&cmd_name
, showlist
, "", NULL
, -1, 1);
14554 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14556 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14557 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14559 Set interrupt sequence to remote target."), _("\
14560 Show interrupt sequence to remote target."), _("\
14561 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14562 NULL
, show_interrupt_sequence
,
14563 &remote_set_cmdlist
,
14564 &remote_show_cmdlist
);
14566 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14567 &interrupt_on_connect
, _("\
14568 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14569 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14570 If set, interrupt sequence is sent to remote target."),
14572 &remote_set_cmdlist
, &remote_show_cmdlist
);
14574 /* Install commands for configuring memory read/write packets. */
14576 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14577 Set the maximum number of bytes per memory write packet (deprecated)."),
14579 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14580 Show the maximum number of bytes per memory write packet (deprecated)."),
14582 add_cmd ("memory-write-packet-size", no_class
,
14583 set_memory_write_packet_size
, _("\
14584 Set the maximum number of bytes per memory-write packet.\n\
14585 Specify the number of bytes in a packet or 0 (zero) for the\n\
14586 default packet size. The actual limit is further reduced\n\
14587 dependent on the target. Specify ``fixed'' to disable the\n\
14588 further restriction and ``limit'' to enable that restriction."),
14589 &remote_set_cmdlist
);
14590 add_cmd ("memory-read-packet-size", no_class
,
14591 set_memory_read_packet_size
, _("\
14592 Set the maximum number of bytes per memory-read packet.\n\
14593 Specify the number of bytes in a packet or 0 (zero) for the\n\
14594 default packet size. The actual limit is further reduced\n\
14595 dependent on the target. Specify ``fixed'' to disable the\n\
14596 further restriction and ``limit'' to enable that restriction."),
14597 &remote_set_cmdlist
);
14598 add_cmd ("memory-write-packet-size", no_class
,
14599 show_memory_write_packet_size
,
14600 _("Show the maximum number of bytes per memory-write packet."),
14601 &remote_show_cmdlist
);
14602 add_cmd ("memory-read-packet-size", no_class
,
14603 show_memory_read_packet_size
,
14604 _("Show the maximum number of bytes per memory-read packet."),
14605 &remote_show_cmdlist
);
14607 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14608 &remote_hw_watchpoint_limit
, _("\
14609 Set the maximum number of target hardware watchpoints."), _("\
14610 Show the maximum number of target hardware watchpoints."), _("\
14611 Specify \"unlimited\" for unlimited hardware watchpoints."),
14612 NULL
, show_hardware_watchpoint_limit
,
14613 &remote_set_cmdlist
,
14614 &remote_show_cmdlist
);
14615 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14617 &remote_hw_watchpoint_length_limit
, _("\
14618 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14619 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14620 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14621 NULL
, show_hardware_watchpoint_length_limit
,
14622 &remote_set_cmdlist
, &remote_show_cmdlist
);
14623 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14624 &remote_hw_breakpoint_limit
, _("\
14625 Set the maximum number of target hardware breakpoints."), _("\
14626 Show the maximum number of target hardware breakpoints."), _("\
14627 Specify \"unlimited\" for unlimited hardware breakpoints."),
14628 NULL
, show_hardware_breakpoint_limit
,
14629 &remote_set_cmdlist
, &remote_show_cmdlist
);
14631 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14632 &remote_address_size
, _("\
14633 Set the maximum size of the address (in bits) in a memory packet."), _("\
14634 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14636 NULL
, /* FIXME: i18n: */
14637 &setlist
, &showlist
);
14639 init_all_packet_configs ();
14641 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14642 "X", "binary-download", 1);
14644 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14645 "vCont", "verbose-resume", 0);
14647 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14648 "QPassSignals", "pass-signals", 0);
14650 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14651 "QCatchSyscalls", "catch-syscalls", 0);
14653 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14654 "QProgramSignals", "program-signals", 0);
14656 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14657 "QSetWorkingDir", "set-working-dir", 0);
14659 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14660 "QStartupWithShell", "startup-with-shell", 0);
14662 add_packet_config_cmd (&remote_protocol_packets
14663 [PACKET_QEnvironmentHexEncoded
],
14664 "QEnvironmentHexEncoded", "environment-hex-encoded",
14667 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14668 "QEnvironmentReset", "environment-reset",
14671 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14672 "QEnvironmentUnset", "environment-unset",
14675 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14676 "qSymbol", "symbol-lookup", 0);
14678 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14679 "P", "set-register", 1);
14681 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14682 "p", "fetch-register", 1);
14684 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14685 "Z0", "software-breakpoint", 0);
14687 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14688 "Z1", "hardware-breakpoint", 0);
14690 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14691 "Z2", "write-watchpoint", 0);
14693 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14694 "Z3", "read-watchpoint", 0);
14696 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14697 "Z4", "access-watchpoint", 0);
14699 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14700 "qXfer:auxv:read", "read-aux-vector", 0);
14702 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14703 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14705 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14706 "qXfer:features:read", "target-features", 0);
14708 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14709 "qXfer:libraries:read", "library-info", 0);
14711 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14712 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14714 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14715 "qXfer:memory-map:read", "memory-map", 0);
14717 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14718 "qXfer:osdata:read", "osdata", 0);
14720 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14721 "qXfer:threads:read", "threads", 0);
14723 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14724 "qXfer:siginfo:read", "read-siginfo-object", 0);
14726 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14727 "qXfer:siginfo:write", "write-siginfo-object", 0);
14729 add_packet_config_cmd
14730 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14731 "qXfer:traceframe-info:read", "traceframe-info", 0);
14733 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14734 "qXfer:uib:read", "unwind-info-block", 0);
14736 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14737 "qGetTLSAddr", "get-thread-local-storage-address",
14740 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14741 "qGetTIBAddr", "get-thread-information-block-address",
14744 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14745 "bc", "reverse-continue", 0);
14747 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14748 "bs", "reverse-step", 0);
14750 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14751 "qSupported", "supported-packets", 0);
14753 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14754 "qSearch:memory", "search-memory", 0);
14756 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14757 "qTStatus", "trace-status", 0);
14759 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14760 "vFile:setfs", "hostio-setfs", 0);
14762 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14763 "vFile:open", "hostio-open", 0);
14765 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14766 "vFile:pread", "hostio-pread", 0);
14768 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14769 "vFile:pwrite", "hostio-pwrite", 0);
14771 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14772 "vFile:close", "hostio-close", 0);
14774 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14775 "vFile:unlink", "hostio-unlink", 0);
14777 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14778 "vFile:readlink", "hostio-readlink", 0);
14780 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14781 "vFile:fstat", "hostio-fstat", 0);
14783 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14784 "vAttach", "attach", 0);
14786 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14789 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14790 "QStartNoAckMode", "noack", 0);
14792 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14793 "vKill", "kill", 0);
14795 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14796 "qAttached", "query-attached", 0);
14798 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14799 "ConditionalTracepoints",
14800 "conditional-tracepoints", 0);
14802 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14803 "ConditionalBreakpoints",
14804 "conditional-breakpoints", 0);
14806 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14807 "BreakpointCommands",
14808 "breakpoint-commands", 0);
14810 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14811 "FastTracepoints", "fast-tracepoints", 0);
14813 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14814 "TracepointSource", "TracepointSource", 0);
14816 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14817 "QAllow", "allow", 0);
14819 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14820 "StaticTracepoints", "static-tracepoints", 0);
14822 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14823 "InstallInTrace", "install-in-trace", 0);
14825 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14826 "qXfer:statictrace:read", "read-sdata-object", 0);
14828 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14829 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14831 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14832 "QDisableRandomization", "disable-randomization", 0);
14834 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14835 "QAgent", "agent", 0);
14837 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14838 "QTBuffer:size", "trace-buffer-size", 0);
14840 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14841 "Qbtrace:off", "disable-btrace", 0);
14843 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14844 "Qbtrace:bts", "enable-btrace-bts", 0);
14846 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14847 "Qbtrace:pt", "enable-btrace-pt", 0);
14849 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14850 "qXfer:btrace", "read-btrace", 0);
14852 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14853 "qXfer:btrace-conf", "read-btrace-conf", 0);
14855 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14856 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14858 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14859 "multiprocess-feature", "multiprocess-feature", 0);
14861 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14862 "swbreak-feature", "swbreak-feature", 0);
14864 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14865 "hwbreak-feature", "hwbreak-feature", 0);
14867 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14868 "fork-event-feature", "fork-event-feature", 0);
14870 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14871 "vfork-event-feature", "vfork-event-feature", 0);
14873 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14874 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14876 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14877 "vContSupported", "verbose-resume-supported", 0);
14879 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14880 "exec-event-feature", "exec-event-feature", 0);
14882 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14883 "vCtrlC", "ctrl-c", 0);
14885 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14886 "QThreadEvents", "thread-events", 0);
14888 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14889 "N stop reply", "no-resumed-stop-reply", 0);
14891 /* Assert that we've registered "set remote foo-packet" commands
14892 for all packet configs. */
14896 for (i
= 0; i
< PACKET_MAX
; i
++)
14898 /* Ideally all configs would have a command associated. Some
14899 still don't though. */
14904 case PACKET_QNonStop
:
14905 case PACKET_EnableDisableTracepoints_feature
:
14906 case PACKET_tracenz_feature
:
14907 case PACKET_DisconnectedTracing_feature
:
14908 case PACKET_augmented_libraries_svr4_read_feature
:
14910 /* Additions to this list need to be well justified:
14911 pre-existing packets are OK; new packets are not. */
14919 /* This catches both forgetting to add a config command, and
14920 forgetting to remove a packet from the exception list. */
14921 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14925 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14926 Z sub-packet has its own set and show commands, but users may
14927 have sets to this variable in their .gdbinit files (or in their
14929 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14930 &remote_Z_packet_detect
, _("\
14931 Set use of remote protocol `Z' packets."), _("\
14932 Show use of remote protocol `Z' packets."), _("\
14933 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14935 set_remote_protocol_Z_packet_cmd
,
14936 show_remote_protocol_Z_packet_cmd
,
14937 /* FIXME: i18n: Use of remote protocol
14938 `Z' packets is %s. */
14939 &remote_set_cmdlist
, &remote_show_cmdlist
);
14941 add_basic_prefix_cmd ("remote", class_files
, _("\
14942 Manipulate files on the remote system.\n\
14943 Transfer files to and from the remote target system."),
14944 &remote_cmdlist
, "remote ",
14945 0 /* allow-unknown */, &cmdlist
);
14947 add_cmd ("put", class_files
, remote_put_command
,
14948 _("Copy a local file to the remote system."),
14951 add_cmd ("get", class_files
, remote_get_command
,
14952 _("Copy a remote file to the local system."),
14955 add_cmd ("delete", class_files
, remote_delete_command
,
14956 _("Delete a remote file."),
14959 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14960 &remote_exec_file_var
, _("\
14961 Set the remote pathname for \"run\"."), _("\
14962 Show the remote pathname for \"run\"."), NULL
,
14963 set_remote_exec_file
,
14964 show_remote_exec_file
,
14965 &remote_set_cmdlist
,
14966 &remote_show_cmdlist
);
14968 add_setshow_boolean_cmd ("range-stepping", class_run
,
14969 &use_range_stepping
, _("\
14970 Enable or disable range stepping."), _("\
14971 Show whether target-assisted range stepping is enabled."), _("\
14972 If on, and the target supports it, when stepping a source line, GDB\n\
14973 tells the target to step the corresponding range of addresses itself instead\n\
14974 of issuing multiple single-steps. This speeds up source level\n\
14975 stepping. If off, GDB always issues single-steps, even if range\n\
14976 stepping is supported by the target. The default is on."),
14977 set_range_stepping
,
14978 show_range_stepping
,
14982 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
14983 Set watchdog timer."), _("\
14984 Show watchdog timer."), _("\
14985 When non-zero, this timeout is used instead of waiting forever for a target\n\
14986 to finish a low-level step or continue operation. If the specified amount\n\
14987 of time passes without a response from the target, an error occurs."),
14990 &setlist
, &showlist
);
14992 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
14993 &remote_packet_max_chars
, _("\
14994 Set the maximum number of characters to display for each remote packet."), _("\
14995 Show the maximum number of characters to display for each remote packet."), _("\
14996 Specify \"unlimited\" to display all the characters."),
14997 NULL
, show_remote_packet_max_chars
,
14998 &setdebuglist
, &showdebuglist
);
15000 add_setshow_boolean_cmd ("remote", no_class
, &remote_debug
,
15001 _("Set debugging of remote protocol."),
15002 _("Show debugging of remote protocol."),
15004 When enabled, each packet sent or received with the remote target\n\
15008 &setdebuglist
, &showdebuglist
);
15010 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
15011 &remote_timeout
, _("\
15012 Set timeout limit to wait for target to respond."), _("\
15013 Show timeout limit to wait for target to respond."), _("\
15014 This value is used to set the time limit for gdb to wait for a response\n\
15015 from the target."),
15017 show_remote_timeout
,
15018 &setlist
, &showlist
);
15020 /* Eventually initialize fileio. See fileio.c */
15021 initialize_remote_fileio (&remote_set_cmdlist
, &remote_show_cmdlist
);