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.).");
90 #define OPAQUETHREADBYTES 8
92 /* a 64 bit opaque identifier */
93 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
95 struct gdb_ext_thread_info
;
96 struct threads_listing_context
;
97 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
98 struct protocol_feature
;
102 typedef std::unique_ptr
<stop_reply
> stop_reply_up
;
104 /* Generic configuration support for packets the stub optionally
105 supports. Allows the user to specify the use of the packet as well
106 as allowing GDB to auto-detect support in the remote stub. */
110 PACKET_SUPPORT_UNKNOWN
= 0,
115 /* Analyze a packet's return value and update the packet config
125 struct threads_listing_context
;
127 /* Stub vCont actions support.
129 Each field is a boolean flag indicating whether the stub reports
130 support for the corresponding action. */
132 struct vCont_action_support
147 /* About this many threadids fit in a packet. */
149 #define MAXTHREADLISTRESULTS 32
151 /* Data for the vFile:pread readahead cache. */
153 struct readahead_cache
155 /* Invalidate the readahead cache. */
158 /* Invalidate the readahead cache if it is holding data for FD. */
159 void invalidate_fd (int fd
);
161 /* Serve pread from the readahead cache. Returns number of bytes
162 read, or 0 if the request can't be served from the cache. */
163 int pread (int fd
, gdb_byte
*read_buf
, size_t len
, ULONGEST offset
);
165 /* The file descriptor for the file that is being cached. -1 if the
169 /* The offset into the file that the cache buffer corresponds
173 /* The buffer holding the cache contents. */
174 gdb_byte
*buf
= nullptr;
175 /* The buffer's size. We try to read as much as fits into a packet
179 /* Cache hit and miss counters. */
180 ULONGEST hit_count
= 0;
181 ULONGEST miss_count
= 0;
184 /* Description of the remote protocol for a given architecture. */
188 long offset
; /* Offset into G packet. */
189 long regnum
; /* GDB's internal register number. */
190 LONGEST pnum
; /* Remote protocol register number. */
191 int in_g_packet
; /* Always part of G packet. */
192 /* long size in bytes; == register_size (target_gdbarch (), regnum);
194 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
198 struct remote_arch_state
200 explicit remote_arch_state (struct gdbarch
*gdbarch
);
202 /* Description of the remote protocol registers. */
203 long sizeof_g_packet
;
205 /* Description of the remote protocol registers indexed by REGNUM
206 (making an array gdbarch_num_regs in size). */
207 std::unique_ptr
<packet_reg
[]> regs
;
209 /* This is the size (in chars) of the first response to the ``g''
210 packet. It is used as a heuristic when determining the maximum
211 size of memory-read and memory-write packets. A target will
212 typically only reserve a buffer large enough to hold the ``g''
213 packet. The size does not include packet overhead (headers and
215 long actual_register_packet_size
;
217 /* This is the maximum size (in chars) of a non read/write packet.
218 It is also used as a cap on the size of read/write packets. */
219 long remote_packet_size
;
222 /* Description of the remote protocol state for the currently
223 connected target. This is per-target state, and independent of the
224 selected architecture. */
233 /* Get the remote arch state for GDBARCH. */
234 struct remote_arch_state
*get_remote_arch_state (struct gdbarch
*gdbarch
);
238 /* A buffer to use for incoming packets, and its current size. The
239 buffer is grown dynamically for larger incoming packets.
240 Outgoing packets may also be constructed in this buffer.
241 The size of the buffer is always at least REMOTE_PACKET_SIZE;
242 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
244 gdb::char_vector buf
;
246 /* True if we're going through initial connection setup (finding out
247 about the remote side's threads, relocating symbols, etc.). */
248 bool starting_up
= false;
250 /* If we negotiated packet size explicitly (and thus can bypass
251 heuristics for the largest packet size that will not overflow
252 a buffer in the stub), this will be set to that packet size.
253 Otherwise zero, meaning to use the guessed size. */
254 long explicit_packet_size
= 0;
256 /* remote_wait is normally called when the target is running and
257 waits for a stop reply packet. But sometimes we need to call it
258 when the target is already stopped. We can send a "?" packet
259 and have remote_wait read the response. Or, if we already have
260 the response, we can stash it in BUF and tell remote_wait to
261 skip calling getpkt. This flag is set when BUF contains a
262 stop reply packet and the target is not waiting. */
263 int cached_wait_status
= 0;
265 /* True, if in no ack mode. That is, neither GDB nor the stub will
266 expect acks from each other. The connection is assumed to be
268 bool noack_mode
= false;
270 /* True if we're connected in extended remote mode. */
271 bool extended
= false;
273 /* True if we resumed the target and we're waiting for the target to
274 stop. In the mean time, we can't start another command/query.
275 The remote server wouldn't be ready to process it, so we'd
276 timeout waiting for a reply that would never come and eventually
277 we'd close the connection. This can happen in asynchronous mode
278 because we allow GDB commands while the target is running. */
279 bool waiting_for_stop_reply
= false;
281 /* The status of the stub support for the various vCont actions. */
282 vCont_action_support supports_vCont
;
283 /* Whether vCont support was probed already. This is a workaround
284 until packet_support is per-connection. */
285 bool supports_vCont_probed
;
287 /* True if the user has pressed Ctrl-C, but the target hasn't
288 responded to that. */
289 bool ctrlc_pending_p
= false;
291 /* True if we saw a Ctrl-C while reading or writing from/to the
292 remote descriptor. At that point it is not safe to send a remote
293 interrupt packet, so we instead remember we saw the Ctrl-C and
294 process it once we're done with sending/receiving the current
295 packet, which should be shortly. If however that takes too long,
296 and the user presses Ctrl-C again, we offer to disconnect. */
297 bool got_ctrlc_during_io
= false;
299 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
300 remote_open knows that we don't have a file open when the program
302 struct serial
*remote_desc
= nullptr;
304 /* These are the threads which we last sent to the remote system. The
305 TID member will be -1 for all or -2 for not sent yet. */
306 ptid_t general_thread
= null_ptid
;
307 ptid_t continue_thread
= null_ptid
;
309 /* This is the traceframe which we last selected on the remote system.
310 It will be -1 if no traceframe is selected. */
311 int remote_traceframe_number
= -1;
313 char *last_pass_packet
= nullptr;
315 /* The last QProgramSignals packet sent to the target. We bypass
316 sending a new program signals list down to the target if the new
317 packet is exactly the same as the last we sent. IOW, we only let
318 the target know about program signals list changes. */
319 char *last_program_signals_packet
= nullptr;
321 gdb_signal last_sent_signal
= GDB_SIGNAL_0
;
323 bool last_sent_step
= false;
325 /* The execution direction of the last resume we got. */
326 exec_direction_kind last_resume_exec_dir
= EXEC_FORWARD
;
328 char *finished_object
= nullptr;
329 char *finished_annex
= nullptr;
330 ULONGEST finished_offset
= 0;
332 /* Should we try the 'ThreadInfo' query packet?
334 This variable (NOT available to the user: auto-detect only!)
335 determines whether GDB will use the new, simpler "ThreadInfo"
336 query or the older, more complex syntax for thread queries.
337 This is an auto-detect variable (set to true at each connect,
338 and set to false when the target fails to recognize it). */
339 bool use_threadinfo_query
= false;
340 bool use_threadextra_query
= false;
342 threadref echo_nextthread
{};
343 threadref nextthread
{};
344 threadref resultthreadlist
[MAXTHREADLISTRESULTS
] {};
346 /* The state of remote notification. */
347 struct remote_notif_state
*notif_state
= nullptr;
349 /* The branch trace configuration. */
350 struct btrace_config btrace_config
{};
352 /* The argument to the last "vFile:setfs:" packet we sent, used
353 to avoid sending repeated unnecessary "vFile:setfs:" packets.
354 Initialized to -1 to indicate that no "vFile:setfs:" packet
355 has yet been sent. */
358 /* A readahead cache for vFile:pread. Often, reading a binary
359 involves a sequence of small reads. E.g., when parsing an ELF
360 file. A readahead cache helps mostly the case of remote
361 debugging on a connection with higher latency, due to the
362 request/reply nature of the RSP. We only cache data for a single
363 file descriptor at a time. */
364 struct readahead_cache readahead_cache
;
366 /* The list of already fetched and acknowledged stop events. This
367 queue is used for notification Stop, and other notifications
368 don't need queue for their events, because the notification
369 events of Stop can't be consumed immediately, so that events
370 should be queued first, and be consumed by remote_wait_{ns,as}
371 one per time. Other notifications can consume their events
372 immediately, so queue is not needed for them. */
373 std::vector
<stop_reply_up
> stop_reply_queue
;
375 /* Asynchronous signal handle registered as event loop source for
376 when we have pending events ready to be passed to the core. */
377 struct async_event_handler
*remote_async_inferior_event_token
= nullptr;
379 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
380 ``forever'' still use the normal timeout mechanism. This is
381 currently used by the ASYNC code to guarentee that target reads
382 during the initial connect always time-out. Once getpkt has been
383 modified to return a timeout indication and, in turn
384 remote_wait()/wait_for_inferior() have gained a timeout parameter
386 int wait_forever_enabled_p
= 1;
389 /* Mapping of remote protocol data for each gdbarch. Usually there
390 is only one entry here, though we may see more with stubs that
391 support multi-process. */
392 std::unordered_map
<struct gdbarch
*, remote_arch_state
>
396 static const target_info remote_target_info
= {
398 N_("Remote serial target in gdb-specific protocol"),
402 class remote_target
: public process_stratum_target
405 remote_target () = default;
406 ~remote_target () override
;
408 const target_info
&info () const override
409 { return remote_target_info
; }
411 const char *connection_string () override
;
413 thread_control_capabilities
get_thread_control_capabilities () override
414 { return tc_schedlock
; }
416 /* Open a remote connection. */
417 static void open (const char *, int);
419 void close () override
;
421 void detach (inferior
*, int) override
;
422 void disconnect (const char *, int) override
;
424 void commit_resume () override
;
425 void resume (ptid_t
, int, enum gdb_signal
) override
;
426 ptid_t
wait (ptid_t
, struct target_waitstatus
*, target_wait_flags
) override
;
428 void fetch_registers (struct regcache
*, int) override
;
429 void store_registers (struct regcache
*, int) override
;
430 void prepare_to_store (struct regcache
*) override
;
432 void files_info () override
;
434 int insert_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
436 int remove_breakpoint (struct gdbarch
*, struct bp_target_info
*,
437 enum remove_bp_reason
) override
;
440 bool stopped_by_sw_breakpoint () override
;
441 bool supports_stopped_by_sw_breakpoint () override
;
443 bool stopped_by_hw_breakpoint () override
;
445 bool supports_stopped_by_hw_breakpoint () override
;
447 bool stopped_by_watchpoint () override
;
449 bool stopped_data_address (CORE_ADDR
*) override
;
451 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
453 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
455 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
457 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
459 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
461 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
462 struct expression
*) override
;
464 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
465 struct expression
*) override
;
467 void kill () override
;
469 void load (const char *, int) override
;
471 void mourn_inferior () override
;
473 void pass_signals (gdb::array_view
<const unsigned char>) override
;
475 int set_syscall_catchpoint (int, bool, int,
476 gdb::array_view
<const int>) override
;
478 void program_signals (gdb::array_view
<const unsigned char>) override
;
480 bool thread_alive (ptid_t ptid
) override
;
482 const char *thread_name (struct thread_info
*) override
;
484 void update_thread_list () override
;
486 std::string
pid_to_str (ptid_t
) override
;
488 const char *extra_thread_info (struct thread_info
*) override
;
490 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
492 thread_info
*thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
494 inferior
*inf
) override
;
496 gdb::byte_vector
thread_info_to_thread_handle (struct thread_info
*tp
)
499 void stop (ptid_t
) override
;
501 void interrupt () override
;
503 void pass_ctrlc () override
;
505 enum target_xfer_status
xfer_partial (enum target_object object
,
508 const gdb_byte
*writebuf
,
509 ULONGEST offset
, ULONGEST len
,
510 ULONGEST
*xfered_len
) override
;
512 ULONGEST
get_memory_xfer_limit () override
;
514 void rcmd (const char *command
, struct ui_file
*output
) override
;
516 char *pid_to_exec_file (int pid
) override
;
518 void log_command (const char *cmd
) override
520 serial_log_command (this, cmd
);
523 CORE_ADDR
get_thread_local_address (ptid_t ptid
,
524 CORE_ADDR load_module_addr
,
525 CORE_ADDR offset
) override
;
527 bool can_execute_reverse () override
;
529 std::vector
<mem_region
> memory_map () override
;
531 void flash_erase (ULONGEST address
, LONGEST length
) override
;
533 void flash_done () override
;
535 const struct target_desc
*read_description () override
;
537 int search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
538 const gdb_byte
*pattern
, ULONGEST pattern_len
,
539 CORE_ADDR
*found_addrp
) override
;
541 bool can_async_p () override
;
543 bool is_async_p () override
;
545 void async (int) override
;
547 int async_wait_fd () override
;
549 void thread_events (int) override
;
551 int can_do_single_step () override
;
553 void terminal_inferior () override
;
555 void terminal_ours () override
;
557 bool supports_non_stop () override
;
559 bool supports_multi_process () override
;
561 bool supports_disable_randomization () override
;
563 bool filesystem_is_local () override
;
566 int fileio_open (struct inferior
*inf
, const char *filename
,
567 int flags
, int mode
, int warn_if_slow
,
568 int *target_errno
) override
;
570 int fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
571 ULONGEST offset
, int *target_errno
) override
;
573 int fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
574 ULONGEST offset
, int *target_errno
) override
;
576 int fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
) override
;
578 int fileio_close (int fd
, int *target_errno
) override
;
580 int fileio_unlink (struct inferior
*inf
,
581 const char *filename
,
582 int *target_errno
) override
;
584 gdb::optional
<std::string
>
585 fileio_readlink (struct inferior
*inf
,
586 const char *filename
,
587 int *target_errno
) override
;
589 bool supports_enable_disable_tracepoint () override
;
591 bool supports_string_tracing () override
;
593 bool supports_evaluation_of_breakpoint_conditions () override
;
595 bool can_run_breakpoint_commands () override
;
597 void trace_init () override
;
599 void download_tracepoint (struct bp_location
*location
) override
;
601 bool can_download_tracepoint () override
;
603 void download_trace_state_variable (const trace_state_variable
&tsv
) override
;
605 void enable_tracepoint (struct bp_location
*location
) override
;
607 void disable_tracepoint (struct bp_location
*location
) override
;
609 void trace_set_readonly_regions () override
;
611 void trace_start () override
;
613 int get_trace_status (struct trace_status
*ts
) override
;
615 void get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
618 void trace_stop () override
;
620 int trace_find (enum trace_find_type type
, int num
,
621 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
) override
;
623 bool get_trace_state_variable_value (int tsv
, LONGEST
*val
) override
;
625 int save_trace_data (const char *filename
) override
;
627 int upload_tracepoints (struct uploaded_tp
**utpp
) override
;
629 int upload_trace_state_variables (struct uploaded_tsv
**utsvp
) override
;
631 LONGEST
get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
) override
;
633 int get_min_fast_tracepoint_insn_len () override
;
635 void set_disconnected_tracing (int val
) override
;
637 void set_circular_trace_buffer (int val
) override
;
639 void set_trace_buffer_size (LONGEST val
) override
;
641 bool set_trace_notes (const char *user
, const char *notes
,
642 const char *stopnotes
) override
;
644 int core_of_thread (ptid_t ptid
) override
;
646 int verify_memory (const gdb_byte
*data
,
647 CORE_ADDR memaddr
, ULONGEST size
) override
;
650 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
652 void set_permissions () override
;
654 bool static_tracepoint_marker_at (CORE_ADDR
,
655 struct static_tracepoint_marker
*marker
)
658 std::vector
<static_tracepoint_marker
>
659 static_tracepoint_markers_by_strid (const char *id
) override
;
661 traceframe_info_up
traceframe_info () override
;
663 bool use_agent (bool use
) override
;
664 bool can_use_agent () override
;
666 struct btrace_target_info
*enable_btrace (ptid_t ptid
,
667 const struct btrace_config
*conf
) override
;
669 void disable_btrace (struct btrace_target_info
*tinfo
) override
;
671 void teardown_btrace (struct btrace_target_info
*tinfo
) override
;
673 enum btrace_error
read_btrace (struct btrace_data
*data
,
674 struct btrace_target_info
*btinfo
,
675 enum btrace_read_type type
) override
;
677 const struct btrace_config
*btrace_conf (const struct btrace_target_info
*) override
;
678 bool augmented_libraries_svr4_read () override
;
679 bool follow_fork (bool, bool) override
;
680 void follow_exec (struct inferior
*, const char *) override
;
681 int insert_fork_catchpoint (int) override
;
682 int remove_fork_catchpoint (int) override
;
683 int insert_vfork_catchpoint (int) override
;
684 int remove_vfork_catchpoint (int) override
;
685 int insert_exec_catchpoint (int) override
;
686 int remove_exec_catchpoint (int) override
;
687 enum exec_direction_kind
execution_direction () override
;
689 public: /* Remote specific methods. */
691 void remote_download_command_source (int num
, ULONGEST addr
,
692 struct command_line
*cmds
);
694 void remote_file_put (const char *local_file
, const char *remote_file
,
696 void remote_file_get (const char *remote_file
, const char *local_file
,
698 void remote_file_delete (const char *remote_file
, int from_tty
);
700 int remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
701 ULONGEST offset
, int *remote_errno
);
702 int remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
703 ULONGEST offset
, int *remote_errno
);
704 int remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
705 ULONGEST offset
, int *remote_errno
);
707 int remote_hostio_send_command (int command_bytes
, int which_packet
,
708 int *remote_errno
, char **attachment
,
709 int *attachment_len
);
710 int remote_hostio_set_filesystem (struct inferior
*inf
,
712 /* We should get rid of this and use fileio_open directly. */
713 int remote_hostio_open (struct inferior
*inf
, const char *filename
,
714 int flags
, int mode
, int warn_if_slow
,
716 int remote_hostio_close (int fd
, int *remote_errno
);
718 int remote_hostio_unlink (inferior
*inf
, const char *filename
,
721 struct remote_state
*get_remote_state ();
723 long get_remote_packet_size (void);
724 long get_memory_packet_size (struct memory_packet_config
*config
);
726 long get_memory_write_packet_size ();
727 long get_memory_read_packet_size ();
729 char *append_pending_thread_resumptions (char *p
, char *endp
,
731 static void open_1 (const char *name
, int from_tty
, int extended_p
);
732 void start_remote (int from_tty
, int extended_p
);
733 void remote_detach_1 (struct inferior
*inf
, int from_tty
);
735 char *append_resumption (char *p
, char *endp
,
736 ptid_t ptid
, int step
, gdb_signal siggnal
);
737 int remote_resume_with_vcont (ptid_t ptid
, int step
,
740 void add_current_inferior_and_thread (char *wait_status
);
742 ptid_t
wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
743 target_wait_flags options
);
744 ptid_t
wait_as (ptid_t ptid
, target_waitstatus
*status
,
745 target_wait_flags options
);
747 ptid_t
process_stop_reply (struct stop_reply
*stop_reply
,
748 target_waitstatus
*status
);
750 ptid_t select_thread_for_ambiguous_stop_reply
751 (const struct target_waitstatus
*status
);
753 void remote_notice_new_inferior (ptid_t currthread
, int executing
);
755 void process_initial_stop_replies (int from_tty
);
757 thread_info
*remote_add_thread (ptid_t ptid
, bool running
, bool executing
);
759 void btrace_sync_conf (const btrace_config
*conf
);
761 void remote_btrace_maybe_reopen ();
763 void remove_new_fork_children (threads_listing_context
*context
);
764 void kill_new_fork_children (int pid
);
765 void discard_pending_stop_replies (struct inferior
*inf
);
766 int stop_reply_queue_length ();
768 void check_pending_events_prevent_wildcard_vcont
769 (int *may_global_wildcard_vcont
);
771 void discard_pending_stop_replies_in_queue ();
772 struct stop_reply
*remote_notif_remove_queued_reply (ptid_t ptid
);
773 struct stop_reply
*queued_stop_reply (ptid_t ptid
);
774 int peek_stop_reply (ptid_t ptid
);
775 void remote_parse_stop_reply (const char *buf
, stop_reply
*event
);
777 void remote_stop_ns (ptid_t ptid
);
778 void remote_interrupt_as ();
779 void remote_interrupt_ns ();
781 char *remote_get_noisy_reply ();
782 int remote_query_attached (int pid
);
783 inferior
*remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
786 ptid_t
remote_current_thread (ptid_t oldpid
);
787 ptid_t
get_current_thread (char *wait_status
);
789 void set_thread (ptid_t ptid
, int gen
);
790 void set_general_thread (ptid_t ptid
);
791 void set_continue_thread (ptid_t ptid
);
792 void set_general_process ();
794 char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
796 int remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
797 gdb_ext_thread_info
*info
);
798 int remote_get_threadinfo (threadref
*threadid
, int fieldset
,
799 gdb_ext_thread_info
*info
);
801 int parse_threadlist_response (char *pkt
, int result_limit
,
802 threadref
*original_echo
,
803 threadref
*resultlist
,
805 int remote_get_threadlist (int startflag
, threadref
*nextthread
,
806 int result_limit
, int *done
, int *result_count
,
807 threadref
*threadlist
);
809 int remote_threadlist_iterator (rmt_thread_action stepfunction
,
810 void *context
, int looplimit
);
812 int remote_get_threads_with_ql (threads_listing_context
*context
);
813 int remote_get_threads_with_qxfer (threads_listing_context
*context
);
814 int remote_get_threads_with_qthreadinfo (threads_listing_context
*context
);
816 void extended_remote_restart ();
820 void remote_check_symbols ();
822 void remote_supported_packet (const struct protocol_feature
*feature
,
823 enum packet_support support
,
824 const char *argument
);
826 void remote_query_supported ();
828 void remote_packet_size (const protocol_feature
*feature
,
829 packet_support support
, const char *value
);
831 void remote_serial_quit_handler ();
833 void remote_detach_pid (int pid
);
835 void remote_vcont_probe ();
837 void remote_resume_with_hc (ptid_t ptid
, int step
,
840 void send_interrupt_sequence ();
841 void interrupt_query ();
843 void remote_notif_get_pending_events (notif_client
*nc
);
845 int fetch_register_using_p (struct regcache
*regcache
,
847 int send_g_packet ();
848 void process_g_packet (struct regcache
*regcache
);
849 void fetch_registers_using_g (struct regcache
*regcache
);
850 int store_register_using_P (const struct regcache
*regcache
,
852 void store_registers_using_G (const struct regcache
*regcache
);
854 void set_remote_traceframe ();
856 void check_binary_download (CORE_ADDR addr
);
858 target_xfer_status
remote_write_bytes_aux (const char *header
,
860 const gdb_byte
*myaddr
,
863 ULONGEST
*xfered_len_units
,
867 target_xfer_status
remote_write_bytes (CORE_ADDR memaddr
,
868 const gdb_byte
*myaddr
, ULONGEST len
,
869 int unit_size
, ULONGEST
*xfered_len
);
871 target_xfer_status
remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
873 int unit_size
, ULONGEST
*xfered_len_units
);
875 target_xfer_status
remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
879 ULONGEST
*xfered_len
);
881 target_xfer_status
remote_read_bytes (CORE_ADDR memaddr
,
882 gdb_byte
*myaddr
, ULONGEST len
,
884 ULONGEST
*xfered_len
);
886 packet_result
remote_send_printf (const char *format
, ...)
887 ATTRIBUTE_PRINTF (2, 3);
889 target_xfer_status
remote_flash_write (ULONGEST address
,
890 ULONGEST length
, ULONGEST
*xfered_len
,
891 const gdb_byte
*data
);
893 int readchar (int timeout
);
895 void remote_serial_write (const char *str
, int len
);
897 int putpkt (const char *buf
);
898 int putpkt_binary (const char *buf
, int cnt
);
900 int putpkt (const gdb::char_vector
&buf
)
902 return putpkt (buf
.data ());
906 long read_frame (gdb::char_vector
*buf_p
);
907 void getpkt (gdb::char_vector
*buf
, int forever
);
908 int getpkt_or_notif_sane_1 (gdb::char_vector
*buf
, int forever
,
909 int expecting_notif
, int *is_notif
);
910 int getpkt_sane (gdb::char_vector
*buf
, int forever
);
911 int getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
913 int remote_vkill (int pid
);
914 void remote_kill_k ();
916 void extended_remote_disable_randomization (int val
);
917 int extended_remote_run (const std::string
&args
);
919 void send_environment_packet (const char *action
,
923 void extended_remote_environment_support ();
924 void extended_remote_set_inferior_cwd ();
926 target_xfer_status
remote_write_qxfer (const char *object_name
,
928 const gdb_byte
*writebuf
,
929 ULONGEST offset
, LONGEST len
,
930 ULONGEST
*xfered_len
,
931 struct packet_config
*packet
);
933 target_xfer_status
remote_read_qxfer (const char *object_name
,
935 gdb_byte
*readbuf
, ULONGEST offset
,
937 ULONGEST
*xfered_len
,
938 struct packet_config
*packet
);
940 void push_stop_reply (struct stop_reply
*new_event
);
942 bool vcont_r_supported ();
944 void packet_command (const char *args
, int from_tty
);
946 private: /* data fields */
948 /* The remote state. Don't reference this directly. Use the
949 get_remote_state method instead. */
950 remote_state m_remote_state
;
953 static const target_info extended_remote_target_info
= {
955 N_("Extended remote serial target in gdb-specific protocol"),
959 /* Set up the extended remote target by extending the standard remote
960 target and adding to it. */
962 class extended_remote_target final
: public remote_target
965 const target_info
&info () const override
966 { return extended_remote_target_info
; }
968 /* Open an extended-remote connection. */
969 static void open (const char *, int);
971 bool can_create_inferior () override
{ return true; }
972 void create_inferior (const char *, const std::string
&,
973 char **, int) override
;
975 void detach (inferior
*, int) override
;
977 bool can_attach () override
{ return true; }
978 void attach (const char *, int) override
;
980 void post_attach (int) override
;
981 bool supports_disable_randomization () override
;
984 /* Per-program-space data key. */
985 static const struct program_space_key
<char, gdb::xfree_deleter
<char>>
988 /* The variable registered as the control variable used by the
989 remote exec-file commands. While the remote exec-file setting is
990 per-program-space, the set/show machinery uses this as the
991 location of the remote exec-file value. */
992 static char *remote_exec_file_var
;
994 /* The size to align memory write packets, when practical. The protocol
995 does not guarantee any alignment, and gdb will generate short
996 writes and unaligned writes, but even as a best-effort attempt this
997 can improve bulk transfers. For instance, if a write is misaligned
998 relative to the target's data bus, the stub may need to make an extra
999 round trip fetching data from the target. This doesn't make a
1000 huge difference, but it's easy to do, so we try to be helpful.
1002 The alignment chosen is arbitrary; usually data bus width is
1003 important here, not the possibly larger cache line size. */
1004 enum { REMOTE_ALIGN_WRITES
= 16 };
1006 /* Prototypes for local functions. */
1008 static int hexnumlen (ULONGEST num
);
1010 static int stubhex (int ch
);
1012 static int hexnumstr (char *, ULONGEST
);
1014 static int hexnumnstr (char *, ULONGEST
, int);
1016 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
1018 static void print_packet (const char *);
1020 static int stub_unpack_int (char *buff
, int fieldlength
);
1022 struct packet_config
;
1024 static void show_packet_config_cmd (struct packet_config
*config
);
1026 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
1028 struct cmd_list_element
*c
,
1031 static ptid_t
read_ptid (const char *buf
, const char **obuf
);
1033 static void remote_async_inferior_event_handler (gdb_client_data
);
1035 static bool remote_read_description_p (struct target_ops
*target
);
1037 static void remote_console_output (const char *msg
);
1039 static void remote_btrace_reset (remote_state
*rs
);
1041 static void remote_unpush_and_throw (remote_target
*target
);
1045 static struct cmd_list_element
*remote_cmdlist
;
1047 /* For "set remote" and "show remote". */
1049 static struct cmd_list_element
*remote_set_cmdlist
;
1050 static struct cmd_list_element
*remote_show_cmdlist
;
1052 /* Controls whether GDB is willing to use range stepping. */
1054 static bool use_range_stepping
= true;
1056 /* From the remote target's point of view, each thread is in one of these three
1058 enum class resume_state
1060 /* Not resumed - we haven't been asked to resume this thread. */
1063 /* We have been asked to resume this thread, but haven't sent a vCont action
1064 for it yet. We'll need to consider it next time commit_resume is
1066 RESUMED_PENDING_VCONT
,
1068 /* We have been asked to resume this thread, and we have sent a vCont action
1073 /* Information about a thread's pending vCont-resume. Used when a thread is in
1074 the remote_resume_state::RESUMED_PENDING_VCONT state. remote_target::resume
1075 stores this information which is then picked up by
1076 remote_target::commit_resume to know which is the proper action for this
1077 thread to include in the vCont packet. */
1078 struct resumed_pending_vcont_info
1080 /* True if the last resume call for this thread was a step request, false
1081 if a continue request. */
1084 /* The signal specified in the last resume call for this thread. */
1088 /* Private data that we'll store in (struct thread_info)->priv. */
1089 struct remote_thread_info
: public private_thread_info
1095 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1096 sequence of bytes. */
1097 gdb::byte_vector thread_handle
;
1099 /* Whether the target stopped for a breakpoint/watchpoint. */
1100 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1102 /* This is set to the data address of the access causing the target
1103 to stop for a watchpoint. */
1104 CORE_ADDR watch_data_address
= 0;
1106 /* Get the thread's resume state. */
1107 enum resume_state
resume_state () const
1109 return m_resume_state
;
1112 /* Put the thread in the NOT_RESUMED state. */
1113 void set_not_resumed ()
1115 m_resume_state
= resume_state::NOT_RESUMED
;
1118 /* Put the thread in the RESUMED_PENDING_VCONT state. */
1119 void set_resumed_pending_vcont (bool step
, gdb_signal sig
)
1121 m_resume_state
= resume_state::RESUMED_PENDING_VCONT
;
1122 m_resumed_pending_vcont_info
.step
= step
;
1123 m_resumed_pending_vcont_info
.sig
= sig
;
1126 /* Get the information this thread's pending vCont-resumption.
1128 Must only be called if the thread is in the RESUMED_PENDING_VCONT resume
1130 const struct resumed_pending_vcont_info
&resumed_pending_vcont_info () const
1132 gdb_assert (m_resume_state
== resume_state::RESUMED_PENDING_VCONT
);
1134 return m_resumed_pending_vcont_info
;
1137 /* Put the thread in the VCONT_RESUMED state. */
1140 m_resume_state
= resume_state::RESUMED
;
1144 /* Resume state for this thread. This is used to implement vCont action
1145 coalescing (only when the target operates in non-stop mode).
1147 remote_target::resume moves the thread to the RESUMED_PENDING_VCONT state,
1148 which notes that this thread must be considered in the next commit_resume
1151 remote_target::commit_resume sends a vCont packet with actions for the
1152 threads in the RESUMED_PENDING_VCONT state and moves them to the
1153 VCONT_RESUMED state.
1155 When reporting a stop to the core for a thread, that thread is moved back
1156 to the NOT_RESUMED state. */
1157 enum resume_state m_resume_state
= resume_state::NOT_RESUMED
;
1159 /* Extra info used if the thread is in the RESUMED_PENDING_VCONT state. */
1160 struct resumed_pending_vcont_info m_resumed_pending_vcont_info
;
1163 remote_state::remote_state ()
1168 remote_state::~remote_state ()
1170 xfree (this->last_pass_packet
);
1171 xfree (this->last_program_signals_packet
);
1172 xfree (this->finished_object
);
1173 xfree (this->finished_annex
);
1176 /* Utility: generate error from an incoming stub packet. */
1178 trace_error (char *buf
)
1181 return; /* not an error msg */
1184 case '1': /* malformed packet error */
1185 if (*++buf
== '0') /* general case: */
1186 error (_("remote.c: error in outgoing packet."));
1188 error (_("remote.c: error in outgoing packet at field #%ld."),
1189 strtol (buf
, NULL
, 16));
1191 error (_("Target returns error code '%s'."), buf
);
1195 /* Utility: wait for reply from stub, while accepting "O" packets. */
1198 remote_target::remote_get_noisy_reply ()
1200 struct remote_state
*rs
= get_remote_state ();
1202 do /* Loop on reply from remote stub. */
1206 QUIT
; /* Allow user to bail out with ^C. */
1207 getpkt (&rs
->buf
, 0);
1208 buf
= rs
->buf
.data ();
1211 else if (startswith (buf
, "qRelocInsn:"))
1214 CORE_ADDR from
, to
, org_to
;
1216 int adjusted_size
= 0;
1219 p
= buf
+ strlen ("qRelocInsn:");
1220 pp
= unpack_varlen_hex (p
, &ul
);
1222 error (_("invalid qRelocInsn packet: %s"), buf
);
1226 unpack_varlen_hex (p
, &ul
);
1233 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1236 catch (const gdb_exception
&ex
)
1238 if (ex
.error
== MEMORY_ERROR
)
1240 /* Propagate memory errors silently back to the
1241 target. The stub may have limited the range of
1242 addresses we can write to, for example. */
1246 /* Something unexpectedly bad happened. Be verbose
1247 so we can tell what, and propagate the error back
1248 to the stub, so it doesn't get stuck waiting for
1250 exception_fprintf (gdb_stderr
, ex
,
1251 _("warning: relocating instruction: "));
1258 adjusted_size
= to
- org_to
;
1260 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1264 else if (buf
[0] == 'O' && buf
[1] != 'K')
1265 remote_console_output (buf
+ 1); /* 'O' message from stub */
1267 return buf
; /* Here's the actual reply. */
1272 struct remote_arch_state
*
1273 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1275 remote_arch_state
*rsa
;
1277 auto it
= this->m_arch_states
.find (gdbarch
);
1278 if (it
== this->m_arch_states
.end ())
1280 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1281 std::forward_as_tuple (gdbarch
),
1282 std::forward_as_tuple (gdbarch
));
1283 rsa
= &p
.first
->second
;
1285 /* Make sure that the packet buffer is plenty big enough for
1286 this architecture. */
1287 if (this->buf
.size () < rsa
->remote_packet_size
)
1288 this->buf
.resize (2 * rsa
->remote_packet_size
);
1296 /* Fetch the global remote target state. */
1299 remote_target::get_remote_state ()
1301 /* Make sure that the remote architecture state has been
1302 initialized, because doing so might reallocate rs->buf. Any
1303 function which calls getpkt also needs to be mindful of changes
1304 to rs->buf, but this call limits the number of places which run
1306 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1308 return &m_remote_state
;
1311 /* Fetch the remote exec-file from the current program space. */
1314 get_remote_exec_file (void)
1316 char *remote_exec_file
;
1318 remote_exec_file
= remote_pspace_data
.get (current_program_space
);
1319 if (remote_exec_file
== NULL
)
1322 return remote_exec_file
;
1325 /* Set the remote exec file for PSPACE. */
1328 set_pspace_remote_exec_file (struct program_space
*pspace
,
1329 const char *remote_exec_file
)
1331 char *old_file
= remote_pspace_data
.get (pspace
);
1334 remote_pspace_data
.set (pspace
, xstrdup (remote_exec_file
));
1337 /* The "set/show remote exec-file" set command hook. */
1340 set_remote_exec_file (const char *ignored
, int from_tty
,
1341 struct cmd_list_element
*c
)
1343 gdb_assert (remote_exec_file_var
!= NULL
);
1344 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
1347 /* The "set/show remote exec-file" show command hook. */
1350 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1351 struct cmd_list_element
*cmd
, const char *value
)
1353 fprintf_filtered (file
, "%s\n", get_remote_exec_file ());
1357 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1359 int regnum
, num_remote_regs
, offset
;
1360 struct packet_reg
**remote_regs
;
1362 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1364 struct packet_reg
*r
= ®s
[regnum
];
1366 if (register_size (gdbarch
, regnum
) == 0)
1367 /* Do not try to fetch zero-sized (placeholder) registers. */
1370 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1375 /* Define the g/G packet format as the contents of each register
1376 with a remote protocol number, in order of ascending protocol
1379 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1380 for (num_remote_regs
= 0, regnum
= 0;
1381 regnum
< gdbarch_num_regs (gdbarch
);
1383 if (regs
[regnum
].pnum
!= -1)
1384 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1386 std::sort (remote_regs
, remote_regs
+ num_remote_regs
,
1387 [] (const packet_reg
*a
, const packet_reg
*b
)
1388 { return a
->pnum
< b
->pnum
; });
1390 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1392 remote_regs
[regnum
]->in_g_packet
= 1;
1393 remote_regs
[regnum
]->offset
= offset
;
1394 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1400 /* Given the architecture described by GDBARCH, return the remote
1401 protocol register's number and the register's offset in the g/G
1402 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1403 If the target does not have a mapping for REGNUM, return false,
1404 otherwise, return true. */
1407 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1408 int *pnum
, int *poffset
)
1410 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1412 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1414 map_regcache_remote_table (gdbarch
, regs
.data ());
1416 *pnum
= regs
[regnum
].pnum
;
1417 *poffset
= regs
[regnum
].offset
;
1422 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1424 /* Use the architecture to build a regnum<->pnum table, which will be
1425 1:1 unless a feature set specifies otherwise. */
1426 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1428 /* Record the maximum possible size of the g packet - it may turn out
1430 this->sizeof_g_packet
1431 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1433 /* Default maximum number of characters in a packet body. Many
1434 remote stubs have a hardwired buffer size of 400 bytes
1435 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1436 as the maximum packet-size to ensure that the packet and an extra
1437 NUL character can always fit in the buffer. This stops GDB
1438 trashing stubs that try to squeeze an extra NUL into what is
1439 already a full buffer (As of 1999-12-04 that was most stubs). */
1440 this->remote_packet_size
= 400 - 1;
1442 /* This one is filled in when a ``g'' packet is received. */
1443 this->actual_register_packet_size
= 0;
1445 /* Should rsa->sizeof_g_packet needs more space than the
1446 default, adjust the size accordingly. Remember that each byte is
1447 encoded as two characters. 32 is the overhead for the packet
1448 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1449 (``$NN:G...#NN'') is a better guess, the below has been padded a
1451 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1452 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1455 /* Get a pointer to the current remote target. If not connected to a
1456 remote target, return NULL. */
1458 static remote_target
*
1459 get_current_remote_target ()
1461 target_ops
*proc_target
= current_inferior ()->process_target ();
1462 return dynamic_cast<remote_target
*> (proc_target
);
1465 /* Return the current allowed size of a remote packet. This is
1466 inferred from the current architecture, and should be used to
1467 limit the length of outgoing packets. */
1469 remote_target::get_remote_packet_size ()
1471 struct remote_state
*rs
= get_remote_state ();
1472 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1474 if (rs
->explicit_packet_size
)
1475 return rs
->explicit_packet_size
;
1477 return rsa
->remote_packet_size
;
1480 static struct packet_reg
*
1481 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1484 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1488 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1490 gdb_assert (r
->regnum
== regnum
);
1495 static struct packet_reg
*
1496 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1501 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1503 struct packet_reg
*r
= &rsa
->regs
[i
];
1505 if (r
->pnum
== pnum
)
1511 /* Allow the user to specify what sequence to send to the remote
1512 when he requests a program interruption: Although ^C is usually
1513 what remote systems expect (this is the default, here), it is
1514 sometimes preferable to send a break. On other systems such
1515 as the Linux kernel, a break followed by g, which is Magic SysRq g
1516 is required in order to interrupt the execution. */
1517 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1518 const char interrupt_sequence_break
[] = "BREAK";
1519 const char interrupt_sequence_break_g
[] = "BREAK-g";
1520 static const char *const interrupt_sequence_modes
[] =
1522 interrupt_sequence_control_c
,
1523 interrupt_sequence_break
,
1524 interrupt_sequence_break_g
,
1527 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1530 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1531 struct cmd_list_element
*c
,
1534 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1535 fprintf_filtered (file
,
1536 _("Send the ASCII ETX character (Ctrl-c) "
1537 "to the remote target to interrupt the "
1538 "execution of the program.\n"));
1539 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1540 fprintf_filtered (file
,
1541 _("send a break signal to the remote target "
1542 "to interrupt the execution of the program.\n"));
1543 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1544 fprintf_filtered (file
,
1545 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1546 "the remote target to interrupt the execution "
1547 "of Linux kernel.\n"));
1549 internal_error (__FILE__
, __LINE__
,
1550 _("Invalid value for interrupt_sequence_mode: %s."),
1551 interrupt_sequence_mode
);
1554 /* This boolean variable specifies whether interrupt_sequence is sent
1555 to the remote target when gdb connects to it.
1556 This is mostly needed when you debug the Linux kernel: The Linux kernel
1557 expects BREAK g which is Magic SysRq g for connecting gdb. */
1558 static bool interrupt_on_connect
= false;
1560 /* This variable is used to implement the "set/show remotebreak" commands.
1561 Since these commands are now deprecated in favor of "set/show remote
1562 interrupt-sequence", it no longer has any effect on the code. */
1563 static bool remote_break
;
1566 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1569 interrupt_sequence_mode
= interrupt_sequence_break
;
1571 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1575 show_remotebreak (struct ui_file
*file
, int from_tty
,
1576 struct cmd_list_element
*c
,
1581 /* This variable sets the number of bits in an address that are to be
1582 sent in a memory ("M" or "m") packet. Normally, after stripping
1583 leading zeros, the entire address would be sent. This variable
1584 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1585 initial implementation of remote.c restricted the address sent in
1586 memory packets to ``host::sizeof long'' bytes - (typically 32
1587 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1588 address was never sent. Since fixing this bug may cause a break in
1589 some remote targets this variable is principally provided to
1590 facilitate backward compatibility. */
1592 static unsigned int remote_address_size
;
1595 /* User configurable variables for the number of characters in a
1596 memory read/write packet. MIN (rsa->remote_packet_size,
1597 rsa->sizeof_g_packet) is the default. Some targets need smaller
1598 values (fifo overruns, et.al.) and some users need larger values
1599 (speed up transfers). The variables ``preferred_*'' (the user
1600 request), ``current_*'' (what was actually set) and ``forced_*''
1601 (Positive - a soft limit, negative - a hard limit). */
1603 struct memory_packet_config
1610 /* The default max memory-write-packet-size, when the setting is
1611 "fixed". The 16k is historical. (It came from older GDB's using
1612 alloca for buffers and the knowledge (folklore?) that some hosts
1613 don't cope very well with large alloca calls.) */
1614 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1616 /* The minimum remote packet size for memory transfers. Ensures we
1617 can write at least one byte. */
1618 #define MIN_MEMORY_PACKET_SIZE 20
1620 /* Get the memory packet size, assuming it is fixed. */
1623 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1625 gdb_assert (config
->fixed_p
);
1627 if (config
->size
<= 0)
1628 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1630 return config
->size
;
1633 /* Compute the current size of a read/write packet. Since this makes
1634 use of ``actual_register_packet_size'' the computation is dynamic. */
1637 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1639 struct remote_state
*rs
= get_remote_state ();
1640 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1643 if (config
->fixed_p
)
1644 what_they_get
= get_fixed_memory_packet_size (config
);
1647 what_they_get
= get_remote_packet_size ();
1648 /* Limit the packet to the size specified by the user. */
1649 if (config
->size
> 0
1650 && what_they_get
> config
->size
)
1651 what_they_get
= config
->size
;
1653 /* Limit it to the size of the targets ``g'' response unless we have
1654 permission from the stub to use a larger packet size. */
1655 if (rs
->explicit_packet_size
== 0
1656 && rsa
->actual_register_packet_size
> 0
1657 && what_they_get
> rsa
->actual_register_packet_size
)
1658 what_they_get
= rsa
->actual_register_packet_size
;
1660 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1661 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1663 /* Make sure there is room in the global buffer for this packet
1664 (including its trailing NUL byte). */
1665 if (rs
->buf
.size () < what_they_get
+ 1)
1666 rs
->buf
.resize (2 * what_they_get
);
1668 return what_they_get
;
1671 /* Update the size of a read/write packet. If they user wants
1672 something really big then do a sanity check. */
1675 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1677 int fixed_p
= config
->fixed_p
;
1678 long size
= config
->size
;
1681 error (_("Argument required (integer, `fixed' or `limited')."));
1682 else if (strcmp (args
, "hard") == 0
1683 || strcmp (args
, "fixed") == 0)
1685 else if (strcmp (args
, "soft") == 0
1686 || strcmp (args
, "limit") == 0)
1692 size
= strtoul (args
, &end
, 0);
1694 error (_("Invalid %s (bad syntax)."), config
->name
);
1696 /* Instead of explicitly capping the size of a packet to or
1697 disallowing it, the user is allowed to set the size to
1698 something arbitrarily large. */
1702 if (fixed_p
&& !config
->fixed_p
)
1704 /* So that the query shows the correct value. */
1705 long query_size
= (size
<= 0
1706 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1709 if (! query (_("The target may not be able to correctly handle a %s\n"
1710 "of %ld bytes. Change the packet size? "),
1711 config
->name
, query_size
))
1712 error (_("Packet size not changed."));
1714 /* Update the config. */
1715 config
->fixed_p
= fixed_p
;
1716 config
->size
= size
;
1720 show_memory_packet_size (struct memory_packet_config
*config
)
1722 if (config
->size
== 0)
1723 printf_filtered (_("The %s is 0 (default). "), config
->name
);
1725 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1726 if (config
->fixed_p
)
1727 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1728 get_fixed_memory_packet_size (config
));
1731 remote_target
*remote
= get_current_remote_target ();
1734 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1735 remote
->get_memory_packet_size (config
));
1737 puts_filtered ("The actual limit will be further reduced "
1738 "dependent on the target.\n");
1742 /* FIXME: needs to be per-remote-target. */
1743 static struct memory_packet_config memory_write_packet_config
=
1745 "memory-write-packet-size",
1749 set_memory_write_packet_size (const char *args
, int from_tty
)
1751 set_memory_packet_size (args
, &memory_write_packet_config
);
1755 show_memory_write_packet_size (const char *args
, int from_tty
)
1757 show_memory_packet_size (&memory_write_packet_config
);
1760 /* Show the number of hardware watchpoints that can be used. */
1763 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1764 struct cmd_list_element
*c
,
1767 fprintf_filtered (file
, _("The maximum number of target hardware "
1768 "watchpoints is %s.\n"), value
);
1771 /* Show the length limit (in bytes) for hardware watchpoints. */
1774 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1775 struct cmd_list_element
*c
,
1778 fprintf_filtered (file
, _("The maximum length (in bytes) of a target "
1779 "hardware watchpoint is %s.\n"), value
);
1782 /* Show the number of hardware breakpoints that can be used. */
1785 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1786 struct cmd_list_element
*c
,
1789 fprintf_filtered (file
, _("The maximum number of target hardware "
1790 "breakpoints is %s.\n"), value
);
1793 /* Controls the maximum number of characters to display in the debug output
1794 for each remote packet. The remaining characters are omitted. */
1796 static int remote_packet_max_chars
= 512;
1798 /* Show the maximum number of characters to display for each remote packet
1799 when remote debugging is enabled. */
1802 show_remote_packet_max_chars (struct ui_file
*file
, int from_tty
,
1803 struct cmd_list_element
*c
,
1806 fprintf_filtered (file
, _("Number of remote packet characters to "
1807 "display is %s.\n"), value
);
1811 remote_target::get_memory_write_packet_size ()
1813 return get_memory_packet_size (&memory_write_packet_config
);
1816 /* FIXME: needs to be per-remote-target. */
1817 static struct memory_packet_config memory_read_packet_config
=
1819 "memory-read-packet-size",
1823 set_memory_read_packet_size (const char *args
, int from_tty
)
1825 set_memory_packet_size (args
, &memory_read_packet_config
);
1829 show_memory_read_packet_size (const char *args
, int from_tty
)
1831 show_memory_packet_size (&memory_read_packet_config
);
1835 remote_target::get_memory_read_packet_size ()
1837 long size
= get_memory_packet_size (&memory_read_packet_config
);
1839 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1840 extra buffer size argument before the memory read size can be
1841 increased beyond this. */
1842 if (size
> get_remote_packet_size ())
1843 size
= get_remote_packet_size ();
1849 struct packet_config
1854 /* If auto, GDB auto-detects support for this packet or feature,
1855 either through qSupported, or by trying the packet and looking
1856 at the response. If true, GDB assumes the target supports this
1857 packet. If false, the packet is disabled. Configs that don't
1858 have an associated command always have this set to auto. */
1859 enum auto_boolean detect
;
1861 /* Does the target support this packet? */
1862 enum packet_support support
;
1865 static enum packet_support
packet_config_support (struct packet_config
*config
);
1866 static enum packet_support
packet_support (int packet
);
1869 show_packet_config_cmd (struct packet_config
*config
)
1871 const char *support
= "internal-error";
1873 switch (packet_config_support (config
))
1876 support
= "enabled";
1878 case PACKET_DISABLE
:
1879 support
= "disabled";
1881 case PACKET_SUPPORT_UNKNOWN
:
1882 support
= "unknown";
1885 switch (config
->detect
)
1887 case AUTO_BOOLEAN_AUTO
:
1888 printf_filtered (_("Support for the `%s' packet "
1889 "is auto-detected, currently %s.\n"),
1890 config
->name
, support
);
1892 case AUTO_BOOLEAN_TRUE
:
1893 case AUTO_BOOLEAN_FALSE
:
1894 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1895 config
->name
, support
);
1901 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1902 const char *title
, int legacy
)
1908 config
->name
= name
;
1909 config
->title
= title
;
1910 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1912 show_doc
= xstrprintf ("Show current use of remote "
1913 "protocol `%s' (%s) packet.",
1915 /* set/show TITLE-packet {auto,on,off} */
1916 cmd_name
= xstrprintf ("%s-packet", title
);
1917 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1918 &config
->detect
, set_doc
,
1919 show_doc
, NULL
, /* help_doc */
1921 show_remote_protocol_packet_cmd
,
1922 &remote_set_cmdlist
, &remote_show_cmdlist
);
1923 /* The command code copies the documentation strings. */
1926 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1931 legacy_name
= xstrprintf ("%s-packet", name
);
1932 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1933 &remote_set_cmdlist
);
1934 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1935 &remote_show_cmdlist
);
1939 static enum packet_result
1940 packet_check_result (const char *buf
)
1944 /* The stub recognized the packet request. Check that the
1945 operation succeeded. */
1947 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1949 /* "Enn" - definitely an error. */
1950 return PACKET_ERROR
;
1952 /* Always treat "E." as an error. This will be used for
1953 more verbose error messages, such as E.memtypes. */
1954 if (buf
[0] == 'E' && buf
[1] == '.')
1955 return PACKET_ERROR
;
1957 /* The packet may or may not be OK. Just assume it is. */
1961 /* The stub does not support the packet. */
1962 return PACKET_UNKNOWN
;
1965 static enum packet_result
1966 packet_check_result (const gdb::char_vector
&buf
)
1968 return packet_check_result (buf
.data ());
1971 static enum packet_result
1972 packet_ok (const char *buf
, struct packet_config
*config
)
1974 enum packet_result result
;
1976 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1977 && config
->support
== PACKET_DISABLE
)
1978 internal_error (__FILE__
, __LINE__
,
1979 _("packet_ok: attempt to use a disabled packet"));
1981 result
= packet_check_result (buf
);
1986 /* The stub recognized the packet request. */
1987 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1990 fprintf_unfiltered (gdb_stdlog
,
1991 "Packet %s (%s) is supported\n",
1992 config
->name
, config
->title
);
1993 config
->support
= PACKET_ENABLE
;
1996 case PACKET_UNKNOWN
:
1997 /* The stub does not support the packet. */
1998 if (config
->detect
== AUTO_BOOLEAN_AUTO
1999 && config
->support
== PACKET_ENABLE
)
2001 /* If the stub previously indicated that the packet was
2002 supported then there is a protocol error. */
2003 error (_("Protocol error: %s (%s) conflicting enabled responses."),
2004 config
->name
, config
->title
);
2006 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
2008 /* The user set it wrong. */
2009 error (_("Enabled packet %s (%s) not recognized by stub"),
2010 config
->name
, config
->title
);
2014 fprintf_unfiltered (gdb_stdlog
,
2015 "Packet %s (%s) is NOT supported\n",
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)
2733 fprintf_unfiltered (gdb_stdlog
,
2734 "remote_set_syscall_catchpoint "
2735 "pid %d needed %d any_count %d n_sysno %d\n",
2736 pid
, needed
, any_count
, n_sysno
);
2739 std::string built_packet
;
2742 /* Prepare a packet with the sysno list, assuming max 8+1
2743 characters for a sysno. If the resulting packet size is too
2744 big, fallback on the non-selective packet. */
2745 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2746 built_packet
.reserve (maxpktsz
);
2747 built_packet
= "QCatchSyscalls:1";
2750 /* Add in each syscall to be caught. */
2751 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2753 if (syscall_counts
[i
] != 0)
2754 string_appendf (built_packet
, ";%zx", i
);
2757 if (built_packet
.size () > get_remote_packet_size ())
2759 /* catch_packet too big. Fallback to less efficient
2760 non selective mode, with GDB doing the filtering. */
2761 catch_packet
= "QCatchSyscalls:1";
2764 catch_packet
= built_packet
.c_str ();
2767 catch_packet
= "QCatchSyscalls:0";
2769 struct remote_state
*rs
= get_remote_state ();
2771 putpkt (catch_packet
);
2772 getpkt (&rs
->buf
, 0);
2773 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2774 if (result
== PACKET_OK
)
2780 /* If 'QProgramSignals' is supported, tell the remote stub what
2781 signals it should pass through to the inferior when detaching. */
2784 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2786 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2790 struct remote_state
*rs
= get_remote_state ();
2792 gdb_assert (signals
.size () < 256);
2793 for (size_t i
= 0; i
< signals
.size (); i
++)
2798 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2799 strcpy (packet
, "QProgramSignals:");
2800 p
= packet
+ strlen (packet
);
2801 for (size_t i
= 0; i
< signals
.size (); i
++)
2803 if (signal_pass_state (i
))
2806 *p
++ = tohex (i
>> 4);
2807 *p
++ = tohex (i
& 15);
2816 if (!rs
->last_program_signals_packet
2817 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2820 getpkt (&rs
->buf
, 0);
2821 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2822 xfree (rs
->last_program_signals_packet
);
2823 rs
->last_program_signals_packet
= packet
;
2830 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2831 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2832 thread. If GEN is set, set the general thread, if not, then set
2833 the step/continue thread. */
2835 remote_target::set_thread (ptid_t ptid
, int gen
)
2837 struct remote_state
*rs
= get_remote_state ();
2838 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2839 char *buf
= rs
->buf
.data ();
2840 char *endbuf
= buf
+ get_remote_packet_size ();
2846 *buf
++ = gen
? 'g' : 'c';
2847 if (ptid
== magic_null_ptid
)
2848 xsnprintf (buf
, endbuf
- buf
, "0");
2849 else if (ptid
== any_thread_ptid
)
2850 xsnprintf (buf
, endbuf
- buf
, "0");
2851 else if (ptid
== minus_one_ptid
)
2852 xsnprintf (buf
, endbuf
- buf
, "-1");
2854 write_ptid (buf
, endbuf
, ptid
);
2856 getpkt (&rs
->buf
, 0);
2858 rs
->general_thread
= ptid
;
2860 rs
->continue_thread
= ptid
;
2864 remote_target::set_general_thread (ptid_t ptid
)
2866 set_thread (ptid
, 1);
2870 remote_target::set_continue_thread (ptid_t ptid
)
2872 set_thread (ptid
, 0);
2875 /* Change the remote current process. Which thread within the process
2876 ends up selected isn't important, as long as it is the same process
2877 as what INFERIOR_PTID points to.
2879 This comes from that fact that there is no explicit notion of
2880 "selected process" in the protocol. The selected process for
2881 general operations is the process the selected general thread
2885 remote_target::set_general_process ()
2887 struct remote_state
*rs
= get_remote_state ();
2889 /* If the remote can't handle multiple processes, don't bother. */
2890 if (!remote_multi_process_p (rs
))
2893 /* We only need to change the remote current thread if it's pointing
2894 at some other process. */
2895 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2896 set_general_thread (inferior_ptid
);
2900 /* Return nonzero if this is the main thread that we made up ourselves
2901 to model non-threaded targets as single-threaded. */
2904 remote_thread_always_alive (ptid_t ptid
)
2906 if (ptid
== magic_null_ptid
)
2907 /* The main thread is always alive. */
2910 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2911 /* The main thread is always alive. This can happen after a
2912 vAttach, if the remote side doesn't support
2919 /* Return nonzero if the thread PTID is still alive on the remote
2923 remote_target::thread_alive (ptid_t ptid
)
2925 struct remote_state
*rs
= get_remote_state ();
2928 /* Check if this is a thread that we made up ourselves to model
2929 non-threaded targets as single-threaded. */
2930 if (remote_thread_always_alive (ptid
))
2933 p
= rs
->buf
.data ();
2934 endp
= p
+ get_remote_packet_size ();
2937 write_ptid (p
, endp
, ptid
);
2940 getpkt (&rs
->buf
, 0);
2941 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2944 /* Return a pointer to a thread name if we know it and NULL otherwise.
2945 The thread_info object owns the memory for the name. */
2948 remote_target::thread_name (struct thread_info
*info
)
2950 if (info
->priv
!= NULL
)
2952 const std::string
&name
= get_remote_thread_info (info
)->name
;
2953 return !name
.empty () ? name
.c_str () : NULL
;
2959 /* About these extended threadlist and threadinfo packets. They are
2960 variable length packets but, the fields within them are often fixed
2961 length. They are redundant enough to send over UDP as is the
2962 remote protocol in general. There is a matching unit test module
2965 /* WARNING: This threadref data structure comes from the remote O.S.,
2966 libstub protocol encoding, and remote.c. It is not particularly
2969 /* Right now, the internal structure is int. We want it to be bigger.
2970 Plan to fix this. */
2972 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2974 /* gdb_ext_thread_info is an internal GDB data structure which is
2975 equivalent to the reply of the remote threadinfo packet. */
2977 struct gdb_ext_thread_info
2979 threadref threadid
; /* External form of thread reference. */
2980 int active
; /* Has state interesting to GDB?
2982 char display
[256]; /* Brief state display, name,
2983 blocked/suspended. */
2984 char shortname
[32]; /* To be used to name threads. */
2985 char more_display
[256]; /* Long info, statistics, queue depth,
2989 /* The volume of remote transfers can be limited by submitting
2990 a mask containing bits specifying the desired information.
2991 Use a union of these values as the 'selection' parameter to
2992 get_thread_info. FIXME: Make these TAG names more thread specific. */
2994 #define TAG_THREADID 1
2995 #define TAG_EXISTS 2
2996 #define TAG_DISPLAY 4
2997 #define TAG_THREADNAME 8
2998 #define TAG_MOREDISPLAY 16
3000 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
3002 static char *unpack_nibble (char *buf
, int *val
);
3004 static char *unpack_byte (char *buf
, int *value
);
3006 static char *pack_int (char *buf
, int value
);
3008 static char *unpack_int (char *buf
, int *value
);
3010 static char *unpack_string (char *src
, char *dest
, int length
);
3012 static char *pack_threadid (char *pkt
, threadref
*id
);
3014 static char *unpack_threadid (char *inbuf
, threadref
*id
);
3016 void int_to_threadref (threadref
*id
, int value
);
3018 static int threadref_to_int (threadref
*ref
);
3020 static void copy_threadref (threadref
*dest
, threadref
*src
);
3022 static int threadmatch (threadref
*dest
, threadref
*src
);
3024 static char *pack_threadinfo_request (char *pkt
, int mode
,
3027 static char *pack_threadlist_request (char *pkt
, int startflag
,
3029 threadref
*nextthread
);
3031 static int remote_newthread_step (threadref
*ref
, void *context
);
3034 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
3035 buffer we're allowed to write to. Returns
3036 BUF+CHARACTERS_WRITTEN. */
3039 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
3042 struct remote_state
*rs
= get_remote_state ();
3044 if (remote_multi_process_p (rs
))
3048 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
3050 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
3054 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
3056 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
3061 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
3062 last parsed char. Returns null_ptid if no thread id is found, and
3063 throws an error if the thread id has an invalid format. */
3066 read_ptid (const char *buf
, const char **obuf
)
3068 const char *p
= buf
;
3070 ULONGEST pid
= 0, tid
= 0;
3074 /* Multi-process ptid. */
3075 pp
= unpack_varlen_hex (p
+ 1, &pid
);
3077 error (_("invalid remote ptid: %s"), p
);
3080 pp
= unpack_varlen_hex (p
+ 1, &tid
);
3083 return ptid_t (pid
, tid
, 0);
3086 /* No multi-process. Just a tid. */
3087 pp
= unpack_varlen_hex (p
, &tid
);
3089 /* Return null_ptid when no thread id is found. */
3097 /* Since the stub is not sending a process id, then default to
3098 what's in inferior_ptid, unless it's null at this point. If so,
3099 then since there's no way to know the pid of the reported
3100 threads, use the magic number. */
3101 if (inferior_ptid
== null_ptid
)
3102 pid
= magic_null_ptid
.pid ();
3104 pid
= inferior_ptid
.pid ();
3108 return ptid_t (pid
, tid
, 0);
3114 if (ch
>= 'a' && ch
<= 'f')
3115 return ch
- 'a' + 10;
3116 if (ch
>= '0' && ch
<= '9')
3118 if (ch
>= 'A' && ch
<= 'F')
3119 return ch
- 'A' + 10;
3124 stub_unpack_int (char *buff
, int fieldlength
)
3131 nibble
= stubhex (*buff
++);
3135 retval
= retval
<< 4;
3141 unpack_nibble (char *buf
, int *val
)
3143 *val
= fromhex (*buf
++);
3148 unpack_byte (char *buf
, int *value
)
3150 *value
= stub_unpack_int (buf
, 2);
3155 pack_int (char *buf
, int value
)
3157 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3158 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3159 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3160 buf
= pack_hex_byte (buf
, (value
& 0xff));
3165 unpack_int (char *buf
, int *value
)
3167 *value
= stub_unpack_int (buf
, 8);
3171 #if 0 /* Currently unused, uncomment when needed. */
3172 static char *pack_string (char *pkt
, char *string
);
3175 pack_string (char *pkt
, char *string
)
3180 len
= strlen (string
);
3182 len
= 200; /* Bigger than most GDB packets, junk??? */
3183 pkt
= pack_hex_byte (pkt
, len
);
3187 if ((ch
== '\0') || (ch
== '#'))
3188 ch
= '*'; /* Protect encapsulation. */
3193 #endif /* 0 (unused) */
3196 unpack_string (char *src
, char *dest
, int length
)
3205 pack_threadid (char *pkt
, threadref
*id
)
3208 unsigned char *altid
;
3210 altid
= (unsigned char *) id
;
3211 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3213 pkt
= pack_hex_byte (pkt
, *altid
++);
3219 unpack_threadid (char *inbuf
, threadref
*id
)
3222 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3225 altref
= (char *) id
;
3227 while (inbuf
< limit
)
3229 x
= stubhex (*inbuf
++);
3230 y
= stubhex (*inbuf
++);
3231 *altref
++ = (x
<< 4) | y
;
3236 /* Externally, threadrefs are 64 bits but internally, they are still
3237 ints. This is due to a mismatch of specifications. We would like
3238 to use 64bit thread references internally. This is an adapter
3242 int_to_threadref (threadref
*id
, int value
)
3244 unsigned char *scan
;
3246 scan
= (unsigned char *) id
;
3252 *scan
++ = (value
>> 24) & 0xff;
3253 *scan
++ = (value
>> 16) & 0xff;
3254 *scan
++ = (value
>> 8) & 0xff;
3255 *scan
++ = (value
& 0xff);
3259 threadref_to_int (threadref
*ref
)
3262 unsigned char *scan
;
3268 value
= (value
<< 8) | ((*scan
++) & 0xff);
3273 copy_threadref (threadref
*dest
, threadref
*src
)
3276 unsigned char *csrc
, *cdest
;
3278 csrc
= (unsigned char *) src
;
3279 cdest
= (unsigned char *) dest
;
3286 threadmatch (threadref
*dest
, threadref
*src
)
3288 /* Things are broken right now, so just assume we got a match. */
3290 unsigned char *srcp
, *destp
;
3292 srcp
= (char *) src
;
3293 destp
= (char *) dest
;
3297 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3304 threadid:1, # always request threadid
3311 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3314 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3316 *pkt
++ = 'q'; /* Info Query */
3317 *pkt
++ = 'P'; /* process or thread info */
3318 pkt
= pack_int (pkt
, mode
); /* mode */
3319 pkt
= pack_threadid (pkt
, id
); /* threadid */
3320 *pkt
= '\0'; /* terminate */
3324 /* These values tag the fields in a thread info response packet. */
3325 /* Tagging the fields allows us to request specific fields and to
3326 add more fields as time goes by. */
3328 #define TAG_THREADID 1 /* Echo the thread identifier. */
3329 #define TAG_EXISTS 2 /* Is this process defined enough to
3330 fetch registers and its stack? */
3331 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3332 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3333 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3337 remote_target::remote_unpack_thread_info_response (char *pkt
,
3338 threadref
*expectedref
,
3339 gdb_ext_thread_info
*info
)
3341 struct remote_state
*rs
= get_remote_state ();
3345 char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3348 /* info->threadid = 0; FIXME: implement zero_threadref. */
3350 info
->display
[0] = '\0';
3351 info
->shortname
[0] = '\0';
3352 info
->more_display
[0] = '\0';
3354 /* Assume the characters indicating the packet type have been
3356 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3357 pkt
= unpack_threadid (pkt
, &ref
);
3360 warning (_("Incomplete response to threadinfo request."));
3361 if (!threadmatch (&ref
, expectedref
))
3362 { /* This is an answer to a different request. */
3363 warning (_("ERROR RMT Thread info mismatch."));
3366 copy_threadref (&info
->threadid
, &ref
);
3368 /* Loop on tagged fields , try to bail if something goes wrong. */
3370 /* Packets are terminated with nulls. */
3371 while ((pkt
< limit
) && mask
&& *pkt
)
3373 pkt
= unpack_int (pkt
, &tag
); /* tag */
3374 pkt
= unpack_byte (pkt
, &length
); /* length */
3375 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3377 warning (_("ERROR RMT: threadinfo tag mismatch."));
3381 if (tag
== TAG_THREADID
)
3385 warning (_("ERROR RMT: length of threadid is not 16."));
3389 pkt
= unpack_threadid (pkt
, &ref
);
3390 mask
= mask
& ~TAG_THREADID
;
3393 if (tag
== TAG_EXISTS
)
3395 info
->active
= stub_unpack_int (pkt
, length
);
3397 mask
= mask
& ~(TAG_EXISTS
);
3400 warning (_("ERROR RMT: 'exists' length too long."));
3406 if (tag
== TAG_THREADNAME
)
3408 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3409 mask
= mask
& ~TAG_THREADNAME
;
3412 if (tag
== TAG_DISPLAY
)
3414 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3415 mask
= mask
& ~TAG_DISPLAY
;
3418 if (tag
== TAG_MOREDISPLAY
)
3420 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3421 mask
= mask
& ~TAG_MOREDISPLAY
;
3424 warning (_("ERROR RMT: unknown thread info tag."));
3425 break; /* Not a tag we know about. */
3431 remote_target::remote_get_threadinfo (threadref
*threadid
,
3433 gdb_ext_thread_info
*info
)
3435 struct remote_state
*rs
= get_remote_state ();
3438 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3440 getpkt (&rs
->buf
, 0);
3442 if (rs
->buf
[0] == '\0')
3445 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3450 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3453 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3454 threadref
*nextthread
)
3456 *pkt
++ = 'q'; /* info query packet */
3457 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3458 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3459 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3460 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3465 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3468 remote_target::parse_threadlist_response (char *pkt
, int result_limit
,
3469 threadref
*original_echo
,
3470 threadref
*resultlist
,
3473 struct remote_state
*rs
= get_remote_state ();
3475 int count
, resultcount
, done
;
3478 /* Assume the 'q' and 'M chars have been stripped. */
3479 limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3480 /* done parse past here */
3481 pkt
= unpack_byte (pkt
, &count
); /* count field */
3482 pkt
= unpack_nibble (pkt
, &done
);
3483 /* The first threadid is the argument threadid. */
3484 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3485 while ((count
-- > 0) && (pkt
< limit
))
3487 pkt
= unpack_threadid (pkt
, resultlist
++);
3488 if (resultcount
++ >= result_limit
)
3496 /* Fetch the next batch of threads from the remote. Returns -1 if the
3497 qL packet is not supported, 0 on error and 1 on success. */
3500 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3501 int result_limit
, int *done
, int *result_count
,
3502 threadref
*threadlist
)
3504 struct remote_state
*rs
= get_remote_state ();
3507 /* Truncate result limit to be smaller than the packet size. */
3508 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3509 >= get_remote_packet_size ())
3510 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3512 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3515 getpkt (&rs
->buf
, 0);
3516 if (rs
->buf
[0] == '\0')
3518 /* Packet not supported. */
3523 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3524 &rs
->echo_nextthread
, threadlist
, done
);
3526 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3528 /* FIXME: This is a good reason to drop the packet. */
3529 /* Possibly, there is a duplicate response. */
3531 retransmit immediatly - race conditions
3532 retransmit after timeout - yes
3534 wait for packet, then exit
3536 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3537 return 0; /* I choose simply exiting. */
3539 if (*result_count
<= 0)
3543 warning (_("RMT ERROR : failed to get remote thread list."));
3546 return result
; /* break; */
3548 if (*result_count
> result_limit
)
3551 warning (_("RMT ERROR: threadlist response longer than requested."));
3557 /* Fetch the list of remote threads, with the qL packet, and call
3558 STEPFUNCTION for each thread found. Stops iterating and returns 1
3559 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3560 STEPFUNCTION returns false. If the packet is not supported,
3564 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3565 void *context
, int looplimit
)
3567 struct remote_state
*rs
= get_remote_state ();
3568 int done
, i
, result_count
;
3576 if (loopcount
++ > looplimit
)
3579 warning (_("Remote fetch threadlist -infinite loop-."));
3582 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3583 MAXTHREADLISTRESULTS
,
3584 &done
, &result_count
,
3585 rs
->resultthreadlist
);
3588 /* Clear for later iterations. */
3590 /* Setup to resume next batch of thread references, set nextthread. */
3591 if (result_count
>= 1)
3592 copy_threadref (&rs
->nextthread
,
3593 &rs
->resultthreadlist
[result_count
- 1]);
3595 while (result_count
--)
3597 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3607 /* A thread found on the remote target. */
3611 explicit thread_item (ptid_t ptid_
)
3615 thread_item (thread_item
&&other
) = default;
3616 thread_item
&operator= (thread_item
&&other
) = default;
3618 DISABLE_COPY_AND_ASSIGN (thread_item
);
3620 /* The thread's PTID. */
3623 /* The thread's extra info. */
3626 /* The thread's name. */
3629 /* The core the thread was running on. -1 if not known. */
3632 /* The thread handle associated with the thread. */
3633 gdb::byte_vector thread_handle
;
3636 /* Context passed around to the various methods listing remote
3637 threads. As new threads are found, they're added to the ITEMS
3640 struct threads_listing_context
3642 /* Return true if this object contains an entry for a thread with ptid
3645 bool contains_thread (ptid_t ptid
) const
3647 auto match_ptid
= [&] (const thread_item
&item
)
3649 return item
.ptid
== ptid
;
3652 auto it
= std::find_if (this->items
.begin (),
3656 return it
!= this->items
.end ();
3659 /* Remove the thread with ptid PTID. */
3661 void remove_thread (ptid_t ptid
)
3663 auto match_ptid
= [&] (const thread_item
&item
)
3665 return item
.ptid
== ptid
;
3668 auto it
= std::remove_if (this->items
.begin (),
3672 if (it
!= this->items
.end ())
3673 this->items
.erase (it
);
3676 /* The threads found on the remote target. */
3677 std::vector
<thread_item
> items
;
3681 remote_newthread_step (threadref
*ref
, void *data
)
3683 struct threads_listing_context
*context
3684 = (struct threads_listing_context
*) data
;
3685 int pid
= inferior_ptid
.pid ();
3686 int lwp
= threadref_to_int (ref
);
3687 ptid_t
ptid (pid
, lwp
);
3689 context
->items
.emplace_back (ptid
);
3691 return 1; /* continue iterator */
3694 #define CRAZY_MAX_THREADS 1000
3697 remote_target::remote_current_thread (ptid_t oldpid
)
3699 struct remote_state
*rs
= get_remote_state ();
3702 getpkt (&rs
->buf
, 0);
3703 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3708 result
= read_ptid (&rs
->buf
[2], &obuf
);
3709 if (*obuf
!= '\0' && remote_debug
)
3710 fprintf_unfiltered (gdb_stdlog
,
3711 "warning: garbage in qC reply\n");
3719 /* List remote threads using the deprecated qL packet. */
3722 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3724 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3725 CRAZY_MAX_THREADS
) >= 0)
3731 #if defined(HAVE_LIBEXPAT)
3734 start_thread (struct gdb_xml_parser
*parser
,
3735 const struct gdb_xml_element
*element
,
3737 std::vector
<gdb_xml_value
> &attributes
)
3739 struct threads_listing_context
*data
3740 = (struct threads_listing_context
*) user_data
;
3741 struct gdb_xml_value
*attr
;
3743 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3744 ptid_t ptid
= read_ptid (id
, NULL
);
3746 data
->items
.emplace_back (ptid
);
3747 thread_item
&item
= data
->items
.back ();
3749 attr
= xml_find_attribute (attributes
, "core");
3751 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3753 attr
= xml_find_attribute (attributes
, "name");
3755 item
.name
= (const char *) attr
->value
.get ();
3757 attr
= xml_find_attribute (attributes
, "handle");
3759 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3763 end_thread (struct gdb_xml_parser
*parser
,
3764 const struct gdb_xml_element
*element
,
3765 void *user_data
, const char *body_text
)
3767 struct threads_listing_context
*data
3768 = (struct threads_listing_context
*) user_data
;
3770 if (body_text
!= NULL
&& *body_text
!= '\0')
3771 data
->items
.back ().extra
= body_text
;
3774 const struct gdb_xml_attribute thread_attributes
[] = {
3775 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3776 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3777 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3778 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3779 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3782 const struct gdb_xml_element thread_children
[] = {
3783 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3786 const struct gdb_xml_element threads_children
[] = {
3787 { "thread", thread_attributes
, thread_children
,
3788 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3789 start_thread
, end_thread
},
3790 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3793 const struct gdb_xml_element threads_elements
[] = {
3794 { "threads", NULL
, threads_children
,
3795 GDB_XML_EF_NONE
, NULL
, NULL
},
3796 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3801 /* List remote threads using qXfer:threads:read. */
3804 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3806 #if defined(HAVE_LIBEXPAT)
3807 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3809 gdb::optional
<gdb::char_vector
> xml
3810 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3812 if (xml
&& (*xml
)[0] != '\0')
3814 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3815 threads_elements
, xml
->data (), context
);
3825 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3828 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3830 struct remote_state
*rs
= get_remote_state ();
3832 if (rs
->use_threadinfo_query
)
3836 putpkt ("qfThreadInfo");
3837 getpkt (&rs
->buf
, 0);
3838 bufp
= rs
->buf
.data ();
3839 if (bufp
[0] != '\0') /* q packet recognized */
3841 while (*bufp
++ == 'm') /* reply contains one or more TID */
3845 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3846 context
->items
.emplace_back (ptid
);
3848 while (*bufp
++ == ','); /* comma-separated list */
3849 putpkt ("qsThreadInfo");
3850 getpkt (&rs
->buf
, 0);
3851 bufp
= rs
->buf
.data ();
3857 /* Packet not recognized. */
3858 rs
->use_threadinfo_query
= 0;
3865 /* Return true if INF only has one non-exited thread. */
3868 has_single_non_exited_thread (inferior
*inf
)
3871 for (thread_info
*tp ATTRIBUTE_UNUSED
: inf
->non_exited_threads ())
3877 /* Implement the to_update_thread_list function for the remote
3881 remote_target::update_thread_list ()
3883 struct threads_listing_context context
;
3886 /* We have a few different mechanisms to fetch the thread list. Try
3887 them all, starting with the most preferred one first, falling
3888 back to older methods. */
3889 if (remote_get_threads_with_qxfer (&context
)
3890 || remote_get_threads_with_qthreadinfo (&context
)
3891 || remote_get_threads_with_ql (&context
))
3895 if (context
.items
.empty ()
3896 && remote_thread_always_alive (inferior_ptid
))
3898 /* Some targets don't really support threads, but still
3899 reply an (empty) thread list in response to the thread
3900 listing packets, instead of replying "packet not
3901 supported". Exit early so we don't delete the main
3906 /* CONTEXT now holds the current thread list on the remote
3907 target end. Delete GDB-side threads no longer found on the
3909 for (thread_info
*tp
: all_threads_safe ())
3911 if (tp
->inf
->process_target () != this)
3914 if (!context
.contains_thread (tp
->ptid
))
3916 /* Do not remove the thread if it is the last thread in
3917 the inferior. This situation happens when we have a
3918 pending exit process status to process. Otherwise we
3919 may end up with a seemingly live inferior (i.e. pid
3920 != 0) that has no threads. */
3921 if (has_single_non_exited_thread (tp
->inf
))
3929 /* Remove any unreported fork child threads from CONTEXT so
3930 that we don't interfere with follow fork, which is where
3931 creation of such threads is handled. */
3932 remove_new_fork_children (&context
);
3934 /* And now add threads we don't know about yet to our list. */
3935 for (thread_item
&item
: context
.items
)
3937 if (item
.ptid
!= null_ptid
)
3939 /* In non-stop mode, we assume new found threads are
3940 executing until proven otherwise with a stop reply.
3941 In all-stop, we can only get here if all threads are
3943 int executing
= target_is_non_stop_p () ? 1 : 0;
3945 remote_notice_new_inferior (item
.ptid
, executing
);
3947 thread_info
*tp
= find_thread_ptid (this, item
.ptid
);
3948 remote_thread_info
*info
= get_remote_thread_info (tp
);
3949 info
->core
= item
.core
;
3950 info
->extra
= std::move (item
.extra
);
3951 info
->name
= std::move (item
.name
);
3952 info
->thread_handle
= std::move (item
.thread_handle
);
3959 /* If no thread listing method is supported, then query whether
3960 each known thread is alive, one by one, with the T packet.
3961 If the target doesn't support threads at all, then this is a
3962 no-op. See remote_thread_alive. */
3968 * Collect a descriptive string about the given thread.
3969 * The target may say anything it wants to about the thread
3970 * (typically info about its blocked / runnable state, name, etc.).
3971 * This string will appear in the info threads display.
3973 * Optional: targets are not required to implement this function.
3977 remote_target::extra_thread_info (thread_info
*tp
)
3979 struct remote_state
*rs
= get_remote_state ();
3982 struct gdb_ext_thread_info threadinfo
;
3984 if (rs
->remote_desc
== 0) /* paranoia */
3985 internal_error (__FILE__
, __LINE__
,
3986 _("remote_threads_extra_info"));
3988 if (tp
->ptid
== magic_null_ptid
3989 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
3990 /* This is the main thread which was added by GDB. The remote
3991 server doesn't know about it. */
3994 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
3996 /* If already have cached info, use it. */
3997 if (!extra
.empty ())
3998 return extra
.c_str ();
4000 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
4002 /* If we're using qXfer:threads:read, then the extra info is
4003 included in the XML. So if we didn't have anything cached,
4004 it's because there's really no extra info. */
4008 if (rs
->use_threadextra_query
)
4010 char *b
= rs
->buf
.data ();
4011 char *endb
= b
+ get_remote_packet_size ();
4013 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
4015 write_ptid (b
, endb
, tp
->ptid
);
4018 getpkt (&rs
->buf
, 0);
4019 if (rs
->buf
[0] != 0)
4021 extra
.resize (strlen (rs
->buf
.data ()) / 2);
4022 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
4023 return extra
.c_str ();
4027 /* If the above query fails, fall back to the old method. */
4028 rs
->use_threadextra_query
= 0;
4029 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
4030 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
4031 int_to_threadref (&id
, tp
->ptid
.lwp ());
4032 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
4033 if (threadinfo
.active
)
4035 if (*threadinfo
.shortname
)
4036 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
4037 if (*threadinfo
.display
)
4039 if (!extra
.empty ())
4041 string_appendf (extra
, " State: %s", threadinfo
.display
);
4043 if (*threadinfo
.more_display
)
4045 if (!extra
.empty ())
4047 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
4049 return extra
.c_str ();
4056 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
4057 struct static_tracepoint_marker
*marker
)
4059 struct remote_state
*rs
= get_remote_state ();
4060 char *p
= rs
->buf
.data ();
4062 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
4064 p
+= hexnumstr (p
, addr
);
4066 getpkt (&rs
->buf
, 0);
4067 p
= rs
->buf
.data ();
4070 error (_("Remote failure reply: %s"), p
);
4074 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
4081 std::vector
<static_tracepoint_marker
>
4082 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
4084 struct remote_state
*rs
= get_remote_state ();
4085 std::vector
<static_tracepoint_marker
> markers
;
4087 static_tracepoint_marker marker
;
4089 /* Ask for a first packet of static tracepoint marker
4092 getpkt (&rs
->buf
, 0);
4093 p
= rs
->buf
.data ();
4095 error (_("Remote failure reply: %s"), p
);
4101 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
4103 if (strid
== NULL
|| marker
.str_id
== strid
)
4104 markers
.push_back (std::move (marker
));
4106 while (*p
++ == ','); /* comma-separated list */
4107 /* Ask for another packet of static tracepoint definition. */
4109 getpkt (&rs
->buf
, 0);
4110 p
= rs
->buf
.data ();
4117 /* Implement the to_get_ada_task_ptid function for the remote targets. */
4120 remote_target::get_ada_task_ptid (long lwp
, long thread
)
4122 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
4126 /* Restart the remote side; this is an extended protocol operation. */
4129 remote_target::extended_remote_restart ()
4131 struct remote_state
*rs
= get_remote_state ();
4133 /* Send the restart command; for reasons I don't understand the
4134 remote side really expects a number after the "R". */
4135 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
4138 remote_fileio_reset ();
4141 /* Clean up connection to a remote debugger. */
4144 remote_target::close ()
4146 /* Make sure we leave stdin registered in the event loop. */
4149 trace_reset_local_state ();
4154 remote_target::~remote_target ()
4156 struct remote_state
*rs
= get_remote_state ();
4158 /* Check for NULL because we may get here with a partially
4159 constructed target/connection. */
4160 if (rs
->remote_desc
== nullptr)
4163 serial_close (rs
->remote_desc
);
4165 /* We are destroying the remote target, so we should discard
4166 everything of this target. */
4167 discard_pending_stop_replies_in_queue ();
4169 if (rs
->remote_async_inferior_event_token
)
4170 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4172 delete rs
->notif_state
;
4175 /* Query the remote side for the text, data and bss offsets. */
4178 remote_target::get_offsets ()
4180 struct remote_state
*rs
= get_remote_state ();
4183 int lose
, num_segments
= 0, do_sections
, do_segments
;
4184 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4186 if (current_program_space
->symfile_object_file
== NULL
)
4189 putpkt ("qOffsets");
4190 getpkt (&rs
->buf
, 0);
4191 buf
= rs
->buf
.data ();
4193 if (buf
[0] == '\000')
4194 return; /* Return silently. Stub doesn't support
4198 warning (_("Remote failure reply: %s"), buf
);
4202 /* Pick up each field in turn. This used to be done with scanf, but
4203 scanf will make trouble if CORE_ADDR size doesn't match
4204 conversion directives correctly. The following code will work
4205 with any size of CORE_ADDR. */
4206 text_addr
= data_addr
= bss_addr
= 0;
4210 if (startswith (ptr
, "Text="))
4213 /* Don't use strtol, could lose on big values. */
4214 while (*ptr
&& *ptr
!= ';')
4215 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4217 if (startswith (ptr
, ";Data="))
4220 while (*ptr
&& *ptr
!= ';')
4221 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4226 if (!lose
&& startswith (ptr
, ";Bss="))
4229 while (*ptr
&& *ptr
!= ';')
4230 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4232 if (bss_addr
!= data_addr
)
4233 warning (_("Target reported unsupported offsets: %s"), buf
);
4238 else if (startswith (ptr
, "TextSeg="))
4241 /* Don't use strtol, could lose on big values. */
4242 while (*ptr
&& *ptr
!= ';')
4243 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4246 if (startswith (ptr
, ";DataSeg="))
4249 while (*ptr
&& *ptr
!= ';')
4250 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4258 error (_("Malformed response to offset query, %s"), buf
);
4259 else if (*ptr
!= '\0')
4260 warning (_("Target reported unsupported offsets: %s"), buf
);
4262 objfile
*objf
= current_program_space
->symfile_object_file
;
4263 section_offsets offs
= objf
->section_offsets
;
4265 symfile_segment_data_up data
= get_symfile_segment_data (objf
->obfd
);
4266 do_segments
= (data
!= NULL
);
4267 do_sections
= num_segments
== 0;
4269 if (num_segments
> 0)
4271 segments
[0] = text_addr
;
4272 segments
[1] = data_addr
;
4274 /* If we have two segments, we can still try to relocate everything
4275 by assuming that the .text and .data offsets apply to the whole
4276 text and data segments. Convert the offsets given in the packet
4277 to base addresses for symfile_map_offsets_to_segments. */
4278 else if (data
!= nullptr && data
->segments
.size () == 2)
4280 segments
[0] = data
->segments
[0].base
+ text_addr
;
4281 segments
[1] = data
->segments
[1].base
+ data_addr
;
4284 /* If the object file has only one segment, assume that it is text
4285 rather than data; main programs with no writable data are rare,
4286 but programs with no code are useless. Of course the code might
4287 have ended up in the data segment... to detect that we would need
4288 the permissions here. */
4289 else if (data
&& data
->segments
.size () == 1)
4291 segments
[0] = data
->segments
[0].base
+ text_addr
;
4294 /* There's no way to relocate by segment. */
4300 int ret
= symfile_map_offsets_to_segments (objf
->obfd
,
4302 num_segments
, segments
);
4304 if (ret
== 0 && !do_sections
)
4305 error (_("Can not handle qOffsets TextSeg "
4306 "response with this symbol file"));
4314 offs
[SECT_OFF_TEXT (objf
)] = text_addr
;
4316 /* This is a temporary kludge to force data and bss to use the
4317 same offsets because that's what nlmconv does now. The real
4318 solution requires changes to the stub and remote.c that I
4319 don't have time to do right now. */
4321 offs
[SECT_OFF_DATA (objf
)] = data_addr
;
4322 offs
[SECT_OFF_BSS (objf
)] = data_addr
;
4325 objfile_relocate (objf
, offs
);
4328 /* Send interrupt_sequence to remote target. */
4331 remote_target::send_interrupt_sequence ()
4333 struct remote_state
*rs
= get_remote_state ();
4335 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4336 remote_serial_write ("\x03", 1);
4337 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4338 serial_send_break (rs
->remote_desc
);
4339 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4341 serial_send_break (rs
->remote_desc
);
4342 remote_serial_write ("g", 1);
4345 internal_error (__FILE__
, __LINE__
,
4346 _("Invalid value for interrupt_sequence_mode: %s."),
4347 interrupt_sequence_mode
);
4351 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4352 and extract the PTID. Returns NULL_PTID if not found. */
4355 stop_reply_extract_thread (char *stop_reply
)
4357 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4361 /* Txx r:val ; r:val (...) */
4364 /* Look for "register" named "thread". */
4369 p1
= strchr (p
, ':');
4373 if (strncmp (p
, "thread", p1
- p
) == 0)
4374 return read_ptid (++p1
, &p
);
4376 p1
= strchr (p
, ';');
4388 /* Determine the remote side's current thread. If we have a stop
4389 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4390 "thread" register we can extract the current thread from. If not,
4391 ask the remote which is the current thread with qC. The former
4392 method avoids a roundtrip. */
4395 remote_target::get_current_thread (char *wait_status
)
4397 ptid_t ptid
= null_ptid
;
4399 /* Note we don't use remote_parse_stop_reply as that makes use of
4400 the target architecture, which we haven't yet fully determined at
4402 if (wait_status
!= NULL
)
4403 ptid
= stop_reply_extract_thread (wait_status
);
4404 if (ptid
== null_ptid
)
4405 ptid
= remote_current_thread (inferior_ptid
);
4410 /* Query the remote target for which is the current thread/process,
4411 add it to our tables, and update INFERIOR_PTID. The caller is
4412 responsible for setting the state such that the remote end is ready
4413 to return the current thread.
4415 This function is called after handling the '?' or 'vRun' packets,
4416 whose response is a stop reply from which we can also try
4417 extracting the thread. If the target doesn't support the explicit
4418 qC query, we infer the current thread from that stop reply, passed
4419 in in WAIT_STATUS, which may be NULL. */
4422 remote_target::add_current_inferior_and_thread (char *wait_status
)
4424 struct remote_state
*rs
= get_remote_state ();
4425 bool fake_pid_p
= false;
4427 switch_to_no_thread ();
4429 /* Now, if we have thread information, update the current thread's
4431 ptid_t curr_ptid
= get_current_thread (wait_status
);
4433 if (curr_ptid
!= null_ptid
)
4435 if (!remote_multi_process_p (rs
))
4440 /* Without this, some commands which require an active target
4441 (such as kill) won't work. This variable serves (at least)
4442 double duty as both the pid of the target process (if it has
4443 such), and as a flag indicating that a target is active. */
4444 curr_ptid
= magic_null_ptid
;
4448 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4450 /* Add the main thread and switch to it. Don't try reading
4451 registers yet, since we haven't fetched the target description
4453 thread_info
*tp
= add_thread_silent (this, curr_ptid
);
4454 switch_to_thread_no_regs (tp
);
4457 /* Print info about a thread that was found already stopped on
4461 print_one_stopped_thread (struct thread_info
*thread
)
4463 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4465 switch_to_thread (thread
);
4466 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4467 set_current_sal_from_frame (get_current_frame ());
4469 thread
->suspend
.waitstatus_pending_p
= 0;
4471 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4473 enum gdb_signal sig
= ws
->value
.sig
;
4475 if (signal_print_state (sig
))
4476 gdb::observers::signal_received
.notify (sig
);
4478 gdb::observers::normal_stop
.notify (NULL
, 1);
4481 /* Process all initial stop replies the remote side sent in response
4482 to the ? packet. These indicate threads that were already stopped
4483 on initial connection. We mark these threads as stopped and print
4484 their current frame before giving the user the prompt. */
4487 remote_target::process_initial_stop_replies (int from_tty
)
4489 int pending_stop_replies
= stop_reply_queue_length ();
4490 struct thread_info
*selected
= NULL
;
4491 struct thread_info
*lowest_stopped
= NULL
;
4492 struct thread_info
*first
= NULL
;
4494 /* Consume the initial pending events. */
4495 while (pending_stop_replies
-- > 0)
4497 ptid_t waiton_ptid
= minus_one_ptid
;
4499 struct target_waitstatus ws
;
4500 int ignore_event
= 0;
4502 memset (&ws
, 0, sizeof (ws
));
4503 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4505 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4509 case TARGET_WAITKIND_IGNORE
:
4510 case TARGET_WAITKIND_NO_RESUMED
:
4511 case TARGET_WAITKIND_SIGNALLED
:
4512 case TARGET_WAITKIND_EXITED
:
4513 /* We shouldn't see these, but if we do, just ignore. */
4515 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
4519 case TARGET_WAITKIND_EXECD
:
4520 xfree (ws
.value
.execd_pathname
);
4529 thread_info
*evthread
= find_thread_ptid (this, event_ptid
);
4531 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4533 enum gdb_signal sig
= ws
.value
.sig
;
4535 /* Stubs traditionally report SIGTRAP as initial signal,
4536 instead of signal 0. Suppress it. */
4537 if (sig
== GDB_SIGNAL_TRAP
)
4539 evthread
->suspend
.stop_signal
= sig
;
4543 evthread
->suspend
.waitstatus
= ws
;
4545 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4546 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4547 evthread
->suspend
.waitstatus_pending_p
= 1;
4549 set_executing (this, event_ptid
, false);
4550 set_running (this, event_ptid
, false);
4551 get_remote_thread_info (evthread
)->set_not_resumed ();
4554 /* "Notice" the new inferiors before anything related to
4555 registers/memory. */
4556 for (inferior
*inf
: all_non_exited_inferiors (this))
4558 inf
->needs_setup
= 1;
4562 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4563 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4568 /* If all-stop on top of non-stop, pause all threads. Note this
4569 records the threads' stop pc, so must be done after "noticing"
4573 stop_all_threads ();
4575 /* If all threads of an inferior were already stopped, we
4576 haven't setup the inferior yet. */
4577 for (inferior
*inf
: all_non_exited_inferiors (this))
4579 if (inf
->needs_setup
)
4581 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4582 switch_to_thread_no_regs (thread
);
4588 /* Now go over all threads that are stopped, and print their current
4589 frame. If all-stop, then if there's a signalled thread, pick
4591 for (thread_info
*thread
: all_non_exited_threads (this))
4597 thread
->set_running (false);
4598 else if (thread
->state
!= THREAD_STOPPED
)
4601 if (selected
== NULL
4602 && thread
->suspend
.waitstatus_pending_p
)
4605 if (lowest_stopped
== NULL
4606 || thread
->inf
->num
< lowest_stopped
->inf
->num
4607 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4608 lowest_stopped
= thread
;
4611 print_one_stopped_thread (thread
);
4614 /* In all-stop, we only print the status of one thread, and leave
4615 others with their status pending. */
4618 thread_info
*thread
= selected
;
4620 thread
= lowest_stopped
;
4624 print_one_stopped_thread (thread
);
4627 /* For "info program". */
4628 thread_info
*thread
= inferior_thread ();
4629 if (thread
->state
== THREAD_STOPPED
)
4630 set_last_target_status (this, inferior_ptid
, thread
->suspend
.waitstatus
);
4633 /* Start the remote connection and sync state. */
4636 remote_target::start_remote (int from_tty
, int extended_p
)
4638 struct remote_state
*rs
= get_remote_state ();
4639 struct packet_config
*noack_config
;
4640 char *wait_status
= NULL
;
4642 /* Signal other parts that we're going through the initial setup,
4643 and so things may not be stable yet. E.g., we don't try to
4644 install tracepoints until we've relocated symbols. Also, a
4645 Ctrl-C before we're connected and synced up can't interrupt the
4646 target. Instead, it offers to drop the (potentially wedged)
4648 rs
->starting_up
= 1;
4652 if (interrupt_on_connect
)
4653 send_interrupt_sequence ();
4655 /* Ack any packet which the remote side has already sent. */
4656 remote_serial_write ("+", 1);
4658 /* The first packet we send to the target is the optional "supported
4659 packets" request. If the target can answer this, it will tell us
4660 which later probes to skip. */
4661 remote_query_supported ();
4663 /* If the stub wants to get a QAllow, compose one and send it. */
4664 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4667 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4668 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4669 as a reply to known packet. For packet "vFile:setfs:" it is an
4670 invalid reply and GDB would return error in
4671 remote_hostio_set_filesystem, making remote files access impossible.
4672 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4673 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4675 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4677 putpkt (v_mustreplyempty
);
4678 getpkt (&rs
->buf
, 0);
4679 if (strcmp (rs
->buf
.data (), "OK") == 0)
4680 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4681 else if (strcmp (rs
->buf
.data (), "") != 0)
4682 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4686 /* Next, we possibly activate noack mode.
4688 If the QStartNoAckMode packet configuration is set to AUTO,
4689 enable noack mode if the stub reported a wish for it with
4692 If set to TRUE, then enable noack mode even if the stub didn't
4693 report it in qSupported. If the stub doesn't reply OK, the
4694 session ends with an error.
4696 If FALSE, then don't activate noack mode, regardless of what the
4697 stub claimed should be the default with qSupported. */
4699 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4700 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4702 putpkt ("QStartNoAckMode");
4703 getpkt (&rs
->buf
, 0);
4704 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4710 /* Tell the remote that we are using the extended protocol. */
4712 getpkt (&rs
->buf
, 0);
4715 /* Let the target know which signals it is allowed to pass down to
4717 update_signals_program_target ();
4719 /* Next, if the target can specify a description, read it. We do
4720 this before anything involving memory or registers. */
4721 target_find_description ();
4723 /* Next, now that we know something about the target, update the
4724 address spaces in the program spaces. */
4725 update_address_spaces ();
4727 /* On OSs where the list of libraries is global to all
4728 processes, we fetch them early. */
4729 if (gdbarch_has_global_solist (target_gdbarch ()))
4730 solib_add (NULL
, from_tty
, auto_solib_add
);
4732 if (target_is_non_stop_p ())
4734 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4735 error (_("Non-stop mode requested, but remote "
4736 "does not support non-stop"));
4738 putpkt ("QNonStop:1");
4739 getpkt (&rs
->buf
, 0);
4741 if (strcmp (rs
->buf
.data (), "OK") != 0)
4742 error (_("Remote refused setting non-stop mode with: %s"),
4745 /* Find about threads and processes the stub is already
4746 controlling. We default to adding them in the running state.
4747 The '?' query below will then tell us about which threads are
4749 this->update_thread_list ();
4751 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4753 /* Don't assume that the stub can operate in all-stop mode.
4754 Request it explicitly. */
4755 putpkt ("QNonStop:0");
4756 getpkt (&rs
->buf
, 0);
4758 if (strcmp (rs
->buf
.data (), "OK") != 0)
4759 error (_("Remote refused setting all-stop mode with: %s"),
4763 /* Upload TSVs regardless of whether the target is running or not. The
4764 remote stub, such as GDBserver, may have some predefined or builtin
4765 TSVs, even if the target is not running. */
4766 if (get_trace_status (current_trace_status ()) != -1)
4768 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4770 upload_trace_state_variables (&uploaded_tsvs
);
4771 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4774 /* Check whether the target is running now. */
4776 getpkt (&rs
->buf
, 0);
4778 if (!target_is_non_stop_p ())
4780 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4783 error (_("The target is not running (try extended-remote?)"));
4785 /* We're connected, but not running. Drop out before we
4786 call start_remote. */
4787 rs
->starting_up
= 0;
4792 /* Save the reply for later. */
4793 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4794 strcpy (wait_status
, rs
->buf
.data ());
4797 /* Fetch thread list. */
4798 target_update_thread_list ();
4800 /* Let the stub know that we want it to return the thread. */
4801 set_continue_thread (minus_one_ptid
);
4803 if (thread_count (this) == 0)
4805 /* Target has no concept of threads at all. GDB treats
4806 non-threaded target as single-threaded; add a main
4808 add_current_inferior_and_thread (wait_status
);
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. */
4825 fprintf_unfiltered (gdb_stdlog
,
4826 "warning: couldn't determine remote "
4827 "current thread; picking first in list.\n");
4829 for (thread_info
*tp
: all_non_exited_threads (this,
4832 switch_to_thread (tp
);
4837 switch_to_thread (find_thread_ptid (this, curr_thread
));
4840 /* init_wait_for_inferior should be called before get_offsets in order
4841 to manage `inserted' flag in bp loc in a correct state.
4842 breakpoint_init_inferior, called from init_wait_for_inferior, set
4843 `inserted' flag to 0, while before breakpoint_re_set, called from
4844 start_remote, set `inserted' flag to 1. In the initialization of
4845 inferior, breakpoint_init_inferior should be called first, and then
4846 breakpoint_re_set can be called. If this order is broken, state of
4847 `inserted' flag is wrong, and cause some problems on breakpoint
4849 init_wait_for_inferior ();
4851 get_offsets (); /* Get text, data & bss offsets. */
4853 /* If we could not find a description using qXfer, and we know
4854 how to do it some other way, try again. This is not
4855 supported for non-stop; it could be, but it is tricky if
4856 there are no stopped threads when we connect. */
4857 if (remote_read_description_p (this)
4858 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4860 target_clear_description ();
4861 target_find_description ();
4864 /* Use the previously fetched status. */
4865 gdb_assert (wait_status
!= NULL
);
4866 strcpy (rs
->buf
.data (), wait_status
);
4867 rs
->cached_wait_status
= 1;
4869 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4873 /* Clear WFI global state. Do this before finding about new
4874 threads and inferiors, and setting the current inferior.
4875 Otherwise we would clear the proceed status of the current
4876 inferior when we want its stop_soon state to be preserved
4877 (see notice_new_inferior). */
4878 init_wait_for_inferior ();
4880 /* In non-stop, we will either get an "OK", meaning that there
4881 are no stopped threads at this time; or, a regular stop
4882 reply. In the latter case, there may be more than one thread
4883 stopped --- we pull them all out using the vStopped
4885 if (strcmp (rs
->buf
.data (), "OK") != 0)
4887 struct notif_client
*notif
= ¬if_client_stop
;
4889 /* remote_notif_get_pending_replies acks this one, and gets
4891 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4892 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4893 remote_notif_get_pending_events (notif
);
4896 if (thread_count (this) == 0)
4899 error (_("The target is not running (try extended-remote?)"));
4901 /* We're connected, but not running. Drop out before we
4902 call start_remote. */
4903 rs
->starting_up
= 0;
4907 /* In non-stop mode, any cached wait status will be stored in
4908 the stop reply queue. */
4909 gdb_assert (wait_status
== NULL
);
4911 /* Report all signals during attach/startup. */
4914 /* If there are already stopped threads, mark them stopped and
4915 report their stops before giving the prompt to the user. */
4916 process_initial_stop_replies (from_tty
);
4918 if (target_can_async_p ())
4922 /* If we connected to a live target, do some additional setup. */
4923 if (target_has_execution ())
4925 /* No use without a symbol-file. */
4926 if (current_program_space
->symfile_object_file
)
4927 remote_check_symbols ();
4930 /* Possibly the target has been engaged in a trace run started
4931 previously; find out where things are at. */
4932 if (get_trace_status (current_trace_status ()) != -1)
4934 struct uploaded_tp
*uploaded_tps
= NULL
;
4936 if (current_trace_status ()->running
)
4937 printf_filtered (_("Trace is already running on the target.\n"));
4939 upload_tracepoints (&uploaded_tps
);
4941 merge_uploaded_tracepoints (&uploaded_tps
);
4944 /* Possibly the target has been engaged in a btrace record started
4945 previously; find out where things are at. */
4946 remote_btrace_maybe_reopen ();
4948 /* The thread and inferior lists are now synchronized with the
4949 target, our symbols have been relocated, and we're merged the
4950 target's tracepoints with ours. We're done with basic start
4952 rs
->starting_up
= 0;
4954 /* Maybe breakpoints are global and need to be inserted now. */
4955 if (breakpoints_should_be_inserted_now ())
4956 insert_breakpoints ();
4960 remote_target::connection_string ()
4962 remote_state
*rs
= get_remote_state ();
4964 if (rs
->remote_desc
->name
!= NULL
)
4965 return rs
->remote_desc
->name
;
4970 /* Open a connection to a remote debugger.
4971 NAME is the filename used for communication. */
4974 remote_target::open (const char *name
, int from_tty
)
4976 open_1 (name
, from_tty
, 0);
4979 /* Open a connection to a remote debugger using the extended
4980 remote gdb protocol. NAME is the filename used for communication. */
4983 extended_remote_target::open (const char *name
, int from_tty
)
4985 open_1 (name
, from_tty
, 1 /*extended_p */);
4988 /* Reset all packets back to "unknown support". Called when opening a
4989 new connection to a remote target. */
4992 reset_all_packet_configs_support (void)
4996 for (i
= 0; i
< PACKET_MAX
; i
++)
4997 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
5000 /* Initialize all packet configs. */
5003 init_all_packet_configs (void)
5007 for (i
= 0; i
< PACKET_MAX
; i
++)
5009 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
5010 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
5014 /* Symbol look-up. */
5017 remote_target::remote_check_symbols ()
5022 /* The remote side has no concept of inferiors that aren't running
5023 yet, it only knows about running processes. If we're connected
5024 but our current inferior is not running, we should not invite the
5025 remote target to request symbol lookups related to its
5026 (unrelated) current process. */
5027 if (!target_has_execution ())
5030 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
5033 /* Make sure the remote is pointing at the right process. Note
5034 there's no way to select "no process". */
5035 set_general_process ();
5037 /* Allocate a message buffer. We can't reuse the input buffer in RS,
5038 because we need both at the same time. */
5039 gdb::char_vector
msg (get_remote_packet_size ());
5040 gdb::char_vector
reply (get_remote_packet_size ());
5042 /* Invite target to request symbol lookups. */
5044 putpkt ("qSymbol::");
5046 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
5048 while (startswith (reply
.data (), "qSymbol:"))
5050 struct bound_minimal_symbol sym
;
5053 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
5056 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
5057 if (sym
.minsym
== NULL
)
5058 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
5062 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
5063 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
5065 /* If this is a function address, return the start of code
5066 instead of any data function descriptor. */
5067 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
5069 current_top_target ());
5071 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
5072 phex_nz (sym_addr
, addr_size
), &reply
[8]);
5075 putpkt (msg
.data ());
5080 static struct serial
*
5081 remote_serial_open (const char *name
)
5083 static int udp_warning
= 0;
5085 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
5086 of in ser-tcp.c, because it is the remote protocol assuming that the
5087 serial connection is reliable and not the serial connection promising
5089 if (!udp_warning
&& startswith (name
, "udp:"))
5091 warning (_("The remote protocol may be unreliable over UDP.\n"
5092 "Some events may be lost, rendering further debugging "
5097 return serial_open (name
);
5100 /* Inform the target of our permission settings. The permission flags
5101 work without this, but if the target knows the settings, it can do
5102 a couple things. First, it can add its own check, to catch cases
5103 that somehow manage to get by the permissions checks in target
5104 methods. Second, if the target is wired to disallow particular
5105 settings (for instance, a system in the field that is not set up to
5106 be able to stop at a breakpoint), it can object to any unavailable
5110 remote_target::set_permissions ()
5112 struct remote_state
*rs
= get_remote_state ();
5114 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
5115 "WriteReg:%x;WriteMem:%x;"
5116 "InsertBreak:%x;InsertTrace:%x;"
5117 "InsertFastTrace:%x;Stop:%x",
5118 may_write_registers
, may_write_memory
,
5119 may_insert_breakpoints
, may_insert_tracepoints
,
5120 may_insert_fast_tracepoints
, may_stop
);
5122 getpkt (&rs
->buf
, 0);
5124 /* If the target didn't like the packet, warn the user. Do not try
5125 to undo the user's settings, that would just be maddening. */
5126 if (strcmp (rs
->buf
.data (), "OK") != 0)
5127 warning (_("Remote refused setting permissions with: %s"),
5131 /* This type describes each known response to the qSupported
5133 struct protocol_feature
5135 /* The name of this protocol feature. */
5138 /* The default for this protocol feature. */
5139 enum packet_support default_support
;
5141 /* The function to call when this feature is reported, or after
5142 qSupported processing if the feature is not supported.
5143 The first argument points to this structure. The second
5144 argument indicates whether the packet requested support be
5145 enabled, disabled, or probed (or the default, if this function
5146 is being called at the end of processing and this feature was
5147 not reported). The third argument may be NULL; if not NULL, it
5148 is a NUL-terminated string taken from the packet following
5149 this feature's name and an equals sign. */
5150 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5151 enum packet_support
, const char *);
5153 /* The corresponding packet for this feature. Only used if
5154 FUNC is remote_supported_packet. */
5159 remote_supported_packet (remote_target
*remote
,
5160 const struct protocol_feature
*feature
,
5161 enum packet_support support
,
5162 const char *argument
)
5166 warning (_("Remote qSupported response supplied an unexpected value for"
5167 " \"%s\"."), feature
->name
);
5171 remote_protocol_packets
[feature
->packet
].support
= support
;
5175 remote_target::remote_packet_size (const protocol_feature
*feature
,
5176 enum packet_support support
, const char *value
)
5178 struct remote_state
*rs
= get_remote_state ();
5183 if (support
!= PACKET_ENABLE
)
5186 if (value
== NULL
|| *value
== '\0')
5188 warning (_("Remote target reported \"%s\" without a size."),
5194 packet_size
= strtol (value
, &value_end
, 16);
5195 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5197 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5198 feature
->name
, value
);
5202 /* Record the new maximum packet size. */
5203 rs
->explicit_packet_size
= packet_size
;
5207 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5208 enum packet_support support
, const char *value
)
5210 remote
->remote_packet_size (feature
, support
, value
);
5213 static const struct protocol_feature remote_protocol_features
[] = {
5214 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5215 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5216 PACKET_qXfer_auxv
},
5217 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5218 PACKET_qXfer_exec_file
},
5219 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5220 PACKET_qXfer_features
},
5221 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5222 PACKET_qXfer_libraries
},
5223 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5224 PACKET_qXfer_libraries_svr4
},
5225 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5226 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5227 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5228 PACKET_qXfer_memory_map
},
5229 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5230 PACKET_qXfer_osdata
},
5231 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5232 PACKET_qXfer_threads
},
5233 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5234 PACKET_qXfer_traceframe_info
},
5235 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5236 PACKET_QPassSignals
},
5237 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5238 PACKET_QCatchSyscalls
},
5239 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5240 PACKET_QProgramSignals
},
5241 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5242 PACKET_QSetWorkingDir
},
5243 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5244 PACKET_QStartupWithShell
},
5245 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5246 PACKET_QEnvironmentHexEncoded
},
5247 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5248 PACKET_QEnvironmentReset
},
5249 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5250 PACKET_QEnvironmentUnset
},
5251 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5252 PACKET_QStartNoAckMode
},
5253 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5254 PACKET_multiprocess_feature
},
5255 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5256 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5257 PACKET_qXfer_siginfo_read
},
5258 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5259 PACKET_qXfer_siginfo_write
},
5260 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5261 PACKET_ConditionalTracepoints
},
5262 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5263 PACKET_ConditionalBreakpoints
},
5264 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5265 PACKET_BreakpointCommands
},
5266 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5267 PACKET_FastTracepoints
},
5268 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5269 PACKET_StaticTracepoints
},
5270 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5271 PACKET_InstallInTrace
},
5272 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5273 PACKET_DisconnectedTracing_feature
},
5274 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5276 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5278 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5279 PACKET_TracepointSource
},
5280 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5282 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5283 PACKET_EnableDisableTracepoints_feature
},
5284 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5285 PACKET_qXfer_fdpic
},
5286 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5288 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5289 PACKET_QDisableRandomization
},
5290 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5291 { "QTBuffer:size", PACKET_DISABLE
,
5292 remote_supported_packet
, PACKET_QTBuffer_size
},
5293 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5294 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5295 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5296 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5297 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5298 PACKET_qXfer_btrace
},
5299 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5300 PACKET_qXfer_btrace_conf
},
5301 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5302 PACKET_Qbtrace_conf_bts_size
},
5303 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5304 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5305 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5306 PACKET_fork_event_feature
},
5307 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5308 PACKET_vfork_event_feature
},
5309 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5310 PACKET_exec_event_feature
},
5311 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5312 PACKET_Qbtrace_conf_pt_size
},
5313 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5314 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5315 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5318 static char *remote_support_xml
;
5320 /* Register string appended to "xmlRegisters=" in qSupported query. */
5323 register_remote_support_xml (const char *xml
)
5325 #if defined(HAVE_LIBEXPAT)
5326 if (remote_support_xml
== NULL
)
5327 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5330 char *copy
= xstrdup (remote_support_xml
+ 13);
5332 char *p
= strtok_r (copy
, ",", &saveptr
);
5336 if (strcmp (p
, xml
) == 0)
5343 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5346 remote_support_xml
= reconcat (remote_support_xml
,
5347 remote_support_xml
, ",", xml
,
5354 remote_query_supported_append (std::string
*msg
, const char *append
)
5358 msg
->append (append
);
5362 remote_target::remote_query_supported ()
5364 struct remote_state
*rs
= get_remote_state ();
5367 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5369 /* The packet support flags are handled differently for this packet
5370 than for most others. We treat an error, a disabled packet, and
5371 an empty response identically: any features which must be reported
5372 to be used will be automatically disabled. An empty buffer
5373 accomplishes this, since that is also the representation for a list
5374 containing no features. */
5377 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5381 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5382 remote_query_supported_append (&q
, "multiprocess+");
5384 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5385 remote_query_supported_append (&q
, "swbreak+");
5386 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5387 remote_query_supported_append (&q
, "hwbreak+");
5389 remote_query_supported_append (&q
, "qRelocInsn+");
5391 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5392 != AUTO_BOOLEAN_FALSE
)
5393 remote_query_supported_append (&q
, "fork-events+");
5394 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5395 != AUTO_BOOLEAN_FALSE
)
5396 remote_query_supported_append (&q
, "vfork-events+");
5397 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5398 != AUTO_BOOLEAN_FALSE
)
5399 remote_query_supported_append (&q
, "exec-events+");
5401 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5402 remote_query_supported_append (&q
, "vContSupported+");
5404 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5405 remote_query_supported_append (&q
, "QThreadEvents+");
5407 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5408 remote_query_supported_append (&q
, "no-resumed+");
5410 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5411 the qSupported:xmlRegisters=i386 handling. */
5412 if (remote_support_xml
!= NULL
5413 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5414 remote_query_supported_append (&q
, remote_support_xml
);
5416 q
= "qSupported:" + q
;
5417 putpkt (q
.c_str ());
5419 getpkt (&rs
->buf
, 0);
5421 /* If an error occured, warn, but do not return - just reset the
5422 buffer to empty and go on to disable features. */
5423 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5426 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5431 memset (seen
, 0, sizeof (seen
));
5433 next
= rs
->buf
.data ();
5436 enum packet_support is_supported
;
5437 char *p
, *end
, *name_end
, *value
;
5439 /* First separate out this item from the rest of the packet. If
5440 there's another item after this, we overwrite the separator
5441 (terminated strings are much easier to work with). */
5443 end
= strchr (p
, ';');
5446 end
= p
+ strlen (p
);
5456 warning (_("empty item in \"qSupported\" response"));
5461 name_end
= strchr (p
, '=');
5464 /* This is a name=value entry. */
5465 is_supported
= PACKET_ENABLE
;
5466 value
= name_end
+ 1;
5475 is_supported
= PACKET_ENABLE
;
5479 is_supported
= PACKET_DISABLE
;
5483 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5487 warning (_("unrecognized item \"%s\" "
5488 "in \"qSupported\" response"), p
);
5494 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5495 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5497 const struct protocol_feature
*feature
;
5500 feature
= &remote_protocol_features
[i
];
5501 feature
->func (this, feature
, is_supported
, value
);
5506 /* If we increased the packet size, make sure to increase the global
5507 buffer size also. We delay this until after parsing the entire
5508 qSupported packet, because this is the same buffer we were
5510 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5511 rs
->buf
.resize (rs
->explicit_packet_size
);
5513 /* Handle the defaults for unmentioned features. */
5514 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5517 const struct protocol_feature
*feature
;
5519 feature
= &remote_protocol_features
[i
];
5520 feature
->func (this, feature
, feature
->default_support
, NULL
);
5524 /* Serial QUIT handler for the remote serial descriptor.
5526 Defers handling a Ctrl-C until we're done with the current
5527 command/response packet sequence, unless:
5529 - We're setting up the connection. Don't send a remote interrupt
5530 request, as we're not fully synced yet. Quit immediately
5533 - The target has been resumed in the foreground
5534 (target_terminal::is_ours is false) with a synchronous resume
5535 packet, and we're blocked waiting for the stop reply, thus a
5536 Ctrl-C should be immediately sent to the target.
5538 - We get a second Ctrl-C while still within the same serial read or
5539 write. In that case the serial is seemingly wedged --- offer to
5542 - We see a second Ctrl-C without target response, after having
5543 previously interrupted the target. In that case the target/stub
5544 is probably wedged --- offer to quit/disconnect.
5548 remote_target::remote_serial_quit_handler ()
5550 struct remote_state
*rs
= get_remote_state ();
5552 if (check_quit_flag ())
5554 /* If we're starting up, we're not fully synced yet. Quit
5556 if (rs
->starting_up
)
5558 else if (rs
->got_ctrlc_during_io
)
5560 if (query (_("The target is not responding to GDB commands.\n"
5561 "Stop debugging it? ")))
5562 remote_unpush_and_throw (this);
5564 /* If ^C has already been sent once, offer to disconnect. */
5565 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5567 /* All-stop protocol, and blocked waiting for stop reply. Send
5568 an interrupt request. */
5569 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5570 target_interrupt ();
5572 rs
->got_ctrlc_during_io
= 1;
5576 /* The remote_target that is current while the quit handler is
5577 overridden with remote_serial_quit_handler. */
5578 static remote_target
*curr_quit_handler_target
;
5581 remote_serial_quit_handler ()
5583 curr_quit_handler_target
->remote_serial_quit_handler ();
5586 /* Remove the remote target from the target stack of each inferior
5587 that is using it. Upper targets depend on it so remove them
5591 remote_unpush_target (remote_target
*target
)
5593 /* We have to unpush the target from all inferiors, even those that
5595 scoped_restore_current_inferior restore_current_inferior
;
5597 for (inferior
*inf
: all_inferiors (target
))
5599 switch_to_inferior_no_thread (inf
);
5600 pop_all_targets_at_and_above (process_stratum
);
5601 generic_mourn_inferior ();
5606 remote_unpush_and_throw (remote_target
*target
)
5608 remote_unpush_target (target
);
5609 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5613 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5615 remote_target
*curr_remote
= get_current_remote_target ();
5618 error (_("To open a remote debug connection, you need to specify what\n"
5619 "serial device is attached to the remote system\n"
5620 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5622 /* If we're connected to a running target, target_preopen will kill it.
5623 Ask this question first, before target_preopen has a chance to kill
5625 if (curr_remote
!= NULL
&& !target_has_execution ())
5628 && !query (_("Already connected to a remote target. Disconnect? ")))
5629 error (_("Still connected."));
5632 /* Here the possibly existing remote target gets unpushed. */
5633 target_preopen (from_tty
);
5635 remote_fileio_reset ();
5636 reopen_exec_file ();
5639 remote_target
*remote
5640 = (extended_p
? new extended_remote_target () : new remote_target ());
5641 target_ops_up
target_holder (remote
);
5643 remote_state
*rs
= remote
->get_remote_state ();
5645 /* See FIXME above. */
5646 if (!target_async_permitted
)
5647 rs
->wait_forever_enabled_p
= 1;
5649 rs
->remote_desc
= remote_serial_open (name
);
5650 if (!rs
->remote_desc
)
5651 perror_with_name (name
);
5653 if (baud_rate
!= -1)
5655 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5657 /* The requested speed could not be set. Error out to
5658 top level after closing remote_desc. Take care to
5659 set remote_desc to NULL to avoid closing remote_desc
5661 serial_close (rs
->remote_desc
);
5662 rs
->remote_desc
= NULL
;
5663 perror_with_name (name
);
5667 serial_setparity (rs
->remote_desc
, serial_parity
);
5668 serial_raw (rs
->remote_desc
);
5670 /* If there is something sitting in the buffer we might take it as a
5671 response to a command, which would be bad. */
5672 serial_flush_input (rs
->remote_desc
);
5676 puts_filtered ("Remote debugging using ");
5677 puts_filtered (name
);
5678 puts_filtered ("\n");
5681 /* Switch to using the remote target now. */
5682 push_target (std::move (target_holder
));
5684 /* Register extra event sources in the event loop. */
5685 rs
->remote_async_inferior_event_token
5686 = create_async_event_handler (remote_async_inferior_event_handler
, remote
,
5688 rs
->notif_state
= remote_notif_state_allocate (remote
);
5690 /* Reset the target state; these things will be queried either by
5691 remote_query_supported or as they are needed. */
5692 reset_all_packet_configs_support ();
5693 rs
->cached_wait_status
= 0;
5694 rs
->explicit_packet_size
= 0;
5696 rs
->extended
= extended_p
;
5697 rs
->waiting_for_stop_reply
= 0;
5698 rs
->ctrlc_pending_p
= 0;
5699 rs
->got_ctrlc_during_io
= 0;
5701 rs
->general_thread
= not_sent_ptid
;
5702 rs
->continue_thread
= not_sent_ptid
;
5703 rs
->remote_traceframe_number
= -1;
5705 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5707 /* Probe for ability to use "ThreadInfo" query, as required. */
5708 rs
->use_threadinfo_query
= 1;
5709 rs
->use_threadextra_query
= 1;
5711 rs
->readahead_cache
.invalidate ();
5713 if (target_async_permitted
)
5715 /* FIXME: cagney/1999-09-23: During the initial connection it is
5716 assumed that the target is already ready and able to respond to
5717 requests. Unfortunately remote_start_remote() eventually calls
5718 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5719 around this. Eventually a mechanism that allows
5720 wait_for_inferior() to expect/get timeouts will be
5722 rs
->wait_forever_enabled_p
= 0;
5725 /* First delete any symbols previously loaded from shared libraries. */
5726 no_shared_libraries (NULL
, 0);
5728 /* Start the remote connection. If error() or QUIT, discard this
5729 target (we'd otherwise be in an inconsistent state) and then
5730 propogate the error on up the exception chain. This ensures that
5731 the caller doesn't stumble along blindly assuming that the
5732 function succeeded. The CLI doesn't have this problem but other
5733 UI's, such as MI do.
5735 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5736 this function should return an error indication letting the
5737 caller restore the previous state. Unfortunately the command
5738 ``target remote'' is directly wired to this function making that
5739 impossible. On a positive note, the CLI side of this problem has
5740 been fixed - the function set_cmd_context() makes it possible for
5741 all the ``target ....'' commands to share a common callback
5742 function. See cli-dump.c. */
5747 remote
->start_remote (from_tty
, extended_p
);
5749 catch (const gdb_exception
&ex
)
5751 /* Pop the partially set up target - unless something else did
5752 already before throwing the exception. */
5753 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5754 remote_unpush_target (remote
);
5759 remote_btrace_reset (rs
);
5761 if (target_async_permitted
)
5762 rs
->wait_forever_enabled_p
= 1;
5765 /* Detach the specified process. */
5768 remote_target::remote_detach_pid (int pid
)
5770 struct remote_state
*rs
= get_remote_state ();
5772 /* This should not be necessary, but the handling for D;PID in
5773 GDBserver versions prior to 8.2 incorrectly assumes that the
5774 selected process points to the same process we're detaching,
5775 leading to misbehavior (and possibly GDBserver crashing) when it
5776 does not. Since it's easy and cheap, work around it by forcing
5777 GDBserver to select GDB's current process. */
5778 set_general_process ();
5780 if (remote_multi_process_p (rs
))
5781 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5783 strcpy (rs
->buf
.data (), "D");
5786 getpkt (&rs
->buf
, 0);
5788 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5790 else if (rs
->buf
[0] == '\0')
5791 error (_("Remote doesn't know how to detach"));
5793 error (_("Can't detach process."));
5796 /* This detaches a program to which we previously attached, using
5797 inferior_ptid to identify the process. After this is done, GDB
5798 can be used to debug some other program. We better not have left
5799 any breakpoints in the target program or it'll die when it hits
5803 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5805 int pid
= inferior_ptid
.pid ();
5806 struct remote_state
*rs
= get_remote_state ();
5809 if (!target_has_execution ())
5810 error (_("No process to detach from."));
5812 target_announce_detach (from_tty
);
5814 /* Tell the remote target to detach. */
5815 remote_detach_pid (pid
);
5817 /* Exit only if this is the only active inferior. */
5818 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors (this) == 1)
5819 puts_filtered (_("Ending remote debugging.\n"));
5821 thread_info
*tp
= find_thread_ptid (this, inferior_ptid
);
5823 /* Check to see if we are detaching a fork parent. Note that if we
5824 are detaching a fork child, tp == NULL. */
5825 is_fork_parent
= (tp
!= NULL
5826 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5828 /* If doing detach-on-fork, we don't mourn, because that will delete
5829 breakpoints that should be available for the followed inferior. */
5830 if (!is_fork_parent
)
5832 /* Save the pid as a string before mourning, since that will
5833 unpush the remote target, and we need the string after. */
5834 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5836 target_mourn_inferior (inferior_ptid
);
5837 if (print_inferior_events
)
5838 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5839 inf
->num
, infpid
.c_str ());
5843 switch_to_no_thread ();
5844 detach_inferior (current_inferior ());
5849 remote_target::detach (inferior
*inf
, int from_tty
)
5851 remote_detach_1 (inf
, from_tty
);
5855 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5857 remote_detach_1 (inf
, from_tty
);
5860 /* Target follow-fork function for remote targets. On entry, and
5861 at return, the current inferior is the fork parent.
5863 Note that although this is currently only used for extended-remote,
5864 it is named remote_follow_fork in anticipation of using it for the
5865 remote target as well. */
5868 remote_target::follow_fork (bool follow_child
, bool detach_fork
)
5870 struct remote_state
*rs
= get_remote_state ();
5871 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5873 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5874 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5876 /* When following the parent and detaching the child, we detach
5877 the child here. For the case of following the child and
5878 detaching the parent, the detach is done in the target-
5879 independent follow fork code in infrun.c. We can't use
5880 target_detach when detaching an unfollowed child because
5881 the client side doesn't know anything about the child. */
5882 if (detach_fork
&& !follow_child
)
5884 /* Detach the fork child. */
5888 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5889 child_pid
= child_ptid
.pid ();
5891 remote_detach_pid (child_pid
);
5898 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5899 in the program space of the new inferior. On entry and at return the
5900 current inferior is the exec'ing inferior. INF is the new exec'd
5901 inferior, which may be the same as the exec'ing inferior unless
5902 follow-exec-mode is "new". */
5905 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5907 /* We know that this is a target file name, so if it has the "target:"
5908 prefix we strip it off before saving it in the program space. */
5909 if (is_target_filename (execd_pathname
))
5910 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5912 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5915 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5918 remote_target::disconnect (const char *args
, int from_tty
)
5921 error (_("Argument given to \"disconnect\" when remotely debugging."));
5923 /* Make sure we unpush even the extended remote targets. Calling
5924 target_mourn_inferior won't unpush, and
5925 remote_target::mourn_inferior won't unpush if there is more than
5926 one inferior left. */
5927 remote_unpush_target (this);
5930 puts_filtered ("Ending remote debugging.\n");
5933 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5934 be chatty about it. */
5937 extended_remote_target::attach (const char *args
, int from_tty
)
5939 struct remote_state
*rs
= get_remote_state ();
5941 char *wait_status
= NULL
;
5943 pid
= parse_pid_to_attach (args
);
5945 /* Remote PID can be freely equal to getpid, do not check it here the same
5946 way as in other targets. */
5948 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5949 error (_("This target does not support attaching to a process"));
5953 const char *exec_file
= get_exec_file (0);
5956 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5957 target_pid_to_str (ptid_t (pid
)).c_str ());
5959 printf_unfiltered (_("Attaching to %s\n"),
5960 target_pid_to_str (ptid_t (pid
)).c_str ());
5963 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5965 getpkt (&rs
->buf
, 0);
5967 switch (packet_ok (rs
->buf
,
5968 &remote_protocol_packets
[PACKET_vAttach
]))
5971 if (!target_is_non_stop_p ())
5973 /* Save the reply for later. */
5974 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5975 strcpy (wait_status
, rs
->buf
.data ());
5977 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5978 error (_("Attaching to %s failed with: %s"),
5979 target_pid_to_str (ptid_t (pid
)).c_str (),
5982 case PACKET_UNKNOWN
:
5983 error (_("This target does not support attaching to a process"));
5985 error (_("Attaching to %s failed"),
5986 target_pid_to_str (ptid_t (pid
)).c_str ());
5989 switch_to_inferior_no_thread (remote_add_inferior (false, pid
, 1, 0));
5991 inferior_ptid
= ptid_t (pid
);
5993 if (target_is_non_stop_p ())
5995 /* Get list of threads. */
5996 update_thread_list ();
5998 thread_info
*thread
= first_thread_of_inferior (current_inferior ());
5999 if (thread
!= nullptr)
6000 switch_to_thread (thread
);
6002 /* Invalidate our notion of the remote current thread. */
6003 record_currthread (rs
, minus_one_ptid
);
6007 /* Now, if we have thread information, update the main thread's
6009 ptid_t curr_ptid
= remote_current_thread (ptid_t (pid
));
6011 /* Add the main thread to the thread list. */
6012 thread_info
*thr
= add_thread_silent (this, curr_ptid
);
6014 switch_to_thread (thr
);
6016 /* Don't consider the thread stopped until we've processed the
6017 saved stop reply. */
6018 set_executing (this, thr
->ptid
, true);
6021 /* Next, if the target can specify a description, read it. We do
6022 this before anything involving memory or registers. */
6023 target_find_description ();
6025 if (!target_is_non_stop_p ())
6027 /* Use the previously fetched status. */
6028 gdb_assert (wait_status
!= NULL
);
6030 if (target_can_async_p ())
6032 struct notif_event
*reply
6033 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
6035 push_stop_reply ((struct stop_reply
*) reply
);
6041 gdb_assert (wait_status
!= NULL
);
6042 strcpy (rs
->buf
.data (), wait_status
);
6043 rs
->cached_wait_status
= 1;
6047 gdb_assert (wait_status
== NULL
);
6050 /* Implementation of the to_post_attach method. */
6053 extended_remote_target::post_attach (int pid
)
6055 /* Get text, data & bss offsets. */
6058 /* In certain cases GDB might not have had the chance to start
6059 symbol lookup up until now. This could happen if the debugged
6060 binary is not using shared libraries, the vsyscall page is not
6061 present (on Linux) and the binary itself hadn't changed since the
6062 debugging process was started. */
6063 if (current_program_space
->symfile_object_file
!= NULL
)
6064 remote_check_symbols();
6068 /* Check for the availability of vCont. This function should also check
6072 remote_target::remote_vcont_probe ()
6074 remote_state
*rs
= get_remote_state ();
6077 strcpy (rs
->buf
.data (), "vCont?");
6079 getpkt (&rs
->buf
, 0);
6080 buf
= rs
->buf
.data ();
6082 /* Make sure that the features we assume are supported. */
6083 if (startswith (buf
, "vCont"))
6086 int support_c
, support_C
;
6088 rs
->supports_vCont
.s
= 0;
6089 rs
->supports_vCont
.S
= 0;
6092 rs
->supports_vCont
.t
= 0;
6093 rs
->supports_vCont
.r
= 0;
6094 while (p
&& *p
== ';')
6097 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6098 rs
->supports_vCont
.s
= 1;
6099 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6100 rs
->supports_vCont
.S
= 1;
6101 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6103 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6105 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6106 rs
->supports_vCont
.t
= 1;
6107 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6108 rs
->supports_vCont
.r
= 1;
6110 p
= strchr (p
, ';');
6113 /* If c, and C are not all supported, we can't use vCont. Clearing
6114 BUF will make packet_ok disable the packet. */
6115 if (!support_c
|| !support_C
)
6119 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
6120 rs
->supports_vCont_probed
= true;
6123 /* Helper function for building "vCont" resumptions. Write a
6124 resumption to P. ENDP points to one-passed-the-end of the buffer
6125 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
6126 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
6127 resumed thread should be single-stepped and/or signalled. If PTID
6128 equals minus_one_ptid, then all threads are resumed; if PTID
6129 represents a process, then all threads of the process are resumed;
6130 the thread to be stepped and/or signalled is given in the global
6134 remote_target::append_resumption (char *p
, char *endp
,
6135 ptid_t ptid
, int step
, gdb_signal siggnal
)
6137 struct remote_state
*rs
= get_remote_state ();
6139 if (step
&& siggnal
!= GDB_SIGNAL_0
)
6140 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
6142 /* GDB is willing to range step. */
6143 && use_range_stepping
6144 /* Target supports range stepping. */
6145 && rs
->supports_vCont
.r
6146 /* We don't currently support range stepping multiple
6147 threads with a wildcard (though the protocol allows it,
6148 so stubs shouldn't make an active effort to forbid
6150 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6152 struct thread_info
*tp
;
6154 if (ptid
== minus_one_ptid
)
6156 /* If we don't know about the target thread's tid, then
6157 we're resuming magic_null_ptid (see caller). */
6158 tp
= find_thread_ptid (this, magic_null_ptid
);
6161 tp
= find_thread_ptid (this, ptid
);
6162 gdb_assert (tp
!= NULL
);
6164 if (tp
->control
.may_range_step
)
6166 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6168 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6169 phex_nz (tp
->control
.step_range_start
,
6171 phex_nz (tp
->control
.step_range_end
,
6175 p
+= xsnprintf (p
, endp
- p
, ";s");
6178 p
+= xsnprintf (p
, endp
- p
, ";s");
6179 else if (siggnal
!= GDB_SIGNAL_0
)
6180 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6182 p
+= xsnprintf (p
, endp
- p
, ";c");
6184 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6188 /* All (-1) threads of process. */
6189 nptid
= ptid_t (ptid
.pid (), -1, 0);
6191 p
+= xsnprintf (p
, endp
- p
, ":");
6192 p
= write_ptid (p
, endp
, nptid
);
6194 else if (ptid
!= minus_one_ptid
)
6196 p
+= xsnprintf (p
, endp
- p
, ":");
6197 p
= write_ptid (p
, endp
, ptid
);
6203 /* Clear the thread's private info on resume. */
6206 resume_clear_thread_private_info (struct thread_info
*thread
)
6208 if (thread
->priv
!= NULL
)
6210 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6212 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6213 priv
->watch_data_address
= 0;
6217 /* Append a vCont continue-with-signal action for threads that have a
6218 non-zero stop signal. */
6221 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6224 for (thread_info
*thread
: all_non_exited_threads (this, ptid
))
6225 if (inferior_ptid
!= thread
->ptid
6226 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6228 p
= append_resumption (p
, endp
, thread
->ptid
,
6229 0, thread
->suspend
.stop_signal
);
6230 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6231 resume_clear_thread_private_info (thread
);
6237 /* Set the target running, using the packets that use Hc
6241 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6244 struct remote_state
*rs
= get_remote_state ();
6247 rs
->last_sent_signal
= siggnal
;
6248 rs
->last_sent_step
= step
;
6250 /* The c/s/C/S resume packets use Hc, so set the continue
6252 if (ptid
== minus_one_ptid
)
6253 set_continue_thread (any_thread_ptid
);
6255 set_continue_thread (ptid
);
6257 for (thread_info
*thread
: all_non_exited_threads (this))
6258 resume_clear_thread_private_info (thread
);
6260 buf
= rs
->buf
.data ();
6261 if (::execution_direction
== EXEC_REVERSE
)
6263 /* We don't pass signals to the target in reverse exec mode. */
6264 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6265 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6268 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6269 error (_("Remote reverse-step not supported."));
6270 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6271 error (_("Remote reverse-continue not supported."));
6273 strcpy (buf
, step
? "bs" : "bc");
6275 else if (siggnal
!= GDB_SIGNAL_0
)
6277 buf
[0] = step
? 'S' : 'C';
6278 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6279 buf
[2] = tohex (((int) siggnal
) & 0xf);
6283 strcpy (buf
, step
? "s" : "c");
6288 /* Resume the remote inferior by using a "vCont" packet. The thread
6289 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6290 resumed thread should be single-stepped and/or signalled. If PTID
6291 equals minus_one_ptid, then all threads are resumed; the thread to
6292 be stepped and/or signalled is given in the global INFERIOR_PTID.
6293 This function returns non-zero iff it resumes the inferior.
6295 This function issues a strict subset of all possible vCont commands
6299 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6300 enum gdb_signal siggnal
)
6302 struct remote_state
*rs
= get_remote_state ();
6306 /* No reverse execution actions defined for vCont. */
6307 if (::execution_direction
== EXEC_REVERSE
)
6310 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6311 remote_vcont_probe ();
6313 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6316 p
= rs
->buf
.data ();
6317 endp
= p
+ get_remote_packet_size ();
6319 /* If we could generate a wider range of packets, we'd have to worry
6320 about overflowing BUF. Should there be a generic
6321 "multi-part-packet" packet? */
6323 p
+= xsnprintf (p
, endp
- p
, "vCont");
6325 if (ptid
== magic_null_ptid
)
6327 /* MAGIC_NULL_PTID means that we don't have any active threads,
6328 so we don't have any TID numbers the inferior will
6329 understand. Make sure to only send forms that do not specify
6331 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6333 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6335 /* Resume all threads (of all processes, or of a single
6336 process), with preference for INFERIOR_PTID. This assumes
6337 inferior_ptid belongs to the set of all threads we are about
6339 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6341 /* Step inferior_ptid, with or without signal. */
6342 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6345 /* Also pass down any pending signaled resumption for other
6346 threads not the current. */
6347 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6349 /* And continue others without a signal. */
6350 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6354 /* Scheduler locking; resume only PTID. */
6355 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6358 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6361 if (target_is_non_stop_p ())
6363 /* In non-stop, the stub replies to vCont with "OK". The stop
6364 reply will be reported asynchronously by means of a `%Stop'
6366 getpkt (&rs
->buf
, 0);
6367 if (strcmp (rs
->buf
.data (), "OK") != 0)
6368 error (_("Unexpected vCont reply in non-stop mode: %s"),
6375 /* Tell the remote machine to resume. */
6378 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6380 struct remote_state
*rs
= get_remote_state ();
6382 /* When connected in non-stop mode, the core resumes threads
6383 individually. Resuming remote threads directly in target_resume
6384 would thus result in sending one packet per thread. Instead, to
6385 minimize roundtrip latency, here we just store the resume
6386 request (put the thread in RESUMED_PENDING_VCONT state); the actual remote
6387 resumption will be done in remote_target::commit_resume, where we'll be
6388 able to do vCont action coalescing. */
6389 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6391 remote_thread_info
*remote_thr
;
6393 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6394 remote_thr
= get_remote_thread_info (this, inferior_ptid
);
6396 remote_thr
= get_remote_thread_info (this, ptid
);
6398 /* We don't expect the core to ask to resume an already resumed (from
6399 its point of view) thread. */
6400 gdb_assert (remote_thr
->resume_state () == resume_state::NOT_RESUMED
);
6402 remote_thr
->set_resumed_pending_vcont (step
, siggnal
);
6406 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6407 (explained in remote-notif.c:handle_notification) so
6408 remote_notif_process is not called. We need find a place where
6409 it is safe to start a 'vNotif' sequence. It is good to do it
6410 before resuming inferior, because inferior was stopped and no RSP
6411 traffic at that moment. */
6412 if (!target_is_non_stop_p ())
6413 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6415 rs
->last_resume_exec_dir
= ::execution_direction
;
6417 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6418 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6419 remote_resume_with_hc (ptid
, step
, siggnal
);
6421 /* Update resumed state tracked by the remote target. */
6422 for (thread_info
*tp
: all_non_exited_threads (this, ptid
))
6423 get_remote_thread_info (tp
)->set_resumed ();
6425 /* We are about to start executing the inferior, let's register it
6426 with the event loop. NOTE: this is the one place where all the
6427 execution commands end up. We could alternatively do this in each
6428 of the execution commands in infcmd.c. */
6429 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6430 into infcmd.c in order to allow inferior function calls to work
6431 NOT asynchronously. */
6432 if (target_can_async_p ())
6435 /* We've just told the target to resume. The remote server will
6436 wait for the inferior to stop, and then send a stop reply. In
6437 the mean time, we can't start another command/query ourselves
6438 because the stub wouldn't be ready to process it. This applies
6439 only to the base all-stop protocol, however. In non-stop (which
6440 only supports vCont), the stub replies with an "OK", and is
6441 immediate able to process further serial input. */
6442 if (!target_is_non_stop_p ())
6443 rs
->waiting_for_stop_reply
= 1;
6446 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6448 /* Private per-inferior info for target remote processes. */
6450 struct remote_inferior
: public private_inferior
6452 /* Whether we can send a wildcard vCont for this process. */
6453 bool may_wildcard_vcont
= true;
6456 /* Get the remote private inferior data associated to INF. */
6458 static remote_inferior
*
6459 get_remote_inferior (inferior
*inf
)
6461 if (inf
->priv
== NULL
)
6462 inf
->priv
.reset (new remote_inferior
);
6464 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6467 /* Class used to track the construction of a vCont packet in the
6468 outgoing packet buffer. This is used to send multiple vCont
6469 packets if we have more actions than would fit a single packet. */
6474 explicit vcont_builder (remote_target
*remote
)
6481 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6486 /* The remote target. */
6487 remote_target
*m_remote
;
6489 /* Pointer to the first action. P points here if no action has been
6491 char *m_first_action
;
6493 /* Where the next action will be appended. */
6496 /* The end of the buffer. Must never write past this. */
6500 /* Prepare the outgoing buffer for a new vCont packet. */
6503 vcont_builder::restart ()
6505 struct remote_state
*rs
= m_remote
->get_remote_state ();
6507 m_p
= rs
->buf
.data ();
6508 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6509 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6510 m_first_action
= m_p
;
6513 /* If the vCont packet being built has any action, send it to the
6517 vcont_builder::flush ()
6519 struct remote_state
*rs
;
6521 if (m_p
== m_first_action
)
6524 rs
= m_remote
->get_remote_state ();
6525 m_remote
->putpkt (rs
->buf
);
6526 m_remote
->getpkt (&rs
->buf
, 0);
6527 if (strcmp (rs
->buf
.data (), "OK") != 0)
6528 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6531 /* The largest action is range-stepping, with its two addresses. This
6532 is more than sufficient. If a new, bigger action is created, it'll
6533 quickly trigger a failed assertion in append_resumption (and we'll
6535 #define MAX_ACTION_SIZE 200
6537 /* Append a new vCont action in the outgoing packet being built. If
6538 the action doesn't fit the packet along with previous actions, push
6539 what we've got so far to the remote end and start over a new vCont
6540 packet (with the new action). */
6543 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6545 char buf
[MAX_ACTION_SIZE
+ 1];
6547 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6548 ptid
, step
, siggnal
);
6550 /* Check whether this new action would fit in the vCont packet along
6551 with previous actions. If not, send what we've got so far and
6552 start a new vCont packet. */
6553 size_t rsize
= endp
- buf
;
6554 if (rsize
> m_endp
- m_p
)
6559 /* Should now fit. */
6560 gdb_assert (rsize
<= m_endp
- m_p
);
6563 memcpy (m_p
, buf
, rsize
);
6568 /* to_commit_resume implementation. */
6571 remote_target::commit_resume ()
6573 int any_process_wildcard
;
6574 int may_global_wildcard_vcont
;
6576 /* If connected in all-stop mode, we'd send the remote resume
6577 request directly from remote_resume. Likewise if
6578 reverse-debugging, as there are no defined vCont actions for
6579 reverse execution. */
6580 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6583 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6584 instead of resuming all threads of each process individually.
6585 However, if any thread of a process must remain halted, we can't
6586 send wildcard resumes and must send one action per thread.
6588 Care must be taken to not resume threads/processes the server
6589 side already told us are stopped, but the core doesn't know about
6590 yet, because the events are still in the vStopped notification
6593 #1 => vCont s:p1.1;c
6595 #3 <= %Stopped T05 p1.1
6600 #8 (infrun handles the stop for p1.1 and continues stepping)
6601 #9 => vCont s:p1.1;c
6603 The last vCont above would resume thread p1.2 by mistake, because
6604 the server has no idea that the event for p1.2 had not been
6607 The server side must similarly ignore resume actions for the
6608 thread that has a pending %Stopped notification (and any other
6609 threads with events pending), until GDB acks the notification
6610 with vStopped. Otherwise, e.g., the following case is
6613 #1 => g (or any other packet)
6615 #3 <= %Stopped T05 p1.2
6616 #4 => vCont s:p1.1;c
6619 Above, the server must not resume thread p1.2. GDB can't know
6620 that p1.2 stopped until it acks the %Stopped notification, and
6621 since from GDB's perspective all threads should be running, it
6624 Finally, special care must also be given to handling fork/vfork
6625 events. A (v)fork event actually tells us that two processes
6626 stopped -- the parent and the child. Until we follow the fork,
6627 we must not resume the child. Therefore, if we have a pending
6628 fork follow, we must not send a global wildcard resume action
6629 (vCont;c). We can still send process-wide wildcards though. */
6631 /* Start by assuming a global wildcard (vCont;c) is possible. */
6632 may_global_wildcard_vcont
= 1;
6634 /* And assume every process is individually wildcard-able too. */
6635 for (inferior
*inf
: all_non_exited_inferiors (this))
6637 remote_inferior
*priv
= get_remote_inferior (inf
);
6639 priv
->may_wildcard_vcont
= true;
6642 /* Check for any pending events (not reported or processed yet) and
6643 disable process and global wildcard resumes appropriately. */
6644 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6646 for (thread_info
*tp
: all_non_exited_threads (this))
6648 remote_thread_info
*priv
= get_remote_thread_info (tp
);
6650 /* If a thread of a process is not meant to be resumed, then we
6651 can't wildcard that process. */
6652 if (priv
->resume_state () == resume_state::NOT_RESUMED
)
6654 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6656 /* And if we can't wildcard a process, we can't wildcard
6657 everything either. */
6658 may_global_wildcard_vcont
= 0;
6662 /* If a thread is the parent of an unfollowed fork, then we
6663 can't do a global wildcard, as that would resume the fork
6665 if (is_pending_fork_parent_thread (tp
))
6666 may_global_wildcard_vcont
= 0;
6669 /* Now let's build the vCont packet(s). Actions must be appended
6670 from narrower to wider scopes (thread -> process -> global). If
6671 we end up with too many actions for a single packet vcont_builder
6672 flushes the current vCont packet to the remote side and starts a
6674 struct vcont_builder
vcont_builder (this);
6676 /* Threads first. */
6677 for (thread_info
*tp
: all_non_exited_threads (this))
6679 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6681 /* If the thread was previously vCont-resumed, no need to send a specific
6682 action for it. If we didn't receive a resume request for it, don't
6683 send an action for it either. */
6684 if (remote_thr
->resume_state () != resume_state::RESUMED_PENDING_VCONT
)
6687 gdb_assert (!thread_is_in_step_over_chain (tp
));
6689 const resumed_pending_vcont_info
&info
6690 = remote_thr
->resumed_pending_vcont_info ();
6692 /* Check if we need to send a specific action for this thread. If not,
6693 it will be included in a wildcard resume instead. */
6694 if (info
.step
|| info
.sig
!= GDB_SIGNAL_0
6695 || !get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6696 vcont_builder
.push_action (tp
->ptid
, info
.step
, info
.sig
);
6698 remote_thr
->set_resumed ();
6701 /* Now check whether we can send any process-wide wildcard. This is
6702 to avoid sending a global wildcard in the case nothing is
6703 supposed to be resumed. */
6704 any_process_wildcard
= 0;
6706 for (inferior
*inf
: all_non_exited_inferiors (this))
6708 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6710 any_process_wildcard
= 1;
6715 if (any_process_wildcard
)
6717 /* If all processes are wildcard-able, then send a single "c"
6718 action, otherwise, send an "all (-1) threads of process"
6719 continue action for each running process, if any. */
6720 if (may_global_wildcard_vcont
)
6722 vcont_builder
.push_action (minus_one_ptid
,
6723 false, GDB_SIGNAL_0
);
6727 for (inferior
*inf
: all_non_exited_inferiors (this))
6729 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6731 vcont_builder
.push_action (ptid_t (inf
->pid
),
6732 false, GDB_SIGNAL_0
);
6738 vcont_builder
.flush ();
6743 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6744 thread, all threads of a remote process, or all threads of all
6748 remote_target::remote_stop_ns (ptid_t ptid
)
6750 struct remote_state
*rs
= get_remote_state ();
6751 char *p
= rs
->buf
.data ();
6752 char *endp
= p
+ get_remote_packet_size ();
6754 /* FIXME: This supports_vCont_probed check is a workaround until
6755 packet_support is per-connection. */
6756 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
6757 || !rs
->supports_vCont_probed
)
6758 remote_vcont_probe ();
6760 if (!rs
->supports_vCont
.t
)
6761 error (_("Remote server does not support stopping threads"));
6763 if (ptid
== minus_one_ptid
6764 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6765 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6770 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6773 /* All (-1) threads of process. */
6774 nptid
= ptid_t (ptid
.pid (), -1, 0);
6777 /* Small optimization: if we already have a stop reply for
6778 this thread, no use in telling the stub we want this
6780 if (peek_stop_reply (ptid
))
6786 write_ptid (p
, endp
, nptid
);
6789 /* In non-stop, we get an immediate OK reply. The stop reply will
6790 come in asynchronously by notification. */
6792 getpkt (&rs
->buf
, 0);
6793 if (strcmp (rs
->buf
.data (), "OK") != 0)
6794 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6798 /* All-stop version of target_interrupt. Sends a break or a ^C to
6799 interrupt the remote target. It is undefined which thread of which
6800 process reports the interrupt. */
6803 remote_target::remote_interrupt_as ()
6805 struct remote_state
*rs
= get_remote_state ();
6807 rs
->ctrlc_pending_p
= 1;
6809 /* If the inferior is stopped already, but the core didn't know
6810 about it yet, just ignore the request. The cached wait status
6811 will be collected in remote_wait. */
6812 if (rs
->cached_wait_status
)
6815 /* Send interrupt_sequence to remote target. */
6816 send_interrupt_sequence ();
6819 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6820 the remote target. It is undefined which thread of which process
6821 reports the interrupt. Throws an error if the packet is not
6822 supported by the server. */
6825 remote_target::remote_interrupt_ns ()
6827 struct remote_state
*rs
= get_remote_state ();
6828 char *p
= rs
->buf
.data ();
6829 char *endp
= p
+ get_remote_packet_size ();
6831 xsnprintf (p
, endp
- p
, "vCtrlC");
6833 /* In non-stop, we get an immediate OK reply. The stop reply will
6834 come in asynchronously by notification. */
6836 getpkt (&rs
->buf
, 0);
6838 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6842 case PACKET_UNKNOWN
:
6843 error (_("No support for interrupting the remote target."));
6845 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6849 /* Implement the to_stop function for the remote targets. */
6852 remote_target::stop (ptid_t ptid
)
6855 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6857 if (target_is_non_stop_p ())
6858 remote_stop_ns (ptid
);
6861 /* We don't currently have a way to transparently pause the
6862 remote target in all-stop mode. Interrupt it instead. */
6863 remote_interrupt_as ();
6867 /* Implement the to_interrupt function for the remote targets. */
6870 remote_target::interrupt ()
6873 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6875 if (target_is_non_stop_p ())
6876 remote_interrupt_ns ();
6878 remote_interrupt_as ();
6881 /* Implement the to_pass_ctrlc function for the remote targets. */
6884 remote_target::pass_ctrlc ()
6886 struct remote_state
*rs
= get_remote_state ();
6889 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6891 /* If we're starting up, we're not fully synced yet. Quit
6893 if (rs
->starting_up
)
6895 /* If ^C has already been sent once, offer to disconnect. */
6896 else if (rs
->ctrlc_pending_p
)
6899 target_interrupt ();
6902 /* Ask the user what to do when an interrupt is received. */
6905 remote_target::interrupt_query ()
6907 struct remote_state
*rs
= get_remote_state ();
6909 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6911 if (query (_("The target is not responding to interrupt requests.\n"
6912 "Stop debugging it? ")))
6914 remote_unpush_target (this);
6915 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6920 if (query (_("Interrupted while waiting for the program.\n"
6921 "Give up waiting? ")))
6926 /* Enable/disable target terminal ownership. Most targets can use
6927 terminal groups to control terminal ownership. Remote targets are
6928 different in that explicit transfer of ownership to/from GDB/target
6932 remote_target::terminal_inferior ()
6934 /* NOTE: At this point we could also register our selves as the
6935 recipient of all input. Any characters typed could then be
6936 passed on down to the target. */
6940 remote_target::terminal_ours ()
6945 remote_console_output (const char *msg
)
6949 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6952 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6956 gdb_stdtarg
->puts (tb
);
6958 gdb_stdtarg
->flush ();
6961 struct stop_reply
: public notif_event
6965 /* The identifier of the thread about this event */
6968 /* The remote state this event is associated with. When the remote
6969 connection, represented by a remote_state object, is closed,
6970 all the associated stop_reply events should be released. */
6971 struct remote_state
*rs
;
6973 struct target_waitstatus ws
;
6975 /* The architecture associated with the expedited registers. */
6978 /* Expedited registers. This makes remote debugging a bit more
6979 efficient for those targets that provide critical registers as
6980 part of their normal status mechanism (as another roundtrip to
6981 fetch them is avoided). */
6982 std::vector
<cached_reg_t
> regcache
;
6984 enum target_stop_reason stop_reason
;
6986 CORE_ADDR watch_data_address
;
6991 /* Return the length of the stop reply queue. */
6994 remote_target::stop_reply_queue_length ()
6996 remote_state
*rs
= get_remote_state ();
6997 return rs
->stop_reply_queue
.size ();
7001 remote_notif_stop_parse (remote_target
*remote
,
7002 struct notif_client
*self
, const char *buf
,
7003 struct notif_event
*event
)
7005 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
7009 remote_notif_stop_ack (remote_target
*remote
,
7010 struct notif_client
*self
, const char *buf
,
7011 struct notif_event
*event
)
7013 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
7016 putpkt (remote
, self
->ack_command
);
7018 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
7020 /* We got an unknown stop reply. */
7021 error (_("Unknown stop reply"));
7024 remote
->push_stop_reply (stop_reply
);
7028 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
7029 struct notif_client
*self
)
7031 /* We can't get pending events in remote_notif_process for
7032 notification stop, and we have to do this in remote_wait_ns
7033 instead. If we fetch all queued events from stub, remote stub
7034 may exit and we have no chance to process them back in
7036 remote_state
*rs
= remote
->get_remote_state ();
7037 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7041 stop_reply::~stop_reply ()
7043 for (cached_reg_t
®
: regcache
)
7047 static notif_event_up
7048 remote_notif_stop_alloc_reply ()
7050 return notif_event_up (new struct stop_reply ());
7053 /* A client of notification Stop. */
7055 struct notif_client notif_client_stop
=
7059 remote_notif_stop_parse
,
7060 remote_notif_stop_ack
,
7061 remote_notif_stop_can_get_pending_events
,
7062 remote_notif_stop_alloc_reply
,
7066 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
7067 the pid of the process that owns the threads we want to check, or
7068 -1 if we want to check all threads. */
7071 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
7074 if (ws
->kind
== TARGET_WAITKIND_FORKED
7075 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
7077 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
7084 /* Return the thread's pending status used to determine whether the
7085 thread is a fork parent stopped at a fork event. */
7087 static struct target_waitstatus
*
7088 thread_pending_fork_status (struct thread_info
*thread
)
7090 if (thread
->suspend
.waitstatus_pending_p
)
7091 return &thread
->suspend
.waitstatus
;
7093 return &thread
->pending_follow
;
7096 /* Determine if THREAD is a pending fork parent thread. */
7099 is_pending_fork_parent_thread (struct thread_info
*thread
)
7101 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
7104 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
7107 /* If CONTEXT contains any fork child threads that have not been
7108 reported yet, remove them from the CONTEXT list. If such a
7109 thread exists it is because we are stopped at a fork catchpoint
7110 and have not yet called follow_fork, which will set up the
7111 host-side data structures for the new process. */
7114 remote_target::remove_new_fork_children (threads_listing_context
*context
)
7117 struct notif_client
*notif
= ¬if_client_stop
;
7119 /* For any threads stopped at a fork event, remove the corresponding
7120 fork child threads from the CONTEXT list. */
7121 for (thread_info
*thread
: all_non_exited_threads (this))
7123 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
7125 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
7126 context
->remove_thread (ws
->value
.related_pid
);
7129 /* Check for any pending fork events (not reported or processed yet)
7130 in process PID and remove those fork child threads from the
7131 CONTEXT list as well. */
7132 remote_notif_get_pending_events (notif
);
7133 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7134 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7135 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
7136 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
7137 context
->remove_thread (event
->ws
.value
.related_pid
);
7140 /* Check whether any event pending in the vStopped queue would prevent
7141 a global or process wildcard vCont action. Clear
7142 *may_global_wildcard if we can't do a global wildcard (vCont;c),
7143 and clear the event inferior's may_wildcard_vcont flag if we can't
7144 do a process-wide wildcard resume (vCont;c:pPID.-1). */
7147 remote_target::check_pending_events_prevent_wildcard_vcont
7148 (int *may_global_wildcard
)
7150 struct notif_client
*notif
= ¬if_client_stop
;
7152 remote_notif_get_pending_events (notif
);
7153 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7155 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
7156 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
7159 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7160 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
7161 *may_global_wildcard
= 0;
7163 struct inferior
*inf
= find_inferior_ptid (this, event
->ptid
);
7165 /* This may be the first time we heard about this process.
7166 Regardless, we must not do a global wildcard resume, otherwise
7167 we'd resume this process too. */
7168 *may_global_wildcard
= 0;
7170 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7174 /* Discard all pending stop replies of inferior INF. */
7177 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7179 struct stop_reply
*reply
;
7180 struct remote_state
*rs
= get_remote_state ();
7181 struct remote_notif_state
*rns
= rs
->notif_state
;
7183 /* This function can be notified when an inferior exists. When the
7184 target is not remote, the notification state is NULL. */
7185 if (rs
->remote_desc
== NULL
)
7188 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7190 /* Discard the in-flight notification. */
7191 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7194 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7197 /* Discard the stop replies we have already pulled with
7199 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7200 rs
->stop_reply_queue
.end (),
7201 [=] (const stop_reply_up
&event
)
7203 return event
->ptid
.pid () == inf
->pid
;
7205 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7208 /* Discard the stop replies for RS in stop_reply_queue. */
7211 remote_target::discard_pending_stop_replies_in_queue ()
7213 remote_state
*rs
= get_remote_state ();
7215 /* Discard the stop replies we have already pulled with
7217 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7218 rs
->stop_reply_queue
.end (),
7219 [=] (const stop_reply_up
&event
)
7221 return event
->rs
== rs
;
7223 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7226 /* Remove the first reply in 'stop_reply_queue' which matches
7230 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7232 remote_state
*rs
= get_remote_state ();
7234 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7235 rs
->stop_reply_queue
.end (),
7236 [=] (const stop_reply_up
&event
)
7238 return event
->ptid
.matches (ptid
);
7240 struct stop_reply
*result
;
7241 if (iter
== rs
->stop_reply_queue
.end ())
7245 result
= iter
->release ();
7246 rs
->stop_reply_queue
.erase (iter
);
7250 fprintf_unfiltered (gdb_stdlog
,
7251 "notif: discard queued event: 'Stop' in %s\n",
7252 target_pid_to_str (ptid
).c_str ());
7257 /* Look for a queued stop reply belonging to PTID. If one is found,
7258 remove it from the queue, and return it. Returns NULL if none is
7259 found. If there are still queued events left to process, tell the
7260 event loop to get back to target_wait soon. */
7263 remote_target::queued_stop_reply (ptid_t ptid
)
7265 remote_state
*rs
= get_remote_state ();
7266 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7268 if (!rs
->stop_reply_queue
.empty ())
7270 /* There's still at least an event left. */
7271 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7277 /* Push a fully parsed stop reply in the stop reply queue. Since we
7278 know that we now have at least one queued event left to pass to the
7279 core side, tell the event loop to get back to target_wait soon. */
7282 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7284 remote_state
*rs
= get_remote_state ();
7285 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7288 fprintf_unfiltered (gdb_stdlog
,
7289 "notif: push 'Stop' %s to queue %d\n",
7290 target_pid_to_str (new_event
->ptid
).c_str (),
7291 int (rs
->stop_reply_queue
.size ()));
7293 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7296 /* Returns true if we have a stop reply for PTID. */
7299 remote_target::peek_stop_reply (ptid_t ptid
)
7301 remote_state
*rs
= get_remote_state ();
7302 for (auto &event
: rs
->stop_reply_queue
)
7303 if (ptid
== event
->ptid
7304 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7309 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7310 starting with P and ending with PEND matches PREFIX. */
7313 strprefix (const char *p
, const char *pend
, const char *prefix
)
7315 for ( ; p
< pend
; p
++, prefix
++)
7318 return *prefix
== '\0';
7321 /* Parse the stop reply in BUF. Either the function succeeds, and the
7322 result is stored in EVENT, or throws an error. */
7325 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7327 remote_arch_state
*rsa
= NULL
;
7332 event
->ptid
= null_ptid
;
7333 event
->rs
= get_remote_state ();
7334 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7335 event
->ws
.value
.integer
= 0;
7336 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7337 event
->regcache
.clear ();
7342 case 'T': /* Status with PC, SP, FP, ... */
7343 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7344 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7346 n... = register number
7347 r... = register contents
7350 p
= &buf
[3]; /* after Txx */
7356 p1
= strchr (p
, ':');
7358 error (_("Malformed packet(a) (missing colon): %s\n\
7362 error (_("Malformed packet(a) (missing register number): %s\n\
7366 /* Some "registers" are actually extended stop information.
7367 Note if you're adding a new entry here: GDB 7.9 and
7368 earlier assume that all register "numbers" that start
7369 with an hex digit are real register numbers. Make sure
7370 the server only sends such a packet if it knows the
7371 client understands it. */
7373 if (strprefix (p
, p1
, "thread"))
7374 event
->ptid
= read_ptid (++p1
, &p
);
7375 else if (strprefix (p
, p1
, "syscall_entry"))
7379 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7380 p
= unpack_varlen_hex (++p1
, &sysno
);
7381 event
->ws
.value
.syscall_number
= (int) sysno
;
7383 else if (strprefix (p
, p1
, "syscall_return"))
7387 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7388 p
= unpack_varlen_hex (++p1
, &sysno
);
7389 event
->ws
.value
.syscall_number
= (int) sysno
;
7391 else if (strprefix (p
, p1
, "watch")
7392 || strprefix (p
, p1
, "rwatch")
7393 || strprefix (p
, p1
, "awatch"))
7395 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7396 p
= unpack_varlen_hex (++p1
, &addr
);
7397 event
->watch_data_address
= (CORE_ADDR
) addr
;
7399 else if (strprefix (p
, p1
, "swbreak"))
7401 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7403 /* Make sure the stub doesn't forget to indicate support
7405 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7406 error (_("Unexpected swbreak stop reason"));
7408 /* The value part is documented as "must be empty",
7409 though we ignore it, in case we ever decide to make
7410 use of it in a backward compatible way. */
7411 p
= strchrnul (p1
+ 1, ';');
7413 else if (strprefix (p
, p1
, "hwbreak"))
7415 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7417 /* Make sure the stub doesn't forget to indicate support
7419 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7420 error (_("Unexpected hwbreak stop reason"));
7423 p
= strchrnul (p1
+ 1, ';');
7425 else if (strprefix (p
, p1
, "library"))
7427 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7428 p
= strchrnul (p1
+ 1, ';');
7430 else if (strprefix (p
, p1
, "replaylog"))
7432 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7433 /* p1 will indicate "begin" or "end", but it makes
7434 no difference for now, so ignore it. */
7435 p
= strchrnul (p1
+ 1, ';');
7437 else if (strprefix (p
, p1
, "core"))
7441 p
= unpack_varlen_hex (++p1
, &c
);
7444 else if (strprefix (p
, p1
, "fork"))
7446 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7447 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7449 else if (strprefix (p
, p1
, "vfork"))
7451 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7452 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7454 else if (strprefix (p
, p1
, "vforkdone"))
7456 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7457 p
= strchrnul (p1
+ 1, ';');
7459 else if (strprefix (p
, p1
, "exec"))
7464 /* Determine the length of the execd pathname. */
7465 p
= unpack_varlen_hex (++p1
, &ignored
);
7466 pathlen
= (p
- p1
) / 2;
7468 /* Save the pathname for event reporting and for
7469 the next run command. */
7470 gdb::unique_xmalloc_ptr
<char[]> pathname
7471 ((char *) xmalloc (pathlen
+ 1));
7472 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7473 pathname
[pathlen
] = '\0';
7475 /* This is freed during event handling. */
7476 event
->ws
.value
.execd_pathname
= pathname
.release ();
7477 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7479 /* Skip the registers included in this packet, since
7480 they may be for an architecture different from the
7481 one used by the original program. */
7484 else if (strprefix (p
, p1
, "create"))
7486 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7487 p
= strchrnul (p1
+ 1, ';');
7496 p
= strchrnul (p1
+ 1, ';');
7501 /* Maybe a real ``P'' register number. */
7502 p_temp
= unpack_varlen_hex (p
, &pnum
);
7503 /* If the first invalid character is the colon, we got a
7504 register number. Otherwise, it's an unknown stop
7508 /* If we haven't parsed the event's thread yet, find
7509 it now, in order to find the architecture of the
7510 reported expedited registers. */
7511 if (event
->ptid
== null_ptid
)
7513 /* If there is no thread-id information then leave
7514 the event->ptid as null_ptid. Later in
7515 process_stop_reply we will pick a suitable
7517 const char *thr
= strstr (p1
+ 1, ";thread:");
7519 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7526 = (event
->ptid
== null_ptid
7528 : find_inferior_ptid (this, event
->ptid
));
7529 /* If this is the first time we learn anything
7530 about this process, skip the registers
7531 included in this packet, since we don't yet
7532 know which architecture to use to parse them.
7533 We'll determine the architecture later when
7534 we process the stop reply and retrieve the
7535 target description, via
7536 remote_notice_new_inferior ->
7537 post_create_inferior. */
7540 p
= strchrnul (p1
+ 1, ';');
7545 event
->arch
= inf
->gdbarch
;
7546 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7550 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7551 cached_reg_t cached_reg
;
7554 error (_("Remote sent bad register number %s: %s\n\
7556 hex_string (pnum
), p
, buf
);
7558 cached_reg
.num
= reg
->regnum
;
7559 cached_reg
.data
= (gdb_byte
*)
7560 xmalloc (register_size (event
->arch
, reg
->regnum
));
7563 fieldsize
= hex2bin (p
, cached_reg
.data
,
7564 register_size (event
->arch
, reg
->regnum
));
7566 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7567 warning (_("Remote reply is too short: %s"), buf
);
7569 event
->regcache
.push_back (cached_reg
);
7573 /* Not a number. Silently skip unknown optional
7575 p
= strchrnul (p1
+ 1, ';');
7580 error (_("Remote register badly formatted: %s\nhere: %s"),
7585 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7589 case 'S': /* Old style status, just signal only. */
7593 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7594 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7595 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7596 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7598 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7601 case 'w': /* Thread exited. */
7605 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7606 p
= unpack_varlen_hex (&buf
[1], &value
);
7607 event
->ws
.value
.integer
= value
;
7609 error (_("stop reply packet badly formatted: %s"), buf
);
7610 event
->ptid
= read_ptid (++p
, NULL
);
7613 case 'W': /* Target exited. */
7618 /* GDB used to accept only 2 hex chars here. Stubs should
7619 only send more if they detect GDB supports multi-process
7621 p
= unpack_varlen_hex (&buf
[1], &value
);
7625 /* The remote process exited. */
7626 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7627 event
->ws
.value
.integer
= value
;
7631 /* The remote process exited with a signal. */
7632 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7633 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7634 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7636 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7639 /* If no process is specified, return null_ptid, and let the
7640 caller figure out the right process to use. */
7650 else if (startswith (p
, "process:"))
7654 p
+= sizeof ("process:") - 1;
7655 unpack_varlen_hex (p
, &upid
);
7659 error (_("unknown stop reply packet: %s"), buf
);
7662 error (_("unknown stop reply packet: %s"), buf
);
7663 event
->ptid
= ptid_t (pid
);
7667 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7668 event
->ptid
= minus_one_ptid
;
7673 /* When the stub wants to tell GDB about a new notification reply, it
7674 sends a notification (%Stop, for example). Those can come it at
7675 any time, hence, we have to make sure that any pending
7676 putpkt/getpkt sequence we're making is finished, before querying
7677 the stub for more events with the corresponding ack command
7678 (vStopped, for example). E.g., if we started a vStopped sequence
7679 immediately upon receiving the notification, something like this
7687 1.6) <-- (registers reply to step #1.3)
7689 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7692 To solve this, whenever we parse a %Stop notification successfully,
7693 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7694 doing whatever we were doing:
7700 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7701 2.5) <-- (registers reply to step #2.3)
7703 Eventually after step #2.5, we return to the event loop, which
7704 notices there's an event on the
7705 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7706 associated callback --- the function below. At this point, we're
7707 always safe to start a vStopped sequence. :
7710 2.7) <-- T05 thread:2
7716 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7718 struct remote_state
*rs
= get_remote_state ();
7720 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7723 fprintf_unfiltered (gdb_stdlog
,
7724 "notif: process: '%s' ack pending event\n",
7728 nc
->ack (this, nc
, rs
->buf
.data (),
7729 rs
->notif_state
->pending_event
[nc
->id
]);
7730 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7734 getpkt (&rs
->buf
, 0);
7735 if (strcmp (rs
->buf
.data (), "OK") == 0)
7738 remote_notif_ack (this, nc
, rs
->buf
.data ());
7744 fprintf_unfiltered (gdb_stdlog
,
7745 "notif: process: '%s' no pending reply\n",
7750 /* Wrapper around remote_target::remote_notif_get_pending_events to
7751 avoid having to export the whole remote_target class. */
7754 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7756 remote
->remote_notif_get_pending_events (nc
);
7759 /* Called from process_stop_reply when the stop packet we are responding
7760 to didn't include a process-id or thread-id. STATUS is the stop event
7761 we are responding to.
7763 It is the task of this function to select a suitable thread (or process)
7764 and return its ptid, this is the thread (or process) we will assume the
7765 stop event came from.
7767 In some cases there isn't really any choice about which thread (or
7768 process) is selected, a basic remote with a single process containing a
7769 single thread might choose not to send any process-id or thread-id in
7770 its stop packets, this function will select and return the one and only
7773 However, if a target supports multiple threads (or processes) and still
7774 doesn't include a thread-id (or process-id) in its stop packet then
7775 first, this is a badly behaving target, and second, we're going to have
7776 to select a thread (or process) at random and use that. This function
7777 will print a warning to the user if it detects that there is the
7778 possibility that GDB is guessing which thread (or process) to
7781 Note that this is called before GDB fetches the updated thread list from the
7782 target. So it's possible for the stop reply to be ambiguous and for GDB to
7783 not realize it. For example, if there's initially one thread, the target
7784 spawns a second thread, and then sends a stop reply without an id that
7785 concerns the first thread. GDB will assume the stop reply is about the
7786 first thread - the only thread it knows about - without printing a warning.
7787 Anyway, if the remote meant for the stop reply to be about the second thread,
7788 then it would be really broken, because GDB doesn't know about that thread
7792 remote_target::select_thread_for_ambiguous_stop_reply
7793 (const struct target_waitstatus
*status
)
7795 /* Some stop events apply to all threads in an inferior, while others
7796 only apply to a single thread. */
7797 bool process_wide_stop
7798 = (status
->kind
== TARGET_WAITKIND_EXITED
7799 || status
->kind
== TARGET_WAITKIND_SIGNALLED
);
7801 thread_info
*first_resumed_thread
= nullptr;
7802 bool ambiguous
= false;
7804 /* Consider all non-exited threads of the target, find the first resumed
7806 for (thread_info
*thr
: all_non_exited_threads (this))
7808 remote_thread_info
*remote_thr
= get_remote_thread_info (thr
);
7810 if (remote_thr
->resume_state () != resume_state::RESUMED
)
7813 if (first_resumed_thread
== nullptr)
7814 first_resumed_thread
= thr
;
7815 else if (!process_wide_stop
7816 || first_resumed_thread
->ptid
.pid () != thr
->ptid
.pid ())
7820 gdb_assert (first_resumed_thread
!= nullptr);
7822 /* Warn if the remote target is sending ambiguous stop replies. */
7825 static bool warned
= false;
7829 /* If you are seeing this warning then the remote target has
7830 stopped without specifying a thread-id, but the target
7831 does have multiple threads (or inferiors), and so GDB is
7832 having to guess which thread stopped.
7834 Examples of what might cause this are the target sending
7835 and 'S' stop packet, or a 'T' stop packet and not
7836 including a thread-id.
7838 Additionally, the target might send a 'W' or 'X packet
7839 without including a process-id, when the target has
7840 multiple running inferiors. */
7841 if (process_wide_stop
)
7842 warning (_("multi-inferior target stopped without "
7843 "sending a process-id, using first "
7844 "non-exited inferior"));
7846 warning (_("multi-threaded target stopped without "
7847 "sending a thread-id, using first "
7848 "non-exited thread"));
7853 /* If this is a stop for all threads then don't use a particular threads
7854 ptid, instead create a new ptid where only the pid field is set. */
7855 if (process_wide_stop
)
7856 return ptid_t (first_resumed_thread
->ptid
.pid ());
7858 return first_resumed_thread
->ptid
;
7861 /* Called when it is decided that STOP_REPLY holds the info of the
7862 event that is to be returned to the core. This function always
7863 destroys STOP_REPLY. */
7866 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7867 struct target_waitstatus
*status
)
7869 *status
= stop_reply
->ws
;
7870 ptid_t ptid
= stop_reply
->ptid
;
7872 /* If no thread/process was reported by the stub then select a suitable
7874 if (ptid
== null_ptid
)
7875 ptid
= select_thread_for_ambiguous_stop_reply (status
);
7876 gdb_assert (ptid
!= null_ptid
);
7878 if (status
->kind
!= TARGET_WAITKIND_EXITED
7879 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7880 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7882 /* Expedited registers. */
7883 if (!stop_reply
->regcache
.empty ())
7885 struct regcache
*regcache
7886 = get_thread_arch_regcache (this, ptid
, stop_reply
->arch
);
7888 for (cached_reg_t
®
: stop_reply
->regcache
)
7890 regcache
->raw_supply (reg
.num
, reg
.data
);
7894 stop_reply
->regcache
.clear ();
7897 remote_notice_new_inferior (ptid
, 0);
7898 remote_thread_info
*remote_thr
= get_remote_thread_info (this, ptid
);
7899 remote_thr
->core
= stop_reply
->core
;
7900 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7901 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7903 if (target_is_non_stop_p ())
7905 /* If the target works in non-stop mode, a stop-reply indicates that
7906 only this thread stopped. */
7907 remote_thr
->set_not_resumed ();
7911 /* If the target works in all-stop mode, a stop-reply indicates that
7912 all the target's threads stopped. */
7913 for (thread_info
*tp
: all_non_exited_threads (this))
7914 get_remote_thread_info (tp
)->set_not_resumed ();
7922 /* The non-stop mode version of target_wait. */
7925 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
7926 target_wait_flags options
)
7928 struct remote_state
*rs
= get_remote_state ();
7929 struct stop_reply
*stop_reply
;
7933 /* If in non-stop mode, get out of getpkt even if a
7934 notification is received. */
7936 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7939 if (ret
!= -1 && !is_notif
)
7942 case 'E': /* Error of some sort. */
7943 /* We're out of sync with the target now. Did it continue
7944 or not? We can't tell which thread it was in non-stop,
7945 so just ignore this. */
7946 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7948 case 'O': /* Console output. */
7949 remote_console_output (&rs
->buf
[1]);
7952 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7956 /* Acknowledge a pending stop reply that may have arrived in the
7958 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7959 remote_notif_get_pending_events (¬if_client_stop
);
7961 /* If indeed we noticed a stop reply, we're done. */
7962 stop_reply
= queued_stop_reply (ptid
);
7963 if (stop_reply
!= NULL
)
7964 return process_stop_reply (stop_reply
, status
);
7966 /* Still no event. If we're just polling for an event, then
7967 return to the event loop. */
7968 if (options
& TARGET_WNOHANG
)
7970 status
->kind
= TARGET_WAITKIND_IGNORE
;
7971 return minus_one_ptid
;
7974 /* Otherwise do a blocking wait. */
7975 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7979 /* Return the first resumed thread. */
7982 first_remote_resumed_thread (remote_target
*target
)
7984 for (thread_info
*tp
: all_non_exited_threads (target
, minus_one_ptid
))
7990 /* Wait until the remote machine stops, then return, storing status in
7991 STATUS just as `wait' would. */
7994 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
,
7995 target_wait_flags options
)
7997 struct remote_state
*rs
= get_remote_state ();
7998 ptid_t event_ptid
= null_ptid
;
8000 struct stop_reply
*stop_reply
;
8004 status
->kind
= TARGET_WAITKIND_IGNORE
;
8005 status
->value
.integer
= 0;
8007 stop_reply
= queued_stop_reply (ptid
);
8008 if (stop_reply
!= NULL
)
8009 return process_stop_reply (stop_reply
, status
);
8011 if (rs
->cached_wait_status
)
8012 /* Use the cached wait status, but only once. */
8013 rs
->cached_wait_status
= 0;
8018 int forever
= ((options
& TARGET_WNOHANG
) == 0
8019 && rs
->wait_forever_enabled_p
);
8021 if (!rs
->waiting_for_stop_reply
)
8023 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
8024 return minus_one_ptid
;
8027 /* FIXME: cagney/1999-09-27: If we're in async mode we should
8028 _never_ wait for ever -> test on target_is_async_p().
8029 However, before we do that we need to ensure that the caller
8030 knows how to take the target into/out of async mode. */
8031 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
8033 /* GDB gets a notification. Return to core as this event is
8035 if (ret
!= -1 && is_notif
)
8036 return minus_one_ptid
;
8038 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
8039 return minus_one_ptid
;
8042 buf
= rs
->buf
.data ();
8044 /* Assume that the target has acknowledged Ctrl-C unless we receive
8045 an 'F' or 'O' packet. */
8046 if (buf
[0] != 'F' && buf
[0] != 'O')
8047 rs
->ctrlc_pending_p
= 0;
8051 case 'E': /* Error of some sort. */
8052 /* We're out of sync with the target now. Did it continue or
8053 not? Not is more likely, so report a stop. */
8054 rs
->waiting_for_stop_reply
= 0;
8056 warning (_("Remote failure reply: %s"), buf
);
8057 status
->kind
= TARGET_WAITKIND_STOPPED
;
8058 status
->value
.sig
= GDB_SIGNAL_0
;
8060 case 'F': /* File-I/O request. */
8061 /* GDB may access the inferior memory while handling the File-I/O
8062 request, but we don't want GDB accessing memory while waiting
8063 for a stop reply. See the comments in putpkt_binary. Set
8064 waiting_for_stop_reply to 0 temporarily. */
8065 rs
->waiting_for_stop_reply
= 0;
8066 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
8067 rs
->ctrlc_pending_p
= 0;
8068 /* GDB handled the File-I/O request, and the target is running
8069 again. Keep waiting for events. */
8070 rs
->waiting_for_stop_reply
= 1;
8072 case 'N': case 'T': case 'S': case 'X': case 'W':
8074 /* There is a stop reply to handle. */
8075 rs
->waiting_for_stop_reply
= 0;
8078 = (struct stop_reply
*) remote_notif_parse (this,
8082 event_ptid
= process_stop_reply (stop_reply
, status
);
8085 case 'O': /* Console output. */
8086 remote_console_output (buf
+ 1);
8089 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
8091 /* Zero length reply means that we tried 'S' or 'C' and the
8092 remote system doesn't support it. */
8093 target_terminal::ours_for_output ();
8095 ("Can't send signals to this remote system. %s not sent.\n",
8096 gdb_signal_to_name (rs
->last_sent_signal
));
8097 rs
->last_sent_signal
= GDB_SIGNAL_0
;
8098 target_terminal::inferior ();
8100 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
8106 warning (_("Invalid remote reply: %s"), buf
);
8110 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
8111 return minus_one_ptid
;
8112 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
8114 /* Nothing interesting happened. If we're doing a non-blocking
8115 poll, we're done. Otherwise, go back to waiting. */
8116 if (options
& TARGET_WNOHANG
)
8117 return minus_one_ptid
;
8121 else if (status
->kind
!= TARGET_WAITKIND_EXITED
8122 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
8124 if (event_ptid
!= null_ptid
)
8125 record_currthread (rs
, event_ptid
);
8127 event_ptid
= first_remote_resumed_thread (this);
8131 /* A process exit. Invalidate our notion of current thread. */
8132 record_currthread (rs
, minus_one_ptid
);
8133 /* It's possible that the packet did not include a pid. */
8134 if (event_ptid
== null_ptid
)
8135 event_ptid
= first_remote_resumed_thread (this);
8136 /* EVENT_PTID could still be NULL_PTID. Double-check. */
8137 if (event_ptid
== null_ptid
)
8138 event_ptid
= magic_null_ptid
;
8144 /* Wait until the remote machine stops, then return, storing status in
8145 STATUS just as `wait' would. */
8148 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
8149 target_wait_flags options
)
8153 if (target_is_non_stop_p ())
8154 event_ptid
= wait_ns (ptid
, status
, options
);
8156 event_ptid
= wait_as (ptid
, status
, options
);
8158 if (target_is_async_p ())
8160 remote_state
*rs
= get_remote_state ();
8162 /* If there are are events left in the queue tell the event loop
8164 if (!rs
->stop_reply_queue
.empty ())
8165 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
8171 /* Fetch a single register using a 'p' packet. */
8174 remote_target::fetch_register_using_p (struct regcache
*regcache
,
8177 struct gdbarch
*gdbarch
= regcache
->arch ();
8178 struct remote_state
*rs
= get_remote_state ();
8180 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8183 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
8186 if (reg
->pnum
== -1)
8189 p
= rs
->buf
.data ();
8191 p
+= hexnumstr (p
, reg
->pnum
);
8194 getpkt (&rs
->buf
, 0);
8196 buf
= rs
->buf
.data ();
8198 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
8202 case PACKET_UNKNOWN
:
8205 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
8206 gdbarch_register_name (regcache
->arch (),
8211 /* If this register is unfetchable, tell the regcache. */
8214 regcache
->raw_supply (reg
->regnum
, NULL
);
8218 /* Otherwise, parse and supply the value. */
8224 error (_("fetch_register_using_p: early buf termination"));
8226 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8229 regcache
->raw_supply (reg
->regnum
, regp
);
8233 /* Fetch the registers included in the target's 'g' packet. */
8236 remote_target::send_g_packet ()
8238 struct remote_state
*rs
= get_remote_state ();
8241 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
8243 getpkt (&rs
->buf
, 0);
8244 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8245 error (_("Could not read registers; remote failure reply '%s'"),
8248 /* We can get out of synch in various cases. If the first character
8249 in the buffer is not a hex character, assume that has happened
8250 and try to fetch another packet to read. */
8251 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
8252 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
8253 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
8254 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
8257 fprintf_unfiltered (gdb_stdlog
,
8258 "Bad register packet; fetching a new packet\n");
8259 getpkt (&rs
->buf
, 0);
8262 buf_len
= strlen (rs
->buf
.data ());
8264 /* Sanity check the received packet. */
8265 if (buf_len
% 2 != 0)
8266 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
8272 remote_target::process_g_packet (struct regcache
*regcache
)
8274 struct gdbarch
*gdbarch
= regcache
->arch ();
8275 struct remote_state
*rs
= get_remote_state ();
8276 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8281 buf_len
= strlen (rs
->buf
.data ());
8283 /* Further sanity checks, with knowledge of the architecture. */
8284 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
8285 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8287 rsa
->sizeof_g_packet
, buf_len
/ 2,
8290 /* Save the size of the packet sent to us by the target. It is used
8291 as a heuristic when determining the max size of packets that the
8292 target can safely receive. */
8293 if (rsa
->actual_register_packet_size
== 0)
8294 rsa
->actual_register_packet_size
= buf_len
;
8296 /* If this is smaller than we guessed the 'g' packet would be,
8297 update our records. A 'g' reply that doesn't include a register's
8298 value implies either that the register is not available, or that
8299 the 'p' packet must be used. */
8300 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8302 long sizeof_g_packet
= buf_len
/ 2;
8304 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8306 long offset
= rsa
->regs
[i
].offset
;
8307 long reg_size
= register_size (gdbarch
, i
);
8309 if (rsa
->regs
[i
].pnum
== -1)
8312 if (offset
>= sizeof_g_packet
)
8313 rsa
->regs
[i
].in_g_packet
= 0;
8314 else if (offset
+ reg_size
> sizeof_g_packet
)
8315 error (_("Truncated register %d in remote 'g' packet"), i
);
8317 rsa
->regs
[i
].in_g_packet
= 1;
8320 /* Looks valid enough, we can assume this is the correct length
8321 for a 'g' packet. It's important not to adjust
8322 rsa->sizeof_g_packet if we have truncated registers otherwise
8323 this "if" won't be run the next time the method is called
8324 with a packet of the same size and one of the internal errors
8325 below will trigger instead. */
8326 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8329 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8331 /* Unimplemented registers read as all bits zero. */
8332 memset (regs
, 0, rsa
->sizeof_g_packet
);
8334 /* Reply describes registers byte by byte, each byte encoded as two
8335 hex characters. Suck them all up, then supply them to the
8336 register cacheing/storage mechanism. */
8338 p
= rs
->buf
.data ();
8339 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8341 if (p
[0] == 0 || p
[1] == 0)
8342 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8343 internal_error (__FILE__
, __LINE__
,
8344 _("unexpected end of 'g' packet reply"));
8346 if (p
[0] == 'x' && p
[1] == 'x')
8347 regs
[i
] = 0; /* 'x' */
8349 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8353 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8355 struct packet_reg
*r
= &rsa
->regs
[i
];
8356 long reg_size
= register_size (gdbarch
, i
);
8360 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8361 /* This shouldn't happen - we adjusted in_g_packet above. */
8362 internal_error (__FILE__
, __LINE__
,
8363 _("unexpected end of 'g' packet reply"));
8364 else if (rs
->buf
[r
->offset
* 2] == 'x')
8366 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8367 /* The register isn't available, mark it as such (at
8368 the same time setting the value to zero). */
8369 regcache
->raw_supply (r
->regnum
, NULL
);
8372 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8378 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8381 process_g_packet (regcache
);
8384 /* Make the remote selected traceframe match GDB's selected
8388 remote_target::set_remote_traceframe ()
8391 struct remote_state
*rs
= get_remote_state ();
8393 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8396 /* Avoid recursion, remote_trace_find calls us again. */
8397 rs
->remote_traceframe_number
= get_traceframe_number ();
8399 newnum
= target_trace_find (tfind_number
,
8400 get_traceframe_number (), 0, 0, NULL
);
8402 /* Should not happen. If it does, all bets are off. */
8403 if (newnum
!= get_traceframe_number ())
8404 warning (_("could not set remote traceframe"));
8408 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8410 struct gdbarch
*gdbarch
= regcache
->arch ();
8411 struct remote_state
*rs
= get_remote_state ();
8412 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8415 set_remote_traceframe ();
8416 set_general_thread (regcache
->ptid ());
8420 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8422 gdb_assert (reg
!= NULL
);
8424 /* If this register might be in the 'g' packet, try that first -
8425 we are likely to read more than one register. If this is the
8426 first 'g' packet, we might be overly optimistic about its
8427 contents, so fall back to 'p'. */
8428 if (reg
->in_g_packet
)
8430 fetch_registers_using_g (regcache
);
8431 if (reg
->in_g_packet
)
8435 if (fetch_register_using_p (regcache
, reg
))
8438 /* This register is not available. */
8439 regcache
->raw_supply (reg
->regnum
, NULL
);
8444 fetch_registers_using_g (regcache
);
8446 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8447 if (!rsa
->regs
[i
].in_g_packet
)
8448 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8450 /* This register is not available. */
8451 regcache
->raw_supply (i
, NULL
);
8455 /* Prepare to store registers. Since we may send them all (using a
8456 'G' request), we have to read out the ones we don't want to change
8460 remote_target::prepare_to_store (struct regcache
*regcache
)
8462 struct remote_state
*rs
= get_remote_state ();
8463 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8466 /* Make sure the entire registers array is valid. */
8467 switch (packet_support (PACKET_P
))
8469 case PACKET_DISABLE
:
8470 case PACKET_SUPPORT_UNKNOWN
:
8471 /* Make sure all the necessary registers are cached. */
8472 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8473 if (rsa
->regs
[i
].in_g_packet
)
8474 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8481 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8482 packet was not recognized. */
8485 remote_target::store_register_using_P (const struct regcache
*regcache
,
8488 struct gdbarch
*gdbarch
= regcache
->arch ();
8489 struct remote_state
*rs
= get_remote_state ();
8490 /* Try storing a single register. */
8491 char *buf
= rs
->buf
.data ();
8492 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8495 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8498 if (reg
->pnum
== -1)
8501 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8502 p
= buf
+ strlen (buf
);
8503 regcache
->raw_collect (reg
->regnum
, regp
);
8504 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8506 getpkt (&rs
->buf
, 0);
8508 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8513 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8514 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8515 case PACKET_UNKNOWN
:
8518 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8522 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8523 contents of the register cache buffer. FIXME: ignores errors. */
8526 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8528 struct remote_state
*rs
= get_remote_state ();
8529 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8533 /* Extract all the registers in the regcache copying them into a
8538 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8539 memset (regs
, 0, rsa
->sizeof_g_packet
);
8540 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8542 struct packet_reg
*r
= &rsa
->regs
[i
];
8545 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8549 /* Command describes registers byte by byte,
8550 each byte encoded as two hex characters. */
8551 p
= rs
->buf
.data ();
8553 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8555 getpkt (&rs
->buf
, 0);
8556 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8557 error (_("Could not write registers; remote failure reply '%s'"),
8561 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8562 of the register cache buffer. FIXME: ignores errors. */
8565 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8567 struct gdbarch
*gdbarch
= regcache
->arch ();
8568 struct remote_state
*rs
= get_remote_state ();
8569 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8572 set_remote_traceframe ();
8573 set_general_thread (regcache
->ptid ());
8577 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8579 gdb_assert (reg
!= NULL
);
8581 /* Always prefer to store registers using the 'P' packet if
8582 possible; we often change only a small number of registers.
8583 Sometimes we change a larger number; we'd need help from a
8584 higher layer to know to use 'G'. */
8585 if (store_register_using_P (regcache
, reg
))
8588 /* For now, don't complain if we have no way to write the
8589 register. GDB loses track of unavailable registers too
8590 easily. Some day, this may be an error. We don't have
8591 any way to read the register, either... */
8592 if (!reg
->in_g_packet
)
8595 store_registers_using_G (regcache
);
8599 store_registers_using_G (regcache
);
8601 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8602 if (!rsa
->regs
[i
].in_g_packet
)
8603 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8604 /* See above for why we do not issue an error here. */
8609 /* Return the number of hex digits in num. */
8612 hexnumlen (ULONGEST num
)
8616 for (i
= 0; num
!= 0; i
++)
8619 return std::max (i
, 1);
8622 /* Set BUF to the minimum number of hex digits representing NUM. */
8625 hexnumstr (char *buf
, ULONGEST num
)
8627 int len
= hexnumlen (num
);
8629 return hexnumnstr (buf
, num
, len
);
8633 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8636 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8642 for (i
= width
- 1; i
>= 0; i
--)
8644 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8651 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8654 remote_address_masked (CORE_ADDR addr
)
8656 unsigned int address_size
= remote_address_size
;
8658 /* If "remoteaddresssize" was not set, default to target address size. */
8660 address_size
= gdbarch_addr_bit (target_gdbarch ());
8662 if (address_size
> 0
8663 && address_size
< (sizeof (ULONGEST
) * 8))
8665 /* Only create a mask when that mask can safely be constructed
8666 in a ULONGEST variable. */
8669 mask
= (mask
<< address_size
) - 1;
8675 /* Determine whether the remote target supports binary downloading.
8676 This is accomplished by sending a no-op memory write of zero length
8677 to the target at the specified address. It does not suffice to send
8678 the whole packet, since many stubs strip the eighth bit and
8679 subsequently compute a wrong checksum, which causes real havoc with
8682 NOTE: This can still lose if the serial line is not eight-bit
8683 clean. In cases like this, the user should clear "remote
8687 remote_target::check_binary_download (CORE_ADDR addr
)
8689 struct remote_state
*rs
= get_remote_state ();
8691 switch (packet_support (PACKET_X
))
8693 case PACKET_DISABLE
:
8697 case PACKET_SUPPORT_UNKNOWN
:
8701 p
= rs
->buf
.data ();
8703 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8705 p
+= hexnumstr (p
, (ULONGEST
) 0);
8709 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8710 getpkt (&rs
->buf
, 0);
8712 if (rs
->buf
[0] == '\0')
8715 fprintf_unfiltered (gdb_stdlog
,
8716 "binary downloading NOT "
8717 "supported by target\n");
8718 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8723 fprintf_unfiltered (gdb_stdlog
,
8724 "binary downloading supported by target\n");
8725 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8732 /* Helper function to resize the payload in order to try to get a good
8733 alignment. We try to write an amount of data such that the next write will
8734 start on an address aligned on REMOTE_ALIGN_WRITES. */
8737 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8739 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8742 /* Write memory data directly to the remote machine.
8743 This does not inform the data cache; the data cache uses this.
8744 HEADER is the starting part of the packet.
8745 MEMADDR is the address in the remote memory space.
8746 MYADDR is the address of the buffer in our space.
8747 LEN_UNITS is the number of addressable units to write.
8748 UNIT_SIZE is the length in bytes of an addressable unit.
8749 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8750 should send data as binary ('X'), or hex-encoded ('M').
8752 The function creates packet of the form
8753 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8755 where encoding of <DATA> is terminated by PACKET_FORMAT.
8757 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8760 Return the transferred status, error or OK (an
8761 'enum target_xfer_status' value). Save the number of addressable units
8762 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8764 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8765 exchange between gdb and the stub could look like (?? in place of the
8771 -> $M1000,3:eeeeffffeeee#??
8775 <- eeeeffffeeeedddd */
8778 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8779 const gdb_byte
*myaddr
,
8782 ULONGEST
*xfered_len_units
,
8783 char packet_format
, int use_length
)
8785 struct remote_state
*rs
= get_remote_state ();
8791 int payload_capacity_bytes
;
8792 int payload_length_bytes
;
8794 if (packet_format
!= 'X' && packet_format
!= 'M')
8795 internal_error (__FILE__
, __LINE__
,
8796 _("remote_write_bytes_aux: bad packet format"));
8799 return TARGET_XFER_EOF
;
8801 payload_capacity_bytes
= get_memory_write_packet_size ();
8803 /* The packet buffer will be large enough for the payload;
8804 get_memory_packet_size ensures this. */
8807 /* Compute the size of the actual payload by subtracting out the
8808 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8810 payload_capacity_bytes
-= strlen ("$,:#NN");
8812 /* The comma won't be used. */
8813 payload_capacity_bytes
+= 1;
8814 payload_capacity_bytes
-= strlen (header
);
8815 payload_capacity_bytes
-= hexnumlen (memaddr
);
8817 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8819 strcat (rs
->buf
.data (), header
);
8820 p
= rs
->buf
.data () + strlen (header
);
8822 /* Compute a best guess of the number of bytes actually transfered. */
8823 if (packet_format
== 'X')
8825 /* Best guess at number of bytes that will fit. */
8826 todo_units
= std::min (len_units
,
8827 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8829 payload_capacity_bytes
-= hexnumlen (todo_units
);
8830 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8834 /* Number of bytes that will fit. */
8836 = std::min (len_units
,
8837 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8839 payload_capacity_bytes
-= hexnumlen (todo_units
);
8840 todo_units
= std::min (todo_units
,
8841 (payload_capacity_bytes
/ unit_size
) / 2);
8844 if (todo_units
<= 0)
8845 internal_error (__FILE__
, __LINE__
,
8846 _("minimum packet size too small to write data"));
8848 /* If we already need another packet, then try to align the end
8849 of this packet to a useful boundary. */
8850 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8851 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8853 /* Append "<memaddr>". */
8854 memaddr
= remote_address_masked (memaddr
);
8855 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8862 /* Append the length and retain its location and size. It may need to be
8863 adjusted once the packet body has been created. */
8865 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8873 /* Append the packet body. */
8874 if (packet_format
== 'X')
8876 /* Binary mode. Send target system values byte by byte, in
8877 increasing byte addresses. Only escape certain critical
8879 payload_length_bytes
=
8880 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8881 &units_written
, payload_capacity_bytes
);
8883 /* If not all TODO units fit, then we'll need another packet. Make
8884 a second try to keep the end of the packet aligned. Don't do
8885 this if the packet is tiny. */
8886 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8890 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8892 if (new_todo_units
!= units_written
)
8893 payload_length_bytes
=
8894 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8895 (gdb_byte
*) p
, &units_written
,
8896 payload_capacity_bytes
);
8899 p
+= payload_length_bytes
;
8900 if (use_length
&& units_written
< todo_units
)
8902 /* Escape chars have filled up the buffer prematurely,
8903 and we have actually sent fewer units than planned.
8904 Fix-up the length field of the packet. Use the same
8905 number of characters as before. */
8906 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8908 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8913 /* Normal mode: Send target system values byte by byte, in
8914 increasing byte addresses. Each byte is encoded as a two hex
8916 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8917 units_written
= todo_units
;
8920 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8921 getpkt (&rs
->buf
, 0);
8923 if (rs
->buf
[0] == 'E')
8924 return TARGET_XFER_E_IO
;
8926 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8927 send fewer units than we'd planned. */
8928 *xfered_len_units
= (ULONGEST
) units_written
;
8929 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8932 /* Write memory data directly to the remote machine.
8933 This does not inform the data cache; the data cache uses this.
8934 MEMADDR is the address in the remote memory space.
8935 MYADDR is the address of the buffer in our space.
8936 LEN is the number of bytes.
8938 Return the transferred status, error or OK (an
8939 'enum target_xfer_status' value). Save the number of bytes
8940 transferred in *XFERED_LEN. Only transfer a single packet. */
8943 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8944 ULONGEST len
, int unit_size
,
8945 ULONGEST
*xfered_len
)
8947 const char *packet_format
= NULL
;
8949 /* Check whether the target supports binary download. */
8950 check_binary_download (memaddr
);
8952 switch (packet_support (PACKET_X
))
8955 packet_format
= "X";
8957 case PACKET_DISABLE
:
8958 packet_format
= "M";
8960 case PACKET_SUPPORT_UNKNOWN
:
8961 internal_error (__FILE__
, __LINE__
,
8962 _("remote_write_bytes: bad internal state"));
8964 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8967 return remote_write_bytes_aux (packet_format
,
8968 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8969 packet_format
[0], 1);
8972 /* Read memory data directly from the remote machine.
8973 This does not use the data cache; the data cache uses this.
8974 MEMADDR is the address in the remote memory space.
8975 MYADDR is the address of the buffer in our space.
8976 LEN_UNITS is the number of addressable memory units to read..
8977 UNIT_SIZE is the length in bytes of an addressable unit.
8979 Return the transferred status, error or OK (an
8980 'enum target_xfer_status' value). Save the number of bytes
8981 transferred in *XFERED_LEN_UNITS.
8983 See the comment of remote_write_bytes_aux for an example of
8984 memory read/write exchange between gdb and the stub. */
8987 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8989 int unit_size
, ULONGEST
*xfered_len_units
)
8991 struct remote_state
*rs
= get_remote_state ();
8992 int buf_size_bytes
; /* Max size of packet output buffer. */
8997 buf_size_bytes
= get_memory_read_packet_size ();
8998 /* The packet buffer will be large enough for the payload;
8999 get_memory_packet_size ensures this. */
9001 /* Number of units that will fit. */
9002 todo_units
= std::min (len_units
,
9003 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
9005 /* Construct "m"<memaddr>","<len>". */
9006 memaddr
= remote_address_masked (memaddr
);
9007 p
= rs
->buf
.data ();
9009 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
9011 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
9014 getpkt (&rs
->buf
, 0);
9015 if (rs
->buf
[0] == 'E'
9016 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
9017 && rs
->buf
[3] == '\0')
9018 return TARGET_XFER_E_IO
;
9019 /* Reply describes memory byte by byte, each byte encoded as two hex
9021 p
= rs
->buf
.data ();
9022 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
9023 /* Return what we have. Let higher layers handle partial reads. */
9024 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
9025 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
9028 /* Using the set of read-only target sections of remote, read live
9031 For interface/parameters/return description see target.h,
9035 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
9039 ULONGEST
*xfered_len
)
9041 struct target_section
*secp
;
9043 secp
= target_section_by_addr (this, memaddr
);
9045 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
9047 ULONGEST memend
= memaddr
+ len
;
9049 target_section_table
*table
= target_get_section_table (this);
9050 for (target_section
&p
: *table
)
9052 if (memaddr
>= p
.addr
)
9054 if (memend
<= p
.endaddr
)
9056 /* Entire transfer is within this section. */
9057 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
9060 else if (memaddr
>= p
.endaddr
)
9062 /* This section ends before the transfer starts. */
9067 /* This section overlaps the transfer. Just do half. */
9068 len
= p
.endaddr
- memaddr
;
9069 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
9076 return TARGET_XFER_EOF
;
9079 /* Similar to remote_read_bytes_1, but it reads from the remote stub
9080 first if the requested memory is unavailable in traceframe.
9081 Otherwise, fall back to remote_read_bytes_1. */
9084 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
9085 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
9086 ULONGEST
*xfered_len
)
9089 return TARGET_XFER_EOF
;
9091 if (get_traceframe_number () != -1)
9093 std::vector
<mem_range
> available
;
9095 /* If we fail to get the set of available memory, then the
9096 target does not support querying traceframe info, and so we
9097 attempt reading from the traceframe anyway (assuming the
9098 target implements the old QTro packet then). */
9099 if (traceframe_available_memory (&available
, memaddr
, len
))
9101 if (available
.empty () || available
[0].start
!= memaddr
)
9103 enum target_xfer_status res
;
9105 /* Don't read into the traceframe's available
9107 if (!available
.empty ())
9109 LONGEST oldlen
= len
;
9111 len
= available
[0].start
- memaddr
;
9112 gdb_assert (len
<= oldlen
);
9115 /* This goes through the topmost target again. */
9116 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
9117 len
, unit_size
, xfered_len
);
9118 if (res
== TARGET_XFER_OK
)
9119 return TARGET_XFER_OK
;
9122 /* No use trying further, we know some memory starting
9123 at MEMADDR isn't available. */
9125 return (*xfered_len
!= 0) ?
9126 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
9130 /* Don't try to read more than how much is available, in
9131 case the target implements the deprecated QTro packet to
9132 cater for older GDBs (the target's knowledge of read-only
9133 sections may be outdated by now). */
9134 len
= available
[0].length
;
9138 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
9143 /* Sends a packet with content determined by the printf format string
9144 FORMAT and the remaining arguments, then gets the reply. Returns
9145 whether the packet was a success, a failure, or unknown. */
9148 remote_target::remote_send_printf (const char *format
, ...)
9150 struct remote_state
*rs
= get_remote_state ();
9151 int max_size
= get_remote_packet_size ();
9154 va_start (ap
, format
);
9157 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
9161 if (size
>= max_size
)
9162 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
9164 if (putpkt (rs
->buf
) < 0)
9165 error (_("Communication problem with target."));
9168 getpkt (&rs
->buf
, 0);
9170 return packet_check_result (rs
->buf
);
9173 /* Flash writing can take quite some time. We'll set
9174 effectively infinite timeout for flash operations.
9175 In future, we'll need to decide on a better approach. */
9176 static const int remote_flash_timeout
= 1000;
9179 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
9181 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
9182 enum packet_result ret
;
9183 scoped_restore restore_timeout
9184 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9186 ret
= remote_send_printf ("vFlashErase:%s,%s",
9187 phex (address
, addr_size
),
9191 case PACKET_UNKNOWN
:
9192 error (_("Remote target does not support flash erase"));
9194 error (_("Error erasing flash with vFlashErase packet"));
9201 remote_target::remote_flash_write (ULONGEST address
,
9202 ULONGEST length
, ULONGEST
*xfered_len
,
9203 const gdb_byte
*data
)
9205 scoped_restore restore_timeout
9206 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9207 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
9212 remote_target::flash_done ()
9216 scoped_restore restore_timeout
9217 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9219 ret
= remote_send_printf ("vFlashDone");
9223 case PACKET_UNKNOWN
:
9224 error (_("Remote target does not support vFlashDone"));
9226 error (_("Error finishing flash operation"));
9233 remote_target::files_info ()
9235 puts_filtered ("Debugging a target over a serial line.\n");
9238 /* Stuff for dealing with the packets which are part of this protocol.
9239 See comment at top of file for details. */
9241 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
9242 error to higher layers. Called when a serial error is detected.
9243 The exception message is STRING, followed by a colon and a blank,
9244 the system error message for errno at function entry and final dot
9245 for output compatibility with throw_perror_with_name. */
9248 unpush_and_perror (remote_target
*target
, const char *string
)
9250 int saved_errno
= errno
;
9252 remote_unpush_target (target
);
9253 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
9254 safe_strerror (saved_errno
));
9257 /* Read a single character from the remote end. The current quit
9258 handler is overridden to avoid quitting in the middle of packet
9259 sequence, as that would break communication with the remote server.
9260 See remote_serial_quit_handler for more detail. */
9263 remote_target::readchar (int timeout
)
9266 struct remote_state
*rs
= get_remote_state ();
9269 scoped_restore restore_quit_target
9270 = make_scoped_restore (&curr_quit_handler_target
, this);
9271 scoped_restore restore_quit
9272 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9274 rs
->got_ctrlc_during_io
= 0;
9276 ch
= serial_readchar (rs
->remote_desc
, timeout
);
9278 if (rs
->got_ctrlc_during_io
)
9285 switch ((enum serial_rc
) ch
)
9288 remote_unpush_target (this);
9289 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9292 unpush_and_perror (this, _("Remote communication error. "
9293 "Target disconnected."));
9295 case SERIAL_TIMEOUT
:
9301 /* Wrapper for serial_write that closes the target and throws if
9302 writing fails. The current quit handler is overridden to avoid
9303 quitting in the middle of packet sequence, as that would break
9304 communication with the remote server. See
9305 remote_serial_quit_handler for more detail. */
9308 remote_target::remote_serial_write (const char *str
, int len
)
9310 struct remote_state
*rs
= get_remote_state ();
9312 scoped_restore restore_quit_target
9313 = make_scoped_restore (&curr_quit_handler_target
, this);
9314 scoped_restore restore_quit
9315 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9317 rs
->got_ctrlc_during_io
= 0;
9319 if (serial_write (rs
->remote_desc
, str
, len
))
9321 unpush_and_perror (this, _("Remote communication error. "
9322 "Target disconnected."));
9325 if (rs
->got_ctrlc_during_io
)
9329 /* Return a string representing an escaped version of BUF, of len N.
9330 E.g. \n is converted to \\n, \t to \\t, etc. */
9333 escape_buffer (const char *buf
, int n
)
9337 stb
.putstrn (buf
, n
, '\\');
9338 return std::move (stb
.string ());
9341 /* Display a null-terminated packet on stdout, for debugging, using C
9345 print_packet (const char *buf
)
9347 puts_filtered ("\"");
9348 fputstr_filtered (buf
, '"', gdb_stdout
);
9349 puts_filtered ("\"");
9353 remote_target::putpkt (const char *buf
)
9355 return putpkt_binary (buf
, strlen (buf
));
9358 /* Wrapper around remote_target::putpkt to avoid exporting
9362 putpkt (remote_target
*remote
, const char *buf
)
9364 return remote
->putpkt (buf
);
9367 /* Send a packet to the remote machine, with error checking. The data
9368 of the packet is in BUF. The string in BUF can be at most
9369 get_remote_packet_size () - 5 to account for the $, # and checksum,
9370 and for a possible /0 if we are debugging (remote_debug) and want
9371 to print the sent packet as a string. */
9374 remote_target::putpkt_binary (const char *buf
, int cnt
)
9376 struct remote_state
*rs
= get_remote_state ();
9378 unsigned char csum
= 0;
9379 gdb::def_vector
<char> data (cnt
+ 6);
9380 char *buf2
= data
.data ();
9386 /* Catch cases like trying to read memory or listing threads while
9387 we're waiting for a stop reply. The remote server wouldn't be
9388 ready to handle this request, so we'd hang and timeout. We don't
9389 have to worry about this in synchronous mode, because in that
9390 case it's not possible to issue a command while the target is
9391 running. This is not a problem in non-stop mode, because in that
9392 case, the stub is always ready to process serial input. */
9393 if (!target_is_non_stop_p ()
9394 && target_is_async_p ()
9395 && rs
->waiting_for_stop_reply
)
9397 error (_("Cannot execute this command while the target is running.\n"
9398 "Use the \"interrupt\" command to stop the target\n"
9399 "and then try again."));
9402 /* We're sending out a new packet. Make sure we don't look at a
9403 stale cached response. */
9404 rs
->cached_wait_status
= 0;
9406 /* Copy the packet into buffer BUF2, encapsulating it
9407 and giving it a checksum. */
9412 for (i
= 0; i
< cnt
; i
++)
9418 *p
++ = tohex ((csum
>> 4) & 0xf);
9419 *p
++ = tohex (csum
& 0xf);
9421 /* Send it over and over until we get a positive ack. */
9425 int started_error_output
= 0;
9431 int len
= (int) (p
- buf2
);
9434 if (remote_packet_max_chars
< 0)
9437 max_chars
= remote_packet_max_chars
;
9440 = escape_buffer (buf2
, std::min (len
, max_chars
));
9442 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9444 if (len
> max_chars
)
9445 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9448 fprintf_unfiltered (gdb_stdlog
, "...");
9450 gdb_flush (gdb_stdlog
);
9452 remote_serial_write (buf2
, p
- buf2
);
9454 /* If this is a no acks version of the remote protocol, send the
9455 packet and move on. */
9459 /* Read until either a timeout occurs (-2) or '+' is read.
9460 Handle any notification that arrives in the mean time. */
9463 ch
= readchar (remote_timeout
);
9471 case SERIAL_TIMEOUT
:
9474 if (started_error_output
)
9476 putchar_unfiltered ('\n');
9477 started_error_output
= 0;
9486 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9490 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9492 case SERIAL_TIMEOUT
:
9496 break; /* Retransmit buffer. */
9500 fprintf_unfiltered (gdb_stdlog
,
9501 "Packet instead of Ack, ignoring it\n");
9502 /* It's probably an old response sent because an ACK
9503 was lost. Gobble up the packet and ack it so it
9504 doesn't get retransmitted when we resend this
9507 remote_serial_write ("+", 1);
9508 continue; /* Now, go look for +. */
9515 /* If we got a notification, handle it, and go back to looking
9517 /* We've found the start of a notification. Now
9518 collect the data. */
9519 val
= read_frame (&rs
->buf
);
9524 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9526 fprintf_unfiltered (gdb_stdlog
,
9527 " Notification received: %s\n",
9530 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9531 /* We're in sync now, rewait for the ack. */
9538 if (!started_error_output
)
9540 started_error_output
= 1;
9541 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9543 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9544 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9553 if (!started_error_output
)
9555 started_error_output
= 1;
9556 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9558 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9562 break; /* Here to retransmit. */
9566 /* This is wrong. If doing a long backtrace, the user should be
9567 able to get out next time we call QUIT, without anything as
9568 violent as interrupt_query. If we want to provide a way out of
9569 here without getting to the next QUIT, it should be based on
9570 hitting ^C twice as in remote_wait. */
9582 /* Come here after finding the start of a frame when we expected an
9583 ack. Do our best to discard the rest of this packet. */
9586 remote_target::skip_frame ()
9592 c
= readchar (remote_timeout
);
9595 case SERIAL_TIMEOUT
:
9596 /* Nothing we can do. */
9599 /* Discard the two bytes of checksum and stop. */
9600 c
= readchar (remote_timeout
);
9602 c
= readchar (remote_timeout
);
9605 case '*': /* Run length encoding. */
9606 /* Discard the repeat count. */
9607 c
= readchar (remote_timeout
);
9612 /* A regular character. */
9618 /* Come here after finding the start of the frame. Collect the rest
9619 into *BUF, verifying the checksum, length, and handling run-length
9620 compression. NUL terminate the buffer. If there is not enough room,
9623 Returns -1 on error, number of characters in buffer (ignoring the
9624 trailing NULL) on success. (could be extended to return one of the
9625 SERIAL status indications). */
9628 remote_target::read_frame (gdb::char_vector
*buf_p
)
9633 char *buf
= buf_p
->data ();
9634 struct remote_state
*rs
= get_remote_state ();
9641 c
= readchar (remote_timeout
);
9644 case SERIAL_TIMEOUT
:
9646 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9650 fputs_filtered ("Saw new packet start in middle of old one\n",
9652 return -1; /* Start a new packet, count retries. */
9655 unsigned char pktcsum
;
9661 check_0
= readchar (remote_timeout
);
9663 check_1
= readchar (remote_timeout
);
9665 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9668 fputs_filtered ("Timeout in checksum, retrying\n",
9672 else if (check_0
< 0 || check_1
< 0)
9675 fputs_filtered ("Communication error in checksum\n",
9680 /* Don't recompute the checksum; with no ack packets we
9681 don't have any way to indicate a packet retransmission
9686 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9687 if (csum
== pktcsum
)
9692 std::string str
= escape_buffer (buf
, bc
);
9694 fprintf_unfiltered (gdb_stdlog
,
9695 "Bad checksum, sentsum=0x%x, "
9696 "csum=0x%x, buf=%s\n",
9697 pktcsum
, csum
, str
.c_str ());
9699 /* Number of characters in buffer ignoring trailing
9703 case '*': /* Run length encoding. */
9708 c
= readchar (remote_timeout
);
9710 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9712 /* The character before ``*'' is repeated. */
9714 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9716 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9718 /* Make some more room in the buffer. */
9719 buf_p
->resize (buf_p
->size () + repeat
);
9720 buf
= buf_p
->data ();
9723 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9729 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9733 if (bc
>= buf_p
->size () - 1)
9735 /* Make some more room in the buffer. */
9736 buf_p
->resize (buf_p
->size () * 2);
9737 buf
= buf_p
->data ();
9747 /* Set this to the maximum number of seconds to wait instead of waiting forever
9748 in target_wait(). If this timer times out, then it generates an error and
9749 the command is aborted. This replaces most of the need for timeouts in the
9750 GDB test suite, and makes it possible to distinguish between a hung target
9751 and one with slow communications. */
9753 static int watchdog
= 0;
9755 show_watchdog (struct ui_file
*file
, int from_tty
,
9756 struct cmd_list_element
*c
, const char *value
)
9758 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9761 /* Read a packet from the remote machine, with error checking, and
9762 store it in *BUF. Resize *BUF if necessary to hold the result. If
9763 FOREVER, wait forever rather than timing out; this is used (in
9764 synchronous mode) to wait for a target that is is executing user
9766 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9767 don't have to change all the calls to getpkt to deal with the
9768 return value, because at the moment I don't know what the right
9769 thing to do it for those. */
9772 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9774 getpkt_sane (buf
, forever
);
9778 /* Read a packet from the remote machine, with error checking, and
9779 store it in *BUF. Resize *BUF if necessary to hold the result. If
9780 FOREVER, wait forever rather than timing out; this is used (in
9781 synchronous mode) to wait for a target that is is executing user
9782 code to stop. If FOREVER == 0, this function is allowed to time
9783 out gracefully and return an indication of this to the caller.
9784 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9785 consider receiving a notification enough reason to return to the
9786 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9787 holds a notification or not (a regular packet). */
9790 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9791 int forever
, int expecting_notif
,
9794 struct remote_state
*rs
= get_remote_state ();
9800 /* We're reading a new response. Make sure we don't look at a
9801 previously cached response. */
9802 rs
->cached_wait_status
= 0;
9804 strcpy (buf
->data (), "timeout");
9807 timeout
= watchdog
> 0 ? watchdog
: -1;
9808 else if (expecting_notif
)
9809 timeout
= 0; /* There should already be a char in the buffer. If
9812 timeout
= remote_timeout
;
9816 /* Process any number of notifications, and then return when
9820 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9822 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9824 /* This can loop forever if the remote side sends us
9825 characters continuously, but if it pauses, we'll get
9826 SERIAL_TIMEOUT from readchar because of timeout. Then
9827 we'll count that as a retry.
9829 Note that even when forever is set, we will only wait
9830 forever prior to the start of a packet. After that, we
9831 expect characters to arrive at a brisk pace. They should
9832 show up within remote_timeout intervals. */
9834 c
= readchar (timeout
);
9835 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9837 if (c
== SERIAL_TIMEOUT
)
9839 if (expecting_notif
)
9840 return -1; /* Don't complain, it's normal to not get
9841 anything in this case. */
9843 if (forever
) /* Watchdog went off? Kill the target. */
9845 remote_unpush_target (this);
9846 throw_error (TARGET_CLOSE_ERROR
,
9847 _("Watchdog timeout has expired. "
9848 "Target detached."));
9851 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9855 /* We've found the start of a packet or notification.
9856 Now collect the data. */
9857 val
= read_frame (buf
);
9862 remote_serial_write ("-", 1);
9865 if (tries
> MAX_TRIES
)
9867 /* We have tried hard enough, and just can't receive the
9868 packet/notification. Give up. */
9869 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9871 /* Skip the ack char if we're in no-ack mode. */
9872 if (!rs
->noack_mode
)
9873 remote_serial_write ("+", 1);
9877 /* If we got an ordinary packet, return that to our caller. */
9884 if (remote_packet_max_chars
< 0)
9887 max_chars
= remote_packet_max_chars
;
9890 = escape_buffer (buf
->data (),
9891 std::min (val
, max_chars
));
9893 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9896 if (val
> max_chars
)
9897 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9900 fprintf_unfiltered (gdb_stdlog
, "\n");
9903 /* Skip the ack char if we're in no-ack mode. */
9904 if (!rs
->noack_mode
)
9905 remote_serial_write ("+", 1);
9906 if (is_notif
!= NULL
)
9911 /* If we got a notification, handle it, and go back to looking
9915 gdb_assert (c
== '%');
9919 std::string str
= escape_buffer (buf
->data (), val
);
9921 fprintf_unfiltered (gdb_stdlog
,
9922 " Notification received: %s\n",
9925 if (is_notif
!= NULL
)
9928 handle_notification (rs
->notif_state
, buf
->data ());
9930 /* Notifications require no acknowledgement. */
9932 if (expecting_notif
)
9939 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9941 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9945 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9948 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9951 /* Kill any new fork children of process PID that haven't been
9952 processed by follow_fork. */
9955 remote_target::kill_new_fork_children (int pid
)
9957 remote_state
*rs
= get_remote_state ();
9958 struct notif_client
*notif
= ¬if_client_stop
;
9960 /* Kill the fork child threads of any threads in process PID
9961 that are stopped at a fork event. */
9962 for (thread_info
*thread
: all_non_exited_threads (this))
9964 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9966 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9968 int child_pid
= ws
->value
.related_pid
.pid ();
9971 res
= remote_vkill (child_pid
);
9973 error (_("Can't kill fork child process %d"), child_pid
);
9977 /* Check for any pending fork events (not reported or processed yet)
9978 in process PID and kill those fork child threads as well. */
9979 remote_notif_get_pending_events (notif
);
9980 for (auto &event
: rs
->stop_reply_queue
)
9981 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9983 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9986 res
= remote_vkill (child_pid
);
9988 error (_("Can't kill fork child process %d"), child_pid
);
9993 /* Target hook to kill the current inferior. */
9996 remote_target::kill ()
9999 int pid
= inferior_ptid
.pid ();
10000 struct remote_state
*rs
= get_remote_state ();
10002 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
10004 /* If we're stopped while forking and we haven't followed yet,
10005 kill the child task. We need to do this before killing the
10006 parent task because if this is a vfork then the parent will
10008 kill_new_fork_children (pid
);
10010 res
= remote_vkill (pid
);
10013 target_mourn_inferior (inferior_ptid
);
10018 /* If we are in 'target remote' mode and we are killing the only
10019 inferior, then we will tell gdbserver to exit and unpush the
10021 if (res
== -1 && !remote_multi_process_p (rs
)
10022 && number_of_live_inferiors (this) == 1)
10026 /* We've killed the remote end, we get to mourn it. If we are
10027 not in extended mode, mourning the inferior also unpushes
10028 remote_ops from the target stack, which closes the remote
10030 target_mourn_inferior (inferior_ptid
);
10035 error (_("Can't kill process"));
10038 /* Send a kill request to the target using the 'vKill' packet. */
10041 remote_target::remote_vkill (int pid
)
10043 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
10046 remote_state
*rs
= get_remote_state ();
10048 /* Tell the remote target to detach. */
10049 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
10051 getpkt (&rs
->buf
, 0);
10053 switch (packet_ok (rs
->buf
,
10054 &remote_protocol_packets
[PACKET_vKill
]))
10060 case PACKET_UNKNOWN
:
10063 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
10067 /* Send a kill request to the target using the 'k' packet. */
10070 remote_target::remote_kill_k ()
10072 /* Catch errors so the user can quit from gdb even when we
10073 aren't on speaking terms with the remote system. */
10078 catch (const gdb_exception_error
&ex
)
10080 if (ex
.error
== TARGET_CLOSE_ERROR
)
10082 /* If we got an (EOF) error that caused the target
10083 to go away, then we're done, that's what we wanted.
10084 "k" is susceptible to cause a premature EOF, given
10085 that the remote server isn't actually required to
10086 reply to "k", and it can happen that it doesn't
10087 even get to reply ACK to the "k". */
10091 /* Otherwise, something went wrong. We didn't actually kill
10092 the target. Just propagate the exception, and let the
10093 user or higher layers decide what to do. */
10099 remote_target::mourn_inferior ()
10101 struct remote_state
*rs
= get_remote_state ();
10103 /* We're no longer interested in notification events of an inferior
10104 that exited or was killed/detached. */
10105 discard_pending_stop_replies (current_inferior ());
10107 /* In 'target remote' mode with one inferior, we close the connection. */
10108 if (!rs
->extended
&& number_of_live_inferiors (this) <= 1)
10110 remote_unpush_target (this);
10114 /* In case we got here due to an error, but we're going to stay
10116 rs
->waiting_for_stop_reply
= 0;
10118 /* If the current general thread belonged to the process we just
10119 detached from or has exited, the remote side current general
10120 thread becomes undefined. Considering a case like this:
10122 - We just got here due to a detach.
10123 - The process that we're detaching from happens to immediately
10124 report a global breakpoint being hit in non-stop mode, in the
10125 same thread we had selected before.
10126 - GDB attaches to this process again.
10127 - This event happens to be the next event we handle.
10129 GDB would consider that the current general thread didn't need to
10130 be set on the stub side (with Hg), since for all it knew,
10131 GENERAL_THREAD hadn't changed.
10133 Notice that although in all-stop mode, the remote server always
10134 sets the current thread to the thread reporting the stop event,
10135 that doesn't happen in non-stop mode; in non-stop, the stub *must
10136 not* change the current thread when reporting a breakpoint hit,
10137 due to the decoupling of event reporting and event handling.
10139 To keep things simple, we always invalidate our notion of the
10141 record_currthread (rs
, minus_one_ptid
);
10143 /* Call common code to mark the inferior as not running. */
10144 generic_mourn_inferior ();
10148 extended_remote_target::supports_disable_randomization ()
10150 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
10154 remote_target::extended_remote_disable_randomization (int val
)
10156 struct remote_state
*rs
= get_remote_state ();
10159 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10160 "QDisableRandomization:%x", val
);
10162 reply
= remote_get_noisy_reply ();
10163 if (*reply
== '\0')
10164 error (_("Target does not support QDisableRandomization."));
10165 if (strcmp (reply
, "OK") != 0)
10166 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
10170 remote_target::extended_remote_run (const std::string
&args
)
10172 struct remote_state
*rs
= get_remote_state ();
10174 const char *remote_exec_file
= get_remote_exec_file ();
10176 /* If the user has disabled vRun support, or we have detected that
10177 support is not available, do not try it. */
10178 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
10181 strcpy (rs
->buf
.data (), "vRun;");
10182 len
= strlen (rs
->buf
.data ());
10184 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
10185 error (_("Remote file name too long for run packet"));
10186 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
10187 strlen (remote_exec_file
));
10189 if (!args
.empty ())
10193 gdb_argv
argv (args
.c_str ());
10194 for (i
= 0; argv
[i
] != NULL
; i
++)
10196 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
10197 error (_("Argument list too long for run packet"));
10198 rs
->buf
[len
++] = ';';
10199 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
10204 rs
->buf
[len
++] = '\0';
10207 getpkt (&rs
->buf
, 0);
10209 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
10212 /* We have a wait response. All is well. */
10214 case PACKET_UNKNOWN
:
10217 if (remote_exec_file
[0] == '\0')
10218 error (_("Running the default executable on the remote target failed; "
10219 "try \"set remote exec-file\"?"));
10221 error (_("Running \"%s\" on the remote target failed"),
10224 gdb_assert_not_reached (_("bad switch"));
10228 /* Helper function to send set/unset environment packets. ACTION is
10229 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
10230 or "QEnvironmentUnsetVariable". VALUE is the variable to be
10234 remote_target::send_environment_packet (const char *action
,
10235 const char *packet
,
10238 remote_state
*rs
= get_remote_state ();
10240 /* Convert the environment variable to an hex string, which
10241 is the best format to be transmitted over the wire. */
10242 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
10245 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10246 "%s:%s", packet
, encoded_value
.c_str ());
10249 getpkt (&rs
->buf
, 0);
10250 if (strcmp (rs
->buf
.data (), "OK") != 0)
10251 warning (_("Unable to %s environment variable '%s' on remote."),
10255 /* Helper function to handle the QEnvironment* packets. */
10258 remote_target::extended_remote_environment_support ()
10260 remote_state
*rs
= get_remote_state ();
10262 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
10264 putpkt ("QEnvironmentReset");
10265 getpkt (&rs
->buf
, 0);
10266 if (strcmp (rs
->buf
.data (), "OK") != 0)
10267 warning (_("Unable to reset environment on remote."));
10270 gdb_environ
*e
= ¤t_inferior ()->environment
;
10272 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
10273 for (const std::string
&el
: e
->user_set_env ())
10274 send_environment_packet ("set", "QEnvironmentHexEncoded",
10277 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
10278 for (const std::string
&el
: e
->user_unset_env ())
10279 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10282 /* Helper function to set the current working directory for the
10283 inferior in the remote target. */
10286 remote_target::extended_remote_set_inferior_cwd ()
10288 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10290 const char *inferior_cwd
= get_inferior_cwd ();
10291 remote_state
*rs
= get_remote_state ();
10293 if (inferior_cwd
!= NULL
)
10295 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10296 strlen (inferior_cwd
));
10298 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10299 "QSetWorkingDir:%s", hexpath
.c_str ());
10303 /* An empty inferior_cwd means that the user wants us to
10304 reset the remote server's inferior's cwd. */
10305 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10306 "QSetWorkingDir:");
10310 getpkt (&rs
->buf
, 0);
10311 if (packet_ok (rs
->buf
,
10312 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10315 Remote replied unexpectedly while setting the inferior's working\n\
10322 /* In the extended protocol we want to be able to do things like
10323 "run" and have them basically work as expected. So we need
10324 a special create_inferior function. We support changing the
10325 executable file and the command line arguments, but not the
10329 extended_remote_target::create_inferior (const char *exec_file
,
10330 const std::string
&args
,
10331 char **env
, int from_tty
)
10335 struct remote_state
*rs
= get_remote_state ();
10336 const char *remote_exec_file
= get_remote_exec_file ();
10338 /* If running asynchronously, register the target file descriptor
10339 with the event loop. */
10340 if (target_can_async_p ())
10343 /* Disable address space randomization if requested (and supported). */
10344 if (supports_disable_randomization ())
10345 extended_remote_disable_randomization (disable_randomization
);
10347 /* If startup-with-shell is on, we inform gdbserver to start the
10348 remote inferior using a shell. */
10349 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10351 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10352 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10354 getpkt (&rs
->buf
, 0);
10355 if (strcmp (rs
->buf
.data (), "OK") != 0)
10357 Remote replied unexpectedly while setting startup-with-shell: %s"),
10361 extended_remote_environment_support ();
10363 extended_remote_set_inferior_cwd ();
10365 /* Now restart the remote server. */
10366 run_worked
= extended_remote_run (args
) != -1;
10369 /* vRun was not supported. Fail if we need it to do what the
10371 if (remote_exec_file
[0])
10372 error (_("Remote target does not support \"set remote exec-file\""));
10373 if (!args
.empty ())
10374 error (_("Remote target does not support \"set args\" or run ARGS"));
10376 /* Fall back to "R". */
10377 extended_remote_restart ();
10380 /* vRun's success return is a stop reply. */
10381 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10382 add_current_inferior_and_thread (stop_reply
);
10384 /* Get updated offsets, if the stub uses qOffsets. */
10389 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10390 the list of conditions (in agent expression bytecode format), if any, the
10391 target needs to evaluate. The output is placed into the packet buffer
10392 started from BUF and ended at BUF_END. */
10395 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10396 struct bp_target_info
*bp_tgt
, char *buf
,
10399 if (bp_tgt
->conditions
.empty ())
10402 buf
+= strlen (buf
);
10403 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10406 /* Send conditions to the target. */
10407 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10409 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10410 buf
+= strlen (buf
);
10411 for (int i
= 0; i
< aexpr
->len
; ++i
)
10412 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10419 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10420 struct bp_target_info
*bp_tgt
, char *buf
)
10422 if (bp_tgt
->tcommands
.empty ())
10425 buf
+= strlen (buf
);
10427 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10428 buf
+= strlen (buf
);
10430 /* Concatenate all the agent expressions that are commands into the
10432 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10434 sprintf (buf
, "X%x,", aexpr
->len
);
10435 buf
+= strlen (buf
);
10436 for (int i
= 0; i
< aexpr
->len
; ++i
)
10437 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10442 /* Insert a breakpoint. On targets that have software breakpoint
10443 support, we ask the remote target to do the work; on targets
10444 which don't, we insert a traditional memory breakpoint. */
10447 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10448 struct bp_target_info
*bp_tgt
)
10450 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10451 If it succeeds, then set the support to PACKET_ENABLE. If it
10452 fails, and the user has explicitly requested the Z support then
10453 report an error, otherwise, mark it disabled and go on. */
10455 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10457 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10458 struct remote_state
*rs
;
10461 /* Make sure the remote is pointing at the right process, if
10463 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10464 set_general_process ();
10466 rs
= get_remote_state ();
10467 p
= rs
->buf
.data ();
10468 endbuf
= p
+ get_remote_packet_size ();
10473 addr
= (ULONGEST
) remote_address_masked (addr
);
10474 p
+= hexnumstr (p
, addr
);
10475 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10477 if (supports_evaluation_of_breakpoint_conditions ())
10478 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10480 if (can_run_breakpoint_commands ())
10481 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10484 getpkt (&rs
->buf
, 0);
10486 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10492 case PACKET_UNKNOWN
:
10497 /* If this breakpoint has target-side commands but this stub doesn't
10498 support Z0 packets, throw error. */
10499 if (!bp_tgt
->tcommands
.empty ())
10500 throw_error (NOT_SUPPORTED_ERROR
, _("\
10501 Target doesn't support breakpoints that have target side commands."));
10503 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10507 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10508 struct bp_target_info
*bp_tgt
,
10509 enum remove_bp_reason reason
)
10511 CORE_ADDR addr
= bp_tgt
->placed_address
;
10512 struct remote_state
*rs
= get_remote_state ();
10514 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10516 char *p
= rs
->buf
.data ();
10517 char *endbuf
= p
+ get_remote_packet_size ();
10519 /* Make sure the remote is pointing at the right process, if
10521 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10522 set_general_process ();
10528 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10529 p
+= hexnumstr (p
, addr
);
10530 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10533 getpkt (&rs
->buf
, 0);
10535 return (rs
->buf
[0] == 'E');
10538 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10541 static enum Z_packet_type
10542 watchpoint_to_Z_packet (int type
)
10547 return Z_PACKET_WRITE_WP
;
10550 return Z_PACKET_READ_WP
;
10553 return Z_PACKET_ACCESS_WP
;
10556 internal_error (__FILE__
, __LINE__
,
10557 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10562 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10563 enum target_hw_bp_type type
, struct expression
*cond
)
10565 struct remote_state
*rs
= get_remote_state ();
10566 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10568 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10570 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10573 /* Make sure the remote is pointing at the right process, if
10575 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10576 set_general_process ();
10578 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10579 p
= strchr (rs
->buf
.data (), '\0');
10580 addr
= remote_address_masked (addr
);
10581 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10582 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10585 getpkt (&rs
->buf
, 0);
10587 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10591 case PACKET_UNKNOWN
:
10596 internal_error (__FILE__
, __LINE__
,
10597 _("remote_insert_watchpoint: reached end of function"));
10601 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10602 CORE_ADDR start
, int length
)
10604 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10606 return diff
< length
;
10611 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10612 enum target_hw_bp_type type
, struct expression
*cond
)
10614 struct remote_state
*rs
= get_remote_state ();
10615 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10617 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10619 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10622 /* Make sure the remote is pointing at the right process, if
10624 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10625 set_general_process ();
10627 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10628 p
= strchr (rs
->buf
.data (), '\0');
10629 addr
= remote_address_masked (addr
);
10630 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10631 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10633 getpkt (&rs
->buf
, 0);
10635 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10638 case PACKET_UNKNOWN
:
10643 internal_error (__FILE__
, __LINE__
,
10644 _("remote_remove_watchpoint: reached end of function"));
10648 static int remote_hw_watchpoint_limit
= -1;
10649 static int remote_hw_watchpoint_length_limit
= -1;
10650 static int remote_hw_breakpoint_limit
= -1;
10653 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10655 if (remote_hw_watchpoint_length_limit
== 0)
10657 else if (remote_hw_watchpoint_length_limit
< 0)
10659 else if (len
<= remote_hw_watchpoint_length_limit
)
10666 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10668 if (type
== bp_hardware_breakpoint
)
10670 if (remote_hw_breakpoint_limit
== 0)
10672 else if (remote_hw_breakpoint_limit
< 0)
10674 else if (cnt
<= remote_hw_breakpoint_limit
)
10679 if (remote_hw_watchpoint_limit
== 0)
10681 else if (remote_hw_watchpoint_limit
< 0)
10685 else if (cnt
<= remote_hw_watchpoint_limit
)
10691 /* The to_stopped_by_sw_breakpoint method of target remote. */
10694 remote_target::stopped_by_sw_breakpoint ()
10696 struct thread_info
*thread
= inferior_thread ();
10698 return (thread
->priv
!= NULL
10699 && (get_remote_thread_info (thread
)->stop_reason
10700 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10703 /* The to_supports_stopped_by_sw_breakpoint method of target
10707 remote_target::supports_stopped_by_sw_breakpoint ()
10709 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10712 /* The to_stopped_by_hw_breakpoint method of target remote. */
10715 remote_target::stopped_by_hw_breakpoint ()
10717 struct thread_info
*thread
= inferior_thread ();
10719 return (thread
->priv
!= NULL
10720 && (get_remote_thread_info (thread
)->stop_reason
10721 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10724 /* The to_supports_stopped_by_hw_breakpoint method of target
10728 remote_target::supports_stopped_by_hw_breakpoint ()
10730 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10734 remote_target::stopped_by_watchpoint ()
10736 struct thread_info
*thread
= inferior_thread ();
10738 return (thread
->priv
!= NULL
10739 && (get_remote_thread_info (thread
)->stop_reason
10740 == TARGET_STOPPED_BY_WATCHPOINT
));
10744 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10746 struct thread_info
*thread
= inferior_thread ();
10748 if (thread
->priv
!= NULL
10749 && (get_remote_thread_info (thread
)->stop_reason
10750 == TARGET_STOPPED_BY_WATCHPOINT
))
10752 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10761 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10762 struct bp_target_info
*bp_tgt
)
10764 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10765 struct remote_state
*rs
;
10769 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10772 /* Make sure the remote is pointing at the right process, if
10774 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10775 set_general_process ();
10777 rs
= get_remote_state ();
10778 p
= rs
->buf
.data ();
10779 endbuf
= p
+ get_remote_packet_size ();
10785 addr
= remote_address_masked (addr
);
10786 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10787 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10789 if (supports_evaluation_of_breakpoint_conditions ())
10790 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10792 if (can_run_breakpoint_commands ())
10793 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10796 getpkt (&rs
->buf
, 0);
10798 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10801 if (rs
->buf
[1] == '.')
10803 message
= strchr (&rs
->buf
[2], '.');
10805 error (_("Remote failure reply: %s"), message
+ 1);
10808 case PACKET_UNKNOWN
:
10813 internal_error (__FILE__
, __LINE__
,
10814 _("remote_insert_hw_breakpoint: reached end of function"));
10819 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10820 struct bp_target_info
*bp_tgt
)
10823 struct remote_state
*rs
= get_remote_state ();
10824 char *p
= rs
->buf
.data ();
10825 char *endbuf
= p
+ get_remote_packet_size ();
10827 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10830 /* Make sure the remote is pointing at the right process, if
10832 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10833 set_general_process ();
10839 addr
= remote_address_masked (bp_tgt
->placed_address
);
10840 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10841 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10844 getpkt (&rs
->buf
, 0);
10846 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10849 case PACKET_UNKNOWN
:
10854 internal_error (__FILE__
, __LINE__
,
10855 _("remote_remove_hw_breakpoint: reached end of function"));
10858 /* Verify memory using the "qCRC:" request. */
10861 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10863 struct remote_state
*rs
= get_remote_state ();
10864 unsigned long host_crc
, target_crc
;
10867 /* It doesn't make sense to use qCRC if the remote target is
10868 connected but not running. */
10869 if (target_has_execution ()
10870 && packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10872 enum packet_result result
;
10874 /* Make sure the remote is pointing at the right process. */
10875 set_general_process ();
10877 /* FIXME: assumes lma can fit into long. */
10878 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10879 (long) lma
, (long) size
);
10882 /* Be clever; compute the host_crc before waiting for target
10884 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10886 getpkt (&rs
->buf
, 0);
10888 result
= packet_ok (rs
->buf
,
10889 &remote_protocol_packets
[PACKET_qCRC
]);
10890 if (result
== PACKET_ERROR
)
10892 else if (result
== PACKET_OK
)
10894 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10895 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10897 return (host_crc
== target_crc
);
10901 return simple_verify_memory (this, data
, lma
, size
);
10904 /* compare-sections command
10906 With no arguments, compares each loadable section in the exec bfd
10907 with the same memory range on the target, and reports mismatches.
10908 Useful for verifying the image on the target against the exec file. */
10911 compare_sections_command (const char *args
, int from_tty
)
10914 const char *sectname
;
10915 bfd_size_type size
;
10918 int mismatched
= 0;
10922 if (!current_program_space
->exec_bfd ())
10923 error (_("command cannot be used without an exec file"));
10925 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10931 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
10933 if (!(s
->flags
& SEC_LOAD
))
10934 continue; /* Skip non-loadable section. */
10936 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10937 continue; /* Skip writeable sections */
10939 size
= bfd_section_size (s
);
10941 continue; /* Skip zero-length section. */
10943 sectname
= bfd_section_name (s
);
10944 if (args
&& strcmp (args
, sectname
) != 0)
10945 continue; /* Not the section selected by user. */
10947 matched
= 1; /* Do this section. */
10950 gdb::byte_vector
sectdata (size
);
10951 bfd_get_section_contents (current_program_space
->exec_bfd (), s
,
10952 sectdata
.data (), 0, size
);
10954 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10957 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10958 paddress (target_gdbarch (), lma
),
10959 paddress (target_gdbarch (), lma
+ size
));
10961 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10962 paddress (target_gdbarch (), lma
),
10963 paddress (target_gdbarch (), lma
+ size
));
10965 printf_filtered ("matched.\n");
10968 printf_filtered ("MIS-MATCHED!\n");
10972 if (mismatched
> 0)
10973 warning (_("One or more sections of the target image does not match\n\
10974 the loaded file\n"));
10975 if (args
&& !matched
)
10976 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10979 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10980 into remote target. The number of bytes written to the remote
10981 target is returned, or -1 for error. */
10984 remote_target::remote_write_qxfer (const char *object_name
,
10985 const char *annex
, const gdb_byte
*writebuf
,
10986 ULONGEST offset
, LONGEST len
,
10987 ULONGEST
*xfered_len
,
10988 struct packet_config
*packet
)
10992 struct remote_state
*rs
= get_remote_state ();
10993 int max_size
= get_memory_write_packet_size ();
10995 if (packet_config_support (packet
) == PACKET_DISABLE
)
10996 return TARGET_XFER_E_IO
;
10998 /* Insert header. */
10999 i
= snprintf (rs
->buf
.data (), max_size
,
11000 "qXfer:%s:write:%s:%s:",
11001 object_name
, annex
? annex
: "",
11002 phex_nz (offset
, sizeof offset
));
11003 max_size
-= (i
+ 1);
11005 /* Escape as much data as fits into rs->buf. */
11006 buf_len
= remote_escape_output
11007 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
11009 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
11010 || getpkt_sane (&rs
->buf
, 0) < 0
11011 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11012 return TARGET_XFER_E_IO
;
11014 unpack_varlen_hex (rs
->buf
.data (), &n
);
11017 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11020 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
11021 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
11022 number of bytes read is returned, or 0 for EOF, or -1 for error.
11023 The number of bytes read may be less than LEN without indicating an
11024 EOF. PACKET is checked and updated to indicate whether the remote
11025 target supports this object. */
11028 remote_target::remote_read_qxfer (const char *object_name
,
11030 gdb_byte
*readbuf
, ULONGEST offset
,
11032 ULONGEST
*xfered_len
,
11033 struct packet_config
*packet
)
11035 struct remote_state
*rs
= get_remote_state ();
11036 LONGEST i
, n
, packet_len
;
11038 if (packet_config_support (packet
) == PACKET_DISABLE
)
11039 return TARGET_XFER_E_IO
;
11041 /* Check whether we've cached an end-of-object packet that matches
11043 if (rs
->finished_object
)
11045 if (strcmp (object_name
, rs
->finished_object
) == 0
11046 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
11047 && offset
== rs
->finished_offset
)
11048 return TARGET_XFER_EOF
;
11051 /* Otherwise, we're now reading something different. Discard
11053 xfree (rs
->finished_object
);
11054 xfree (rs
->finished_annex
);
11055 rs
->finished_object
= NULL
;
11056 rs
->finished_annex
= NULL
;
11059 /* Request only enough to fit in a single packet. The actual data
11060 may not, since we don't know how much of it will need to be escaped;
11061 the target is free to respond with slightly less data. We subtract
11062 five to account for the response type and the protocol frame. */
11063 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
11064 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
11065 "qXfer:%s:read:%s:%s,%s",
11066 object_name
, annex
? annex
: "",
11067 phex_nz (offset
, sizeof offset
),
11068 phex_nz (n
, sizeof n
));
11069 i
= putpkt (rs
->buf
);
11071 return TARGET_XFER_E_IO
;
11074 packet_len
= getpkt_sane (&rs
->buf
, 0);
11075 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11076 return TARGET_XFER_E_IO
;
11078 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
11079 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
11081 /* 'm' means there is (or at least might be) more data after this
11082 batch. That does not make sense unless there's at least one byte
11083 of data in this reply. */
11084 if (rs
->buf
[0] == 'm' && packet_len
== 1)
11085 error (_("Remote qXfer reply contained no data."));
11087 /* Got some data. */
11088 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
11089 packet_len
- 1, readbuf
, n
);
11091 /* 'l' is an EOF marker, possibly including a final block of data,
11092 or possibly empty. If we have the final block of a non-empty
11093 object, record this fact to bypass a subsequent partial read. */
11094 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
11096 rs
->finished_object
= xstrdup (object_name
);
11097 rs
->finished_annex
= xstrdup (annex
? annex
: "");
11098 rs
->finished_offset
= offset
+ i
;
11102 return TARGET_XFER_EOF
;
11106 return TARGET_XFER_OK
;
11110 enum target_xfer_status
11111 remote_target::xfer_partial (enum target_object object
,
11112 const char *annex
, gdb_byte
*readbuf
,
11113 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
11114 ULONGEST
*xfered_len
)
11116 struct remote_state
*rs
;
11120 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
11122 set_remote_traceframe ();
11123 set_general_thread (inferior_ptid
);
11125 rs
= get_remote_state ();
11127 /* Handle memory using the standard memory routines. */
11128 if (object
== TARGET_OBJECT_MEMORY
)
11130 /* If the remote target is connected but not running, we should
11131 pass this request down to a lower stratum (e.g. the executable
11133 if (!target_has_execution ())
11134 return TARGET_XFER_EOF
;
11136 if (writebuf
!= NULL
)
11137 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
11140 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
11144 /* Handle extra signal info using qxfer packets. */
11145 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
11148 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
11149 xfered_len
, &remote_protocol_packets
11150 [PACKET_qXfer_siginfo_read
]);
11152 return remote_write_qxfer ("siginfo", annex
,
11153 writebuf
, offset
, len
, xfered_len
,
11154 &remote_protocol_packets
11155 [PACKET_qXfer_siginfo_write
]);
11158 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
11161 return remote_read_qxfer ("statictrace", annex
,
11162 readbuf
, offset
, len
, xfered_len
,
11163 &remote_protocol_packets
11164 [PACKET_qXfer_statictrace_read
]);
11166 return TARGET_XFER_E_IO
;
11169 /* Only handle flash writes. */
11170 if (writebuf
!= NULL
)
11174 case TARGET_OBJECT_FLASH
:
11175 return remote_flash_write (offset
, len
, xfered_len
,
11179 return TARGET_XFER_E_IO
;
11183 /* Map pre-existing objects onto letters. DO NOT do this for new
11184 objects!!! Instead specify new query packets. */
11187 case TARGET_OBJECT_AVR
:
11191 case TARGET_OBJECT_AUXV
:
11192 gdb_assert (annex
== NULL
);
11193 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
11195 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
11197 case TARGET_OBJECT_AVAILABLE_FEATURES
:
11198 return remote_read_qxfer
11199 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
11200 &remote_protocol_packets
[PACKET_qXfer_features
]);
11202 case TARGET_OBJECT_LIBRARIES
:
11203 return remote_read_qxfer
11204 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
11205 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
11207 case TARGET_OBJECT_LIBRARIES_SVR4
:
11208 return remote_read_qxfer
11209 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
11210 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
11212 case TARGET_OBJECT_MEMORY_MAP
:
11213 gdb_assert (annex
== NULL
);
11214 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
11216 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
11218 case TARGET_OBJECT_OSDATA
:
11219 /* Should only get here if we're connected. */
11220 gdb_assert (rs
->remote_desc
);
11221 return remote_read_qxfer
11222 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
11223 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
11225 case TARGET_OBJECT_THREADS
:
11226 gdb_assert (annex
== NULL
);
11227 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
11229 &remote_protocol_packets
[PACKET_qXfer_threads
]);
11231 case TARGET_OBJECT_TRACEFRAME_INFO
:
11232 gdb_assert (annex
== NULL
);
11233 return remote_read_qxfer
11234 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
11235 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
11237 case TARGET_OBJECT_FDPIC
:
11238 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
11240 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
11242 case TARGET_OBJECT_OPENVMS_UIB
:
11243 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
11245 &remote_protocol_packets
[PACKET_qXfer_uib
]);
11247 case TARGET_OBJECT_BTRACE
:
11248 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
11250 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
11252 case TARGET_OBJECT_BTRACE_CONF
:
11253 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
11255 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
11257 case TARGET_OBJECT_EXEC_FILE
:
11258 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
11260 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
11263 return TARGET_XFER_E_IO
;
11266 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
11267 large enough let the caller deal with it. */
11268 if (len
< get_remote_packet_size ())
11269 return TARGET_XFER_E_IO
;
11270 len
= get_remote_packet_size ();
11272 /* Except for querying the minimum buffer size, target must be open. */
11273 if (!rs
->remote_desc
)
11274 error (_("remote query is only available after target open"));
11276 gdb_assert (annex
!= NULL
);
11277 gdb_assert (readbuf
!= NULL
);
11279 p2
= rs
->buf
.data ();
11281 *p2
++ = query_type
;
11283 /* We used one buffer char for the remote protocol q command and
11284 another for the query type. As the remote protocol encapsulation
11285 uses 4 chars plus one extra in case we are debugging
11286 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11289 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11291 /* Bad caller may have sent forbidden characters. */
11292 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11297 gdb_assert (annex
[i
] == '\0');
11299 i
= putpkt (rs
->buf
);
11301 return TARGET_XFER_E_IO
;
11303 getpkt (&rs
->buf
, 0);
11304 strcpy ((char *) readbuf
, rs
->buf
.data ());
11306 *xfered_len
= strlen ((char *) readbuf
);
11307 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11310 /* Implementation of to_get_memory_xfer_limit. */
11313 remote_target::get_memory_xfer_limit ()
11315 return get_memory_write_packet_size ();
11319 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11320 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11321 CORE_ADDR
*found_addrp
)
11323 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11324 struct remote_state
*rs
= get_remote_state ();
11325 int max_size
= get_memory_write_packet_size ();
11326 struct packet_config
*packet
=
11327 &remote_protocol_packets
[PACKET_qSearch_memory
];
11328 /* Number of packet bytes used to encode the pattern;
11329 this could be more than PATTERN_LEN due to escape characters. */
11330 int escaped_pattern_len
;
11331 /* Amount of pattern that was encodable in the packet. */
11332 int used_pattern_len
;
11335 ULONGEST found_addr
;
11337 auto read_memory
= [=] (CORE_ADDR addr
, gdb_byte
*result
, size_t len
)
11339 return (target_read (this, TARGET_OBJECT_MEMORY
, NULL
, result
, addr
, len
)
11343 /* Don't go to the target if we don't have to. This is done before
11344 checking packet_config_support to avoid the possibility that a
11345 success for this edge case means the facility works in
11347 if (pattern_len
> search_space_len
)
11349 if (pattern_len
== 0)
11351 *found_addrp
= start_addr
;
11355 /* If we already know the packet isn't supported, fall back to the simple
11356 way of searching memory. */
11358 if (packet_config_support (packet
) == PACKET_DISABLE
)
11360 /* Target doesn't provided special support, fall back and use the
11361 standard support (copy memory and do the search here). */
11362 return simple_search_memory (read_memory
, start_addr
, search_space_len
,
11363 pattern
, pattern_len
, found_addrp
);
11366 /* Make sure the remote is pointing at the right process. */
11367 set_general_process ();
11369 /* Insert header. */
11370 i
= snprintf (rs
->buf
.data (), max_size
,
11371 "qSearch:memory:%s;%s;",
11372 phex_nz (start_addr
, addr_size
),
11373 phex_nz (search_space_len
, sizeof (search_space_len
)));
11374 max_size
-= (i
+ 1);
11376 /* Escape as much data as fits into rs->buf. */
11377 escaped_pattern_len
=
11378 remote_escape_output (pattern
, pattern_len
, 1,
11379 (gdb_byte
*) rs
->buf
.data () + i
,
11380 &used_pattern_len
, max_size
);
11382 /* Bail if the pattern is too large. */
11383 if (used_pattern_len
!= pattern_len
)
11384 error (_("Pattern is too large to transmit to remote target."));
11386 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11387 || getpkt_sane (&rs
->buf
, 0) < 0
11388 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11390 /* The request may not have worked because the command is not
11391 supported. If so, fall back to the simple way. */
11392 if (packet_config_support (packet
) == PACKET_DISABLE
)
11394 return simple_search_memory (read_memory
, start_addr
, search_space_len
,
11395 pattern
, pattern_len
, found_addrp
);
11400 if (rs
->buf
[0] == '0')
11402 else if (rs
->buf
[0] == '1')
11405 if (rs
->buf
[1] != ',')
11406 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11407 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11408 *found_addrp
= found_addr
;
11411 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11417 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11419 struct remote_state
*rs
= get_remote_state ();
11420 char *p
= rs
->buf
.data ();
11422 if (!rs
->remote_desc
)
11423 error (_("remote rcmd is only available after target open"));
11425 /* Send a NULL command across as an empty command. */
11426 if (command
== NULL
)
11429 /* The query prefix. */
11430 strcpy (rs
->buf
.data (), "qRcmd,");
11431 p
= strchr (rs
->buf
.data (), '\0');
11433 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11434 > get_remote_packet_size ())
11435 error (_("\"monitor\" command ``%s'' is too long."), command
);
11437 /* Encode the actual command. */
11438 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11440 if (putpkt (rs
->buf
) < 0)
11441 error (_("Communication problem with target."));
11443 /* get/display the response */
11448 /* XXX - see also remote_get_noisy_reply(). */
11449 QUIT
; /* Allow user to bail out with ^C. */
11451 if (getpkt_sane (&rs
->buf
, 0) == -1)
11453 /* Timeout. Continue to (try to) read responses.
11454 This is better than stopping with an error, assuming the stub
11455 is still executing the (long) monitor command.
11456 If needed, the user can interrupt gdb using C-c, obtaining
11457 an effect similar to stop on timeout. */
11460 buf
= rs
->buf
.data ();
11461 if (buf
[0] == '\0')
11462 error (_("Target does not support this command."));
11463 if (buf
[0] == 'O' && buf
[1] != 'K')
11465 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11468 if (strcmp (buf
, "OK") == 0)
11470 if (strlen (buf
) == 3 && buf
[0] == 'E'
11471 && isdigit (buf
[1]) && isdigit (buf
[2]))
11473 error (_("Protocol error with Rcmd"));
11475 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11477 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11479 fputc_unfiltered (c
, outbuf
);
11485 std::vector
<mem_region
>
11486 remote_target::memory_map ()
11488 std::vector
<mem_region
> result
;
11489 gdb::optional
<gdb::char_vector
> text
11490 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11493 result
= parse_memory_map (text
->data ());
11499 packet_command (const char *args
, int from_tty
)
11501 remote_target
*remote
= get_current_remote_target ();
11503 if (remote
== nullptr)
11504 error (_("command can only be used with remote target"));
11506 remote
->packet_command (args
, from_tty
);
11510 remote_target::packet_command (const char *args
, int from_tty
)
11513 error (_("remote-packet command requires packet text as argument"));
11515 puts_filtered ("sending: ");
11516 print_packet (args
);
11517 puts_filtered ("\n");
11520 remote_state
*rs
= get_remote_state ();
11522 getpkt (&rs
->buf
, 0);
11523 puts_filtered ("received: ");
11524 print_packet (rs
->buf
.data ());
11525 puts_filtered ("\n");
11529 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11531 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11533 static void threadset_test_cmd (char *cmd
, int tty
);
11535 static void threadalive_test (char *cmd
, int tty
);
11537 static void threadlist_test_cmd (char *cmd
, int tty
);
11539 int get_and_display_threadinfo (threadref
*ref
);
11541 static void threadinfo_test_cmd (char *cmd
, int tty
);
11543 static int thread_display_step (threadref
*ref
, void *context
);
11545 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11547 static void init_remote_threadtests (void);
11549 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11552 threadset_test_cmd (const char *cmd
, int tty
)
11554 int sample_thread
= SAMPLE_THREAD
;
11556 printf_filtered (_("Remote threadset test\n"));
11557 set_general_thread (sample_thread
);
11562 threadalive_test (const char *cmd
, int tty
)
11564 int sample_thread
= SAMPLE_THREAD
;
11565 int pid
= inferior_ptid
.pid ();
11566 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11568 if (remote_thread_alive (ptid
))
11569 printf_filtered ("PASS: Thread alive test\n");
11571 printf_filtered ("FAIL: Thread alive test\n");
11574 void output_threadid (char *title
, threadref
*ref
);
11577 output_threadid (char *title
, threadref
*ref
)
11581 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11583 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11587 threadlist_test_cmd (const char *cmd
, int tty
)
11590 threadref nextthread
;
11591 int done
, result_count
;
11592 threadref threadlist
[3];
11594 printf_filtered ("Remote Threadlist test\n");
11595 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11596 &result_count
, &threadlist
[0]))
11597 printf_filtered ("FAIL: threadlist test\n");
11600 threadref
*scan
= threadlist
;
11601 threadref
*limit
= scan
+ result_count
;
11603 while (scan
< limit
)
11604 output_threadid (" thread ", scan
++);
11609 display_thread_info (struct gdb_ext_thread_info
*info
)
11611 output_threadid ("Threadid: ", &info
->threadid
);
11612 printf_filtered ("Name: %s\n ", info
->shortname
);
11613 printf_filtered ("State: %s\n", info
->display
);
11614 printf_filtered ("other: %s\n\n", info
->more_display
);
11618 get_and_display_threadinfo (threadref
*ref
)
11622 struct gdb_ext_thread_info threadinfo
;
11624 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11625 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11626 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11627 display_thread_info (&threadinfo
);
11632 threadinfo_test_cmd (const char *cmd
, int tty
)
11634 int athread
= SAMPLE_THREAD
;
11638 int_to_threadref (&thread
, athread
);
11639 printf_filtered ("Remote Threadinfo test\n");
11640 if (!get_and_display_threadinfo (&thread
))
11641 printf_filtered ("FAIL cannot get thread info\n");
11645 thread_display_step (threadref
*ref
, void *context
)
11647 /* output_threadid(" threadstep ",ref); *//* simple test */
11648 return get_and_display_threadinfo (ref
);
11652 threadlist_update_test_cmd (const char *cmd
, int tty
)
11654 printf_filtered ("Remote Threadlist update test\n");
11655 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11659 init_remote_threadtests (void)
11661 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11662 _("Fetch and print the remote list of "
11663 "thread identifiers, one pkt only."));
11664 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11665 _("Fetch and display info about one thread."));
11666 add_com ("tset", class_obscure
, threadset_test_cmd
,
11667 _("Test setting to a different thread."));
11668 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11669 _("Iterate through updating all remote thread info."));
11670 add_com ("talive", class_obscure
, threadalive_test
,
11671 _("Remote thread alive test."));
11676 /* Convert a thread ID to a string. */
11679 remote_target::pid_to_str (ptid_t ptid
)
11681 struct remote_state
*rs
= get_remote_state ();
11683 if (ptid
== null_ptid
)
11684 return normal_pid_to_str (ptid
);
11685 else if (ptid
.is_pid ())
11687 /* Printing an inferior target id. */
11689 /* When multi-process extensions are off, there's no way in the
11690 remote protocol to know the remote process id, if there's any
11691 at all. There's one exception --- when we're connected with
11692 target extended-remote, and we manually attached to a process
11693 with "attach PID". We don't record anywhere a flag that
11694 allows us to distinguish that case from the case of
11695 connecting with extended-remote and the stub already being
11696 attached to a process, and reporting yes to qAttached, hence
11697 no smart special casing here. */
11698 if (!remote_multi_process_p (rs
))
11699 return "Remote target";
11701 return normal_pid_to_str (ptid
);
11705 if (magic_null_ptid
== ptid
)
11706 return "Thread <main>";
11707 else if (remote_multi_process_p (rs
))
11708 if (ptid
.lwp () == 0)
11709 return normal_pid_to_str (ptid
);
11711 return string_printf ("Thread %d.%ld",
11712 ptid
.pid (), ptid
.lwp ());
11714 return string_printf ("Thread %ld", ptid
.lwp ());
11718 /* Get the address of the thread local variable in OBJFILE which is
11719 stored at OFFSET within the thread local storage for thread PTID. */
11722 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11725 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11727 struct remote_state
*rs
= get_remote_state ();
11728 char *p
= rs
->buf
.data ();
11729 char *endp
= p
+ get_remote_packet_size ();
11730 enum packet_result result
;
11732 strcpy (p
, "qGetTLSAddr:");
11734 p
= write_ptid (p
, endp
, ptid
);
11736 p
+= hexnumstr (p
, offset
);
11738 p
+= hexnumstr (p
, lm
);
11742 getpkt (&rs
->buf
, 0);
11743 result
= packet_ok (rs
->buf
,
11744 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11745 if (result
== PACKET_OK
)
11749 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11752 else if (result
== PACKET_UNKNOWN
)
11753 throw_error (TLS_GENERIC_ERROR
,
11754 _("Remote target doesn't support qGetTLSAddr packet"));
11756 throw_error (TLS_GENERIC_ERROR
,
11757 _("Remote target failed to process qGetTLSAddr request"));
11760 throw_error (TLS_GENERIC_ERROR
,
11761 _("TLS not supported or disabled on this target"));
11766 /* Provide thread local base, i.e. Thread Information Block address.
11767 Returns 1 if ptid is found and thread_local_base is non zero. */
11770 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11772 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11774 struct remote_state
*rs
= get_remote_state ();
11775 char *p
= rs
->buf
.data ();
11776 char *endp
= p
+ get_remote_packet_size ();
11777 enum packet_result result
;
11779 strcpy (p
, "qGetTIBAddr:");
11781 p
= write_ptid (p
, endp
, ptid
);
11785 getpkt (&rs
->buf
, 0);
11786 result
= packet_ok (rs
->buf
,
11787 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11788 if (result
== PACKET_OK
)
11791 unpack_varlen_hex (rs
->buf
.data (), &val
);
11793 *addr
= (CORE_ADDR
) val
;
11796 else if (result
== PACKET_UNKNOWN
)
11797 error (_("Remote target doesn't support qGetTIBAddr packet"));
11799 error (_("Remote target failed to process qGetTIBAddr request"));
11802 error (_("qGetTIBAddr not supported or disabled on this target"));
11807 /* Support for inferring a target description based on the current
11808 architecture and the size of a 'g' packet. While the 'g' packet
11809 can have any size (since optional registers can be left off the
11810 end), some sizes are easily recognizable given knowledge of the
11811 approximate architecture. */
11813 struct remote_g_packet_guess
11815 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11822 const struct target_desc
*tdesc
;
11825 struct remote_g_packet_data
: public allocate_on_obstack
11827 std::vector
<remote_g_packet_guess
> guesses
;
11830 static struct gdbarch_data
*remote_g_packet_data_handle
;
11833 remote_g_packet_data_init (struct obstack
*obstack
)
11835 return new (obstack
) remote_g_packet_data
;
11839 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11840 const struct target_desc
*tdesc
)
11842 struct remote_g_packet_data
*data
11843 = ((struct remote_g_packet_data
*)
11844 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11846 gdb_assert (tdesc
!= NULL
);
11848 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11849 if (guess
.bytes
== bytes
)
11850 internal_error (__FILE__
, __LINE__
,
11851 _("Duplicate g packet description added for size %d"),
11854 data
->guesses
.emplace_back (bytes
, tdesc
);
11857 /* Return true if remote_read_description would do anything on this target
11858 and architecture, false otherwise. */
11861 remote_read_description_p (struct target_ops
*target
)
11863 struct remote_g_packet_data
*data
11864 = ((struct remote_g_packet_data
*)
11865 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11867 return !data
->guesses
.empty ();
11870 const struct target_desc
*
11871 remote_target::read_description ()
11873 struct remote_g_packet_data
*data
11874 = ((struct remote_g_packet_data
*)
11875 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11877 /* Do not try this during initial connection, when we do not know
11878 whether there is a running but stopped thread. */
11879 if (!target_has_execution () || inferior_ptid
== null_ptid
)
11880 return beneath ()->read_description ();
11882 if (!data
->guesses
.empty ())
11884 int bytes
= send_g_packet ();
11886 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11887 if (guess
.bytes
== bytes
)
11888 return guess
.tdesc
;
11890 /* We discard the g packet. A minor optimization would be to
11891 hold on to it, and fill the register cache once we have selected
11892 an architecture, but it's too tricky to do safely. */
11895 return beneath ()->read_description ();
11898 /* Remote file transfer support. This is host-initiated I/O, not
11899 target-initiated; for target-initiated, see remote-fileio.c. */
11901 /* If *LEFT is at least the length of STRING, copy STRING to
11902 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11903 decrease *LEFT. Otherwise raise an error. */
11906 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11908 int len
= strlen (string
);
11911 error (_("Packet too long for target."));
11913 memcpy (*buffer
, string
, len
);
11917 /* NUL-terminate the buffer as a convenience, if there is
11923 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11924 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11925 decrease *LEFT. Otherwise raise an error. */
11928 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11931 if (2 * len
> *left
)
11932 error (_("Packet too long for target."));
11934 bin2hex (bytes
, *buffer
, len
);
11935 *buffer
+= 2 * len
;
11938 /* NUL-terminate the buffer as a convenience, if there is
11944 /* If *LEFT is large enough, convert VALUE to hex and add it to
11945 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11946 decrease *LEFT. Otherwise raise an error. */
11949 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11951 int len
= hexnumlen (value
);
11954 error (_("Packet too long for target."));
11956 hexnumstr (*buffer
, value
);
11960 /* NUL-terminate the buffer as a convenience, if there is
11966 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11967 value, *REMOTE_ERRNO to the remote error number or zero if none
11968 was included, and *ATTACHMENT to point to the start of the annex
11969 if any. The length of the packet isn't needed here; there may
11970 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11972 Return 0 if the packet could be parsed, -1 if it could not. If
11973 -1 is returned, the other variables may not be initialized. */
11976 remote_hostio_parse_result (char *buffer
, int *retcode
,
11977 int *remote_errno
, char **attachment
)
11982 *attachment
= NULL
;
11984 if (buffer
[0] != 'F')
11988 *retcode
= strtol (&buffer
[1], &p
, 16);
11989 if (errno
!= 0 || p
== &buffer
[1])
11992 /* Check for ",errno". */
11996 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11997 if (errno
!= 0 || p
+ 1 == p2
)
12002 /* Check for ";attachment". If there is no attachment, the
12003 packet should end here. */
12006 *attachment
= p
+ 1;
12009 else if (*p
== '\0')
12015 /* Send a prepared I/O packet to the target and read its response.
12016 The prepared packet is in the global RS->BUF before this function
12017 is called, and the answer is there when we return.
12019 COMMAND_BYTES is the length of the request to send, which may include
12020 binary data. WHICH_PACKET is the packet configuration to check
12021 before attempting a packet. If an error occurs, *REMOTE_ERRNO
12022 is set to the error number and -1 is returned. Otherwise the value
12023 returned by the function is returned.
12025 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
12026 attachment is expected; an error will be reported if there's a
12027 mismatch. If one is found, *ATTACHMENT will be set to point into
12028 the packet buffer and *ATTACHMENT_LEN will be set to the
12029 attachment's length. */
12032 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
12033 int *remote_errno
, char **attachment
,
12034 int *attachment_len
)
12036 struct remote_state
*rs
= get_remote_state ();
12037 int ret
, bytes_read
;
12038 char *attachment_tmp
;
12040 if (packet_support (which_packet
) == PACKET_DISABLE
)
12042 *remote_errno
= FILEIO_ENOSYS
;
12046 putpkt_binary (rs
->buf
.data (), command_bytes
);
12047 bytes_read
= getpkt_sane (&rs
->buf
, 0);
12049 /* If it timed out, something is wrong. Don't try to parse the
12051 if (bytes_read
< 0)
12053 *remote_errno
= FILEIO_EINVAL
;
12057 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
12060 *remote_errno
= FILEIO_EINVAL
;
12062 case PACKET_UNKNOWN
:
12063 *remote_errno
= FILEIO_ENOSYS
;
12069 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
12072 *remote_errno
= FILEIO_EINVAL
;
12076 /* Make sure we saw an attachment if and only if we expected one. */
12077 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
12078 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
12080 *remote_errno
= FILEIO_EINVAL
;
12084 /* If an attachment was found, it must point into the packet buffer;
12085 work out how many bytes there were. */
12086 if (attachment_tmp
!= NULL
)
12088 *attachment
= attachment_tmp
;
12089 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
12095 /* See declaration.h. */
12098 readahead_cache::invalidate ()
12103 /* See declaration.h. */
12106 readahead_cache::invalidate_fd (int fd
)
12108 if (this->fd
== fd
)
12112 /* Set the filesystem remote_hostio functions that take FILENAME
12113 arguments will use. Return 0 on success, or -1 if an error
12114 occurs (and set *REMOTE_ERRNO). */
12117 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
12120 struct remote_state
*rs
= get_remote_state ();
12121 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
12122 char *p
= rs
->buf
.data ();
12123 int left
= get_remote_packet_size () - 1;
12127 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
12130 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
12133 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
12135 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
12136 remote_buffer_add_string (&p
, &left
, arg
);
12138 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
12139 remote_errno
, NULL
, NULL
);
12141 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
12145 rs
->fs_pid
= required_pid
;
12150 /* Implementation of to_fileio_open. */
12153 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
12154 int flags
, int mode
, int warn_if_slow
,
12157 struct remote_state
*rs
= get_remote_state ();
12158 char *p
= rs
->buf
.data ();
12159 int left
= get_remote_packet_size () - 1;
12163 static int warning_issued
= 0;
12165 printf_unfiltered (_("Reading %s from remote target...\n"),
12168 if (!warning_issued
)
12170 warning (_("File transfers from remote targets can be slow."
12171 " Use \"set sysroot\" to access files locally"
12173 warning_issued
= 1;
12177 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12180 remote_buffer_add_string (&p
, &left
, "vFile:open:");
12182 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12183 strlen (filename
));
12184 remote_buffer_add_string (&p
, &left
, ",");
12186 remote_buffer_add_int (&p
, &left
, flags
);
12187 remote_buffer_add_string (&p
, &left
, ",");
12189 remote_buffer_add_int (&p
, &left
, mode
);
12191 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
12192 remote_errno
, NULL
, NULL
);
12196 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
12197 int flags
, int mode
, int warn_if_slow
,
12200 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
12204 /* Implementation of to_fileio_pwrite. */
12207 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12208 ULONGEST offset
, int *remote_errno
)
12210 struct remote_state
*rs
= get_remote_state ();
12211 char *p
= rs
->buf
.data ();
12212 int left
= get_remote_packet_size ();
12215 rs
->readahead_cache
.invalidate_fd (fd
);
12217 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
12219 remote_buffer_add_int (&p
, &left
, fd
);
12220 remote_buffer_add_string (&p
, &left
, ",");
12222 remote_buffer_add_int (&p
, &left
, offset
);
12223 remote_buffer_add_string (&p
, &left
, ",");
12225 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
12226 (get_remote_packet_size ()
12227 - (p
- rs
->buf
.data ())));
12229 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
12230 remote_errno
, NULL
, NULL
);
12234 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12235 ULONGEST offset
, int *remote_errno
)
12237 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
12240 /* Helper for the implementation of to_fileio_pread. Read the file
12241 from the remote side with vFile:pread. */
12244 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
12245 ULONGEST offset
, int *remote_errno
)
12247 struct remote_state
*rs
= get_remote_state ();
12248 char *p
= rs
->buf
.data ();
12250 int left
= get_remote_packet_size ();
12251 int ret
, attachment_len
;
12254 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
12256 remote_buffer_add_int (&p
, &left
, fd
);
12257 remote_buffer_add_string (&p
, &left
, ",");
12259 remote_buffer_add_int (&p
, &left
, len
);
12260 remote_buffer_add_string (&p
, &left
, ",");
12262 remote_buffer_add_int (&p
, &left
, offset
);
12264 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
12265 remote_errno
, &attachment
,
12271 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12273 if (read_len
!= ret
)
12274 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
12279 /* See declaration.h. */
12282 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12286 && this->offset
<= offset
12287 && offset
< this->offset
+ this->bufsize
)
12289 ULONGEST max
= this->offset
+ this->bufsize
;
12291 if (offset
+ len
> max
)
12292 len
= max
- offset
;
12294 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12301 /* Implementation of to_fileio_pread. */
12304 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12305 ULONGEST offset
, int *remote_errno
)
12308 struct remote_state
*rs
= get_remote_state ();
12309 readahead_cache
*cache
= &rs
->readahead_cache
;
12311 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12314 cache
->hit_count
++;
12317 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12318 pulongest (cache
->hit_count
));
12322 cache
->miss_count
++;
12324 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12325 pulongest (cache
->miss_count
));
12328 cache
->offset
= offset
;
12329 cache
->bufsize
= get_remote_packet_size ();
12330 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12332 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12333 cache
->offset
, remote_errno
);
12336 cache
->invalidate_fd (fd
);
12340 cache
->bufsize
= ret
;
12341 return cache
->pread (fd
, read_buf
, len
, offset
);
12345 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12346 ULONGEST offset
, int *remote_errno
)
12348 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12351 /* Implementation of to_fileio_close. */
12354 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12356 struct remote_state
*rs
= get_remote_state ();
12357 char *p
= rs
->buf
.data ();
12358 int left
= get_remote_packet_size () - 1;
12360 rs
->readahead_cache
.invalidate_fd (fd
);
12362 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12364 remote_buffer_add_int (&p
, &left
, fd
);
12366 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12367 remote_errno
, NULL
, NULL
);
12371 remote_target::fileio_close (int fd
, int *remote_errno
)
12373 return remote_hostio_close (fd
, remote_errno
);
12376 /* Implementation of to_fileio_unlink. */
12379 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12382 struct remote_state
*rs
= get_remote_state ();
12383 char *p
= rs
->buf
.data ();
12384 int left
= get_remote_packet_size () - 1;
12386 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12389 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12391 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12392 strlen (filename
));
12394 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12395 remote_errno
, NULL
, NULL
);
12399 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12402 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12405 /* Implementation of to_fileio_readlink. */
12407 gdb::optional
<std::string
>
12408 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12411 struct remote_state
*rs
= get_remote_state ();
12412 char *p
= rs
->buf
.data ();
12414 int left
= get_remote_packet_size ();
12415 int len
, attachment_len
;
12418 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12421 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12423 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12424 strlen (filename
));
12426 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12427 remote_errno
, &attachment
,
12433 std::string
ret (len
, '\0');
12435 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12436 (gdb_byte
*) &ret
[0], len
);
12437 if (read_len
!= len
)
12438 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12443 /* Implementation of to_fileio_fstat. */
12446 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12448 struct remote_state
*rs
= get_remote_state ();
12449 char *p
= rs
->buf
.data ();
12450 int left
= get_remote_packet_size ();
12451 int attachment_len
, ret
;
12453 struct fio_stat fst
;
12456 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12458 remote_buffer_add_int (&p
, &left
, fd
);
12460 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12461 remote_errno
, &attachment
,
12465 if (*remote_errno
!= FILEIO_ENOSYS
)
12468 /* Strictly we should return -1, ENOSYS here, but when
12469 "set sysroot remote:" was implemented in August 2008
12470 BFD's need for a stat function was sidestepped with
12471 this hack. This was not remedied until March 2015
12472 so we retain the previous behavior to avoid breaking
12475 Note that the memset is a March 2015 addition; older
12476 GDBs set st_size *and nothing else* so the structure
12477 would have garbage in all other fields. This might
12478 break something but retaining the previous behavior
12479 here would be just too wrong. */
12481 memset (st
, 0, sizeof (struct stat
));
12482 st
->st_size
= INT_MAX
;
12486 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12487 (gdb_byte
*) &fst
, sizeof (fst
));
12489 if (read_len
!= ret
)
12490 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12492 if (read_len
!= sizeof (fst
))
12493 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12494 read_len
, (int) sizeof (fst
));
12496 remote_fileio_to_host_stat (&fst
, st
);
12501 /* Implementation of to_filesystem_is_local. */
12504 remote_target::filesystem_is_local ()
12506 /* Valgrind GDB presents itself as a remote target but works
12507 on the local filesystem: it does not implement remote get
12508 and users are not expected to set a sysroot. To handle
12509 this case we treat the remote filesystem as local if the
12510 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12511 does not support vFile:open. */
12512 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12514 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12516 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12518 int fd
, remote_errno
;
12520 /* Try opening a file to probe support. The supplied
12521 filename is irrelevant, we only care about whether
12522 the stub recognizes the packet or not. */
12523 fd
= remote_hostio_open (NULL
, "just probing",
12524 FILEIO_O_RDONLY
, 0700, 0,
12528 remote_hostio_close (fd
, &remote_errno
);
12530 ps
= packet_support (PACKET_vFile_open
);
12533 if (ps
== PACKET_DISABLE
)
12535 static int warning_issued
= 0;
12537 if (!warning_issued
)
12539 warning (_("remote target does not support file"
12540 " transfer, attempting to access files"
12541 " from local filesystem."));
12542 warning_issued
= 1;
12553 remote_fileio_errno_to_host (int errnum
)
12559 case FILEIO_ENOENT
:
12567 case FILEIO_EACCES
:
12569 case FILEIO_EFAULT
:
12573 case FILEIO_EEXIST
:
12575 case FILEIO_ENODEV
:
12577 case FILEIO_ENOTDIR
:
12579 case FILEIO_EISDIR
:
12581 case FILEIO_EINVAL
:
12583 case FILEIO_ENFILE
:
12585 case FILEIO_EMFILE
:
12589 case FILEIO_ENOSPC
:
12591 case FILEIO_ESPIPE
:
12595 case FILEIO_ENOSYS
:
12597 case FILEIO_ENAMETOOLONG
:
12598 return ENAMETOOLONG
;
12604 remote_hostio_error (int errnum
)
12606 int host_error
= remote_fileio_errno_to_host (errnum
);
12608 if (host_error
== -1)
12609 error (_("Unknown remote I/O error %d"), errnum
);
12611 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12614 /* A RAII wrapper around a remote file descriptor. */
12616 class scoped_remote_fd
12619 scoped_remote_fd (remote_target
*remote
, int fd
)
12620 : m_remote (remote
), m_fd (fd
)
12624 ~scoped_remote_fd ()
12631 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12635 /* Swallow exception before it escapes the dtor. If
12636 something goes wrong, likely the connection is gone,
12637 and there's nothing else that can be done. */
12642 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12644 /* Release ownership of the file descriptor, and return it. */
12645 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12652 /* Return the owned file descriptor. */
12653 int get () const noexcept
12659 /* The remote target. */
12660 remote_target
*m_remote
;
12662 /* The owned remote I/O file descriptor. */
12667 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12669 remote_target
*remote
= get_current_remote_target ();
12671 if (remote
== nullptr)
12672 error (_("command can only be used with remote target"));
12674 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12678 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12681 int retcode
, remote_errno
, bytes
, io_size
;
12682 int bytes_in_buffer
;
12686 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12688 perror_with_name (local_file
);
12690 scoped_remote_fd fd
12691 (this, remote_hostio_open (NULL
,
12692 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12694 0700, 0, &remote_errno
));
12695 if (fd
.get () == -1)
12696 remote_hostio_error (remote_errno
);
12698 /* Send up to this many bytes at once. They won't all fit in the
12699 remote packet limit, so we'll transfer slightly fewer. */
12700 io_size
= get_remote_packet_size ();
12701 gdb::byte_vector
buffer (io_size
);
12703 bytes_in_buffer
= 0;
12706 while (bytes_in_buffer
|| !saw_eof
)
12710 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12711 io_size
- bytes_in_buffer
,
12715 if (ferror (file
.get ()))
12716 error (_("Error reading %s."), local_file
);
12719 /* EOF. Unless there is something still in the
12720 buffer from the last iteration, we are done. */
12722 if (bytes_in_buffer
== 0)
12730 bytes
+= bytes_in_buffer
;
12731 bytes_in_buffer
= 0;
12733 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12734 offset
, &remote_errno
);
12737 remote_hostio_error (remote_errno
);
12738 else if (retcode
== 0)
12739 error (_("Remote write of %d bytes returned 0!"), bytes
);
12740 else if (retcode
< bytes
)
12742 /* Short write. Save the rest of the read data for the next
12744 bytes_in_buffer
= bytes
- retcode
;
12745 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12751 if (remote_hostio_close (fd
.release (), &remote_errno
))
12752 remote_hostio_error (remote_errno
);
12755 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12759 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12761 remote_target
*remote
= get_current_remote_target ();
12763 if (remote
== nullptr)
12764 error (_("command can only be used with remote target"));
12766 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12770 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12773 int remote_errno
, bytes
, io_size
;
12776 scoped_remote_fd fd
12777 (this, remote_hostio_open (NULL
,
12778 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12780 if (fd
.get () == -1)
12781 remote_hostio_error (remote_errno
);
12783 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12785 perror_with_name (local_file
);
12787 /* Send up to this many bytes at once. They won't all fit in the
12788 remote packet limit, so we'll transfer slightly fewer. */
12789 io_size
= get_remote_packet_size ();
12790 gdb::byte_vector
buffer (io_size
);
12795 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12798 /* Success, but no bytes, means end-of-file. */
12801 remote_hostio_error (remote_errno
);
12805 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12807 perror_with_name (local_file
);
12810 if (remote_hostio_close (fd
.release (), &remote_errno
))
12811 remote_hostio_error (remote_errno
);
12814 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12818 remote_file_delete (const char *remote_file
, int from_tty
)
12820 remote_target
*remote
= get_current_remote_target ();
12822 if (remote
== nullptr)
12823 error (_("command can only be used with remote target"));
12825 remote
->remote_file_delete (remote_file
, from_tty
);
12829 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12831 int retcode
, remote_errno
;
12833 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12835 remote_hostio_error (remote_errno
);
12838 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12842 remote_put_command (const char *args
, int from_tty
)
12845 error_no_arg (_("file to put"));
12847 gdb_argv
argv (args
);
12848 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12849 error (_("Invalid parameters to remote put"));
12851 remote_file_put (argv
[0], argv
[1], from_tty
);
12855 remote_get_command (const char *args
, int from_tty
)
12858 error_no_arg (_("file to get"));
12860 gdb_argv
argv (args
);
12861 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12862 error (_("Invalid parameters to remote get"));
12864 remote_file_get (argv
[0], argv
[1], from_tty
);
12868 remote_delete_command (const char *args
, int from_tty
)
12871 error_no_arg (_("file to delete"));
12873 gdb_argv
argv (args
);
12874 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12875 error (_("Invalid parameters to remote delete"));
12877 remote_file_delete (argv
[0], from_tty
);
12881 remote_target::can_execute_reverse ()
12883 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12884 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12891 remote_target::supports_non_stop ()
12897 remote_target::supports_disable_randomization ()
12899 /* Only supported in extended mode. */
12904 remote_target::supports_multi_process ()
12906 struct remote_state
*rs
= get_remote_state ();
12908 return remote_multi_process_p (rs
);
12912 remote_supports_cond_tracepoints ()
12914 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12918 remote_target::supports_evaluation_of_breakpoint_conditions ()
12920 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12924 remote_supports_fast_tracepoints ()
12926 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12930 remote_supports_static_tracepoints ()
12932 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12936 remote_supports_install_in_trace ()
12938 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12942 remote_target::supports_enable_disable_tracepoint ()
12944 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12949 remote_target::supports_string_tracing ()
12951 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12955 remote_target::can_run_breakpoint_commands ()
12957 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12961 remote_target::trace_init ()
12963 struct remote_state
*rs
= get_remote_state ();
12966 remote_get_noisy_reply ();
12967 if (strcmp (rs
->buf
.data (), "OK") != 0)
12968 error (_("Target does not support this command."));
12971 /* Recursive routine to walk through command list including loops, and
12972 download packets for each command. */
12975 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12976 struct command_line
*cmds
)
12978 struct remote_state
*rs
= get_remote_state ();
12979 struct command_line
*cmd
;
12981 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12983 QUIT
; /* Allow user to bail out with ^C. */
12984 strcpy (rs
->buf
.data (), "QTDPsrc:");
12985 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12986 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12987 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12989 remote_get_noisy_reply ();
12990 if (strcmp (rs
->buf
.data (), "OK"))
12991 warning (_("Target does not support source download."));
12993 if (cmd
->control_type
== while_control
12994 || cmd
->control_type
== while_stepping_control
)
12996 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12998 QUIT
; /* Allow user to bail out with ^C. */
12999 strcpy (rs
->buf
.data (), "QTDPsrc:");
13000 encode_source_string (num
, addr
, "cmd", "end",
13001 rs
->buf
.data () + strlen (rs
->buf
.data ()),
13002 rs
->buf
.size () - strlen (rs
->buf
.data ()));
13004 remote_get_noisy_reply ();
13005 if (strcmp (rs
->buf
.data (), "OK"))
13006 warning (_("Target does not support source download."));
13012 remote_target::download_tracepoint (struct bp_location
*loc
)
13016 std::vector
<std::string
> tdp_actions
;
13017 std::vector
<std::string
> stepping_actions
;
13019 struct breakpoint
*b
= loc
->owner
;
13020 struct tracepoint
*t
= (struct tracepoint
*) b
;
13021 struct remote_state
*rs
= get_remote_state ();
13023 const char *err_msg
= _("Tracepoint packet too large for target.");
13026 /* We use a buffer other than rs->buf because we'll build strings
13027 across multiple statements, and other statements in between could
13029 gdb::char_vector
buf (get_remote_packet_size ());
13031 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
13033 tpaddr
= loc
->address
;
13034 strcpy (addrbuf
, phex (tpaddr
, sizeof (CORE_ADDR
)));
13035 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
13036 b
->number
, addrbuf
, /* address */
13037 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
13038 t
->step_count
, t
->pass_count
);
13040 if (ret
< 0 || ret
>= buf
.size ())
13041 error ("%s", err_msg
);
13043 /* Fast tracepoints are mostly handled by the target, but we can
13044 tell the target how big of an instruction block should be moved
13046 if (b
->type
== bp_fast_tracepoint
)
13048 /* Only test for support at download time; we may not know
13049 target capabilities at definition time. */
13050 if (remote_supports_fast_tracepoints ())
13052 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
13055 size_left
= buf
.size () - strlen (buf
.data ());
13056 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13058 gdb_insn_length (loc
->gdbarch
, tpaddr
));
13060 if (ret
< 0 || ret
>= size_left
)
13061 error ("%s", err_msg
);
13064 /* If it passed validation at definition but fails now,
13065 something is very wrong. */
13066 internal_error (__FILE__
, __LINE__
,
13067 _("Fast tracepoint not "
13068 "valid during download"));
13071 /* Fast tracepoints are functionally identical to regular
13072 tracepoints, so don't take lack of support as a reason to
13073 give up on the trace run. */
13074 warning (_("Target does not support fast tracepoints, "
13075 "downloading %d as regular tracepoint"), b
->number
);
13077 else if (b
->type
== bp_static_tracepoint
)
13079 /* Only test for support at download time; we may not know
13080 target capabilities at definition time. */
13081 if (remote_supports_static_tracepoints ())
13083 struct static_tracepoint_marker marker
;
13085 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
13087 size_left
= buf
.size () - strlen (buf
.data ());
13088 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13091 if (ret
< 0 || ret
>= size_left
)
13092 error ("%s", err_msg
);
13095 error (_("Static tracepoint not valid during download"));
13098 /* Fast tracepoints are functionally identical to regular
13099 tracepoints, so don't take lack of support as a reason
13100 to give up on the trace run. */
13101 error (_("Target does not support static tracepoints"));
13103 /* If the tracepoint has a conditional, make it into an agent
13104 expression and append to the definition. */
13107 /* Only test support at download time, we may not know target
13108 capabilities at definition time. */
13109 if (remote_supports_cond_tracepoints ())
13111 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
13114 size_left
= buf
.size () - strlen (buf
.data ());
13116 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13117 size_left
, ":X%x,", aexpr
->len
);
13119 if (ret
< 0 || ret
>= size_left
)
13120 error ("%s", err_msg
);
13122 size_left
= buf
.size () - strlen (buf
.data ());
13124 /* Two bytes to encode each aexpr byte, plus the terminating
13126 if (aexpr
->len
* 2 + 1 > size_left
)
13127 error ("%s", err_msg
);
13129 pkt
= buf
.data () + strlen (buf
.data ());
13131 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
13132 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
13136 warning (_("Target does not support conditional tracepoints, "
13137 "ignoring tp %d cond"), b
->number
);
13140 if (b
->commands
|| *default_collect
)
13142 size_left
= buf
.size () - strlen (buf
.data ());
13144 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
13147 if (ret
< 0 || ret
>= size_left
)
13148 error ("%s", err_msg
);
13151 putpkt (buf
.data ());
13152 remote_get_noisy_reply ();
13153 if (strcmp (rs
->buf
.data (), "OK"))
13154 error (_("Target does not support tracepoints."));
13156 /* do_single_steps (t); */
13157 for (auto action_it
= tdp_actions
.begin ();
13158 action_it
!= tdp_actions
.end (); action_it
++)
13160 QUIT
; /* Allow user to bail out with ^C. */
13162 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
13163 || !stepping_actions
.empty ());
13165 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
13166 b
->number
, addrbuf
, /* address */
13167 action_it
->c_str (),
13168 has_more
? '-' : 0);
13170 if (ret
< 0 || ret
>= buf
.size ())
13171 error ("%s", err_msg
);
13173 putpkt (buf
.data ());
13174 remote_get_noisy_reply ();
13175 if (strcmp (rs
->buf
.data (), "OK"))
13176 error (_("Error on target while setting tracepoints."));
13179 for (auto action_it
= stepping_actions
.begin ();
13180 action_it
!= stepping_actions
.end (); action_it
++)
13182 QUIT
; /* Allow user to bail out with ^C. */
13184 bool is_first
= action_it
== stepping_actions
.begin ();
13185 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
13187 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
13188 b
->number
, addrbuf
, /* address */
13189 is_first
? "S" : "",
13190 action_it
->c_str (),
13191 has_more
? "-" : "");
13193 if (ret
< 0 || ret
>= buf
.size ())
13194 error ("%s", err_msg
);
13196 putpkt (buf
.data ());
13197 remote_get_noisy_reply ();
13198 if (strcmp (rs
->buf
.data (), "OK"))
13199 error (_("Error on target while setting tracepoints."));
13202 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
13204 if (b
->location
!= NULL
)
13206 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13208 if (ret
< 0 || ret
>= buf
.size ())
13209 error ("%s", err_msg
);
13211 encode_source_string (b
->number
, loc
->address
, "at",
13212 event_location_to_string (b
->location
.get ()),
13213 buf
.data () + strlen (buf
.data ()),
13214 buf
.size () - strlen (buf
.data ()));
13215 putpkt (buf
.data ());
13216 remote_get_noisy_reply ();
13217 if (strcmp (rs
->buf
.data (), "OK"))
13218 warning (_("Target does not support source download."));
13220 if (b
->cond_string
)
13222 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13224 if (ret
< 0 || ret
>= buf
.size ())
13225 error ("%s", err_msg
);
13227 encode_source_string (b
->number
, loc
->address
,
13228 "cond", b
->cond_string
,
13229 buf
.data () + strlen (buf
.data ()),
13230 buf
.size () - strlen (buf
.data ()));
13231 putpkt (buf
.data ());
13232 remote_get_noisy_reply ();
13233 if (strcmp (rs
->buf
.data (), "OK"))
13234 warning (_("Target does not support source download."));
13236 remote_download_command_source (b
->number
, loc
->address
,
13237 breakpoint_commands (b
));
13242 remote_target::can_download_tracepoint ()
13244 struct remote_state
*rs
= get_remote_state ();
13245 struct trace_status
*ts
;
13248 /* Don't try to install tracepoints until we've relocated our
13249 symbols, and fetched and merged the target's tracepoint list with
13251 if (rs
->starting_up
)
13254 ts
= current_trace_status ();
13255 status
= get_trace_status (ts
);
13257 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
13260 /* If we are in a tracing experiment, but remote stub doesn't support
13261 installing tracepoint in trace, we have to return. */
13262 if (!remote_supports_install_in_trace ())
13270 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
13272 struct remote_state
*rs
= get_remote_state ();
13275 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13276 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13278 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13279 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13280 >= get_remote_packet_size ())
13281 error (_("Trace state variable name too long for tsv definition packet"));
13282 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13285 remote_get_noisy_reply ();
13286 if (rs
->buf
[0] == '\0')
13287 error (_("Target does not support this command."));
13288 if (strcmp (rs
->buf
.data (), "OK") != 0)
13289 error (_("Error on target while downloading trace state variable."));
13293 remote_target::enable_tracepoint (struct bp_location
*location
)
13295 struct remote_state
*rs
= get_remote_state ();
13297 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13298 location
->owner
->number
,
13299 phex (location
->address
, sizeof (CORE_ADDR
)));
13301 remote_get_noisy_reply ();
13302 if (rs
->buf
[0] == '\0')
13303 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13304 if (strcmp (rs
->buf
.data (), "OK") != 0)
13305 error (_("Error on target while enabling tracepoint."));
13309 remote_target::disable_tracepoint (struct bp_location
*location
)
13311 struct remote_state
*rs
= get_remote_state ();
13313 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13314 location
->owner
->number
,
13315 phex (location
->address
, sizeof (CORE_ADDR
)));
13317 remote_get_noisy_reply ();
13318 if (rs
->buf
[0] == '\0')
13319 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13320 if (strcmp (rs
->buf
.data (), "OK") != 0)
13321 error (_("Error on target while disabling tracepoint."));
13325 remote_target::trace_set_readonly_regions ()
13328 bfd_size_type size
;
13333 if (!current_program_space
->exec_bfd ())
13334 return; /* No information to give. */
13336 struct remote_state
*rs
= get_remote_state ();
13338 strcpy (rs
->buf
.data (), "QTro");
13339 offset
= strlen (rs
->buf
.data ());
13340 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
13342 char tmp1
[40], tmp2
[40];
13345 if ((s
->flags
& SEC_LOAD
) == 0 ||
13346 /* (s->flags & SEC_CODE) == 0 || */
13347 (s
->flags
& SEC_READONLY
) == 0)
13351 vma
= bfd_section_vma (s
);
13352 size
= bfd_section_size (s
);
13353 sprintf_vma (tmp1
, vma
);
13354 sprintf_vma (tmp2
, vma
+ size
);
13355 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13356 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13358 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13360 Too many sections for read-only sections definition packet."));
13363 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13365 offset
+= sec_length
;
13370 getpkt (&rs
->buf
, 0);
13375 remote_target::trace_start ()
13377 struct remote_state
*rs
= get_remote_state ();
13379 putpkt ("QTStart");
13380 remote_get_noisy_reply ();
13381 if (rs
->buf
[0] == '\0')
13382 error (_("Target does not support this command."));
13383 if (strcmp (rs
->buf
.data (), "OK") != 0)
13384 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13388 remote_target::get_trace_status (struct trace_status
*ts
)
13390 /* Initialize it just to avoid a GCC false warning. */
13392 enum packet_result result
;
13393 struct remote_state
*rs
= get_remote_state ();
13395 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13398 /* FIXME we need to get register block size some other way. */
13399 trace_regblock_size
13400 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13402 putpkt ("qTStatus");
13406 p
= remote_get_noisy_reply ();
13408 catch (const gdb_exception_error
&ex
)
13410 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13412 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13418 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13420 /* If the remote target doesn't do tracing, flag it. */
13421 if (result
== PACKET_UNKNOWN
)
13424 /* We're working with a live target. */
13425 ts
->filename
= NULL
;
13428 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13430 /* Function 'parse_trace_status' sets default value of each field of
13431 'ts' at first, so we don't have to do it here. */
13432 parse_trace_status (p
, ts
);
13434 return ts
->running
;
13438 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13439 struct uploaded_tp
*utp
)
13441 struct remote_state
*rs
= get_remote_state ();
13443 struct bp_location
*loc
;
13444 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13445 size_t size
= get_remote_packet_size ();
13450 tp
->traceframe_usage
= 0;
13451 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13453 /* If the tracepoint was never downloaded, don't go asking for
13455 if (tp
->number_on_target
== 0)
13457 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13458 phex_nz (loc
->address
, 0));
13460 reply
= remote_get_noisy_reply ();
13461 if (reply
&& *reply
)
13464 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13470 utp
->hit_count
= 0;
13471 utp
->traceframe_usage
= 0;
13472 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13473 phex_nz (utp
->addr
, 0));
13475 reply
= remote_get_noisy_reply ();
13476 if (reply
&& *reply
)
13479 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13485 remote_target::trace_stop ()
13487 struct remote_state
*rs
= get_remote_state ();
13490 remote_get_noisy_reply ();
13491 if (rs
->buf
[0] == '\0')
13492 error (_("Target does not support this command."));
13493 if (strcmp (rs
->buf
.data (), "OK") != 0)
13494 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13498 remote_target::trace_find (enum trace_find_type type
, int num
,
13499 CORE_ADDR addr1
, CORE_ADDR addr2
,
13502 struct remote_state
*rs
= get_remote_state ();
13503 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13505 int target_frameno
= -1, target_tracept
= -1;
13507 /* Lookups other than by absolute frame number depend on the current
13508 trace selected, so make sure it is correct on the remote end
13510 if (type
!= tfind_number
)
13511 set_remote_traceframe ();
13513 p
= rs
->buf
.data ();
13514 strcpy (p
, "QTFrame:");
13515 p
= strchr (p
, '\0');
13519 xsnprintf (p
, endbuf
- p
, "%x", num
);
13522 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13525 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13528 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13529 phex_nz (addr2
, 0));
13531 case tfind_outside
:
13532 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13533 phex_nz (addr2
, 0));
13536 error (_("Unknown trace find type %d"), type
);
13540 reply
= remote_get_noisy_reply ();
13541 if (*reply
== '\0')
13542 error (_("Target does not support this command."));
13544 while (reply
&& *reply
)
13549 target_frameno
= (int) strtol (p
, &reply
, 16);
13551 error (_("Unable to parse trace frame number"));
13552 /* Don't update our remote traceframe number cache on failure
13553 to select a remote traceframe. */
13554 if (target_frameno
== -1)
13559 target_tracept
= (int) strtol (p
, &reply
, 16);
13561 error (_("Unable to parse tracepoint number"));
13563 case 'O': /* "OK"? */
13564 if (reply
[1] == 'K' && reply
[2] == '\0')
13567 error (_("Bogus reply from target: %s"), reply
);
13570 error (_("Bogus reply from target: %s"), reply
);
13573 *tpp
= target_tracept
;
13575 rs
->remote_traceframe_number
= target_frameno
;
13576 return target_frameno
;
13580 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13582 struct remote_state
*rs
= get_remote_state ();
13586 set_remote_traceframe ();
13588 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13590 reply
= remote_get_noisy_reply ();
13591 if (reply
&& *reply
)
13595 unpack_varlen_hex (reply
+ 1, &uval
);
13596 *val
= (LONGEST
) uval
;
13604 remote_target::save_trace_data (const char *filename
)
13606 struct remote_state
*rs
= get_remote_state ();
13609 p
= rs
->buf
.data ();
13610 strcpy (p
, "QTSave:");
13612 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13613 >= get_remote_packet_size ())
13614 error (_("Remote file name too long for trace save packet"));
13615 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13618 reply
= remote_get_noisy_reply ();
13619 if (*reply
== '\0')
13620 error (_("Target does not support this command."));
13621 if (strcmp (reply
, "OK") != 0)
13622 error (_("Bogus reply from target: %s"), reply
);
13626 /* This is basically a memory transfer, but needs to be its own packet
13627 because we don't know how the target actually organizes its trace
13628 memory, plus we want to be able to ask for as much as possible, but
13629 not be unhappy if we don't get as much as we ask for. */
13632 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13634 struct remote_state
*rs
= get_remote_state ();
13639 p
= rs
->buf
.data ();
13640 strcpy (p
, "qTBuffer:");
13642 p
+= hexnumstr (p
, offset
);
13644 p
+= hexnumstr (p
, len
);
13648 reply
= remote_get_noisy_reply ();
13649 if (reply
&& *reply
)
13651 /* 'l' by itself means we're at the end of the buffer and
13652 there is nothing more to get. */
13656 /* Convert the reply into binary. Limit the number of bytes to
13657 convert according to our passed-in buffer size, rather than
13658 what was returned in the packet; if the target is
13659 unexpectedly generous and gives us a bigger reply than we
13660 asked for, we don't want to crash. */
13661 rslt
= hex2bin (reply
, buf
, len
);
13665 /* Something went wrong, flag as an error. */
13670 remote_target::set_disconnected_tracing (int val
)
13672 struct remote_state
*rs
= get_remote_state ();
13674 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13678 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13679 "QTDisconnected:%x", val
);
13681 reply
= remote_get_noisy_reply ();
13682 if (*reply
== '\0')
13683 error (_("Target does not support this command."));
13684 if (strcmp (reply
, "OK") != 0)
13685 error (_("Bogus reply from target: %s"), reply
);
13688 warning (_("Target does not support disconnected tracing."));
13692 remote_target::core_of_thread (ptid_t ptid
)
13694 thread_info
*info
= find_thread_ptid (this, ptid
);
13696 if (info
!= NULL
&& info
->priv
!= NULL
)
13697 return get_remote_thread_info (info
)->core
;
13703 remote_target::set_circular_trace_buffer (int val
)
13705 struct remote_state
*rs
= get_remote_state ();
13708 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13709 "QTBuffer:circular:%x", val
);
13711 reply
= remote_get_noisy_reply ();
13712 if (*reply
== '\0')
13713 error (_("Target does not support this command."));
13714 if (strcmp (reply
, "OK") != 0)
13715 error (_("Bogus reply from target: %s"), reply
);
13719 remote_target::traceframe_info ()
13721 gdb::optional
<gdb::char_vector
> text
13722 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13725 return parse_traceframe_info (text
->data ());
13730 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13731 instruction on which a fast tracepoint may be placed. Returns -1
13732 if the packet is not supported, and 0 if the minimum instruction
13733 length is unknown. */
13736 remote_target::get_min_fast_tracepoint_insn_len ()
13738 struct remote_state
*rs
= get_remote_state ();
13741 /* If we're not debugging a process yet, the IPA can't be
13743 if (!target_has_execution ())
13746 /* Make sure the remote is pointing at the right process. */
13747 set_general_process ();
13749 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13751 reply
= remote_get_noisy_reply ();
13752 if (*reply
== '\0')
13756 ULONGEST min_insn_len
;
13758 unpack_varlen_hex (reply
, &min_insn_len
);
13760 return (int) min_insn_len
;
13765 remote_target::set_trace_buffer_size (LONGEST val
)
13767 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13769 struct remote_state
*rs
= get_remote_state ();
13770 char *buf
= rs
->buf
.data ();
13771 char *endbuf
= buf
+ get_remote_packet_size ();
13772 enum packet_result result
;
13774 gdb_assert (val
>= 0 || val
== -1);
13775 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13776 /* Send -1 as literal "-1" to avoid host size dependency. */
13780 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13783 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13786 remote_get_noisy_reply ();
13787 result
= packet_ok (rs
->buf
,
13788 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13790 if (result
!= PACKET_OK
)
13791 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13796 remote_target::set_trace_notes (const char *user
, const char *notes
,
13797 const char *stop_notes
)
13799 struct remote_state
*rs
= get_remote_state ();
13801 char *buf
= rs
->buf
.data ();
13802 char *endbuf
= buf
+ get_remote_packet_size ();
13805 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13808 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13809 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13815 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13816 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13822 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13823 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13827 /* Ensure the buffer is terminated. */
13831 reply
= remote_get_noisy_reply ();
13832 if (*reply
== '\0')
13835 if (strcmp (reply
, "OK") != 0)
13836 error (_("Bogus reply from target: %s"), reply
);
13842 remote_target::use_agent (bool use
)
13844 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13846 struct remote_state
*rs
= get_remote_state ();
13848 /* If the stub supports QAgent. */
13849 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13851 getpkt (&rs
->buf
, 0);
13853 if (strcmp (rs
->buf
.data (), "OK") == 0)
13864 remote_target::can_use_agent ()
13866 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13869 struct btrace_target_info
13871 /* The ptid of the traced thread. */
13874 /* The obtained branch trace configuration. */
13875 struct btrace_config conf
;
13878 /* Reset our idea of our target's btrace configuration. */
13881 remote_btrace_reset (remote_state
*rs
)
13883 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13886 /* Synchronize the configuration with the target. */
13889 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13891 struct packet_config
*packet
;
13892 struct remote_state
*rs
;
13893 char *buf
, *pos
, *endbuf
;
13895 rs
= get_remote_state ();
13896 buf
= rs
->buf
.data ();
13897 endbuf
= buf
+ get_remote_packet_size ();
13899 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13900 if (packet_config_support (packet
) == PACKET_ENABLE
13901 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13904 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13908 getpkt (&rs
->buf
, 0);
13910 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13912 if (buf
[0] == 'E' && buf
[1] == '.')
13913 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13915 error (_("Failed to configure the BTS buffer size."));
13918 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13921 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13922 if (packet_config_support (packet
) == PACKET_ENABLE
13923 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13926 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13930 getpkt (&rs
->buf
, 0);
13932 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13934 if (buf
[0] == 'E' && buf
[1] == '.')
13935 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13937 error (_("Failed to configure the trace buffer size."));
13940 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13944 /* Read the current thread's btrace configuration from the target and
13945 store it into CONF. */
13948 btrace_read_config (struct btrace_config
*conf
)
13950 gdb::optional
<gdb::char_vector
> xml
13951 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13953 parse_xml_btrace_conf (conf
, xml
->data ());
13956 /* Maybe reopen target btrace. */
13959 remote_target::remote_btrace_maybe_reopen ()
13961 struct remote_state
*rs
= get_remote_state ();
13962 int btrace_target_pushed
= 0;
13963 #if !defined (HAVE_LIBIPT)
13967 /* Don't bother walking the entirety of the remote thread list when
13968 we know the feature isn't supported by the remote. */
13969 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13972 scoped_restore_current_thread restore_thread
;
13974 for (thread_info
*tp
: all_non_exited_threads (this))
13976 set_general_thread (tp
->ptid
);
13978 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13979 btrace_read_config (&rs
->btrace_config
);
13981 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13984 #if !defined (HAVE_LIBIPT)
13985 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13990 warning (_("Target is recording using Intel Processor Trace "
13991 "but support was disabled at compile time."));
13996 #endif /* !defined (HAVE_LIBIPT) */
13998 /* Push target, once, but before anything else happens. This way our
13999 changes to the threads will be cleaned up by unpushing the target
14000 in case btrace_read_config () throws. */
14001 if (!btrace_target_pushed
)
14003 btrace_target_pushed
= 1;
14004 record_btrace_push_target ();
14005 printf_filtered (_("Target is recording using %s.\n"),
14006 btrace_format_string (rs
->btrace_config
.format
));
14009 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
14010 tp
->btrace
.target
->ptid
= tp
->ptid
;
14011 tp
->btrace
.target
->conf
= rs
->btrace_config
;
14015 /* Enable branch tracing. */
14017 struct btrace_target_info
*
14018 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
14020 struct btrace_target_info
*tinfo
= NULL
;
14021 struct packet_config
*packet
= NULL
;
14022 struct remote_state
*rs
= get_remote_state ();
14023 char *buf
= rs
->buf
.data ();
14024 char *endbuf
= buf
+ get_remote_packet_size ();
14026 switch (conf
->format
)
14028 case BTRACE_FORMAT_BTS
:
14029 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
14032 case BTRACE_FORMAT_PT
:
14033 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
14037 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
14038 error (_("Target does not support branch tracing."));
14040 btrace_sync_conf (conf
);
14042 set_general_thread (ptid
);
14044 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
14046 getpkt (&rs
->buf
, 0);
14048 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
14050 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
14051 error (_("Could not enable branch tracing for %s: %s"),
14052 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
14054 error (_("Could not enable branch tracing for %s."),
14055 target_pid_to_str (ptid
).c_str ());
14058 tinfo
= XCNEW (struct btrace_target_info
);
14059 tinfo
->ptid
= ptid
;
14061 /* If we fail to read the configuration, we lose some information, but the
14062 tracing itself is not impacted. */
14065 btrace_read_config (&tinfo
->conf
);
14067 catch (const gdb_exception_error
&err
)
14069 if (err
.message
!= NULL
)
14070 warning ("%s", err
.what ());
14076 /* Disable branch tracing. */
14079 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
14081 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
14082 struct remote_state
*rs
= get_remote_state ();
14083 char *buf
= rs
->buf
.data ();
14084 char *endbuf
= buf
+ get_remote_packet_size ();
14086 if (packet_config_support (packet
) != PACKET_ENABLE
)
14087 error (_("Target does not support branch tracing."));
14089 set_general_thread (tinfo
->ptid
);
14091 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
14093 getpkt (&rs
->buf
, 0);
14095 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
14097 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
14098 error (_("Could not disable branch tracing for %s: %s"),
14099 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
14101 error (_("Could not disable branch tracing for %s."),
14102 target_pid_to_str (tinfo
->ptid
).c_str ());
14108 /* Teardown branch tracing. */
14111 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
14113 /* We must not talk to the target during teardown. */
14117 /* Read the branch trace. */
14120 remote_target::read_btrace (struct btrace_data
*btrace
,
14121 struct btrace_target_info
*tinfo
,
14122 enum btrace_read_type type
)
14124 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
14127 if (packet_config_support (packet
) != PACKET_ENABLE
)
14128 error (_("Target does not support branch tracing."));
14130 #if !defined(HAVE_LIBEXPAT)
14131 error (_("Cannot process branch tracing result. XML parsing not supported."));
14136 case BTRACE_READ_ALL
:
14139 case BTRACE_READ_NEW
:
14142 case BTRACE_READ_DELTA
:
14146 internal_error (__FILE__
, __LINE__
,
14147 _("Bad branch tracing read type: %u."),
14148 (unsigned int) type
);
14151 gdb::optional
<gdb::char_vector
> xml
14152 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
14154 return BTRACE_ERR_UNKNOWN
;
14156 parse_xml_btrace (btrace
, xml
->data ());
14158 return BTRACE_ERR_NONE
;
14161 const struct btrace_config
*
14162 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
14164 return &tinfo
->conf
;
14168 remote_target::augmented_libraries_svr4_read ()
14170 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
14174 /* Implementation of to_load. */
14177 remote_target::load (const char *name
, int from_tty
)
14179 generic_load (name
, from_tty
);
14182 /* Accepts an integer PID; returns a string representing a file that
14183 can be opened on the remote side to get the symbols for the child
14184 process. Returns NULL if the operation is not supported. */
14187 remote_target::pid_to_exec_file (int pid
)
14189 static gdb::optional
<gdb::char_vector
> filename
;
14190 char *annex
= NULL
;
14192 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
14195 inferior
*inf
= find_inferior_pid (this, pid
);
14197 internal_error (__FILE__
, __LINE__
,
14198 _("not currently attached to process %d"), pid
);
14200 if (!inf
->fake_pid_p
)
14202 const int annex_size
= 9;
14204 annex
= (char *) alloca (annex_size
);
14205 xsnprintf (annex
, annex_size
, "%x", pid
);
14208 filename
= target_read_stralloc (current_top_target (),
14209 TARGET_OBJECT_EXEC_FILE
, annex
);
14211 return filename
? filename
->data () : nullptr;
14214 /* Implement the to_can_do_single_step target_ops method. */
14217 remote_target::can_do_single_step ()
14219 /* We can only tell whether target supports single step or not by
14220 supported s and S vCont actions if the stub supports vContSupported
14221 feature. If the stub doesn't support vContSupported feature,
14222 we have conservatively to think target doesn't supports single
14224 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
14226 struct remote_state
*rs
= get_remote_state ();
14228 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14229 remote_vcont_probe ();
14231 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
14237 /* Implementation of the to_execution_direction method for the remote
14240 enum exec_direction_kind
14241 remote_target::execution_direction ()
14243 struct remote_state
*rs
= get_remote_state ();
14245 return rs
->last_resume_exec_dir
;
14248 /* Return pointer to the thread_info struct which corresponds to
14249 THREAD_HANDLE (having length HANDLE_LEN). */
14252 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
14256 for (thread_info
*tp
: all_non_exited_threads (this))
14258 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14260 if (tp
->inf
== inf
&& priv
!= NULL
)
14262 if (handle_len
!= priv
->thread_handle
.size ())
14263 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14264 handle_len
, priv
->thread_handle
.size ());
14265 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14275 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
14277 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14278 return priv
->thread_handle
;
14282 remote_target::can_async_p ()
14284 struct remote_state
*rs
= get_remote_state ();
14286 /* We don't go async if the user has explicitly prevented it with the
14287 "maint set target-async" command. */
14288 if (!target_async_permitted
)
14291 /* We're async whenever the serial device is. */
14292 return serial_can_async_p (rs
->remote_desc
);
14296 remote_target::is_async_p ()
14298 struct remote_state
*rs
= get_remote_state ();
14300 if (!target_async_permitted
)
14301 /* We only enable async when the user specifically asks for it. */
14304 /* We're async whenever the serial device is. */
14305 return serial_is_async_p (rs
->remote_desc
);
14308 /* Pass the SERIAL event on and up to the client. One day this code
14309 will be able to delay notifying the client of an event until the
14310 point where an entire packet has been received. */
14312 static serial_event_ftype remote_async_serial_handler
;
14315 remote_async_serial_handler (struct serial
*scb
, void *context
)
14317 /* Don't propogate error information up to the client. Instead let
14318 the client find out about the error by querying the target. */
14319 inferior_event_handler (INF_REG_EVENT
);
14323 remote_async_inferior_event_handler (gdb_client_data data
)
14325 inferior_event_handler (INF_REG_EVENT
);
14327 remote_target
*remote
= (remote_target
*) data
;
14328 remote_state
*rs
= remote
->get_remote_state ();
14330 /* inferior_event_handler may have consumed an event pending on the
14331 infrun side without calling target_wait on the REMOTE target, or
14332 may have pulled an event out of a different target. Keep trying
14333 for this remote target as long it still has either pending events
14334 or unacknowledged notifications. */
14336 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
14337 || !rs
->stop_reply_queue
.empty ())
14338 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14342 remote_target::async_wait_fd ()
14344 struct remote_state
*rs
= get_remote_state ();
14345 return rs
->remote_desc
->fd
;
14349 remote_target::async (int enable
)
14351 struct remote_state
*rs
= get_remote_state ();
14355 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14357 /* If there are pending events in the stop reply queue tell the
14358 event loop to process them. */
14359 if (!rs
->stop_reply_queue
.empty ())
14360 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14361 /* For simplicity, below we clear the pending events token
14362 without remembering whether it is marked, so here we always
14363 mark it. If there's actually no pending notification to
14364 process, this ends up being a no-op (other than a spurious
14365 event-loop wakeup). */
14366 if (target_is_non_stop_p ())
14367 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14371 serial_async (rs
->remote_desc
, NULL
, NULL
);
14372 /* If the core is disabling async, it doesn't want to be
14373 disturbed with target events. Clear all async event sources
14375 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14376 if (target_is_non_stop_p ())
14377 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14381 /* Implementation of the to_thread_events method. */
14384 remote_target::thread_events (int enable
)
14386 struct remote_state
*rs
= get_remote_state ();
14387 size_t size
= get_remote_packet_size ();
14389 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14392 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14394 getpkt (&rs
->buf
, 0);
14396 switch (packet_ok (rs
->buf
,
14397 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14400 if (strcmp (rs
->buf
.data (), "OK") != 0)
14401 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14404 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14406 case PACKET_UNKNOWN
:
14412 show_remote_cmd (const char *args
, int from_tty
)
14414 /* We can't just use cmd_show_list here, because we want to skip
14415 the redundant "show remote Z-packet" and the legacy aliases. */
14416 struct cmd_list_element
*list
= remote_show_cmdlist
;
14417 struct ui_out
*uiout
= current_uiout
;
14419 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14420 for (; list
!= NULL
; list
= list
->next
)
14421 if (strcmp (list
->name
, "Z-packet") == 0)
14423 else if (list
->type
== not_set_cmd
)
14424 /* Alias commands are exactly like the original, except they
14425 don't have the normal type. */
14429 ui_out_emit_tuple
option_emitter (uiout
, "option");
14431 uiout
->field_string ("name", list
->name
);
14432 uiout
->text (": ");
14433 if (list
->type
== show_cmd
)
14434 do_show_command (NULL
, from_tty
, list
);
14436 cmd_func (list
, NULL
, from_tty
);
14441 /* Function to be called whenever a new objfile (shlib) is detected. */
14443 remote_new_objfile (struct objfile
*objfile
)
14445 remote_target
*remote
= get_current_remote_target ();
14447 if (remote
!= NULL
) /* Have a remote connection. */
14448 remote
->remote_check_symbols ();
14451 /* Pull all the tracepoints defined on the target and create local
14452 data structures representing them. We don't want to create real
14453 tracepoints yet, we don't want to mess up the user's existing
14457 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14459 struct remote_state
*rs
= get_remote_state ();
14462 /* Ask for a first packet of tracepoint definition. */
14464 getpkt (&rs
->buf
, 0);
14465 p
= rs
->buf
.data ();
14466 while (*p
&& *p
!= 'l')
14468 parse_tracepoint_definition (p
, utpp
);
14469 /* Ask for another packet of tracepoint definition. */
14471 getpkt (&rs
->buf
, 0);
14472 p
= rs
->buf
.data ();
14478 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14480 struct remote_state
*rs
= get_remote_state ();
14483 /* Ask for a first packet of variable definition. */
14485 getpkt (&rs
->buf
, 0);
14486 p
= rs
->buf
.data ();
14487 while (*p
&& *p
!= 'l')
14489 parse_tsv_definition (p
, utsvp
);
14490 /* Ask for another packet of variable definition. */
14492 getpkt (&rs
->buf
, 0);
14493 p
= rs
->buf
.data ();
14498 /* The "set/show range-stepping" show hook. */
14501 show_range_stepping (struct ui_file
*file
, int from_tty
,
14502 struct cmd_list_element
*c
,
14505 fprintf_filtered (file
,
14506 _("Debugger's willingness to use range stepping "
14507 "is %s.\n"), value
);
14510 /* Return true if the vCont;r action is supported by the remote
14514 remote_target::vcont_r_supported ()
14516 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14517 remote_vcont_probe ();
14519 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14520 && get_remote_state ()->supports_vCont
.r
);
14523 /* The "set/show range-stepping" set hook. */
14526 set_range_stepping (const char *ignore_args
, int from_tty
,
14527 struct cmd_list_element
*c
)
14529 /* When enabling, check whether range stepping is actually supported
14530 by the target, and warn if not. */
14531 if (use_range_stepping
)
14533 remote_target
*remote
= get_current_remote_target ();
14535 || !remote
->vcont_r_supported ())
14536 warning (_("Range stepping is not supported by the current target"));
14540 void _initialize_remote ();
14542 _initialize_remote ()
14544 struct cmd_list_element
*cmd
;
14545 const char *cmd_name
;
14547 /* architecture specific data */
14548 remote_g_packet_data_handle
=
14549 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14551 add_target (remote_target_info
, remote_target::open
);
14552 add_target (extended_remote_target_info
, extended_remote_target::open
);
14554 /* Hook into new objfile notification. */
14555 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14558 init_remote_threadtests ();
14561 /* set/show remote ... */
14563 add_basic_prefix_cmd ("remote", class_maintenance
, _("\
14564 Remote protocol specific variables.\n\
14565 Configure various remote-protocol specific variables such as\n\
14566 the packets being used."),
14567 &remote_set_cmdlist
, "set remote ",
14568 0 /* allow-unknown */, &setlist
);
14569 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14570 Remote protocol specific variables.\n\
14571 Configure various remote-protocol specific variables such as\n\
14572 the packets being used."),
14573 &remote_show_cmdlist
, "show remote ",
14574 0 /* allow-unknown */, &showlist
);
14576 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14577 Compare section data on target to the exec file.\n\
14578 Argument is a single section name (default: all loaded sections).\n\
14579 To compare only read-only loaded sections, specify the -r option."),
14582 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14583 Send an arbitrary packet to a remote target.\n\
14584 maintenance packet TEXT\n\
14585 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14586 this command sends the string TEXT to the inferior, and displays the\n\
14587 response packet. GDB supplies the initial `$' character, and the\n\
14588 terminating `#' character and checksum."),
14591 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14592 Set whether to send break if interrupted."), _("\
14593 Show whether to send break if interrupted."), _("\
14594 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14595 set_remotebreak
, show_remotebreak
,
14596 &setlist
, &showlist
);
14597 cmd_name
= "remotebreak";
14598 cmd
= lookup_cmd (&cmd_name
, setlist
, "", NULL
, -1, 1);
14599 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14600 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14601 cmd
= lookup_cmd (&cmd_name
, showlist
, "", NULL
, -1, 1);
14602 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14604 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14605 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14607 Set interrupt sequence to remote target."), _("\
14608 Show interrupt sequence to remote target."), _("\
14609 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14610 NULL
, show_interrupt_sequence
,
14611 &remote_set_cmdlist
,
14612 &remote_show_cmdlist
);
14614 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14615 &interrupt_on_connect
, _("\
14616 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14617 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14618 If set, interrupt sequence is sent to remote target."),
14620 &remote_set_cmdlist
, &remote_show_cmdlist
);
14622 /* Install commands for configuring memory read/write packets. */
14624 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14625 Set the maximum number of bytes per memory write packet (deprecated)."),
14627 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14628 Show the maximum number of bytes per memory write packet (deprecated)."),
14630 add_cmd ("memory-write-packet-size", no_class
,
14631 set_memory_write_packet_size
, _("\
14632 Set the maximum number of bytes per memory-write packet.\n\
14633 Specify the number of bytes in a packet or 0 (zero) for the\n\
14634 default packet size. The actual limit is further reduced\n\
14635 dependent on the target. Specify ``fixed'' to disable the\n\
14636 further restriction and ``limit'' to enable that restriction."),
14637 &remote_set_cmdlist
);
14638 add_cmd ("memory-read-packet-size", no_class
,
14639 set_memory_read_packet_size
, _("\
14640 Set the maximum number of bytes per memory-read packet.\n\
14641 Specify the number of bytes in a packet or 0 (zero) for the\n\
14642 default packet size. The actual limit is further reduced\n\
14643 dependent on the target. Specify ``fixed'' to disable the\n\
14644 further restriction and ``limit'' to enable that restriction."),
14645 &remote_set_cmdlist
);
14646 add_cmd ("memory-write-packet-size", no_class
,
14647 show_memory_write_packet_size
,
14648 _("Show the maximum number of bytes per memory-write packet."),
14649 &remote_show_cmdlist
);
14650 add_cmd ("memory-read-packet-size", no_class
,
14651 show_memory_read_packet_size
,
14652 _("Show the maximum number of bytes per memory-read packet."),
14653 &remote_show_cmdlist
);
14655 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14656 &remote_hw_watchpoint_limit
, _("\
14657 Set the maximum number of target hardware watchpoints."), _("\
14658 Show the maximum number of target hardware watchpoints."), _("\
14659 Specify \"unlimited\" for unlimited hardware watchpoints."),
14660 NULL
, show_hardware_watchpoint_limit
,
14661 &remote_set_cmdlist
,
14662 &remote_show_cmdlist
);
14663 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14665 &remote_hw_watchpoint_length_limit
, _("\
14666 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14667 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14668 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14669 NULL
, show_hardware_watchpoint_length_limit
,
14670 &remote_set_cmdlist
, &remote_show_cmdlist
);
14671 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14672 &remote_hw_breakpoint_limit
, _("\
14673 Set the maximum number of target hardware breakpoints."), _("\
14674 Show the maximum number of target hardware breakpoints."), _("\
14675 Specify \"unlimited\" for unlimited hardware breakpoints."),
14676 NULL
, show_hardware_breakpoint_limit
,
14677 &remote_set_cmdlist
, &remote_show_cmdlist
);
14679 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14680 &remote_address_size
, _("\
14681 Set the maximum size of the address (in bits) in a memory packet."), _("\
14682 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14684 NULL
, /* FIXME: i18n: */
14685 &setlist
, &showlist
);
14687 init_all_packet_configs ();
14689 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14690 "X", "binary-download", 1);
14692 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14693 "vCont", "verbose-resume", 0);
14695 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14696 "QPassSignals", "pass-signals", 0);
14698 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14699 "QCatchSyscalls", "catch-syscalls", 0);
14701 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14702 "QProgramSignals", "program-signals", 0);
14704 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14705 "QSetWorkingDir", "set-working-dir", 0);
14707 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14708 "QStartupWithShell", "startup-with-shell", 0);
14710 add_packet_config_cmd (&remote_protocol_packets
14711 [PACKET_QEnvironmentHexEncoded
],
14712 "QEnvironmentHexEncoded", "environment-hex-encoded",
14715 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14716 "QEnvironmentReset", "environment-reset",
14719 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14720 "QEnvironmentUnset", "environment-unset",
14723 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14724 "qSymbol", "symbol-lookup", 0);
14726 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14727 "P", "set-register", 1);
14729 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14730 "p", "fetch-register", 1);
14732 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14733 "Z0", "software-breakpoint", 0);
14735 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14736 "Z1", "hardware-breakpoint", 0);
14738 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14739 "Z2", "write-watchpoint", 0);
14741 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14742 "Z3", "read-watchpoint", 0);
14744 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14745 "Z4", "access-watchpoint", 0);
14747 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14748 "qXfer:auxv:read", "read-aux-vector", 0);
14750 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14751 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14753 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14754 "qXfer:features:read", "target-features", 0);
14756 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14757 "qXfer:libraries:read", "library-info", 0);
14759 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14760 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14762 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14763 "qXfer:memory-map:read", "memory-map", 0);
14765 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14766 "qXfer:osdata:read", "osdata", 0);
14768 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14769 "qXfer:threads:read", "threads", 0);
14771 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14772 "qXfer:siginfo:read", "read-siginfo-object", 0);
14774 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14775 "qXfer:siginfo:write", "write-siginfo-object", 0);
14777 add_packet_config_cmd
14778 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14779 "qXfer:traceframe-info:read", "traceframe-info", 0);
14781 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14782 "qXfer:uib:read", "unwind-info-block", 0);
14784 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14785 "qGetTLSAddr", "get-thread-local-storage-address",
14788 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14789 "qGetTIBAddr", "get-thread-information-block-address",
14792 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14793 "bc", "reverse-continue", 0);
14795 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14796 "bs", "reverse-step", 0);
14798 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14799 "qSupported", "supported-packets", 0);
14801 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14802 "qSearch:memory", "search-memory", 0);
14804 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14805 "qTStatus", "trace-status", 0);
14807 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14808 "vFile:setfs", "hostio-setfs", 0);
14810 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14811 "vFile:open", "hostio-open", 0);
14813 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14814 "vFile:pread", "hostio-pread", 0);
14816 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14817 "vFile:pwrite", "hostio-pwrite", 0);
14819 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14820 "vFile:close", "hostio-close", 0);
14822 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14823 "vFile:unlink", "hostio-unlink", 0);
14825 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14826 "vFile:readlink", "hostio-readlink", 0);
14828 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14829 "vFile:fstat", "hostio-fstat", 0);
14831 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14832 "vAttach", "attach", 0);
14834 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14837 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14838 "QStartNoAckMode", "noack", 0);
14840 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14841 "vKill", "kill", 0);
14843 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14844 "qAttached", "query-attached", 0);
14846 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14847 "ConditionalTracepoints",
14848 "conditional-tracepoints", 0);
14850 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14851 "ConditionalBreakpoints",
14852 "conditional-breakpoints", 0);
14854 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14855 "BreakpointCommands",
14856 "breakpoint-commands", 0);
14858 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14859 "FastTracepoints", "fast-tracepoints", 0);
14861 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14862 "TracepointSource", "TracepointSource", 0);
14864 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14865 "QAllow", "allow", 0);
14867 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14868 "StaticTracepoints", "static-tracepoints", 0);
14870 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14871 "InstallInTrace", "install-in-trace", 0);
14873 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14874 "qXfer:statictrace:read", "read-sdata-object", 0);
14876 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14877 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14879 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14880 "QDisableRandomization", "disable-randomization", 0);
14882 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14883 "QAgent", "agent", 0);
14885 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14886 "QTBuffer:size", "trace-buffer-size", 0);
14888 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14889 "Qbtrace:off", "disable-btrace", 0);
14891 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14892 "Qbtrace:bts", "enable-btrace-bts", 0);
14894 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14895 "Qbtrace:pt", "enable-btrace-pt", 0);
14897 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14898 "qXfer:btrace", "read-btrace", 0);
14900 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14901 "qXfer:btrace-conf", "read-btrace-conf", 0);
14903 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14904 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14906 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14907 "multiprocess-feature", "multiprocess-feature", 0);
14909 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14910 "swbreak-feature", "swbreak-feature", 0);
14912 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14913 "hwbreak-feature", "hwbreak-feature", 0);
14915 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14916 "fork-event-feature", "fork-event-feature", 0);
14918 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14919 "vfork-event-feature", "vfork-event-feature", 0);
14921 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14922 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14924 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14925 "vContSupported", "verbose-resume-supported", 0);
14927 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14928 "exec-event-feature", "exec-event-feature", 0);
14930 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14931 "vCtrlC", "ctrl-c", 0);
14933 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14934 "QThreadEvents", "thread-events", 0);
14936 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14937 "N stop reply", "no-resumed-stop-reply", 0);
14939 /* Assert that we've registered "set remote foo-packet" commands
14940 for all packet configs. */
14944 for (i
= 0; i
< PACKET_MAX
; i
++)
14946 /* Ideally all configs would have a command associated. Some
14947 still don't though. */
14952 case PACKET_QNonStop
:
14953 case PACKET_EnableDisableTracepoints_feature
:
14954 case PACKET_tracenz_feature
:
14955 case PACKET_DisconnectedTracing_feature
:
14956 case PACKET_augmented_libraries_svr4_read_feature
:
14958 /* Additions to this list need to be well justified:
14959 pre-existing packets are OK; new packets are not. */
14967 /* This catches both forgetting to add a config command, and
14968 forgetting to remove a packet from the exception list. */
14969 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14973 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14974 Z sub-packet has its own set and show commands, but users may
14975 have sets to this variable in their .gdbinit files (or in their
14977 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14978 &remote_Z_packet_detect
, _("\
14979 Set use of remote protocol `Z' packets."), _("\
14980 Show use of remote protocol `Z' packets."), _("\
14981 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14983 set_remote_protocol_Z_packet_cmd
,
14984 show_remote_protocol_Z_packet_cmd
,
14985 /* FIXME: i18n: Use of remote protocol
14986 `Z' packets is %s. */
14987 &remote_set_cmdlist
, &remote_show_cmdlist
);
14989 add_basic_prefix_cmd ("remote", class_files
, _("\
14990 Manipulate files on the remote system.\n\
14991 Transfer files to and from the remote target system."),
14992 &remote_cmdlist
, "remote ",
14993 0 /* allow-unknown */, &cmdlist
);
14995 add_cmd ("put", class_files
, remote_put_command
,
14996 _("Copy a local file to the remote system."),
14999 add_cmd ("get", class_files
, remote_get_command
,
15000 _("Copy a remote file to the local system."),
15003 add_cmd ("delete", class_files
, remote_delete_command
,
15004 _("Delete a remote file."),
15007 add_setshow_string_noescape_cmd ("exec-file", class_files
,
15008 &remote_exec_file_var
, _("\
15009 Set the remote pathname for \"run\"."), _("\
15010 Show the remote pathname for \"run\"."), NULL
,
15011 set_remote_exec_file
,
15012 show_remote_exec_file
,
15013 &remote_set_cmdlist
,
15014 &remote_show_cmdlist
);
15016 add_setshow_boolean_cmd ("range-stepping", class_run
,
15017 &use_range_stepping
, _("\
15018 Enable or disable range stepping."), _("\
15019 Show whether target-assisted range stepping is enabled."), _("\
15020 If on, and the target supports it, when stepping a source line, GDB\n\
15021 tells the target to step the corresponding range of addresses itself instead\n\
15022 of issuing multiple single-steps. This speeds up source level\n\
15023 stepping. If off, GDB always issues single-steps, even if range\n\
15024 stepping is supported by the target. The default is on."),
15025 set_range_stepping
,
15026 show_range_stepping
,
15030 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
15031 Set watchdog timer."), _("\
15032 Show watchdog timer."), _("\
15033 When non-zero, this timeout is used instead of waiting forever for a target\n\
15034 to finish a low-level step or continue operation. If the specified amount\n\
15035 of time passes without a response from the target, an error occurs."),
15038 &setlist
, &showlist
);
15040 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
15041 &remote_packet_max_chars
, _("\
15042 Set the maximum number of characters to display for each remote packet."), _("\
15043 Show the maximum number of characters to display for each remote packet."), _("\
15044 Specify \"unlimited\" to display all the characters."),
15045 NULL
, show_remote_packet_max_chars
,
15046 &setdebuglist
, &showdebuglist
);
15048 /* Eventually initialize fileio. See fileio.c */
15049 initialize_remote_fileio (&remote_set_cmdlist
, &remote_show_cmdlist
);