1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2019 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 "event-loop.h"
53 #include "event-top.h"
59 #include "gdbcore.h" /* for exec_bfd */
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 <unordered_map>
80 /* The remote target. */
82 static const char remote_doc
[] = N_("\
83 Use a remote computer via a serial line, using a gdb-specific protocol.\n\
84 Specify the serial device it is connected to\n\
85 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
87 #define OPAQUETHREADBYTES 8
89 /* a 64 bit opaque identifier */
90 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
92 struct gdb_ext_thread_info
;
93 struct threads_listing_context
;
94 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
95 struct protocol_feature
;
99 typedef std::unique_ptr
<stop_reply
> stop_reply_up
;
101 /* Generic configuration support for packets the stub optionally
102 supports. Allows the user to specify the use of the packet as well
103 as allowing GDB to auto-detect support in the remote stub. */
107 PACKET_SUPPORT_UNKNOWN
= 0,
112 /* Analyze a packet's return value and update the packet config
122 struct threads_listing_context
;
124 /* Stub vCont actions support.
126 Each field is a boolean flag indicating whether the stub reports
127 support for the corresponding action. */
129 struct vCont_action_support
144 /* About this many threadisds fit in a packet. */
146 #define MAXTHREADLISTRESULTS 32
148 /* Data for the vFile:pread readahead cache. */
150 struct readahead_cache
152 /* Invalidate the readahead cache. */
155 /* Invalidate the readahead cache if it is holding data for FD. */
156 void invalidate_fd (int fd
);
158 /* Serve pread from the readahead cache. Returns number of bytes
159 read, or 0 if the request can't be served from the cache. */
160 int pread (int fd
, gdb_byte
*read_buf
, size_t len
, ULONGEST offset
);
162 /* The file descriptor for the file that is being cached. -1 if the
166 /* The offset into the file that the cache buffer corresponds
170 /* The buffer holding the cache contents. */
171 gdb_byte
*buf
= nullptr;
172 /* The buffer's size. We try to read as much as fits into a packet
176 /* Cache hit and miss counters. */
177 ULONGEST hit_count
= 0;
178 ULONGEST miss_count
= 0;
181 /* Description of the remote protocol for a given architecture. */
185 long offset
; /* Offset into G packet. */
186 long regnum
; /* GDB's internal register number. */
187 LONGEST pnum
; /* Remote protocol register number. */
188 int in_g_packet
; /* Always part of G packet. */
189 /* long size in bytes; == register_size (target_gdbarch (), regnum);
191 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
195 struct remote_arch_state
197 explicit remote_arch_state (struct gdbarch
*gdbarch
);
199 /* Description of the remote protocol registers. */
200 long sizeof_g_packet
;
202 /* Description of the remote protocol registers indexed by REGNUM
203 (making an array gdbarch_num_regs in size). */
204 std::unique_ptr
<packet_reg
[]> regs
;
206 /* This is the size (in chars) of the first response to the ``g''
207 packet. It is used as a heuristic when determining the maximum
208 size of memory-read and memory-write packets. A target will
209 typically only reserve a buffer large enough to hold the ``g''
210 packet. The size does not include packet overhead (headers and
212 long actual_register_packet_size
;
214 /* This is the maximum size (in chars) of a non read/write packet.
215 It is also used as a cap on the size of read/write packets. */
216 long remote_packet_size
;
219 /* Description of the remote protocol state for the currently
220 connected target. This is per-target state, and independent of the
221 selected architecture. */
230 /* Get the remote arch state for GDBARCH. */
231 struct remote_arch_state
*get_remote_arch_state (struct gdbarch
*gdbarch
);
235 /* A buffer to use for incoming packets, and its current size. The
236 buffer is grown dynamically for larger incoming packets.
237 Outgoing packets may also be constructed in this buffer.
238 The size of the buffer is always at least REMOTE_PACKET_SIZE;
239 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
241 gdb::char_vector buf
;
243 /* True if we're going through initial connection setup (finding out
244 about the remote side's threads, relocating symbols, etc.). */
245 bool starting_up
= false;
247 /* If we negotiated packet size explicitly (and thus can bypass
248 heuristics for the largest packet size that will not overflow
249 a buffer in the stub), this will be set to that packet size.
250 Otherwise zero, meaning to use the guessed size. */
251 long explicit_packet_size
= 0;
253 /* remote_wait is normally called when the target is running and
254 waits for a stop reply packet. But sometimes we need to call it
255 when the target is already stopped. We can send a "?" packet
256 and have remote_wait read the response. Or, if we already have
257 the response, we can stash it in BUF and tell remote_wait to
258 skip calling getpkt. This flag is set when BUF contains a
259 stop reply packet and the target is not waiting. */
260 int cached_wait_status
= 0;
262 /* True, if in no ack mode. That is, neither GDB nor the stub will
263 expect acks from each other. The connection is assumed to be
265 bool noack_mode
= false;
267 /* True if we're connected in extended remote mode. */
268 bool extended
= false;
270 /* True if we resumed the target and we're waiting for the target to
271 stop. In the mean time, we can't start another command/query.
272 The remote server wouldn't be ready to process it, so we'd
273 timeout waiting for a reply that would never come and eventually
274 we'd close the connection. This can happen in asynchronous mode
275 because we allow GDB commands while the target is running. */
276 bool waiting_for_stop_reply
= false;
278 /* The status of the stub support for the various vCont actions. */
279 vCont_action_support supports_vCont
;
281 /* True if the user has pressed Ctrl-C, but the target hasn't
282 responded to that. */
283 bool ctrlc_pending_p
= false;
285 /* True if we saw a Ctrl-C while reading or writing from/to the
286 remote descriptor. At that point it is not safe to send a remote
287 interrupt packet, so we instead remember we saw the Ctrl-C and
288 process it once we're done with sending/receiving the current
289 packet, which should be shortly. If however that takes too long,
290 and the user presses Ctrl-C again, we offer to disconnect. */
291 bool got_ctrlc_during_io
= false;
293 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
294 remote_open knows that we don't have a file open when the program
296 struct serial
*remote_desc
= nullptr;
298 /* These are the threads which we last sent to the remote system. The
299 TID member will be -1 for all or -2 for not sent yet. */
300 ptid_t general_thread
= null_ptid
;
301 ptid_t continue_thread
= null_ptid
;
303 /* This is the traceframe which we last selected on the remote system.
304 It will be -1 if no traceframe is selected. */
305 int remote_traceframe_number
= -1;
307 char *last_pass_packet
= nullptr;
309 /* The last QProgramSignals packet sent to the target. We bypass
310 sending a new program signals list down to the target if the new
311 packet is exactly the same as the last we sent. IOW, we only let
312 the target know about program signals list changes. */
313 char *last_program_signals_packet
= nullptr;
315 gdb_signal last_sent_signal
= GDB_SIGNAL_0
;
317 bool last_sent_step
= false;
319 /* The execution direction of the last resume we got. */
320 exec_direction_kind last_resume_exec_dir
= EXEC_FORWARD
;
322 char *finished_object
= nullptr;
323 char *finished_annex
= nullptr;
324 ULONGEST finished_offset
= 0;
326 /* Should we try the 'ThreadInfo' query packet?
328 This variable (NOT available to the user: auto-detect only!)
329 determines whether GDB will use the new, simpler "ThreadInfo"
330 query or the older, more complex syntax for thread queries.
331 This is an auto-detect variable (set to true at each connect,
332 and set to false when the target fails to recognize it). */
333 bool use_threadinfo_query
= false;
334 bool use_threadextra_query
= false;
336 threadref echo_nextthread
{};
337 threadref nextthread
{};
338 threadref resultthreadlist
[MAXTHREADLISTRESULTS
] {};
340 /* The state of remote notification. */
341 struct remote_notif_state
*notif_state
= nullptr;
343 /* The branch trace configuration. */
344 struct btrace_config btrace_config
{};
346 /* The argument to the last "vFile:setfs:" packet we sent, used
347 to avoid sending repeated unnecessary "vFile:setfs:" packets.
348 Initialized to -1 to indicate that no "vFile:setfs:" packet
349 has yet been sent. */
352 /* A readahead cache for vFile:pread. Often, reading a binary
353 involves a sequence of small reads. E.g., when parsing an ELF
354 file. A readahead cache helps mostly the case of remote
355 debugging on a connection with higher latency, due to the
356 request/reply nature of the RSP. We only cache data for a single
357 file descriptor at a time. */
358 struct readahead_cache readahead_cache
;
360 /* The list of already fetched and acknowledged stop events. This
361 queue is used for notification Stop, and other notifications
362 don't need queue for their events, because the notification
363 events of Stop can't be consumed immediately, so that events
364 should be queued first, and be consumed by remote_wait_{ns,as}
365 one per time. Other notifications can consume their events
366 immediately, so queue is not needed for them. */
367 std::vector
<stop_reply_up
> stop_reply_queue
;
369 /* Asynchronous signal handle registered as event loop source for
370 when we have pending events ready to be passed to the core. */
371 struct async_event_handler
*remote_async_inferior_event_token
= nullptr;
373 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
374 ``forever'' still use the normal timeout mechanism. This is
375 currently used by the ASYNC code to guarentee that target reads
376 during the initial connect always time-out. Once getpkt has been
377 modified to return a timeout indication and, in turn
378 remote_wait()/wait_for_inferior() have gained a timeout parameter
380 int wait_forever_enabled_p
= 1;
383 /* Mapping of remote protocol data for each gdbarch. Usually there
384 is only one entry here, though we may see more with stubs that
385 support multi-process. */
386 std::unordered_map
<struct gdbarch
*, remote_arch_state
>
390 static const target_info remote_target_info
= {
392 N_("Remote serial target in gdb-specific protocol"),
396 class remote_target
: public process_stratum_target
399 remote_target () = default;
400 ~remote_target () override
;
402 const target_info
&info () const override
403 { return remote_target_info
; }
405 thread_control_capabilities
get_thread_control_capabilities () override
406 { return tc_schedlock
; }
408 /* Open a remote connection. */
409 static void open (const char *, int);
411 void close () override
;
413 void detach (inferior
*, int) override
;
414 void disconnect (const char *, int) override
;
416 void commit_resume () override
;
417 void resume (ptid_t
, int, enum gdb_signal
) override
;
418 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
420 void fetch_registers (struct regcache
*, int) override
;
421 void store_registers (struct regcache
*, int) override
;
422 void prepare_to_store (struct regcache
*) override
;
424 void files_info () override
;
426 int insert_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
428 int remove_breakpoint (struct gdbarch
*, struct bp_target_info
*,
429 enum remove_bp_reason
) override
;
432 bool stopped_by_sw_breakpoint () override
;
433 bool supports_stopped_by_sw_breakpoint () override
;
435 bool stopped_by_hw_breakpoint () override
;
437 bool supports_stopped_by_hw_breakpoint () override
;
439 bool stopped_by_watchpoint () override
;
441 bool stopped_data_address (CORE_ADDR
*) override
;
443 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
445 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
447 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
449 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
451 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
453 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
454 struct expression
*) override
;
456 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
457 struct expression
*) override
;
459 void kill () override
;
461 void load (const char *, int) override
;
463 void mourn_inferior () override
;
465 void pass_signals (gdb::array_view
<const unsigned char>) override
;
467 int set_syscall_catchpoint (int, bool, int,
468 gdb::array_view
<const int>) override
;
470 void program_signals (gdb::array_view
<const unsigned char>) override
;
472 bool thread_alive (ptid_t ptid
) override
;
474 const char *thread_name (struct thread_info
*) override
;
476 void update_thread_list () override
;
478 std::string
pid_to_str (ptid_t
) override
;
480 const char *extra_thread_info (struct thread_info
*) override
;
482 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
484 thread_info
*thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
486 inferior
*inf
) override
;
488 gdb::byte_vector
thread_info_to_thread_handle (struct thread_info
*tp
)
491 void stop (ptid_t
) override
;
493 void interrupt () override
;
495 void pass_ctrlc () override
;
497 enum target_xfer_status
xfer_partial (enum target_object object
,
500 const gdb_byte
*writebuf
,
501 ULONGEST offset
, ULONGEST len
,
502 ULONGEST
*xfered_len
) override
;
504 ULONGEST
get_memory_xfer_limit () override
;
506 void rcmd (const char *command
, struct ui_file
*output
) override
;
508 char *pid_to_exec_file (int pid
) override
;
510 void log_command (const char *cmd
) override
512 serial_log_command (this, cmd
);
515 CORE_ADDR
get_thread_local_address (ptid_t ptid
,
516 CORE_ADDR load_module_addr
,
517 CORE_ADDR offset
) override
;
519 bool can_execute_reverse () override
;
521 std::vector
<mem_region
> memory_map () override
;
523 void flash_erase (ULONGEST address
, LONGEST length
) override
;
525 void flash_done () override
;
527 const struct target_desc
*read_description () override
;
529 int search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
530 const gdb_byte
*pattern
, ULONGEST pattern_len
,
531 CORE_ADDR
*found_addrp
) override
;
533 bool can_async_p () override
;
535 bool is_async_p () override
;
537 void async (int) override
;
539 void thread_events (int) override
;
541 int can_do_single_step () override
;
543 void terminal_inferior () override
;
545 void terminal_ours () override
;
547 bool supports_non_stop () override
;
549 bool supports_multi_process () override
;
551 bool supports_disable_randomization () override
;
553 bool filesystem_is_local () override
;
556 int fileio_open (struct inferior
*inf
, const char *filename
,
557 int flags
, int mode
, int warn_if_slow
,
558 int *target_errno
) override
;
560 int fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
561 ULONGEST offset
, int *target_errno
) override
;
563 int fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
564 ULONGEST offset
, int *target_errno
) override
;
566 int fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
) override
;
568 int fileio_close (int fd
, int *target_errno
) override
;
570 int fileio_unlink (struct inferior
*inf
,
571 const char *filename
,
572 int *target_errno
) override
;
574 gdb::optional
<std::string
>
575 fileio_readlink (struct inferior
*inf
,
576 const char *filename
,
577 int *target_errno
) override
;
579 bool supports_enable_disable_tracepoint () override
;
581 bool supports_string_tracing () override
;
583 bool supports_evaluation_of_breakpoint_conditions () override
;
585 bool can_run_breakpoint_commands () override
;
587 void trace_init () override
;
589 void download_tracepoint (struct bp_location
*location
) override
;
591 bool can_download_tracepoint () override
;
593 void download_trace_state_variable (const trace_state_variable
&tsv
) override
;
595 void enable_tracepoint (struct bp_location
*location
) override
;
597 void disable_tracepoint (struct bp_location
*location
) override
;
599 void trace_set_readonly_regions () override
;
601 void trace_start () override
;
603 int get_trace_status (struct trace_status
*ts
) override
;
605 void get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
608 void trace_stop () override
;
610 int trace_find (enum trace_find_type type
, int num
,
611 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
) override
;
613 bool get_trace_state_variable_value (int tsv
, LONGEST
*val
) override
;
615 int save_trace_data (const char *filename
) override
;
617 int upload_tracepoints (struct uploaded_tp
**utpp
) override
;
619 int upload_trace_state_variables (struct uploaded_tsv
**utsvp
) override
;
621 LONGEST
get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
) override
;
623 int get_min_fast_tracepoint_insn_len () override
;
625 void set_disconnected_tracing (int val
) override
;
627 void set_circular_trace_buffer (int val
) override
;
629 void set_trace_buffer_size (LONGEST val
) override
;
631 bool set_trace_notes (const char *user
, const char *notes
,
632 const char *stopnotes
) override
;
634 int core_of_thread (ptid_t ptid
) override
;
636 int verify_memory (const gdb_byte
*data
,
637 CORE_ADDR memaddr
, ULONGEST size
) override
;
640 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
642 void set_permissions () override
;
644 bool static_tracepoint_marker_at (CORE_ADDR
,
645 struct static_tracepoint_marker
*marker
)
648 std::vector
<static_tracepoint_marker
>
649 static_tracepoint_markers_by_strid (const char *id
) override
;
651 traceframe_info_up
traceframe_info () override
;
653 bool use_agent (bool use
) override
;
654 bool can_use_agent () override
;
656 struct btrace_target_info
*enable_btrace (ptid_t ptid
,
657 const struct btrace_config
*conf
) override
;
659 void disable_btrace (struct btrace_target_info
*tinfo
) override
;
661 void teardown_btrace (struct btrace_target_info
*tinfo
) override
;
663 enum btrace_error
read_btrace (struct btrace_data
*data
,
664 struct btrace_target_info
*btinfo
,
665 enum btrace_read_type type
) override
;
667 const struct btrace_config
*btrace_conf (const struct btrace_target_info
*) override
;
668 bool augmented_libraries_svr4_read () override
;
669 int follow_fork (int, int) override
;
670 void follow_exec (struct inferior
*, const char *) override
;
671 int insert_fork_catchpoint (int) override
;
672 int remove_fork_catchpoint (int) override
;
673 int insert_vfork_catchpoint (int) override
;
674 int remove_vfork_catchpoint (int) override
;
675 int insert_exec_catchpoint (int) override
;
676 int remove_exec_catchpoint (int) override
;
677 enum exec_direction_kind
execution_direction () override
;
679 public: /* Remote specific methods. */
681 void remote_download_command_source (int num
, ULONGEST addr
,
682 struct command_line
*cmds
);
684 void remote_file_put (const char *local_file
, const char *remote_file
,
686 void remote_file_get (const char *remote_file
, const char *local_file
,
688 void remote_file_delete (const char *remote_file
, int from_tty
);
690 int remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
691 ULONGEST offset
, int *remote_errno
);
692 int remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
693 ULONGEST offset
, int *remote_errno
);
694 int remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
695 ULONGEST offset
, int *remote_errno
);
697 int remote_hostio_send_command (int command_bytes
, int which_packet
,
698 int *remote_errno
, char **attachment
,
699 int *attachment_len
);
700 int remote_hostio_set_filesystem (struct inferior
*inf
,
702 /* We should get rid of this and use fileio_open directly. */
703 int remote_hostio_open (struct inferior
*inf
, const char *filename
,
704 int flags
, int mode
, int warn_if_slow
,
706 int remote_hostio_close (int fd
, int *remote_errno
);
708 int remote_hostio_unlink (inferior
*inf
, const char *filename
,
711 struct remote_state
*get_remote_state ();
713 long get_remote_packet_size (void);
714 long get_memory_packet_size (struct memory_packet_config
*config
);
716 long get_memory_write_packet_size ();
717 long get_memory_read_packet_size ();
719 char *append_pending_thread_resumptions (char *p
, char *endp
,
721 static void open_1 (const char *name
, int from_tty
, int extended_p
);
722 void start_remote (int from_tty
, int extended_p
);
723 void remote_detach_1 (struct inferior
*inf
, int from_tty
);
725 char *append_resumption (char *p
, char *endp
,
726 ptid_t ptid
, int step
, gdb_signal siggnal
);
727 int remote_resume_with_vcont (ptid_t ptid
, int step
,
730 void add_current_inferior_and_thread (char *wait_status
);
732 ptid_t
wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
734 ptid_t
wait_as (ptid_t ptid
, target_waitstatus
*status
,
737 ptid_t
process_stop_reply (struct stop_reply
*stop_reply
,
738 target_waitstatus
*status
);
740 void remote_notice_new_inferior (ptid_t currthread
, int executing
);
742 void process_initial_stop_replies (int from_tty
);
744 thread_info
*remote_add_thread (ptid_t ptid
, bool running
, bool executing
);
746 void btrace_sync_conf (const btrace_config
*conf
);
748 void remote_btrace_maybe_reopen ();
750 void remove_new_fork_children (threads_listing_context
*context
);
751 void kill_new_fork_children (int pid
);
752 void discard_pending_stop_replies (struct inferior
*inf
);
753 int stop_reply_queue_length ();
755 void check_pending_events_prevent_wildcard_vcont
756 (int *may_global_wildcard_vcont
);
758 void discard_pending_stop_replies_in_queue ();
759 struct stop_reply
*remote_notif_remove_queued_reply (ptid_t ptid
);
760 struct stop_reply
*queued_stop_reply (ptid_t ptid
);
761 int peek_stop_reply (ptid_t ptid
);
762 void remote_parse_stop_reply (const char *buf
, stop_reply
*event
);
764 void remote_stop_ns (ptid_t ptid
);
765 void remote_interrupt_as ();
766 void remote_interrupt_ns ();
768 char *remote_get_noisy_reply ();
769 int remote_query_attached (int pid
);
770 inferior
*remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
773 ptid_t
remote_current_thread (ptid_t oldpid
);
774 ptid_t
get_current_thread (char *wait_status
);
776 void set_thread (ptid_t ptid
, int gen
);
777 void set_general_thread (ptid_t ptid
);
778 void set_continue_thread (ptid_t ptid
);
779 void set_general_process ();
781 char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
783 int remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
784 gdb_ext_thread_info
*info
);
785 int remote_get_threadinfo (threadref
*threadid
, int fieldset
,
786 gdb_ext_thread_info
*info
);
788 int parse_threadlist_response (char *pkt
, int result_limit
,
789 threadref
*original_echo
,
790 threadref
*resultlist
,
792 int remote_get_threadlist (int startflag
, threadref
*nextthread
,
793 int result_limit
, int *done
, int *result_count
,
794 threadref
*threadlist
);
796 int remote_threadlist_iterator (rmt_thread_action stepfunction
,
797 void *context
, int looplimit
);
799 int remote_get_threads_with_ql (threads_listing_context
*context
);
800 int remote_get_threads_with_qxfer (threads_listing_context
*context
);
801 int remote_get_threads_with_qthreadinfo (threads_listing_context
*context
);
803 void extended_remote_restart ();
807 void remote_check_symbols ();
809 void remote_supported_packet (const struct protocol_feature
*feature
,
810 enum packet_support support
,
811 const char *argument
);
813 void remote_query_supported ();
815 void remote_packet_size (const protocol_feature
*feature
,
816 packet_support support
, const char *value
);
818 void remote_serial_quit_handler ();
820 void remote_detach_pid (int pid
);
822 void remote_vcont_probe ();
824 void remote_resume_with_hc (ptid_t ptid
, int step
,
827 void send_interrupt_sequence ();
828 void interrupt_query ();
830 void remote_notif_get_pending_events (notif_client
*nc
);
832 int fetch_register_using_p (struct regcache
*regcache
,
834 int send_g_packet ();
835 void process_g_packet (struct regcache
*regcache
);
836 void fetch_registers_using_g (struct regcache
*regcache
);
837 int store_register_using_P (const struct regcache
*regcache
,
839 void store_registers_using_G (const struct regcache
*regcache
);
841 void set_remote_traceframe ();
843 void check_binary_download (CORE_ADDR addr
);
845 target_xfer_status
remote_write_bytes_aux (const char *header
,
847 const gdb_byte
*myaddr
,
850 ULONGEST
*xfered_len_units
,
854 target_xfer_status
remote_write_bytes (CORE_ADDR memaddr
,
855 const gdb_byte
*myaddr
, ULONGEST len
,
856 int unit_size
, ULONGEST
*xfered_len
);
858 target_xfer_status
remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
860 int unit_size
, ULONGEST
*xfered_len_units
);
862 target_xfer_status
remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
866 ULONGEST
*xfered_len
);
868 target_xfer_status
remote_read_bytes (CORE_ADDR memaddr
,
869 gdb_byte
*myaddr
, ULONGEST len
,
871 ULONGEST
*xfered_len
);
873 packet_result
remote_send_printf (const char *format
, ...)
874 ATTRIBUTE_PRINTF (2, 3);
876 target_xfer_status
remote_flash_write (ULONGEST address
,
877 ULONGEST length
, ULONGEST
*xfered_len
,
878 const gdb_byte
*data
);
880 int readchar (int timeout
);
882 void remote_serial_write (const char *str
, int len
);
884 int putpkt (const char *buf
);
885 int putpkt_binary (const char *buf
, int cnt
);
887 int putpkt (const gdb::char_vector
&buf
)
889 return putpkt (buf
.data ());
893 long read_frame (gdb::char_vector
*buf_p
);
894 void getpkt (gdb::char_vector
*buf
, int forever
);
895 int getpkt_or_notif_sane_1 (gdb::char_vector
*buf
, int forever
,
896 int expecting_notif
, int *is_notif
);
897 int getpkt_sane (gdb::char_vector
*buf
, int forever
);
898 int getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
900 int remote_vkill (int pid
);
901 void remote_kill_k ();
903 void extended_remote_disable_randomization (int val
);
904 int extended_remote_run (const std::string
&args
);
906 void send_environment_packet (const char *action
,
910 void extended_remote_environment_support ();
911 void extended_remote_set_inferior_cwd ();
913 target_xfer_status
remote_write_qxfer (const char *object_name
,
915 const gdb_byte
*writebuf
,
916 ULONGEST offset
, LONGEST len
,
917 ULONGEST
*xfered_len
,
918 struct packet_config
*packet
);
920 target_xfer_status
remote_read_qxfer (const char *object_name
,
922 gdb_byte
*readbuf
, ULONGEST offset
,
924 ULONGEST
*xfered_len
,
925 struct packet_config
*packet
);
927 void push_stop_reply (struct stop_reply
*new_event
);
929 bool vcont_r_supported ();
931 void packet_command (const char *args
, int from_tty
);
933 private: /* data fields */
935 /* The remote state. Don't reference this directly. Use the
936 get_remote_state method instead. */
937 remote_state m_remote_state
;
940 static const target_info extended_remote_target_info
= {
942 N_("Extended remote serial target in gdb-specific protocol"),
946 /* Set up the extended remote target by extending the standard remote
947 target and adding to it. */
949 class extended_remote_target final
: public remote_target
952 const target_info
&info () const override
953 { return extended_remote_target_info
; }
955 /* Open an extended-remote connection. */
956 static void open (const char *, int);
958 bool can_create_inferior () override
{ return true; }
959 void create_inferior (const char *, const std::string
&,
960 char **, int) override
;
962 void detach (inferior
*, int) override
;
964 bool can_attach () override
{ return true; }
965 void attach (const char *, int) override
;
967 void post_attach (int) override
;
968 bool supports_disable_randomization () override
;
971 /* Per-program-space data key. */
972 static const struct program_space_key
<char, gdb::xfree_deleter
<char>>
975 /* The variable registered as the control variable used by the
976 remote exec-file commands. While the remote exec-file setting is
977 per-program-space, the set/show machinery uses this as the
978 location of the remote exec-file value. */
979 static char *remote_exec_file_var
;
981 /* The size to align memory write packets, when practical. The protocol
982 does not guarantee any alignment, and gdb will generate short
983 writes and unaligned writes, but even as a best-effort attempt this
984 can improve bulk transfers. For instance, if a write is misaligned
985 relative to the target's data bus, the stub may need to make an extra
986 round trip fetching data from the target. This doesn't make a
987 huge difference, but it's easy to do, so we try to be helpful.
989 The alignment chosen is arbitrary; usually data bus width is
990 important here, not the possibly larger cache line size. */
991 enum { REMOTE_ALIGN_WRITES
= 16 };
993 /* Prototypes for local functions. */
995 static int hexnumlen (ULONGEST num
);
997 static int stubhex (int ch
);
999 static int hexnumstr (char *, ULONGEST
);
1001 static int hexnumnstr (char *, ULONGEST
, int);
1003 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
1005 static void print_packet (const char *);
1007 static int stub_unpack_int (char *buff
, int fieldlength
);
1009 struct packet_config
;
1011 static void show_packet_config_cmd (struct packet_config
*config
);
1013 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
1015 struct cmd_list_element
*c
,
1018 static ptid_t
read_ptid (const char *buf
, const char **obuf
);
1020 static void remote_async_inferior_event_handler (gdb_client_data
);
1022 static bool remote_read_description_p (struct target_ops
*target
);
1024 static void remote_console_output (const char *msg
);
1026 static void remote_btrace_reset (remote_state
*rs
);
1028 static void remote_unpush_and_throw (void);
1032 static struct cmd_list_element
*remote_cmdlist
;
1034 /* For "set remote" and "show remote". */
1036 static struct cmd_list_element
*remote_set_cmdlist
;
1037 static struct cmd_list_element
*remote_show_cmdlist
;
1039 /* Controls whether GDB is willing to use range stepping. */
1041 static bool use_range_stepping
= true;
1043 /* The max number of chars in debug output. The rest of chars are
1046 #define REMOTE_DEBUG_MAX_CHAR 512
1048 /* Private data that we'll store in (struct thread_info)->priv. */
1049 struct remote_thread_info
: public private_thread_info
1055 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1056 sequence of bytes. */
1057 gdb::byte_vector thread_handle
;
1059 /* Whether the target stopped for a breakpoint/watchpoint. */
1060 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1062 /* This is set to the data address of the access causing the target
1063 to stop for a watchpoint. */
1064 CORE_ADDR watch_data_address
= 0;
1066 /* Fields used by the vCont action coalescing implemented in
1067 remote_resume / remote_commit_resume. remote_resume stores each
1068 thread's last resume request in these fields, so that a later
1069 remote_commit_resume knows which is the proper action for this
1070 thread to include in the vCont packet. */
1072 /* True if the last target_resume call for this thread was a step
1073 request, false if a continue request. */
1074 int last_resume_step
= 0;
1076 /* The signal specified in the last target_resume call for this
1078 gdb_signal last_resume_sig
= GDB_SIGNAL_0
;
1080 /* Whether this thread was already vCont-resumed on the remote
1082 int vcont_resumed
= 0;
1085 remote_state::remote_state ()
1090 remote_state::~remote_state ()
1092 xfree (this->last_pass_packet
);
1093 xfree (this->last_program_signals_packet
);
1094 xfree (this->finished_object
);
1095 xfree (this->finished_annex
);
1098 /* Utility: generate error from an incoming stub packet. */
1100 trace_error (char *buf
)
1103 return; /* not an error msg */
1106 case '1': /* malformed packet error */
1107 if (*++buf
== '0') /* general case: */
1108 error (_("remote.c: error in outgoing packet."));
1110 error (_("remote.c: error in outgoing packet at field #%ld."),
1111 strtol (buf
, NULL
, 16));
1113 error (_("Target returns error code '%s'."), buf
);
1117 /* Utility: wait for reply from stub, while accepting "O" packets. */
1120 remote_target::remote_get_noisy_reply ()
1122 struct remote_state
*rs
= get_remote_state ();
1124 do /* Loop on reply from remote stub. */
1128 QUIT
; /* Allow user to bail out with ^C. */
1129 getpkt (&rs
->buf
, 0);
1130 buf
= rs
->buf
.data ();
1133 else if (startswith (buf
, "qRelocInsn:"))
1136 CORE_ADDR from
, to
, org_to
;
1138 int adjusted_size
= 0;
1141 p
= buf
+ strlen ("qRelocInsn:");
1142 pp
= unpack_varlen_hex (p
, &ul
);
1144 error (_("invalid qRelocInsn packet: %s"), buf
);
1148 unpack_varlen_hex (p
, &ul
);
1155 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1158 catch (const gdb_exception
&ex
)
1160 if (ex
.error
== MEMORY_ERROR
)
1162 /* Propagate memory errors silently back to the
1163 target. The stub may have limited the range of
1164 addresses we can write to, for example. */
1168 /* Something unexpectedly bad happened. Be verbose
1169 so we can tell what, and propagate the error back
1170 to the stub, so it doesn't get stuck waiting for
1172 exception_fprintf (gdb_stderr
, ex
,
1173 _("warning: relocating instruction: "));
1180 adjusted_size
= to
- org_to
;
1182 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1186 else if (buf
[0] == 'O' && buf
[1] != 'K')
1187 remote_console_output (buf
+ 1); /* 'O' message from stub */
1189 return buf
; /* Here's the actual reply. */
1194 struct remote_arch_state
*
1195 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1197 remote_arch_state
*rsa
;
1199 auto it
= this->m_arch_states
.find (gdbarch
);
1200 if (it
== this->m_arch_states
.end ())
1202 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1203 std::forward_as_tuple (gdbarch
),
1204 std::forward_as_tuple (gdbarch
));
1205 rsa
= &p
.first
->second
;
1207 /* Make sure that the packet buffer is plenty big enough for
1208 this architecture. */
1209 if (this->buf
.size () < rsa
->remote_packet_size
)
1210 this->buf
.resize (2 * rsa
->remote_packet_size
);
1218 /* Fetch the global remote target state. */
1221 remote_target::get_remote_state ()
1223 /* Make sure that the remote architecture state has been
1224 initialized, because doing so might reallocate rs->buf. Any
1225 function which calls getpkt also needs to be mindful of changes
1226 to rs->buf, but this call limits the number of places which run
1228 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1230 return &m_remote_state
;
1233 /* Fetch the remote exec-file from the current program space. */
1236 get_remote_exec_file (void)
1238 char *remote_exec_file
;
1240 remote_exec_file
= remote_pspace_data
.get (current_program_space
);
1241 if (remote_exec_file
== NULL
)
1244 return remote_exec_file
;
1247 /* Set the remote exec file for PSPACE. */
1250 set_pspace_remote_exec_file (struct program_space
*pspace
,
1251 const char *remote_exec_file
)
1253 char *old_file
= remote_pspace_data
.get (pspace
);
1256 remote_pspace_data
.set (pspace
, xstrdup (remote_exec_file
));
1259 /* The "set/show remote exec-file" set command hook. */
1262 set_remote_exec_file (const char *ignored
, int from_tty
,
1263 struct cmd_list_element
*c
)
1265 gdb_assert (remote_exec_file_var
!= NULL
);
1266 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
1269 /* The "set/show remote exec-file" show command hook. */
1272 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1273 struct cmd_list_element
*cmd
, const char *value
)
1275 fprintf_filtered (file
, "%s\n", remote_exec_file_var
);
1279 compare_pnums (const void *lhs_
, const void *rhs_
)
1281 const struct packet_reg
* const *lhs
1282 = (const struct packet_reg
* const *) lhs_
;
1283 const struct packet_reg
* const *rhs
1284 = (const struct packet_reg
* const *) rhs_
;
1286 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
1288 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
1295 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1297 int regnum
, num_remote_regs
, offset
;
1298 struct packet_reg
**remote_regs
;
1300 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1302 struct packet_reg
*r
= ®s
[regnum
];
1304 if (register_size (gdbarch
, regnum
) == 0)
1305 /* Do not try to fetch zero-sized (placeholder) registers. */
1308 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1313 /* Define the g/G packet format as the contents of each register
1314 with a remote protocol number, in order of ascending protocol
1317 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1318 for (num_remote_regs
= 0, regnum
= 0;
1319 regnum
< gdbarch_num_regs (gdbarch
);
1321 if (regs
[regnum
].pnum
!= -1)
1322 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1324 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
1327 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1329 remote_regs
[regnum
]->in_g_packet
= 1;
1330 remote_regs
[regnum
]->offset
= offset
;
1331 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1337 /* Given the architecture described by GDBARCH, return the remote
1338 protocol register's number and the register's offset in the g/G
1339 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1340 If the target does not have a mapping for REGNUM, return false,
1341 otherwise, return true. */
1344 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1345 int *pnum
, int *poffset
)
1347 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1349 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1351 map_regcache_remote_table (gdbarch
, regs
.data ());
1353 *pnum
= regs
[regnum
].pnum
;
1354 *poffset
= regs
[regnum
].offset
;
1359 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1361 /* Use the architecture to build a regnum<->pnum table, which will be
1362 1:1 unless a feature set specifies otherwise. */
1363 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1365 /* Record the maximum possible size of the g packet - it may turn out
1367 this->sizeof_g_packet
1368 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1370 /* Default maximum number of characters in a packet body. Many
1371 remote stubs have a hardwired buffer size of 400 bytes
1372 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1373 as the maximum packet-size to ensure that the packet and an extra
1374 NUL character can always fit in the buffer. This stops GDB
1375 trashing stubs that try to squeeze an extra NUL into what is
1376 already a full buffer (As of 1999-12-04 that was most stubs). */
1377 this->remote_packet_size
= 400 - 1;
1379 /* This one is filled in when a ``g'' packet is received. */
1380 this->actual_register_packet_size
= 0;
1382 /* Should rsa->sizeof_g_packet needs more space than the
1383 default, adjust the size accordingly. Remember that each byte is
1384 encoded as two characters. 32 is the overhead for the packet
1385 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1386 (``$NN:G...#NN'') is a better guess, the below has been padded a
1388 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1389 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1392 /* Get a pointer to the current remote target. If not connected to a
1393 remote target, return NULL. */
1395 static remote_target
*
1396 get_current_remote_target ()
1398 target_ops
*proc_target
= find_target_at (process_stratum
);
1399 return dynamic_cast<remote_target
*> (proc_target
);
1402 /* Return the current allowed size of a remote packet. This is
1403 inferred from the current architecture, and should be used to
1404 limit the length of outgoing packets. */
1406 remote_target::get_remote_packet_size ()
1408 struct remote_state
*rs
= get_remote_state ();
1409 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1411 if (rs
->explicit_packet_size
)
1412 return rs
->explicit_packet_size
;
1414 return rsa
->remote_packet_size
;
1417 static struct packet_reg
*
1418 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1421 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1425 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1427 gdb_assert (r
->regnum
== regnum
);
1432 static struct packet_reg
*
1433 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1438 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1440 struct packet_reg
*r
= &rsa
->regs
[i
];
1442 if (r
->pnum
== pnum
)
1448 /* Allow the user to specify what sequence to send to the remote
1449 when he requests a program interruption: Although ^C is usually
1450 what remote systems expect (this is the default, here), it is
1451 sometimes preferable to send a break. On other systems such
1452 as the Linux kernel, a break followed by g, which is Magic SysRq g
1453 is required in order to interrupt the execution. */
1454 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1455 const char interrupt_sequence_break
[] = "BREAK";
1456 const char interrupt_sequence_break_g
[] = "BREAK-g";
1457 static const char *const interrupt_sequence_modes
[] =
1459 interrupt_sequence_control_c
,
1460 interrupt_sequence_break
,
1461 interrupt_sequence_break_g
,
1464 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1467 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1468 struct cmd_list_element
*c
,
1471 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1472 fprintf_filtered (file
,
1473 _("Send the ASCII ETX character (Ctrl-c) "
1474 "to the remote target to interrupt the "
1475 "execution of the program.\n"));
1476 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1477 fprintf_filtered (file
,
1478 _("send a break signal to the remote target "
1479 "to interrupt the execution of the program.\n"));
1480 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1481 fprintf_filtered (file
,
1482 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1483 "the remote target to interrupt the execution "
1484 "of Linux kernel.\n"));
1486 internal_error (__FILE__
, __LINE__
,
1487 _("Invalid value for interrupt_sequence_mode: %s."),
1488 interrupt_sequence_mode
);
1491 /* This boolean variable specifies whether interrupt_sequence is sent
1492 to the remote target when gdb connects to it.
1493 This is mostly needed when you debug the Linux kernel: The Linux kernel
1494 expects BREAK g which is Magic SysRq g for connecting gdb. */
1495 static bool interrupt_on_connect
= false;
1497 /* This variable is used to implement the "set/show remotebreak" commands.
1498 Since these commands are now deprecated in favor of "set/show remote
1499 interrupt-sequence", it no longer has any effect on the code. */
1500 static bool remote_break
;
1503 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1506 interrupt_sequence_mode
= interrupt_sequence_break
;
1508 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1512 show_remotebreak (struct ui_file
*file
, int from_tty
,
1513 struct cmd_list_element
*c
,
1518 /* This variable sets the number of bits in an address that are to be
1519 sent in a memory ("M" or "m") packet. Normally, after stripping
1520 leading zeros, the entire address would be sent. This variable
1521 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1522 initial implementation of remote.c restricted the address sent in
1523 memory packets to ``host::sizeof long'' bytes - (typically 32
1524 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1525 address was never sent. Since fixing this bug may cause a break in
1526 some remote targets this variable is principly provided to
1527 facilitate backward compatibility. */
1529 static unsigned int remote_address_size
;
1532 /* User configurable variables for the number of characters in a
1533 memory read/write packet. MIN (rsa->remote_packet_size,
1534 rsa->sizeof_g_packet) is the default. Some targets need smaller
1535 values (fifo overruns, et.al.) and some users need larger values
1536 (speed up transfers). The variables ``preferred_*'' (the user
1537 request), ``current_*'' (what was actually set) and ``forced_*''
1538 (Positive - a soft limit, negative - a hard limit). */
1540 struct memory_packet_config
1547 /* The default max memory-write-packet-size, when the setting is
1548 "fixed". The 16k is historical. (It came from older GDB's using
1549 alloca for buffers and the knowledge (folklore?) that some hosts
1550 don't cope very well with large alloca calls.) */
1551 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1553 /* The minimum remote packet size for memory transfers. Ensures we
1554 can write at least one byte. */
1555 #define MIN_MEMORY_PACKET_SIZE 20
1557 /* Get the memory packet size, assuming it is fixed. */
1560 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1562 gdb_assert (config
->fixed_p
);
1564 if (config
->size
<= 0)
1565 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1567 return config
->size
;
1570 /* Compute the current size of a read/write packet. Since this makes
1571 use of ``actual_register_packet_size'' the computation is dynamic. */
1574 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1576 struct remote_state
*rs
= get_remote_state ();
1577 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1580 if (config
->fixed_p
)
1581 what_they_get
= get_fixed_memory_packet_size (config
);
1584 what_they_get
= get_remote_packet_size ();
1585 /* Limit the packet to the size specified by the user. */
1586 if (config
->size
> 0
1587 && what_they_get
> config
->size
)
1588 what_they_get
= config
->size
;
1590 /* Limit it to the size of the targets ``g'' response unless we have
1591 permission from the stub to use a larger packet size. */
1592 if (rs
->explicit_packet_size
== 0
1593 && rsa
->actual_register_packet_size
> 0
1594 && what_they_get
> rsa
->actual_register_packet_size
)
1595 what_they_get
= rsa
->actual_register_packet_size
;
1597 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1598 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1600 /* Make sure there is room in the global buffer for this packet
1601 (including its trailing NUL byte). */
1602 if (rs
->buf
.size () < what_they_get
+ 1)
1603 rs
->buf
.resize (2 * what_they_get
);
1605 return what_they_get
;
1608 /* Update the size of a read/write packet. If they user wants
1609 something really big then do a sanity check. */
1612 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1614 int fixed_p
= config
->fixed_p
;
1615 long size
= config
->size
;
1618 error (_("Argument required (integer, `fixed' or `limited')."));
1619 else if (strcmp (args
, "hard") == 0
1620 || strcmp (args
, "fixed") == 0)
1622 else if (strcmp (args
, "soft") == 0
1623 || strcmp (args
, "limit") == 0)
1629 size
= strtoul (args
, &end
, 0);
1631 error (_("Invalid %s (bad syntax)."), config
->name
);
1633 /* Instead of explicitly capping the size of a packet to or
1634 disallowing it, the user is allowed to set the size to
1635 something arbitrarily large. */
1639 if (fixed_p
&& !config
->fixed_p
)
1641 /* So that the query shows the correct value. */
1642 long query_size
= (size
<= 0
1643 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1646 if (! query (_("The target may not be able to correctly handle a %s\n"
1647 "of %ld bytes. Change the packet size? "),
1648 config
->name
, query_size
))
1649 error (_("Packet size not changed."));
1651 /* Update the config. */
1652 config
->fixed_p
= fixed_p
;
1653 config
->size
= size
;
1657 show_memory_packet_size (struct memory_packet_config
*config
)
1659 if (config
->size
== 0)
1660 printf_filtered (_("The %s is 0 (default). "), config
->name
);
1662 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1663 if (config
->fixed_p
)
1664 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1665 get_fixed_memory_packet_size (config
));
1668 remote_target
*remote
= get_current_remote_target ();
1671 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1672 remote
->get_memory_packet_size (config
));
1674 puts_filtered ("The actual limit will be further reduced "
1675 "dependent on the target.\n");
1679 static struct memory_packet_config memory_write_packet_config
=
1681 "memory-write-packet-size",
1685 set_memory_write_packet_size (const char *args
, int from_tty
)
1687 set_memory_packet_size (args
, &memory_write_packet_config
);
1691 show_memory_write_packet_size (const char *args
, int from_tty
)
1693 show_memory_packet_size (&memory_write_packet_config
);
1696 /* Show the number of hardware watchpoints that can be used. */
1699 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1700 struct cmd_list_element
*c
,
1703 fprintf_filtered (file
, _("The maximum number of target hardware "
1704 "watchpoints is %s.\n"), value
);
1707 /* Show the length limit (in bytes) for hardware watchpoints. */
1710 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1711 struct cmd_list_element
*c
,
1714 fprintf_filtered (file
, _("The maximum length (in bytes) of a target "
1715 "hardware watchpoint is %s.\n"), value
);
1718 /* Show the number of hardware breakpoints that can be used. */
1721 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1722 struct cmd_list_element
*c
,
1725 fprintf_filtered (file
, _("The maximum number of target hardware "
1726 "breakpoints is %s.\n"), value
);
1730 remote_target::get_memory_write_packet_size ()
1732 return get_memory_packet_size (&memory_write_packet_config
);
1735 static struct memory_packet_config memory_read_packet_config
=
1737 "memory-read-packet-size",
1741 set_memory_read_packet_size (const char *args
, int from_tty
)
1743 set_memory_packet_size (args
, &memory_read_packet_config
);
1747 show_memory_read_packet_size (const char *args
, int from_tty
)
1749 show_memory_packet_size (&memory_read_packet_config
);
1753 remote_target::get_memory_read_packet_size ()
1755 long size
= get_memory_packet_size (&memory_read_packet_config
);
1757 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1758 extra buffer size argument before the memory read size can be
1759 increased beyond this. */
1760 if (size
> get_remote_packet_size ())
1761 size
= get_remote_packet_size ();
1767 struct packet_config
1772 /* If auto, GDB auto-detects support for this packet or feature,
1773 either through qSupported, or by trying the packet and looking
1774 at the response. If true, GDB assumes the target supports this
1775 packet. If false, the packet is disabled. Configs that don't
1776 have an associated command always have this set to auto. */
1777 enum auto_boolean detect
;
1779 /* Does the target support this packet? */
1780 enum packet_support support
;
1783 static enum packet_support
packet_config_support (struct packet_config
*config
);
1784 static enum packet_support
packet_support (int packet
);
1787 show_packet_config_cmd (struct packet_config
*config
)
1789 const char *support
= "internal-error";
1791 switch (packet_config_support (config
))
1794 support
= "enabled";
1796 case PACKET_DISABLE
:
1797 support
= "disabled";
1799 case PACKET_SUPPORT_UNKNOWN
:
1800 support
= "unknown";
1803 switch (config
->detect
)
1805 case AUTO_BOOLEAN_AUTO
:
1806 printf_filtered (_("Support for the `%s' packet "
1807 "is auto-detected, currently %s.\n"),
1808 config
->name
, support
);
1810 case AUTO_BOOLEAN_TRUE
:
1811 case AUTO_BOOLEAN_FALSE
:
1812 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1813 config
->name
, support
);
1819 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1820 const char *title
, int legacy
)
1826 config
->name
= name
;
1827 config
->title
= title
;
1828 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1830 show_doc
= xstrprintf ("Show current use of remote "
1831 "protocol `%s' (%s) packet.",
1833 /* set/show TITLE-packet {auto,on,off} */
1834 cmd_name
= xstrprintf ("%s-packet", title
);
1835 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1836 &config
->detect
, set_doc
,
1837 show_doc
, NULL
, /* help_doc */
1839 show_remote_protocol_packet_cmd
,
1840 &remote_set_cmdlist
, &remote_show_cmdlist
);
1841 /* The command code copies the documentation strings. */
1844 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1849 legacy_name
= xstrprintf ("%s-packet", name
);
1850 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1851 &remote_set_cmdlist
);
1852 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1853 &remote_show_cmdlist
);
1857 static enum packet_result
1858 packet_check_result (const char *buf
)
1862 /* The stub recognized the packet request. Check that the
1863 operation succeeded. */
1865 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1867 /* "Enn" - definitly an error. */
1868 return PACKET_ERROR
;
1870 /* Always treat "E." as an error. This will be used for
1871 more verbose error messages, such as E.memtypes. */
1872 if (buf
[0] == 'E' && buf
[1] == '.')
1873 return PACKET_ERROR
;
1875 /* The packet may or may not be OK. Just assume it is. */
1879 /* The stub does not support the packet. */
1880 return PACKET_UNKNOWN
;
1883 static enum packet_result
1884 packet_check_result (const gdb::char_vector
&buf
)
1886 return packet_check_result (buf
.data ());
1889 static enum packet_result
1890 packet_ok (const char *buf
, struct packet_config
*config
)
1892 enum packet_result result
;
1894 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1895 && config
->support
== PACKET_DISABLE
)
1896 internal_error (__FILE__
, __LINE__
,
1897 _("packet_ok: attempt to use a disabled packet"));
1899 result
= packet_check_result (buf
);
1904 /* The stub recognized the packet request. */
1905 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1908 fprintf_unfiltered (gdb_stdlog
,
1909 "Packet %s (%s) is supported\n",
1910 config
->name
, config
->title
);
1911 config
->support
= PACKET_ENABLE
;
1914 case PACKET_UNKNOWN
:
1915 /* The stub does not support the packet. */
1916 if (config
->detect
== AUTO_BOOLEAN_AUTO
1917 && config
->support
== PACKET_ENABLE
)
1919 /* If the stub previously indicated that the packet was
1920 supported then there is a protocol error. */
1921 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1922 config
->name
, config
->title
);
1924 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
1926 /* The user set it wrong. */
1927 error (_("Enabled packet %s (%s) not recognized by stub"),
1928 config
->name
, config
->title
);
1932 fprintf_unfiltered (gdb_stdlog
,
1933 "Packet %s (%s) is NOT supported\n",
1934 config
->name
, config
->title
);
1935 config
->support
= PACKET_DISABLE
;
1942 static enum packet_result
1943 packet_ok (const gdb::char_vector
&buf
, struct packet_config
*config
)
1945 return packet_ok (buf
.data (), config
);
1962 PACKET_vFile_pwrite
,
1964 PACKET_vFile_unlink
,
1965 PACKET_vFile_readlink
,
1968 PACKET_qXfer_features
,
1969 PACKET_qXfer_exec_file
,
1970 PACKET_qXfer_libraries
,
1971 PACKET_qXfer_libraries_svr4
,
1972 PACKET_qXfer_memory_map
,
1973 PACKET_qXfer_osdata
,
1974 PACKET_qXfer_threads
,
1975 PACKET_qXfer_statictrace_read
,
1976 PACKET_qXfer_traceframe_info
,
1982 PACKET_QPassSignals
,
1983 PACKET_QCatchSyscalls
,
1984 PACKET_QProgramSignals
,
1985 PACKET_QSetWorkingDir
,
1986 PACKET_QStartupWithShell
,
1987 PACKET_QEnvironmentHexEncoded
,
1988 PACKET_QEnvironmentReset
,
1989 PACKET_QEnvironmentUnset
,
1991 PACKET_qSearch_memory
,
1994 PACKET_QStartNoAckMode
,
1996 PACKET_qXfer_siginfo_read
,
1997 PACKET_qXfer_siginfo_write
,
2000 /* Support for conditional tracepoints. */
2001 PACKET_ConditionalTracepoints
,
2003 /* Support for target-side breakpoint conditions. */
2004 PACKET_ConditionalBreakpoints
,
2006 /* Support for target-side breakpoint commands. */
2007 PACKET_BreakpointCommands
,
2009 /* Support for fast tracepoints. */
2010 PACKET_FastTracepoints
,
2012 /* Support for static tracepoints. */
2013 PACKET_StaticTracepoints
,
2015 /* Support for installing tracepoints while a trace experiment is
2017 PACKET_InstallInTrace
,
2021 PACKET_TracepointSource
,
2024 PACKET_QDisableRandomization
,
2026 PACKET_QTBuffer_size
,
2030 PACKET_qXfer_btrace
,
2032 /* Support for the QNonStop packet. */
2035 /* Support for the QThreadEvents packet. */
2036 PACKET_QThreadEvents
,
2038 /* Support for multi-process extensions. */
2039 PACKET_multiprocess_feature
,
2041 /* Support for enabling and disabling tracepoints while a trace
2042 experiment is running. */
2043 PACKET_EnableDisableTracepoints_feature
,
2045 /* Support for collecting strings using the tracenz bytecode. */
2046 PACKET_tracenz_feature
,
2048 /* Support for continuing to run a trace experiment while GDB is
2050 PACKET_DisconnectedTracing_feature
,
2052 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2053 PACKET_augmented_libraries_svr4_read_feature
,
2055 /* Support for the qXfer:btrace-conf:read packet. */
2056 PACKET_qXfer_btrace_conf
,
2058 /* Support for the Qbtrace-conf:bts:size packet. */
2059 PACKET_Qbtrace_conf_bts_size
,
2061 /* Support for swbreak+ feature. */
2062 PACKET_swbreak_feature
,
2064 /* Support for hwbreak+ feature. */
2065 PACKET_hwbreak_feature
,
2067 /* Support for fork events. */
2068 PACKET_fork_event_feature
,
2070 /* Support for vfork events. */
2071 PACKET_vfork_event_feature
,
2073 /* Support for the Qbtrace-conf:pt:size packet. */
2074 PACKET_Qbtrace_conf_pt_size
,
2076 /* Support for exec events. */
2077 PACKET_exec_event_feature
,
2079 /* Support for query supported vCont actions. */
2080 PACKET_vContSupported
,
2082 /* Support remote CTRL-C. */
2085 /* Support TARGET_WAITKIND_NO_RESUMED. */
2091 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
2093 /* Returns the packet's corresponding "set remote foo-packet" command
2094 state. See struct packet_config for more details. */
2096 static enum auto_boolean
2097 packet_set_cmd_state (int packet
)
2099 return remote_protocol_packets
[packet
].detect
;
2102 /* Returns whether a given packet or feature is supported. This takes
2103 into account the state of the corresponding "set remote foo-packet"
2104 command, which may be used to bypass auto-detection. */
2106 static enum packet_support
2107 packet_config_support (struct packet_config
*config
)
2109 switch (config
->detect
)
2111 case AUTO_BOOLEAN_TRUE
:
2112 return PACKET_ENABLE
;
2113 case AUTO_BOOLEAN_FALSE
:
2114 return PACKET_DISABLE
;
2115 case AUTO_BOOLEAN_AUTO
:
2116 return config
->support
;
2118 gdb_assert_not_reached (_("bad switch"));
2122 /* Same as packet_config_support, but takes the packet's enum value as
2125 static enum packet_support
2126 packet_support (int packet
)
2128 struct packet_config
*config
= &remote_protocol_packets
[packet
];
2130 return packet_config_support (config
);
2134 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
2135 struct cmd_list_element
*c
,
2138 struct packet_config
*packet
;
2140 for (packet
= remote_protocol_packets
;
2141 packet
< &remote_protocol_packets
[PACKET_MAX
];
2144 if (&packet
->detect
== c
->var
)
2146 show_packet_config_cmd (packet
);
2150 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
2154 /* Should we try one of the 'Z' requests? */
2158 Z_PACKET_SOFTWARE_BP
,
2159 Z_PACKET_HARDWARE_BP
,
2166 /* For compatibility with older distributions. Provide a ``set remote
2167 Z-packet ...'' command that updates all the Z packet types. */
2169 static enum auto_boolean remote_Z_packet_detect
;
2172 set_remote_protocol_Z_packet_cmd (const char *args
, int from_tty
,
2173 struct cmd_list_element
*c
)
2177 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2178 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
2182 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
2183 struct cmd_list_element
*c
,
2188 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2190 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
2194 /* Returns true if the multi-process extensions are in effect. */
2197 remote_multi_process_p (struct remote_state
*rs
)
2199 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
2202 /* Returns true if fork events are supported. */
2205 remote_fork_event_p (struct remote_state
*rs
)
2207 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
2210 /* Returns true if vfork events are supported. */
2213 remote_vfork_event_p (struct remote_state
*rs
)
2215 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
2218 /* Returns true if exec events are supported. */
2221 remote_exec_event_p (struct remote_state
*rs
)
2223 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
2226 /* Insert fork catchpoint target routine. If fork events are enabled
2227 then return success, nothing more to do. */
2230 remote_target::insert_fork_catchpoint (int pid
)
2232 struct remote_state
*rs
= get_remote_state ();
2234 return !remote_fork_event_p (rs
);
2237 /* Remove fork catchpoint target routine. Nothing to do, just
2241 remote_target::remove_fork_catchpoint (int pid
)
2246 /* Insert vfork catchpoint target routine. If vfork events are enabled
2247 then return success, nothing more to do. */
2250 remote_target::insert_vfork_catchpoint (int pid
)
2252 struct remote_state
*rs
= get_remote_state ();
2254 return !remote_vfork_event_p (rs
);
2257 /* Remove vfork catchpoint target routine. Nothing to do, just
2261 remote_target::remove_vfork_catchpoint (int pid
)
2266 /* Insert exec catchpoint target routine. If exec events are
2267 enabled, just return success. */
2270 remote_target::insert_exec_catchpoint (int pid
)
2272 struct remote_state
*rs
= get_remote_state ();
2274 return !remote_exec_event_p (rs
);
2277 /* Remove exec catchpoint target routine. Nothing to do, just
2281 remote_target::remove_exec_catchpoint (int pid
)
2288 /* Take advantage of the fact that the TID field is not used, to tag
2289 special ptids with it set to != 0. */
2290 static const ptid_t
magic_null_ptid (42000, -1, 1);
2291 static const ptid_t
not_sent_ptid (42000, -2, 1);
2292 static const ptid_t
any_thread_ptid (42000, 0, 1);
2294 /* Find out if the stub attached to PID (and hence GDB should offer to
2295 detach instead of killing it when bailing out). */
2298 remote_target::remote_query_attached (int pid
)
2300 struct remote_state
*rs
= get_remote_state ();
2301 size_t size
= get_remote_packet_size ();
2303 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
2306 if (remote_multi_process_p (rs
))
2307 xsnprintf (rs
->buf
.data (), size
, "qAttached:%x", pid
);
2309 xsnprintf (rs
->buf
.data (), size
, "qAttached");
2312 getpkt (&rs
->buf
, 0);
2314 switch (packet_ok (rs
->buf
,
2315 &remote_protocol_packets
[PACKET_qAttached
]))
2318 if (strcmp (rs
->buf
.data (), "1") == 0)
2322 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
2324 case PACKET_UNKNOWN
:
2331 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2332 has been invented by GDB, instead of reported by the target. Since
2333 we can be connected to a remote system before before knowing about
2334 any inferior, mark the target with execution when we find the first
2335 inferior. If ATTACHED is 1, then we had just attached to this
2336 inferior. If it is 0, then we just created this inferior. If it
2337 is -1, then try querying the remote stub to find out if it had
2338 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2339 attempt to open this inferior's executable as the main executable
2340 if no main executable is open already. */
2343 remote_target::remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
2346 struct inferior
*inf
;
2348 /* Check whether this process we're learning about is to be
2349 considered attached, or if is to be considered to have been
2350 spawned by the stub. */
2352 attached
= remote_query_attached (pid
);
2354 if (gdbarch_has_global_solist (target_gdbarch ()))
2356 /* If the target shares code across all inferiors, then every
2357 attach adds a new inferior. */
2358 inf
= add_inferior (pid
);
2360 /* ... and every inferior is bound to the same program space.
2361 However, each inferior may still have its own address
2363 inf
->aspace
= maybe_new_address_space ();
2364 inf
->pspace
= current_program_space
;
2368 /* In the traditional debugging scenario, there's a 1-1 match
2369 between program/address spaces. We simply bind the inferior
2370 to the program space's address space. */
2371 inf
= current_inferior ();
2372 inferior_appeared (inf
, pid
);
2375 inf
->attach_flag
= attached
;
2376 inf
->fake_pid_p
= fake_pid_p
;
2378 /* If no main executable is currently open then attempt to
2379 open the file that was executed to create this inferior. */
2380 if (try_open_exec
&& get_exec_file (0) == NULL
)
2381 exec_file_locate_attach (pid
, 0, 1);
2386 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2387 static remote_thread_info
*get_remote_thread_info (ptid_t ptid
);
2389 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2390 according to RUNNING. */
2393 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
)
2395 struct remote_state
*rs
= get_remote_state ();
2396 struct thread_info
*thread
;
2398 /* GDB historically didn't pull threads in the initial connection
2399 setup. If the remote target doesn't even have a concept of
2400 threads (e.g., a bare-metal target), even if internally we
2401 consider that a single-threaded target, mentioning a new thread
2402 might be confusing to the user. Be silent then, preserving the
2403 age old behavior. */
2404 if (rs
->starting_up
)
2405 thread
= add_thread_silent (ptid
);
2407 thread
= add_thread (ptid
);
2409 get_remote_thread_info (thread
)->vcont_resumed
= executing
;
2410 set_executing (ptid
, executing
);
2411 set_running (ptid
, running
);
2416 /* Come here when we learn about a thread id from the remote target.
2417 It may be the first time we hear about such thread, so take the
2418 opportunity to add it to GDB's thread list. In case this is the
2419 first time we're noticing its corresponding inferior, add it to
2420 GDB's inferior list as well. EXECUTING indicates whether the
2421 thread is (internally) executing or stopped. */
2424 remote_target::remote_notice_new_inferior (ptid_t currthread
, int executing
)
2426 /* In non-stop mode, we assume new found threads are (externally)
2427 running until proven otherwise with a stop reply. In all-stop,
2428 we can only get here if all threads are stopped. */
2429 int running
= target_is_non_stop_p () ? 1 : 0;
2431 /* If this is a new thread, add it to GDB's thread list.
2432 If we leave it up to WFI to do this, bad things will happen. */
2434 thread_info
*tp
= find_thread_ptid (currthread
);
2435 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2437 /* We're seeing an event on a thread id we knew had exited.
2438 This has to be a new thread reusing the old id. Add it. */
2439 remote_add_thread (currthread
, running
, executing
);
2443 if (!in_thread_list (currthread
))
2445 struct inferior
*inf
= NULL
;
2446 int pid
= currthread
.pid ();
2448 if (inferior_ptid
.is_pid ()
2449 && pid
== inferior_ptid
.pid ())
2451 /* inferior_ptid has no thread member yet. This can happen
2452 with the vAttach -> remote_wait,"TAAthread:" path if the
2453 stub doesn't support qC. This is the first stop reported
2454 after an attach, so this is the main thread. Update the
2455 ptid in the thread list. */
2456 if (in_thread_list (ptid_t (pid
)))
2457 thread_change_ptid (inferior_ptid
, currthread
);
2460 remote_add_thread (currthread
, running
, executing
);
2461 inferior_ptid
= currthread
;
2466 if (magic_null_ptid
== inferior_ptid
)
2468 /* inferior_ptid is not set yet. This can happen with the
2469 vRun -> remote_wait,"TAAthread:" path if the stub
2470 doesn't support qC. This is the first stop reported
2471 after an attach, so this is the main thread. Update the
2472 ptid in the thread list. */
2473 thread_change_ptid (inferior_ptid
, currthread
);
2477 /* When connecting to a target remote, or to a target
2478 extended-remote which already was debugging an inferior, we
2479 may not know about it yet. Add it before adding its child
2480 thread, so notifications are emitted in a sensible order. */
2481 if (find_inferior_pid (currthread
.pid ()) == NULL
)
2483 struct remote_state
*rs
= get_remote_state ();
2484 bool fake_pid_p
= !remote_multi_process_p (rs
);
2486 inf
= remote_add_inferior (fake_pid_p
,
2487 currthread
.pid (), -1, 1);
2490 /* This is really a new thread. Add it. */
2491 thread_info
*new_thr
2492 = remote_add_thread (currthread
, running
, executing
);
2494 /* If we found a new inferior, let the common code do whatever
2495 it needs to with it (e.g., read shared libraries, insert
2496 breakpoints), unless we're just setting up an all-stop
2500 struct remote_state
*rs
= get_remote_state ();
2502 if (!rs
->starting_up
)
2503 notice_new_inferior (new_thr
, executing
, 0);
2508 /* Return THREAD's private thread data, creating it if necessary. */
2510 static remote_thread_info
*
2511 get_remote_thread_info (thread_info
*thread
)
2513 gdb_assert (thread
!= NULL
);
2515 if (thread
->priv
== NULL
)
2516 thread
->priv
.reset (new remote_thread_info
);
2518 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2521 static remote_thread_info
*
2522 get_remote_thread_info (ptid_t ptid
)
2524 thread_info
*thr
= find_thread_ptid (ptid
);
2525 return get_remote_thread_info (thr
);
2528 /* Call this function as a result of
2529 1) A halt indication (T packet) containing a thread id
2530 2) A direct query of currthread
2531 3) Successful execution of set thread */
2534 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2536 rs
->general_thread
= currthread
;
2539 /* If 'QPassSignals' is supported, tell the remote stub what signals
2540 it can simply pass through to the inferior without reporting. */
2543 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2545 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2547 char *pass_packet
, *p
;
2549 struct remote_state
*rs
= get_remote_state ();
2551 gdb_assert (pass_signals
.size () < 256);
2552 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2554 if (pass_signals
[i
])
2557 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2558 strcpy (pass_packet
, "QPassSignals:");
2559 p
= pass_packet
+ strlen (pass_packet
);
2560 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2562 if (pass_signals
[i
])
2565 *p
++ = tohex (i
>> 4);
2566 *p
++ = tohex (i
& 15);
2575 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2577 putpkt (pass_packet
);
2578 getpkt (&rs
->buf
, 0);
2579 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2580 if (rs
->last_pass_packet
)
2581 xfree (rs
->last_pass_packet
);
2582 rs
->last_pass_packet
= pass_packet
;
2585 xfree (pass_packet
);
2589 /* If 'QCatchSyscalls' is supported, tell the remote stub
2590 to report syscalls to GDB. */
2593 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2594 gdb::array_view
<const int> syscall_counts
)
2596 const char *catch_packet
;
2597 enum packet_result result
;
2600 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2602 /* Not supported. */
2606 if (needed
&& any_count
== 0)
2608 /* Count how many syscalls are to be caught. */
2609 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2611 if (syscall_counts
[i
] != 0)
2618 fprintf_unfiltered (gdb_stdlog
,
2619 "remote_set_syscall_catchpoint "
2620 "pid %d needed %d any_count %d n_sysno %d\n",
2621 pid
, needed
, any_count
, n_sysno
);
2624 std::string built_packet
;
2627 /* Prepare a packet with the sysno list, assuming max 8+1
2628 characters for a sysno. If the resulting packet size is too
2629 big, fallback on the non-selective packet. */
2630 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2631 built_packet
.reserve (maxpktsz
);
2632 built_packet
= "QCatchSyscalls:1";
2635 /* Add in each syscall to be caught. */
2636 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2638 if (syscall_counts
[i
] != 0)
2639 string_appendf (built_packet
, ";%zx", i
);
2642 if (built_packet
.size () > get_remote_packet_size ())
2644 /* catch_packet too big. Fallback to less efficient
2645 non selective mode, with GDB doing the filtering. */
2646 catch_packet
= "QCatchSyscalls:1";
2649 catch_packet
= built_packet
.c_str ();
2652 catch_packet
= "QCatchSyscalls:0";
2654 struct remote_state
*rs
= get_remote_state ();
2656 putpkt (catch_packet
);
2657 getpkt (&rs
->buf
, 0);
2658 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2659 if (result
== PACKET_OK
)
2665 /* If 'QProgramSignals' is supported, tell the remote stub what
2666 signals it should pass through to the inferior when detaching. */
2669 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2671 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2675 struct remote_state
*rs
= get_remote_state ();
2677 gdb_assert (signals
.size () < 256);
2678 for (size_t i
= 0; i
< signals
.size (); i
++)
2683 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2684 strcpy (packet
, "QProgramSignals:");
2685 p
= packet
+ strlen (packet
);
2686 for (size_t i
= 0; i
< signals
.size (); i
++)
2688 if (signal_pass_state (i
))
2691 *p
++ = tohex (i
>> 4);
2692 *p
++ = tohex (i
& 15);
2701 if (!rs
->last_program_signals_packet
2702 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2705 getpkt (&rs
->buf
, 0);
2706 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2707 xfree (rs
->last_program_signals_packet
);
2708 rs
->last_program_signals_packet
= packet
;
2715 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2716 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2717 thread. If GEN is set, set the general thread, if not, then set
2718 the step/continue thread. */
2720 remote_target::set_thread (ptid_t ptid
, int gen
)
2722 struct remote_state
*rs
= get_remote_state ();
2723 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2724 char *buf
= rs
->buf
.data ();
2725 char *endbuf
= buf
+ get_remote_packet_size ();
2731 *buf
++ = gen
? 'g' : 'c';
2732 if (ptid
== magic_null_ptid
)
2733 xsnprintf (buf
, endbuf
- buf
, "0");
2734 else if (ptid
== any_thread_ptid
)
2735 xsnprintf (buf
, endbuf
- buf
, "0");
2736 else if (ptid
== minus_one_ptid
)
2737 xsnprintf (buf
, endbuf
- buf
, "-1");
2739 write_ptid (buf
, endbuf
, ptid
);
2741 getpkt (&rs
->buf
, 0);
2743 rs
->general_thread
= ptid
;
2745 rs
->continue_thread
= ptid
;
2749 remote_target::set_general_thread (ptid_t ptid
)
2751 set_thread (ptid
, 1);
2755 remote_target::set_continue_thread (ptid_t ptid
)
2757 set_thread (ptid
, 0);
2760 /* Change the remote current process. Which thread within the process
2761 ends up selected isn't important, as long as it is the same process
2762 as what INFERIOR_PTID points to.
2764 This comes from that fact that there is no explicit notion of
2765 "selected process" in the protocol. The selected process for
2766 general operations is the process the selected general thread
2770 remote_target::set_general_process ()
2772 struct remote_state
*rs
= get_remote_state ();
2774 /* If the remote can't handle multiple processes, don't bother. */
2775 if (!remote_multi_process_p (rs
))
2778 /* We only need to change the remote current thread if it's pointing
2779 at some other process. */
2780 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2781 set_general_thread (inferior_ptid
);
2785 /* Return nonzero if this is the main thread that we made up ourselves
2786 to model non-threaded targets as single-threaded. */
2789 remote_thread_always_alive (ptid_t ptid
)
2791 if (ptid
== magic_null_ptid
)
2792 /* The main thread is always alive. */
2795 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2796 /* The main thread is always alive. This can happen after a
2797 vAttach, if the remote side doesn't support
2804 /* Return nonzero if the thread PTID is still alive on the remote
2808 remote_target::thread_alive (ptid_t ptid
)
2810 struct remote_state
*rs
= get_remote_state ();
2813 /* Check if this is a thread that we made up ourselves to model
2814 non-threaded targets as single-threaded. */
2815 if (remote_thread_always_alive (ptid
))
2818 p
= rs
->buf
.data ();
2819 endp
= p
+ get_remote_packet_size ();
2822 write_ptid (p
, endp
, ptid
);
2825 getpkt (&rs
->buf
, 0);
2826 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2829 /* Return a pointer to a thread name if we know it and NULL otherwise.
2830 The thread_info object owns the memory for the name. */
2833 remote_target::thread_name (struct thread_info
*info
)
2835 if (info
->priv
!= NULL
)
2837 const std::string
&name
= get_remote_thread_info (info
)->name
;
2838 return !name
.empty () ? name
.c_str () : NULL
;
2844 /* About these extended threadlist and threadinfo packets. They are
2845 variable length packets but, the fields within them are often fixed
2846 length. They are redundent enough to send over UDP as is the
2847 remote protocol in general. There is a matching unit test module
2850 /* WARNING: This threadref data structure comes from the remote O.S.,
2851 libstub protocol encoding, and remote.c. It is not particularly
2854 /* Right now, the internal structure is int. We want it to be bigger.
2855 Plan to fix this. */
2857 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2859 /* gdb_ext_thread_info is an internal GDB data structure which is
2860 equivalent to the reply of the remote threadinfo packet. */
2862 struct gdb_ext_thread_info
2864 threadref threadid
; /* External form of thread reference. */
2865 int active
; /* Has state interesting to GDB?
2867 char display
[256]; /* Brief state display, name,
2868 blocked/suspended. */
2869 char shortname
[32]; /* To be used to name threads. */
2870 char more_display
[256]; /* Long info, statistics, queue depth,
2874 /* The volume of remote transfers can be limited by submitting
2875 a mask containing bits specifying the desired information.
2876 Use a union of these values as the 'selection' parameter to
2877 get_thread_info. FIXME: Make these TAG names more thread specific. */
2879 #define TAG_THREADID 1
2880 #define TAG_EXISTS 2
2881 #define TAG_DISPLAY 4
2882 #define TAG_THREADNAME 8
2883 #define TAG_MOREDISPLAY 16
2885 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2887 static char *unpack_nibble (char *buf
, int *val
);
2889 static char *unpack_byte (char *buf
, int *value
);
2891 static char *pack_int (char *buf
, int value
);
2893 static char *unpack_int (char *buf
, int *value
);
2895 static char *unpack_string (char *src
, char *dest
, int length
);
2897 static char *pack_threadid (char *pkt
, threadref
*id
);
2899 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2901 void int_to_threadref (threadref
*id
, int value
);
2903 static int threadref_to_int (threadref
*ref
);
2905 static void copy_threadref (threadref
*dest
, threadref
*src
);
2907 static int threadmatch (threadref
*dest
, threadref
*src
);
2909 static char *pack_threadinfo_request (char *pkt
, int mode
,
2912 static char *pack_threadlist_request (char *pkt
, int startflag
,
2914 threadref
*nextthread
);
2916 static int remote_newthread_step (threadref
*ref
, void *context
);
2919 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2920 buffer we're allowed to write to. Returns
2921 BUF+CHARACTERS_WRITTEN. */
2924 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2927 struct remote_state
*rs
= get_remote_state ();
2929 if (remote_multi_process_p (rs
))
2933 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2935 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2939 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2941 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2946 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2947 last parsed char. Returns null_ptid if no thread id is found, and
2948 throws an error if the thread id has an invalid format. */
2951 read_ptid (const char *buf
, const char **obuf
)
2953 const char *p
= buf
;
2955 ULONGEST pid
= 0, tid
= 0;
2959 /* Multi-process ptid. */
2960 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2962 error (_("invalid remote ptid: %s"), p
);
2965 pp
= unpack_varlen_hex (p
+ 1, &tid
);
2968 return ptid_t (pid
, tid
, 0);
2971 /* No multi-process. Just a tid. */
2972 pp
= unpack_varlen_hex (p
, &tid
);
2974 /* Return null_ptid when no thread id is found. */
2982 /* Since the stub is not sending a process id, then default to
2983 what's in inferior_ptid, unless it's null at this point. If so,
2984 then since there's no way to know the pid of the reported
2985 threads, use the magic number. */
2986 if (inferior_ptid
== null_ptid
)
2987 pid
= magic_null_ptid
.pid ();
2989 pid
= inferior_ptid
.pid ();
2993 return ptid_t (pid
, tid
, 0);
2999 if (ch
>= 'a' && ch
<= 'f')
3000 return ch
- 'a' + 10;
3001 if (ch
>= '0' && ch
<= '9')
3003 if (ch
>= 'A' && ch
<= 'F')
3004 return ch
- 'A' + 10;
3009 stub_unpack_int (char *buff
, int fieldlength
)
3016 nibble
= stubhex (*buff
++);
3020 retval
= retval
<< 4;
3026 unpack_nibble (char *buf
, int *val
)
3028 *val
= fromhex (*buf
++);
3033 unpack_byte (char *buf
, int *value
)
3035 *value
= stub_unpack_int (buf
, 2);
3040 pack_int (char *buf
, int value
)
3042 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3043 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3044 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3045 buf
= pack_hex_byte (buf
, (value
& 0xff));
3050 unpack_int (char *buf
, int *value
)
3052 *value
= stub_unpack_int (buf
, 8);
3056 #if 0 /* Currently unused, uncomment when needed. */
3057 static char *pack_string (char *pkt
, char *string
);
3060 pack_string (char *pkt
, char *string
)
3065 len
= strlen (string
);
3067 len
= 200; /* Bigger than most GDB packets, junk??? */
3068 pkt
= pack_hex_byte (pkt
, len
);
3072 if ((ch
== '\0') || (ch
== '#'))
3073 ch
= '*'; /* Protect encapsulation. */
3078 #endif /* 0 (unused) */
3081 unpack_string (char *src
, char *dest
, int length
)
3090 pack_threadid (char *pkt
, threadref
*id
)
3093 unsigned char *altid
;
3095 altid
= (unsigned char *) id
;
3096 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3098 pkt
= pack_hex_byte (pkt
, *altid
++);
3104 unpack_threadid (char *inbuf
, threadref
*id
)
3107 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3110 altref
= (char *) id
;
3112 while (inbuf
< limit
)
3114 x
= stubhex (*inbuf
++);
3115 y
= stubhex (*inbuf
++);
3116 *altref
++ = (x
<< 4) | y
;
3121 /* Externally, threadrefs are 64 bits but internally, they are still
3122 ints. This is due to a mismatch of specifications. We would like
3123 to use 64bit thread references internally. This is an adapter
3127 int_to_threadref (threadref
*id
, int value
)
3129 unsigned char *scan
;
3131 scan
= (unsigned char *) id
;
3137 *scan
++ = (value
>> 24) & 0xff;
3138 *scan
++ = (value
>> 16) & 0xff;
3139 *scan
++ = (value
>> 8) & 0xff;
3140 *scan
++ = (value
& 0xff);
3144 threadref_to_int (threadref
*ref
)
3147 unsigned char *scan
;
3153 value
= (value
<< 8) | ((*scan
++) & 0xff);
3158 copy_threadref (threadref
*dest
, threadref
*src
)
3161 unsigned char *csrc
, *cdest
;
3163 csrc
= (unsigned char *) src
;
3164 cdest
= (unsigned char *) dest
;
3171 threadmatch (threadref
*dest
, threadref
*src
)
3173 /* Things are broken right now, so just assume we got a match. */
3175 unsigned char *srcp
, *destp
;
3177 srcp
= (char *) src
;
3178 destp
= (char *) dest
;
3182 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3189 threadid:1, # always request threadid
3196 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3199 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3201 *pkt
++ = 'q'; /* Info Query */
3202 *pkt
++ = 'P'; /* process or thread info */
3203 pkt
= pack_int (pkt
, mode
); /* mode */
3204 pkt
= pack_threadid (pkt
, id
); /* threadid */
3205 *pkt
= '\0'; /* terminate */
3209 /* These values tag the fields in a thread info response packet. */
3210 /* Tagging the fields allows us to request specific fields and to
3211 add more fields as time goes by. */
3213 #define TAG_THREADID 1 /* Echo the thread identifier. */
3214 #define TAG_EXISTS 2 /* Is this process defined enough to
3215 fetch registers and its stack? */
3216 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3217 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3218 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3222 remote_target::remote_unpack_thread_info_response (char *pkt
,
3223 threadref
*expectedref
,
3224 gdb_ext_thread_info
*info
)
3226 struct remote_state
*rs
= get_remote_state ();
3230 char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3233 /* info->threadid = 0; FIXME: implement zero_threadref. */
3235 info
->display
[0] = '\0';
3236 info
->shortname
[0] = '\0';
3237 info
->more_display
[0] = '\0';
3239 /* Assume the characters indicating the packet type have been
3241 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3242 pkt
= unpack_threadid (pkt
, &ref
);
3245 warning (_("Incomplete response to threadinfo request."));
3246 if (!threadmatch (&ref
, expectedref
))
3247 { /* This is an answer to a different request. */
3248 warning (_("ERROR RMT Thread info mismatch."));
3251 copy_threadref (&info
->threadid
, &ref
);
3253 /* Loop on tagged fields , try to bail if somthing goes wrong. */
3255 /* Packets are terminated with nulls. */
3256 while ((pkt
< limit
) && mask
&& *pkt
)
3258 pkt
= unpack_int (pkt
, &tag
); /* tag */
3259 pkt
= unpack_byte (pkt
, &length
); /* length */
3260 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3262 warning (_("ERROR RMT: threadinfo tag mismatch."));
3266 if (tag
== TAG_THREADID
)
3270 warning (_("ERROR RMT: length of threadid is not 16."));
3274 pkt
= unpack_threadid (pkt
, &ref
);
3275 mask
= mask
& ~TAG_THREADID
;
3278 if (tag
== TAG_EXISTS
)
3280 info
->active
= stub_unpack_int (pkt
, length
);
3282 mask
= mask
& ~(TAG_EXISTS
);
3285 warning (_("ERROR RMT: 'exists' length too long."));
3291 if (tag
== TAG_THREADNAME
)
3293 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3294 mask
= mask
& ~TAG_THREADNAME
;
3297 if (tag
== TAG_DISPLAY
)
3299 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3300 mask
= mask
& ~TAG_DISPLAY
;
3303 if (tag
== TAG_MOREDISPLAY
)
3305 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3306 mask
= mask
& ~TAG_MOREDISPLAY
;
3309 warning (_("ERROR RMT: unknown thread info tag."));
3310 break; /* Not a tag we know about. */
3316 remote_target::remote_get_threadinfo (threadref
*threadid
,
3318 gdb_ext_thread_info
*info
)
3320 struct remote_state
*rs
= get_remote_state ();
3323 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3325 getpkt (&rs
->buf
, 0);
3327 if (rs
->buf
[0] == '\0')
3330 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3335 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3338 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3339 threadref
*nextthread
)
3341 *pkt
++ = 'q'; /* info query packet */
3342 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3343 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3344 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3345 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3350 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3353 remote_target::parse_threadlist_response (char *pkt
, int result_limit
,
3354 threadref
*original_echo
,
3355 threadref
*resultlist
,
3358 struct remote_state
*rs
= get_remote_state ();
3360 int count
, resultcount
, done
;
3363 /* Assume the 'q' and 'M chars have been stripped. */
3364 limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3365 /* done parse past here */
3366 pkt
= unpack_byte (pkt
, &count
); /* count field */
3367 pkt
= unpack_nibble (pkt
, &done
);
3368 /* The first threadid is the argument threadid. */
3369 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3370 while ((count
-- > 0) && (pkt
< limit
))
3372 pkt
= unpack_threadid (pkt
, resultlist
++);
3373 if (resultcount
++ >= result_limit
)
3381 /* Fetch the next batch of threads from the remote. Returns -1 if the
3382 qL packet is not supported, 0 on error and 1 on success. */
3385 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3386 int result_limit
, int *done
, int *result_count
,
3387 threadref
*threadlist
)
3389 struct remote_state
*rs
= get_remote_state ();
3392 /* Trancate result limit to be smaller than the packet size. */
3393 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3394 >= get_remote_packet_size ())
3395 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3397 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3400 getpkt (&rs
->buf
, 0);
3401 if (rs
->buf
[0] == '\0')
3403 /* Packet not supported. */
3408 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3409 &rs
->echo_nextthread
, threadlist
, done
);
3411 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3413 /* FIXME: This is a good reason to drop the packet. */
3414 /* Possably, there is a duplicate response. */
3416 retransmit immediatly - race conditions
3417 retransmit after timeout - yes
3419 wait for packet, then exit
3421 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3422 return 0; /* I choose simply exiting. */
3424 if (*result_count
<= 0)
3428 warning (_("RMT ERROR : failed to get remote thread list."));
3431 return result
; /* break; */
3433 if (*result_count
> result_limit
)
3436 warning (_("RMT ERROR: threadlist response longer than requested."));
3442 /* Fetch the list of remote threads, with the qL packet, and call
3443 STEPFUNCTION for each thread found. Stops iterating and returns 1
3444 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3445 STEPFUNCTION returns false. If the packet is not supported,
3449 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3450 void *context
, int looplimit
)
3452 struct remote_state
*rs
= get_remote_state ();
3453 int done
, i
, result_count
;
3461 if (loopcount
++ > looplimit
)
3464 warning (_("Remote fetch threadlist -infinite loop-."));
3467 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3468 MAXTHREADLISTRESULTS
,
3469 &done
, &result_count
,
3470 rs
->resultthreadlist
);
3473 /* Clear for later iterations. */
3475 /* Setup to resume next batch of thread references, set nextthread. */
3476 if (result_count
>= 1)
3477 copy_threadref (&rs
->nextthread
,
3478 &rs
->resultthreadlist
[result_count
- 1]);
3480 while (result_count
--)
3482 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3492 /* A thread found on the remote target. */
3496 explicit thread_item (ptid_t ptid_
)
3500 thread_item (thread_item
&&other
) = default;
3501 thread_item
&operator= (thread_item
&&other
) = default;
3503 DISABLE_COPY_AND_ASSIGN (thread_item
);
3505 /* The thread's PTID. */
3508 /* The thread's extra info. */
3511 /* The thread's name. */
3514 /* The core the thread was running on. -1 if not known. */
3517 /* The thread handle associated with the thread. */
3518 gdb::byte_vector thread_handle
;
3521 /* Context passed around to the various methods listing remote
3522 threads. As new threads are found, they're added to the ITEMS
3525 struct threads_listing_context
3527 /* Return true if this object contains an entry for a thread with ptid
3530 bool contains_thread (ptid_t ptid
) const
3532 auto match_ptid
= [&] (const thread_item
&item
)
3534 return item
.ptid
== ptid
;
3537 auto it
= std::find_if (this->items
.begin (),
3541 return it
!= this->items
.end ();
3544 /* Remove the thread with ptid PTID. */
3546 void remove_thread (ptid_t ptid
)
3548 auto match_ptid
= [&] (const thread_item
&item
)
3550 return item
.ptid
== ptid
;
3553 auto it
= std::remove_if (this->items
.begin (),
3557 if (it
!= this->items
.end ())
3558 this->items
.erase (it
);
3561 /* The threads found on the remote target. */
3562 std::vector
<thread_item
> items
;
3566 remote_newthread_step (threadref
*ref
, void *data
)
3568 struct threads_listing_context
*context
3569 = (struct threads_listing_context
*) data
;
3570 int pid
= inferior_ptid
.pid ();
3571 int lwp
= threadref_to_int (ref
);
3572 ptid_t
ptid (pid
, lwp
);
3574 context
->items
.emplace_back (ptid
);
3576 return 1; /* continue iterator */
3579 #define CRAZY_MAX_THREADS 1000
3582 remote_target::remote_current_thread (ptid_t oldpid
)
3584 struct remote_state
*rs
= get_remote_state ();
3587 getpkt (&rs
->buf
, 0);
3588 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3593 result
= read_ptid (&rs
->buf
[2], &obuf
);
3594 if (*obuf
!= '\0' && remote_debug
)
3595 fprintf_unfiltered (gdb_stdlog
,
3596 "warning: garbage in qC reply\n");
3604 /* List remote threads using the deprecated qL packet. */
3607 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3609 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3610 CRAZY_MAX_THREADS
) >= 0)
3616 #if defined(HAVE_LIBEXPAT)
3619 start_thread (struct gdb_xml_parser
*parser
,
3620 const struct gdb_xml_element
*element
,
3622 std::vector
<gdb_xml_value
> &attributes
)
3624 struct threads_listing_context
*data
3625 = (struct threads_listing_context
*) user_data
;
3626 struct gdb_xml_value
*attr
;
3628 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3629 ptid_t ptid
= read_ptid (id
, NULL
);
3631 data
->items
.emplace_back (ptid
);
3632 thread_item
&item
= data
->items
.back ();
3634 attr
= xml_find_attribute (attributes
, "core");
3636 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3638 attr
= xml_find_attribute (attributes
, "name");
3640 item
.name
= (const char *) attr
->value
.get ();
3642 attr
= xml_find_attribute (attributes
, "handle");
3644 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3648 end_thread (struct gdb_xml_parser
*parser
,
3649 const struct gdb_xml_element
*element
,
3650 void *user_data
, const char *body_text
)
3652 struct threads_listing_context
*data
3653 = (struct threads_listing_context
*) user_data
;
3655 if (body_text
!= NULL
&& *body_text
!= '\0')
3656 data
->items
.back ().extra
= body_text
;
3659 const struct gdb_xml_attribute thread_attributes
[] = {
3660 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3661 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3662 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3663 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3664 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3667 const struct gdb_xml_element thread_children
[] = {
3668 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3671 const struct gdb_xml_element threads_children
[] = {
3672 { "thread", thread_attributes
, thread_children
,
3673 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3674 start_thread
, end_thread
},
3675 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3678 const struct gdb_xml_element threads_elements
[] = {
3679 { "threads", NULL
, threads_children
,
3680 GDB_XML_EF_NONE
, NULL
, NULL
},
3681 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3686 /* List remote threads using qXfer:threads:read. */
3689 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3691 #if defined(HAVE_LIBEXPAT)
3692 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3694 gdb::optional
<gdb::char_vector
> xml
3695 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3697 if (xml
&& (*xml
)[0] != '\0')
3699 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3700 threads_elements
, xml
->data (), context
);
3710 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3713 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3715 struct remote_state
*rs
= get_remote_state ();
3717 if (rs
->use_threadinfo_query
)
3721 putpkt ("qfThreadInfo");
3722 getpkt (&rs
->buf
, 0);
3723 bufp
= rs
->buf
.data ();
3724 if (bufp
[0] != '\0') /* q packet recognized */
3726 while (*bufp
++ == 'm') /* reply contains one or more TID */
3730 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3731 context
->items
.emplace_back (ptid
);
3733 while (*bufp
++ == ','); /* comma-separated list */
3734 putpkt ("qsThreadInfo");
3735 getpkt (&rs
->buf
, 0);
3736 bufp
= rs
->buf
.data ();
3742 /* Packet not recognized. */
3743 rs
->use_threadinfo_query
= 0;
3750 /* Implement the to_update_thread_list function for the remote
3754 remote_target::update_thread_list ()
3756 struct threads_listing_context context
;
3759 /* We have a few different mechanisms to fetch the thread list. Try
3760 them all, starting with the most preferred one first, falling
3761 back to older methods. */
3762 if (remote_get_threads_with_qxfer (&context
)
3763 || remote_get_threads_with_qthreadinfo (&context
)
3764 || remote_get_threads_with_ql (&context
))
3768 if (context
.items
.empty ()
3769 && remote_thread_always_alive (inferior_ptid
))
3771 /* Some targets don't really support threads, but still
3772 reply an (empty) thread list in response to the thread
3773 listing packets, instead of replying "packet not
3774 supported". Exit early so we don't delete the main
3779 /* CONTEXT now holds the current thread list on the remote
3780 target end. Delete GDB-side threads no longer found on the
3782 for (thread_info
*tp
: all_threads_safe ())
3784 if (!context
.contains_thread (tp
->ptid
))
3791 /* Remove any unreported fork child threads from CONTEXT so
3792 that we don't interfere with follow fork, which is where
3793 creation of such threads is handled. */
3794 remove_new_fork_children (&context
);
3796 /* And now add threads we don't know about yet to our list. */
3797 for (thread_item
&item
: context
.items
)
3799 if (item
.ptid
!= null_ptid
)
3801 /* In non-stop mode, we assume new found threads are
3802 executing until proven otherwise with a stop reply.
3803 In all-stop, we can only get here if all threads are
3805 int executing
= target_is_non_stop_p () ? 1 : 0;
3807 remote_notice_new_inferior (item
.ptid
, executing
);
3809 thread_info
*tp
= find_thread_ptid (item
.ptid
);
3810 remote_thread_info
*info
= get_remote_thread_info (tp
);
3811 info
->core
= item
.core
;
3812 info
->extra
= std::move (item
.extra
);
3813 info
->name
= std::move (item
.name
);
3814 info
->thread_handle
= std::move (item
.thread_handle
);
3821 /* If no thread listing method is supported, then query whether
3822 each known thread is alive, one by one, with the T packet.
3823 If the target doesn't support threads at all, then this is a
3824 no-op. See remote_thread_alive. */
3830 * Collect a descriptive string about the given thread.
3831 * The target may say anything it wants to about the thread
3832 * (typically info about its blocked / runnable state, name, etc.).
3833 * This string will appear in the info threads display.
3835 * Optional: targets are not required to implement this function.
3839 remote_target::extra_thread_info (thread_info
*tp
)
3841 struct remote_state
*rs
= get_remote_state ();
3844 struct gdb_ext_thread_info threadinfo
;
3846 if (rs
->remote_desc
== 0) /* paranoia */
3847 internal_error (__FILE__
, __LINE__
,
3848 _("remote_threads_extra_info"));
3850 if (tp
->ptid
== magic_null_ptid
3851 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
3852 /* This is the main thread which was added by GDB. The remote
3853 server doesn't know about it. */
3856 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
3858 /* If already have cached info, use it. */
3859 if (!extra
.empty ())
3860 return extra
.c_str ();
3862 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3864 /* If we're using qXfer:threads:read, then the extra info is
3865 included in the XML. So if we didn't have anything cached,
3866 it's because there's really no extra info. */
3870 if (rs
->use_threadextra_query
)
3872 char *b
= rs
->buf
.data ();
3873 char *endb
= b
+ get_remote_packet_size ();
3875 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3877 write_ptid (b
, endb
, tp
->ptid
);
3880 getpkt (&rs
->buf
, 0);
3881 if (rs
->buf
[0] != 0)
3883 extra
.resize (strlen (rs
->buf
.data ()) / 2);
3884 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
3885 return extra
.c_str ();
3889 /* If the above query fails, fall back to the old method. */
3890 rs
->use_threadextra_query
= 0;
3891 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3892 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3893 int_to_threadref (&id
, tp
->ptid
.lwp ());
3894 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3895 if (threadinfo
.active
)
3897 if (*threadinfo
.shortname
)
3898 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
3899 if (*threadinfo
.display
)
3901 if (!extra
.empty ())
3903 string_appendf (extra
, " State: %s", threadinfo
.display
);
3905 if (*threadinfo
.more_display
)
3907 if (!extra
.empty ())
3909 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
3911 return extra
.c_str ();
3918 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
3919 struct static_tracepoint_marker
*marker
)
3921 struct remote_state
*rs
= get_remote_state ();
3922 char *p
= rs
->buf
.data ();
3924 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3926 p
+= hexnumstr (p
, addr
);
3928 getpkt (&rs
->buf
, 0);
3929 p
= rs
->buf
.data ();
3932 error (_("Remote failure reply: %s"), p
);
3936 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
3943 std::vector
<static_tracepoint_marker
>
3944 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
3946 struct remote_state
*rs
= get_remote_state ();
3947 std::vector
<static_tracepoint_marker
> markers
;
3949 static_tracepoint_marker marker
;
3951 /* Ask for a first packet of static tracepoint marker
3954 getpkt (&rs
->buf
, 0);
3955 p
= rs
->buf
.data ();
3957 error (_("Remote failure reply: %s"), p
);
3963 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
3965 if (strid
== NULL
|| marker
.str_id
== strid
)
3966 markers
.push_back (std::move (marker
));
3968 while (*p
++ == ','); /* comma-separated list */
3969 /* Ask for another packet of static tracepoint definition. */
3971 getpkt (&rs
->buf
, 0);
3972 p
= rs
->buf
.data ();
3979 /* Implement the to_get_ada_task_ptid function for the remote targets. */
3982 remote_target::get_ada_task_ptid (long lwp
, long thread
)
3984 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3988 /* Restart the remote side; this is an extended protocol operation. */
3991 remote_target::extended_remote_restart ()
3993 struct remote_state
*rs
= get_remote_state ();
3995 /* Send the restart command; for reasons I don't understand the
3996 remote side really expects a number after the "R". */
3997 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
4000 remote_fileio_reset ();
4003 /* Clean up connection to a remote debugger. */
4006 remote_target::close ()
4008 /* Make sure we leave stdin registered in the event loop. */
4011 /* We don't have a connection to the remote stub anymore. Get rid
4012 of all the inferiors and their threads we were controlling.
4013 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
4014 will be unable to find the thread corresponding to (pid, 0, 0). */
4015 inferior_ptid
= null_ptid
;
4016 discard_all_inferiors ();
4018 trace_reset_local_state ();
4023 remote_target::~remote_target ()
4025 struct remote_state
*rs
= get_remote_state ();
4027 /* Check for NULL because we may get here with a partially
4028 constructed target/connection. */
4029 if (rs
->remote_desc
== nullptr)
4032 serial_close (rs
->remote_desc
);
4034 /* We are destroying the remote target, so we should discard
4035 everything of this target. */
4036 discard_pending_stop_replies_in_queue ();
4038 if (rs
->remote_async_inferior_event_token
)
4039 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4041 delete rs
->notif_state
;
4044 /* Query the remote side for the text, data and bss offsets. */
4047 remote_target::get_offsets ()
4049 struct remote_state
*rs
= get_remote_state ();
4052 int lose
, num_segments
= 0, do_sections
, do_segments
;
4053 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4054 struct section_offsets
*offs
;
4055 struct symfile_segment_data
*data
;
4057 if (symfile_objfile
== NULL
)
4060 putpkt ("qOffsets");
4061 getpkt (&rs
->buf
, 0);
4062 buf
= rs
->buf
.data ();
4064 if (buf
[0] == '\000')
4065 return; /* Return silently. Stub doesn't support
4069 warning (_("Remote failure reply: %s"), buf
);
4073 /* Pick up each field in turn. This used to be done with scanf, but
4074 scanf will make trouble if CORE_ADDR size doesn't match
4075 conversion directives correctly. The following code will work
4076 with any size of CORE_ADDR. */
4077 text_addr
= data_addr
= bss_addr
= 0;
4081 if (startswith (ptr
, "Text="))
4084 /* Don't use strtol, could lose on big values. */
4085 while (*ptr
&& *ptr
!= ';')
4086 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4088 if (startswith (ptr
, ";Data="))
4091 while (*ptr
&& *ptr
!= ';')
4092 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4097 if (!lose
&& startswith (ptr
, ";Bss="))
4100 while (*ptr
&& *ptr
!= ';')
4101 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4103 if (bss_addr
!= data_addr
)
4104 warning (_("Target reported unsupported offsets: %s"), buf
);
4109 else if (startswith (ptr
, "TextSeg="))
4112 /* Don't use strtol, could lose on big values. */
4113 while (*ptr
&& *ptr
!= ';')
4114 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4117 if (startswith (ptr
, ";DataSeg="))
4120 while (*ptr
&& *ptr
!= ';')
4121 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4129 error (_("Malformed response to offset query, %s"), buf
);
4130 else if (*ptr
!= '\0')
4131 warning (_("Target reported unsupported offsets: %s"), buf
);
4133 offs
= ((struct section_offsets
*)
4134 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
4135 memcpy (offs
, symfile_objfile
->section_offsets
,
4136 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
4138 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
4139 do_segments
= (data
!= NULL
);
4140 do_sections
= num_segments
== 0;
4142 if (num_segments
> 0)
4144 segments
[0] = text_addr
;
4145 segments
[1] = data_addr
;
4147 /* If we have two segments, we can still try to relocate everything
4148 by assuming that the .text and .data offsets apply to the whole
4149 text and data segments. Convert the offsets given in the packet
4150 to base addresses for symfile_map_offsets_to_segments. */
4151 else if (data
&& data
->num_segments
== 2)
4153 segments
[0] = data
->segment_bases
[0] + text_addr
;
4154 segments
[1] = data
->segment_bases
[1] + data_addr
;
4157 /* If the object file has only one segment, assume that it is text
4158 rather than data; main programs with no writable data are rare,
4159 but programs with no code are useless. Of course the code might
4160 have ended up in the data segment... to detect that we would need
4161 the permissions here. */
4162 else if (data
&& data
->num_segments
== 1)
4164 segments
[0] = data
->segment_bases
[0] + text_addr
;
4167 /* There's no way to relocate by segment. */
4173 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
4174 offs
, num_segments
, segments
);
4176 if (ret
== 0 && !do_sections
)
4177 error (_("Can not handle qOffsets TextSeg "
4178 "response with this symbol file"));
4185 free_symfile_segment_data (data
);
4189 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
4191 /* This is a temporary kludge to force data and bss to use the
4192 same offsets because that's what nlmconv does now. The real
4193 solution requires changes to the stub and remote.c that I
4194 don't have time to do right now. */
4196 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
4197 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
4200 objfile_relocate (symfile_objfile
, offs
);
4203 /* Send interrupt_sequence to remote target. */
4206 remote_target::send_interrupt_sequence ()
4208 struct remote_state
*rs
= get_remote_state ();
4210 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4211 remote_serial_write ("\x03", 1);
4212 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4213 serial_send_break (rs
->remote_desc
);
4214 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4216 serial_send_break (rs
->remote_desc
);
4217 remote_serial_write ("g", 1);
4220 internal_error (__FILE__
, __LINE__
,
4221 _("Invalid value for interrupt_sequence_mode: %s."),
4222 interrupt_sequence_mode
);
4226 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4227 and extract the PTID. Returns NULL_PTID if not found. */
4230 stop_reply_extract_thread (char *stop_reply
)
4232 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4236 /* Txx r:val ; r:val (...) */
4239 /* Look for "register" named "thread". */
4244 p1
= strchr (p
, ':');
4248 if (strncmp (p
, "thread", p1
- p
) == 0)
4249 return read_ptid (++p1
, &p
);
4251 p1
= strchr (p
, ';');
4263 /* Determine the remote side's current thread. If we have a stop
4264 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4265 "thread" register we can extract the current thread from. If not,
4266 ask the remote which is the current thread with qC. The former
4267 method avoids a roundtrip. */
4270 remote_target::get_current_thread (char *wait_status
)
4272 ptid_t ptid
= null_ptid
;
4274 /* Note we don't use remote_parse_stop_reply as that makes use of
4275 the target architecture, which we haven't yet fully determined at
4277 if (wait_status
!= NULL
)
4278 ptid
= stop_reply_extract_thread (wait_status
);
4279 if (ptid
== null_ptid
)
4280 ptid
= remote_current_thread (inferior_ptid
);
4285 /* Query the remote target for which is the current thread/process,
4286 add it to our tables, and update INFERIOR_PTID. The caller is
4287 responsible for setting the state such that the remote end is ready
4288 to return the current thread.
4290 This function is called after handling the '?' or 'vRun' packets,
4291 whose response is a stop reply from which we can also try
4292 extracting the thread. If the target doesn't support the explicit
4293 qC query, we infer the current thread from that stop reply, passed
4294 in in WAIT_STATUS, which may be NULL. */
4297 remote_target::add_current_inferior_and_thread (char *wait_status
)
4299 struct remote_state
*rs
= get_remote_state ();
4300 bool fake_pid_p
= false;
4302 inferior_ptid
= null_ptid
;
4304 /* Now, if we have thread information, update inferior_ptid. */
4305 ptid_t curr_ptid
= get_current_thread (wait_status
);
4307 if (curr_ptid
!= null_ptid
)
4309 if (!remote_multi_process_p (rs
))
4314 /* Without this, some commands which require an active target
4315 (such as kill) won't work. This variable serves (at least)
4316 double duty as both the pid of the target process (if it has
4317 such), and as a flag indicating that a target is active. */
4318 curr_ptid
= magic_null_ptid
;
4322 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4324 /* Add the main thread and switch to it. Don't try reading
4325 registers yet, since we haven't fetched the target description
4327 thread_info
*tp
= add_thread_silent (curr_ptid
);
4328 switch_to_thread_no_regs (tp
);
4331 /* Print info about a thread that was found already stopped on
4335 print_one_stopped_thread (struct thread_info
*thread
)
4337 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4339 switch_to_thread (thread
);
4340 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4341 set_current_sal_from_frame (get_current_frame ());
4343 thread
->suspend
.waitstatus_pending_p
= 0;
4345 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4347 enum gdb_signal sig
= ws
->value
.sig
;
4349 if (signal_print_state (sig
))
4350 gdb::observers::signal_received
.notify (sig
);
4352 gdb::observers::normal_stop
.notify (NULL
, 1);
4355 /* Process all initial stop replies the remote side sent in response
4356 to the ? packet. These indicate threads that were already stopped
4357 on initial connection. We mark these threads as stopped and print
4358 their current frame before giving the user the prompt. */
4361 remote_target::process_initial_stop_replies (int from_tty
)
4363 int pending_stop_replies
= stop_reply_queue_length ();
4364 struct thread_info
*selected
= NULL
;
4365 struct thread_info
*lowest_stopped
= NULL
;
4366 struct thread_info
*first
= NULL
;
4368 /* Consume the initial pending events. */
4369 while (pending_stop_replies
-- > 0)
4371 ptid_t waiton_ptid
= minus_one_ptid
;
4373 struct target_waitstatus ws
;
4374 int ignore_event
= 0;
4376 memset (&ws
, 0, sizeof (ws
));
4377 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4379 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4383 case TARGET_WAITKIND_IGNORE
:
4384 case TARGET_WAITKIND_NO_RESUMED
:
4385 case TARGET_WAITKIND_SIGNALLED
:
4386 case TARGET_WAITKIND_EXITED
:
4387 /* We shouldn't see these, but if we do, just ignore. */
4389 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
4393 case TARGET_WAITKIND_EXECD
:
4394 xfree (ws
.value
.execd_pathname
);
4403 struct thread_info
*evthread
= find_thread_ptid (event_ptid
);
4405 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4407 enum gdb_signal sig
= ws
.value
.sig
;
4409 /* Stubs traditionally report SIGTRAP as initial signal,
4410 instead of signal 0. Suppress it. */
4411 if (sig
== GDB_SIGNAL_TRAP
)
4413 evthread
->suspend
.stop_signal
= sig
;
4417 evthread
->suspend
.waitstatus
= ws
;
4419 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4420 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4421 evthread
->suspend
.waitstatus_pending_p
= 1;
4423 set_executing (event_ptid
, 0);
4424 set_running (event_ptid
, 0);
4425 get_remote_thread_info (evthread
)->vcont_resumed
= 0;
4428 /* "Notice" the new inferiors before anything related to
4429 registers/memory. */
4430 for (inferior
*inf
: all_non_exited_inferiors ())
4432 inf
->needs_setup
= 1;
4436 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4437 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4442 /* If all-stop on top of non-stop, pause all threads. Note this
4443 records the threads' stop pc, so must be done after "noticing"
4447 stop_all_threads ();
4449 /* If all threads of an inferior were already stopped, we
4450 haven't setup the inferior yet. */
4451 for (inferior
*inf
: all_non_exited_inferiors ())
4453 if (inf
->needs_setup
)
4455 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4456 switch_to_thread_no_regs (thread
);
4462 /* Now go over all threads that are stopped, and print their current
4463 frame. If all-stop, then if there's a signalled thread, pick
4465 for (thread_info
*thread
: all_non_exited_threads ())
4471 thread
->set_running (false);
4472 else if (thread
->state
!= THREAD_STOPPED
)
4475 if (selected
== NULL
4476 && thread
->suspend
.waitstatus_pending_p
)
4479 if (lowest_stopped
== NULL
4480 || thread
->inf
->num
< lowest_stopped
->inf
->num
4481 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4482 lowest_stopped
= thread
;
4485 print_one_stopped_thread (thread
);
4488 /* In all-stop, we only print the status of one thread, and leave
4489 others with their status pending. */
4492 thread_info
*thread
= selected
;
4494 thread
= lowest_stopped
;
4498 print_one_stopped_thread (thread
);
4501 /* For "info program". */
4502 thread_info
*thread
= inferior_thread ();
4503 if (thread
->state
== THREAD_STOPPED
)
4504 set_last_target_status (inferior_ptid
, thread
->suspend
.waitstatus
);
4507 /* Start the remote connection and sync state. */
4510 remote_target::start_remote (int from_tty
, int extended_p
)
4512 struct remote_state
*rs
= get_remote_state ();
4513 struct packet_config
*noack_config
;
4514 char *wait_status
= NULL
;
4516 /* Signal other parts that we're going through the initial setup,
4517 and so things may not be stable yet. E.g., we don't try to
4518 install tracepoints until we've relocated symbols. Also, a
4519 Ctrl-C before we're connected and synced up can't interrupt the
4520 target. Instead, it offers to drop the (potentially wedged)
4522 rs
->starting_up
= 1;
4526 if (interrupt_on_connect
)
4527 send_interrupt_sequence ();
4529 /* Ack any packet which the remote side has already sent. */
4530 remote_serial_write ("+", 1);
4532 /* The first packet we send to the target is the optional "supported
4533 packets" request. If the target can answer this, it will tell us
4534 which later probes to skip. */
4535 remote_query_supported ();
4537 /* If the stub wants to get a QAllow, compose one and send it. */
4538 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4541 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4542 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4543 as a reply to known packet. For packet "vFile:setfs:" it is an
4544 invalid reply and GDB would return error in
4545 remote_hostio_set_filesystem, making remote files access impossible.
4546 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4547 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4549 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4551 putpkt (v_mustreplyempty
);
4552 getpkt (&rs
->buf
, 0);
4553 if (strcmp (rs
->buf
.data (), "OK") == 0)
4554 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4555 else if (strcmp (rs
->buf
.data (), "") != 0)
4556 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4560 /* Next, we possibly activate noack mode.
4562 If the QStartNoAckMode packet configuration is set to AUTO,
4563 enable noack mode if the stub reported a wish for it with
4566 If set to TRUE, then enable noack mode even if the stub didn't
4567 report it in qSupported. If the stub doesn't reply OK, the
4568 session ends with an error.
4570 If FALSE, then don't activate noack mode, regardless of what the
4571 stub claimed should be the default with qSupported. */
4573 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4574 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4576 putpkt ("QStartNoAckMode");
4577 getpkt (&rs
->buf
, 0);
4578 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4584 /* Tell the remote that we are using the extended protocol. */
4586 getpkt (&rs
->buf
, 0);
4589 /* Let the target know which signals it is allowed to pass down to
4591 update_signals_program_target ();
4593 /* Next, if the target can specify a description, read it. We do
4594 this before anything involving memory or registers. */
4595 target_find_description ();
4597 /* Next, now that we know something about the target, update the
4598 address spaces in the program spaces. */
4599 update_address_spaces ();
4601 /* On OSs where the list of libraries is global to all
4602 processes, we fetch them early. */
4603 if (gdbarch_has_global_solist (target_gdbarch ()))
4604 solib_add (NULL
, from_tty
, auto_solib_add
);
4606 if (target_is_non_stop_p ())
4608 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4609 error (_("Non-stop mode requested, but remote "
4610 "does not support non-stop"));
4612 putpkt ("QNonStop:1");
4613 getpkt (&rs
->buf
, 0);
4615 if (strcmp (rs
->buf
.data (), "OK") != 0)
4616 error (_("Remote refused setting non-stop mode with: %s"),
4619 /* Find about threads and processes the stub is already
4620 controlling. We default to adding them in the running state.
4621 The '?' query below will then tell us about which threads are
4623 this->update_thread_list ();
4625 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4627 /* Don't assume that the stub can operate in all-stop mode.
4628 Request it explicitly. */
4629 putpkt ("QNonStop:0");
4630 getpkt (&rs
->buf
, 0);
4632 if (strcmp (rs
->buf
.data (), "OK") != 0)
4633 error (_("Remote refused setting all-stop mode with: %s"),
4637 /* Upload TSVs regardless of whether the target is running or not. The
4638 remote stub, such as GDBserver, may have some predefined or builtin
4639 TSVs, even if the target is not running. */
4640 if (get_trace_status (current_trace_status ()) != -1)
4642 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4644 upload_trace_state_variables (&uploaded_tsvs
);
4645 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4648 /* Check whether the target is running now. */
4650 getpkt (&rs
->buf
, 0);
4652 if (!target_is_non_stop_p ())
4654 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4657 error (_("The target is not running (try extended-remote?)"));
4659 /* We're connected, but not running. Drop out before we
4660 call start_remote. */
4661 rs
->starting_up
= 0;
4666 /* Save the reply for later. */
4667 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4668 strcpy (wait_status
, rs
->buf
.data ());
4671 /* Fetch thread list. */
4672 target_update_thread_list ();
4674 /* Let the stub know that we want it to return the thread. */
4675 set_continue_thread (minus_one_ptid
);
4677 if (thread_count () == 0)
4679 /* Target has no concept of threads at all. GDB treats
4680 non-threaded target as single-threaded; add a main
4682 add_current_inferior_and_thread (wait_status
);
4686 /* We have thread information; select the thread the target
4687 says should be current. If we're reconnecting to a
4688 multi-threaded program, this will ideally be the thread
4689 that last reported an event before GDB disconnected. */
4690 inferior_ptid
= get_current_thread (wait_status
);
4691 if (inferior_ptid
== null_ptid
)
4693 /* Odd... The target was able to list threads, but not
4694 tell us which thread was current (no "thread"
4695 register in T stop reply?). Just pick the first
4696 thread in the thread list then. */
4699 fprintf_unfiltered (gdb_stdlog
,
4700 "warning: couldn't determine remote "
4701 "current thread; picking first in list.\n");
4703 inferior_ptid
= inferior_list
->thread_list
->ptid
;
4707 /* init_wait_for_inferior should be called before get_offsets in order
4708 to manage `inserted' flag in bp loc in a correct state.
4709 breakpoint_init_inferior, called from init_wait_for_inferior, set
4710 `inserted' flag to 0, while before breakpoint_re_set, called from
4711 start_remote, set `inserted' flag to 1. In the initialization of
4712 inferior, breakpoint_init_inferior should be called first, and then
4713 breakpoint_re_set can be called. If this order is broken, state of
4714 `inserted' flag is wrong, and cause some problems on breakpoint
4716 init_wait_for_inferior ();
4718 get_offsets (); /* Get text, data & bss offsets. */
4720 /* If we could not find a description using qXfer, and we know
4721 how to do it some other way, try again. This is not
4722 supported for non-stop; it could be, but it is tricky if
4723 there are no stopped threads when we connect. */
4724 if (remote_read_description_p (this)
4725 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4727 target_clear_description ();
4728 target_find_description ();
4731 /* Use the previously fetched status. */
4732 gdb_assert (wait_status
!= NULL
);
4733 strcpy (rs
->buf
.data (), wait_status
);
4734 rs
->cached_wait_status
= 1;
4736 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4740 /* Clear WFI global state. Do this before finding about new
4741 threads and inferiors, and setting the current inferior.
4742 Otherwise we would clear the proceed status of the current
4743 inferior when we want its stop_soon state to be preserved
4744 (see notice_new_inferior). */
4745 init_wait_for_inferior ();
4747 /* In non-stop, we will either get an "OK", meaning that there
4748 are no stopped threads at this time; or, a regular stop
4749 reply. In the latter case, there may be more than one thread
4750 stopped --- we pull them all out using the vStopped
4752 if (strcmp (rs
->buf
.data (), "OK") != 0)
4754 struct notif_client
*notif
= ¬if_client_stop
;
4756 /* remote_notif_get_pending_replies acks this one, and gets
4758 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4759 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4760 remote_notif_get_pending_events (notif
);
4763 if (thread_count () == 0)
4766 error (_("The target is not running (try extended-remote?)"));
4768 /* We're connected, but not running. Drop out before we
4769 call start_remote. */
4770 rs
->starting_up
= 0;
4774 /* In non-stop mode, any cached wait status will be stored in
4775 the stop reply queue. */
4776 gdb_assert (wait_status
== NULL
);
4778 /* Report all signals during attach/startup. */
4781 /* If there are already stopped threads, mark them stopped and
4782 report their stops before giving the prompt to the user. */
4783 process_initial_stop_replies (from_tty
);
4785 if (target_can_async_p ())
4789 /* If we connected to a live target, do some additional setup. */
4790 if (target_has_execution
)
4792 if (symfile_objfile
) /* No use without a symbol-file. */
4793 remote_check_symbols ();
4796 /* Possibly the target has been engaged in a trace run started
4797 previously; find out where things are at. */
4798 if (get_trace_status (current_trace_status ()) != -1)
4800 struct uploaded_tp
*uploaded_tps
= NULL
;
4802 if (current_trace_status ()->running
)
4803 printf_filtered (_("Trace is already running on the target.\n"));
4805 upload_tracepoints (&uploaded_tps
);
4807 merge_uploaded_tracepoints (&uploaded_tps
);
4810 /* Possibly the target has been engaged in a btrace record started
4811 previously; find out where things are at. */
4812 remote_btrace_maybe_reopen ();
4814 /* The thread and inferior lists are now synchronized with the
4815 target, our symbols have been relocated, and we're merged the
4816 target's tracepoints with ours. We're done with basic start
4818 rs
->starting_up
= 0;
4820 /* Maybe breakpoints are global and need to be inserted now. */
4821 if (breakpoints_should_be_inserted_now ())
4822 insert_breakpoints ();
4825 /* Open a connection to a remote debugger.
4826 NAME is the filename used for communication. */
4829 remote_target::open (const char *name
, int from_tty
)
4831 open_1 (name
, from_tty
, 0);
4834 /* Open a connection to a remote debugger using the extended
4835 remote gdb protocol. NAME is the filename used for communication. */
4838 extended_remote_target::open (const char *name
, int from_tty
)
4840 open_1 (name
, from_tty
, 1 /*extended_p */);
4843 /* Reset all packets back to "unknown support". Called when opening a
4844 new connection to a remote target. */
4847 reset_all_packet_configs_support (void)
4851 for (i
= 0; i
< PACKET_MAX
; i
++)
4852 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4855 /* Initialize all packet configs. */
4858 init_all_packet_configs (void)
4862 for (i
= 0; i
< PACKET_MAX
; i
++)
4864 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4865 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4869 /* Symbol look-up. */
4872 remote_target::remote_check_symbols ()
4877 /* The remote side has no concept of inferiors that aren't running
4878 yet, it only knows about running processes. If we're connected
4879 but our current inferior is not running, we should not invite the
4880 remote target to request symbol lookups related to its
4881 (unrelated) current process. */
4882 if (!target_has_execution
)
4885 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4888 /* Make sure the remote is pointing at the right process. Note
4889 there's no way to select "no process". */
4890 set_general_process ();
4892 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4893 because we need both at the same time. */
4894 gdb::char_vector
msg (get_remote_packet_size ());
4895 gdb::char_vector
reply (get_remote_packet_size ());
4897 /* Invite target to request symbol lookups. */
4899 putpkt ("qSymbol::");
4901 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4903 while (startswith (reply
.data (), "qSymbol:"))
4905 struct bound_minimal_symbol sym
;
4908 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
4911 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
4912 if (sym
.minsym
== NULL
)
4913 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
4917 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4918 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4920 /* If this is a function address, return the start of code
4921 instead of any data function descriptor. */
4922 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4924 current_top_target ());
4926 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4927 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4930 putpkt (msg
.data ());
4935 static struct serial
*
4936 remote_serial_open (const char *name
)
4938 static int udp_warning
= 0;
4940 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4941 of in ser-tcp.c, because it is the remote protocol assuming that the
4942 serial connection is reliable and not the serial connection promising
4944 if (!udp_warning
&& startswith (name
, "udp:"))
4946 warning (_("The remote protocol may be unreliable over UDP.\n"
4947 "Some events may be lost, rendering further debugging "
4952 return serial_open (name
);
4955 /* Inform the target of our permission settings. The permission flags
4956 work without this, but if the target knows the settings, it can do
4957 a couple things. First, it can add its own check, to catch cases
4958 that somehow manage to get by the permissions checks in target
4959 methods. Second, if the target is wired to disallow particular
4960 settings (for instance, a system in the field that is not set up to
4961 be able to stop at a breakpoint), it can object to any unavailable
4965 remote_target::set_permissions ()
4967 struct remote_state
*rs
= get_remote_state ();
4969 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
4970 "WriteReg:%x;WriteMem:%x;"
4971 "InsertBreak:%x;InsertTrace:%x;"
4972 "InsertFastTrace:%x;Stop:%x",
4973 may_write_registers
, may_write_memory
,
4974 may_insert_breakpoints
, may_insert_tracepoints
,
4975 may_insert_fast_tracepoints
, may_stop
);
4977 getpkt (&rs
->buf
, 0);
4979 /* If the target didn't like the packet, warn the user. Do not try
4980 to undo the user's settings, that would just be maddening. */
4981 if (strcmp (rs
->buf
.data (), "OK") != 0)
4982 warning (_("Remote refused setting permissions with: %s"),
4986 /* This type describes each known response to the qSupported
4988 struct protocol_feature
4990 /* The name of this protocol feature. */
4993 /* The default for this protocol feature. */
4994 enum packet_support default_support
;
4996 /* The function to call when this feature is reported, or after
4997 qSupported processing if the feature is not supported.
4998 The first argument points to this structure. The second
4999 argument indicates whether the packet requested support be
5000 enabled, disabled, or probed (or the default, if this function
5001 is being called at the end of processing and this feature was
5002 not reported). The third argument may be NULL; if not NULL, it
5003 is a NUL-terminated string taken from the packet following
5004 this feature's name and an equals sign. */
5005 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5006 enum packet_support
, const char *);
5008 /* The corresponding packet for this feature. Only used if
5009 FUNC is remote_supported_packet. */
5014 remote_supported_packet (remote_target
*remote
,
5015 const struct protocol_feature
*feature
,
5016 enum packet_support support
,
5017 const char *argument
)
5021 warning (_("Remote qSupported response supplied an unexpected value for"
5022 " \"%s\"."), feature
->name
);
5026 remote_protocol_packets
[feature
->packet
].support
= support
;
5030 remote_target::remote_packet_size (const protocol_feature
*feature
,
5031 enum packet_support support
, const char *value
)
5033 struct remote_state
*rs
= get_remote_state ();
5038 if (support
!= PACKET_ENABLE
)
5041 if (value
== NULL
|| *value
== '\0')
5043 warning (_("Remote target reported \"%s\" without a size."),
5049 packet_size
= strtol (value
, &value_end
, 16);
5050 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5052 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5053 feature
->name
, value
);
5057 /* Record the new maximum packet size. */
5058 rs
->explicit_packet_size
= packet_size
;
5062 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5063 enum packet_support support
, const char *value
)
5065 remote
->remote_packet_size (feature
, support
, value
);
5068 static const struct protocol_feature remote_protocol_features
[] = {
5069 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5070 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5071 PACKET_qXfer_auxv
},
5072 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5073 PACKET_qXfer_exec_file
},
5074 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5075 PACKET_qXfer_features
},
5076 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5077 PACKET_qXfer_libraries
},
5078 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5079 PACKET_qXfer_libraries_svr4
},
5080 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5081 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5082 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5083 PACKET_qXfer_memory_map
},
5084 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5085 PACKET_qXfer_osdata
},
5086 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5087 PACKET_qXfer_threads
},
5088 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5089 PACKET_qXfer_traceframe_info
},
5090 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5091 PACKET_QPassSignals
},
5092 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5093 PACKET_QCatchSyscalls
},
5094 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5095 PACKET_QProgramSignals
},
5096 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5097 PACKET_QSetWorkingDir
},
5098 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5099 PACKET_QStartupWithShell
},
5100 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5101 PACKET_QEnvironmentHexEncoded
},
5102 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5103 PACKET_QEnvironmentReset
},
5104 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5105 PACKET_QEnvironmentUnset
},
5106 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5107 PACKET_QStartNoAckMode
},
5108 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5109 PACKET_multiprocess_feature
},
5110 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5111 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5112 PACKET_qXfer_siginfo_read
},
5113 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5114 PACKET_qXfer_siginfo_write
},
5115 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5116 PACKET_ConditionalTracepoints
},
5117 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5118 PACKET_ConditionalBreakpoints
},
5119 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5120 PACKET_BreakpointCommands
},
5121 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5122 PACKET_FastTracepoints
},
5123 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5124 PACKET_StaticTracepoints
},
5125 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5126 PACKET_InstallInTrace
},
5127 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5128 PACKET_DisconnectedTracing_feature
},
5129 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5131 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5133 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5134 PACKET_TracepointSource
},
5135 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5137 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5138 PACKET_EnableDisableTracepoints_feature
},
5139 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5140 PACKET_qXfer_fdpic
},
5141 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5143 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5144 PACKET_QDisableRandomization
},
5145 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5146 { "QTBuffer:size", PACKET_DISABLE
,
5147 remote_supported_packet
, PACKET_QTBuffer_size
},
5148 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5149 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5150 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5151 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5152 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5153 PACKET_qXfer_btrace
},
5154 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5155 PACKET_qXfer_btrace_conf
},
5156 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5157 PACKET_Qbtrace_conf_bts_size
},
5158 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5159 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5160 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5161 PACKET_fork_event_feature
},
5162 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5163 PACKET_vfork_event_feature
},
5164 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5165 PACKET_exec_event_feature
},
5166 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5167 PACKET_Qbtrace_conf_pt_size
},
5168 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5169 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5170 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5173 static char *remote_support_xml
;
5175 /* Register string appended to "xmlRegisters=" in qSupported query. */
5178 register_remote_support_xml (const char *xml
)
5180 #if defined(HAVE_LIBEXPAT)
5181 if (remote_support_xml
== NULL
)
5182 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5185 char *copy
= xstrdup (remote_support_xml
+ 13);
5186 char *p
= strtok (copy
, ",");
5190 if (strcmp (p
, xml
) == 0)
5197 while ((p
= strtok (NULL
, ",")) != NULL
);
5200 remote_support_xml
= reconcat (remote_support_xml
,
5201 remote_support_xml
, ",", xml
,
5208 remote_query_supported_append (std::string
*msg
, const char *append
)
5212 msg
->append (append
);
5216 remote_target::remote_query_supported ()
5218 struct remote_state
*rs
= get_remote_state ();
5221 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5223 /* The packet support flags are handled differently for this packet
5224 than for most others. We treat an error, a disabled packet, and
5225 an empty response identically: any features which must be reported
5226 to be used will be automatically disabled. An empty buffer
5227 accomplishes this, since that is also the representation for a list
5228 containing no features. */
5231 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5235 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5236 remote_query_supported_append (&q
, "multiprocess+");
5238 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5239 remote_query_supported_append (&q
, "swbreak+");
5240 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5241 remote_query_supported_append (&q
, "hwbreak+");
5243 remote_query_supported_append (&q
, "qRelocInsn+");
5245 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5246 != AUTO_BOOLEAN_FALSE
)
5247 remote_query_supported_append (&q
, "fork-events+");
5248 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5249 != AUTO_BOOLEAN_FALSE
)
5250 remote_query_supported_append (&q
, "vfork-events+");
5251 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5252 != AUTO_BOOLEAN_FALSE
)
5253 remote_query_supported_append (&q
, "exec-events+");
5255 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5256 remote_query_supported_append (&q
, "vContSupported+");
5258 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5259 remote_query_supported_append (&q
, "QThreadEvents+");
5261 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5262 remote_query_supported_append (&q
, "no-resumed+");
5264 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5265 the qSupported:xmlRegisters=i386 handling. */
5266 if (remote_support_xml
!= NULL
5267 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5268 remote_query_supported_append (&q
, remote_support_xml
);
5270 q
= "qSupported:" + q
;
5271 putpkt (q
.c_str ());
5273 getpkt (&rs
->buf
, 0);
5275 /* If an error occured, warn, but do not return - just reset the
5276 buffer to empty and go on to disable features. */
5277 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5280 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5285 memset (seen
, 0, sizeof (seen
));
5287 next
= rs
->buf
.data ();
5290 enum packet_support is_supported
;
5291 char *p
, *end
, *name_end
, *value
;
5293 /* First separate out this item from the rest of the packet. If
5294 there's another item after this, we overwrite the separator
5295 (terminated strings are much easier to work with). */
5297 end
= strchr (p
, ';');
5300 end
= p
+ strlen (p
);
5310 warning (_("empty item in \"qSupported\" response"));
5315 name_end
= strchr (p
, '=');
5318 /* This is a name=value entry. */
5319 is_supported
= PACKET_ENABLE
;
5320 value
= name_end
+ 1;
5329 is_supported
= PACKET_ENABLE
;
5333 is_supported
= PACKET_DISABLE
;
5337 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5341 warning (_("unrecognized item \"%s\" "
5342 "in \"qSupported\" response"), p
);
5348 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5349 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5351 const struct protocol_feature
*feature
;
5354 feature
= &remote_protocol_features
[i
];
5355 feature
->func (this, feature
, is_supported
, value
);
5360 /* If we increased the packet size, make sure to increase the global
5361 buffer size also. We delay this until after parsing the entire
5362 qSupported packet, because this is the same buffer we were
5364 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5365 rs
->buf
.resize (rs
->explicit_packet_size
);
5367 /* Handle the defaults for unmentioned features. */
5368 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5371 const struct protocol_feature
*feature
;
5373 feature
= &remote_protocol_features
[i
];
5374 feature
->func (this, feature
, feature
->default_support
, NULL
);
5378 /* Serial QUIT handler for the remote serial descriptor.
5380 Defers handling a Ctrl-C until we're done with the current
5381 command/response packet sequence, unless:
5383 - We're setting up the connection. Don't send a remote interrupt
5384 request, as we're not fully synced yet. Quit immediately
5387 - The target has been resumed in the foreground
5388 (target_terminal::is_ours is false) with a synchronous resume
5389 packet, and we're blocked waiting for the stop reply, thus a
5390 Ctrl-C should be immediately sent to the target.
5392 - We get a second Ctrl-C while still within the same serial read or
5393 write. In that case the serial is seemingly wedged --- offer to
5396 - We see a second Ctrl-C without target response, after having
5397 previously interrupted the target. In that case the target/stub
5398 is probably wedged --- offer to quit/disconnect.
5402 remote_target::remote_serial_quit_handler ()
5404 struct remote_state
*rs
= get_remote_state ();
5406 if (check_quit_flag ())
5408 /* If we're starting up, we're not fully synced yet. Quit
5410 if (rs
->starting_up
)
5412 else if (rs
->got_ctrlc_during_io
)
5414 if (query (_("The target is not responding to GDB commands.\n"
5415 "Stop debugging it? ")))
5416 remote_unpush_and_throw ();
5418 /* If ^C has already been sent once, offer to disconnect. */
5419 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5421 /* All-stop protocol, and blocked waiting for stop reply. Send
5422 an interrupt request. */
5423 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5424 target_interrupt ();
5426 rs
->got_ctrlc_during_io
= 1;
5430 /* The remote_target that is current while the quit handler is
5431 overridden with remote_serial_quit_handler. */
5432 static remote_target
*curr_quit_handler_target
;
5435 remote_serial_quit_handler ()
5437 curr_quit_handler_target
->remote_serial_quit_handler ();
5440 /* Remove any of the remote.c targets from target stack. Upper targets depend
5441 on it so remove them first. */
5444 remote_unpush_target (void)
5446 pop_all_targets_at_and_above (process_stratum
);
5450 remote_unpush_and_throw (void)
5452 remote_unpush_target ();
5453 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5457 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5459 remote_target
*curr_remote
= get_current_remote_target ();
5462 error (_("To open a remote debug connection, you need to specify what\n"
5463 "serial device is attached to the remote system\n"
5464 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5466 /* If we're connected to a running target, target_preopen will kill it.
5467 Ask this question first, before target_preopen has a chance to kill
5469 if (curr_remote
!= NULL
&& !have_inferiors ())
5472 && !query (_("Already connected to a remote target. Disconnect? ")))
5473 error (_("Still connected."));
5476 /* Here the possibly existing remote target gets unpushed. */
5477 target_preopen (from_tty
);
5479 remote_fileio_reset ();
5480 reopen_exec_file ();
5483 remote_target
*remote
5484 = (extended_p
? new extended_remote_target () : new remote_target ());
5485 target_ops_up
target_holder (remote
);
5487 remote_state
*rs
= remote
->get_remote_state ();
5489 /* See FIXME above. */
5490 if (!target_async_permitted
)
5491 rs
->wait_forever_enabled_p
= 1;
5493 rs
->remote_desc
= remote_serial_open (name
);
5494 if (!rs
->remote_desc
)
5495 perror_with_name (name
);
5497 if (baud_rate
!= -1)
5499 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5501 /* The requested speed could not be set. Error out to
5502 top level after closing remote_desc. Take care to
5503 set remote_desc to NULL to avoid closing remote_desc
5505 serial_close (rs
->remote_desc
);
5506 rs
->remote_desc
= NULL
;
5507 perror_with_name (name
);
5511 serial_setparity (rs
->remote_desc
, serial_parity
);
5512 serial_raw (rs
->remote_desc
);
5514 /* If there is something sitting in the buffer we might take it as a
5515 response to a command, which would be bad. */
5516 serial_flush_input (rs
->remote_desc
);
5520 puts_filtered ("Remote debugging using ");
5521 puts_filtered (name
);
5522 puts_filtered ("\n");
5525 /* Switch to using the remote target now. */
5526 push_target (std::move (target_holder
));
5528 /* Register extra event sources in the event loop. */
5529 rs
->remote_async_inferior_event_token
5530 = create_async_event_handler (remote_async_inferior_event_handler
,
5532 rs
->notif_state
= remote_notif_state_allocate (remote
);
5534 /* Reset the target state; these things will be queried either by
5535 remote_query_supported or as they are needed. */
5536 reset_all_packet_configs_support ();
5537 rs
->cached_wait_status
= 0;
5538 rs
->explicit_packet_size
= 0;
5540 rs
->extended
= extended_p
;
5541 rs
->waiting_for_stop_reply
= 0;
5542 rs
->ctrlc_pending_p
= 0;
5543 rs
->got_ctrlc_during_io
= 0;
5545 rs
->general_thread
= not_sent_ptid
;
5546 rs
->continue_thread
= not_sent_ptid
;
5547 rs
->remote_traceframe_number
= -1;
5549 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5551 /* Probe for ability to use "ThreadInfo" query, as required. */
5552 rs
->use_threadinfo_query
= 1;
5553 rs
->use_threadextra_query
= 1;
5555 rs
->readahead_cache
.invalidate ();
5557 if (target_async_permitted
)
5559 /* FIXME: cagney/1999-09-23: During the initial connection it is
5560 assumed that the target is already ready and able to respond to
5561 requests. Unfortunately remote_start_remote() eventually calls
5562 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5563 around this. Eventually a mechanism that allows
5564 wait_for_inferior() to expect/get timeouts will be
5566 rs
->wait_forever_enabled_p
= 0;
5569 /* First delete any symbols previously loaded from shared libraries. */
5570 no_shared_libraries (NULL
, 0);
5572 /* Start the remote connection. If error() or QUIT, discard this
5573 target (we'd otherwise be in an inconsistent state) and then
5574 propogate the error on up the exception chain. This ensures that
5575 the caller doesn't stumble along blindly assuming that the
5576 function succeeded. The CLI doesn't have this problem but other
5577 UI's, such as MI do.
5579 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5580 this function should return an error indication letting the
5581 caller restore the previous state. Unfortunately the command
5582 ``target remote'' is directly wired to this function making that
5583 impossible. On a positive note, the CLI side of this problem has
5584 been fixed - the function set_cmd_context() makes it possible for
5585 all the ``target ....'' commands to share a common callback
5586 function. See cli-dump.c. */
5591 remote
->start_remote (from_tty
, extended_p
);
5593 catch (const gdb_exception
&ex
)
5595 /* Pop the partially set up target - unless something else did
5596 already before throwing the exception. */
5597 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5598 remote_unpush_target ();
5603 remote_btrace_reset (rs
);
5605 if (target_async_permitted
)
5606 rs
->wait_forever_enabled_p
= 1;
5609 /* Detach the specified process. */
5612 remote_target::remote_detach_pid (int pid
)
5614 struct remote_state
*rs
= get_remote_state ();
5616 /* This should not be necessary, but the handling for D;PID in
5617 GDBserver versions prior to 8.2 incorrectly assumes that the
5618 selected process points to the same process we're detaching,
5619 leading to misbehavior (and possibly GDBserver crashing) when it
5620 does not. Since it's easy and cheap, work around it by forcing
5621 GDBserver to select GDB's current process. */
5622 set_general_process ();
5624 if (remote_multi_process_p (rs
))
5625 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5627 strcpy (rs
->buf
.data (), "D");
5630 getpkt (&rs
->buf
, 0);
5632 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5634 else if (rs
->buf
[0] == '\0')
5635 error (_("Remote doesn't know how to detach"));
5637 error (_("Can't detach process."));
5640 /* This detaches a program to which we previously attached, using
5641 inferior_ptid to identify the process. After this is done, GDB
5642 can be used to debug some other program. We better not have left
5643 any breakpoints in the target program or it'll die when it hits
5647 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5649 int pid
= inferior_ptid
.pid ();
5650 struct remote_state
*rs
= get_remote_state ();
5653 if (!target_has_execution
)
5654 error (_("No process to detach from."));
5656 target_announce_detach (from_tty
);
5658 /* Tell the remote target to detach. */
5659 remote_detach_pid (pid
);
5661 /* Exit only if this is the only active inferior. */
5662 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors () == 1)
5663 puts_filtered (_("Ending remote debugging.\n"));
5665 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
5667 /* Check to see if we are detaching a fork parent. Note that if we
5668 are detaching a fork child, tp == NULL. */
5669 is_fork_parent
= (tp
!= NULL
5670 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5672 /* If doing detach-on-fork, we don't mourn, because that will delete
5673 breakpoints that should be available for the followed inferior. */
5674 if (!is_fork_parent
)
5676 /* Save the pid as a string before mourning, since that will
5677 unpush the remote target, and we need the string after. */
5678 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5680 target_mourn_inferior (inferior_ptid
);
5681 if (print_inferior_events
)
5682 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5683 inf
->num
, infpid
.c_str ());
5687 inferior_ptid
= null_ptid
;
5688 detach_inferior (current_inferior ());
5693 remote_target::detach (inferior
*inf
, int from_tty
)
5695 remote_detach_1 (inf
, from_tty
);
5699 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5701 remote_detach_1 (inf
, from_tty
);
5704 /* Target follow-fork function for remote targets. On entry, and
5705 at return, the current inferior is the fork parent.
5707 Note that although this is currently only used for extended-remote,
5708 it is named remote_follow_fork in anticipation of using it for the
5709 remote target as well. */
5712 remote_target::follow_fork (int follow_child
, int detach_fork
)
5714 struct remote_state
*rs
= get_remote_state ();
5715 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5717 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5718 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5720 /* When following the parent and detaching the child, we detach
5721 the child here. For the case of following the child and
5722 detaching the parent, the detach is done in the target-
5723 independent follow fork code in infrun.c. We can't use
5724 target_detach when detaching an unfollowed child because
5725 the client side doesn't know anything about the child. */
5726 if (detach_fork
&& !follow_child
)
5728 /* Detach the fork child. */
5732 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5733 child_pid
= child_ptid
.pid ();
5735 remote_detach_pid (child_pid
);
5741 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5742 in the program space of the new inferior. On entry and at return the
5743 current inferior is the exec'ing inferior. INF is the new exec'd
5744 inferior, which may be the same as the exec'ing inferior unless
5745 follow-exec-mode is "new". */
5748 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5750 /* We know that this is a target file name, so if it has the "target:"
5751 prefix we strip it off before saving it in the program space. */
5752 if (is_target_filename (execd_pathname
))
5753 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5755 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5758 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5761 remote_target::disconnect (const char *args
, int from_tty
)
5764 error (_("Argument given to \"disconnect\" when remotely debugging."));
5766 /* Make sure we unpush even the extended remote targets. Calling
5767 target_mourn_inferior won't unpush, and remote_mourn won't
5768 unpush if there is more than one inferior left. */
5769 unpush_target (this);
5770 generic_mourn_inferior ();
5773 puts_filtered ("Ending remote debugging.\n");
5776 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5777 be chatty about it. */
5780 extended_remote_target::attach (const char *args
, int from_tty
)
5782 struct remote_state
*rs
= get_remote_state ();
5784 char *wait_status
= NULL
;
5786 pid
= parse_pid_to_attach (args
);
5788 /* Remote PID can be freely equal to getpid, do not check it here the same
5789 way as in other targets. */
5791 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5792 error (_("This target does not support attaching to a process"));
5796 char *exec_file
= get_exec_file (0);
5799 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5800 target_pid_to_str (ptid_t (pid
)).c_str ());
5802 printf_unfiltered (_("Attaching to %s\n"),
5803 target_pid_to_str (ptid_t (pid
)).c_str ());
5806 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5808 getpkt (&rs
->buf
, 0);
5810 switch (packet_ok (rs
->buf
,
5811 &remote_protocol_packets
[PACKET_vAttach
]))
5814 if (!target_is_non_stop_p ())
5816 /* Save the reply for later. */
5817 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5818 strcpy (wait_status
, rs
->buf
.data ());
5820 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5821 error (_("Attaching to %s failed with: %s"),
5822 target_pid_to_str (ptid_t (pid
)).c_str (),
5825 case PACKET_UNKNOWN
:
5826 error (_("This target does not support attaching to a process"));
5829 std::string errmsg
= rs
->buf
.data ();
5831 if (!errmsg
.empty ())
5833 /* Get rid of the "E." prefix. */
5834 errmsg
.erase (0, 2);
5837 error (_("Attaching to %s failed%s%s"),
5838 target_pid_to_str (ptid_t (pid
)).c_str (),
5839 !errmsg
.empty () ? "\n" : "",
5844 set_current_inferior (remote_add_inferior (false, pid
, 1, 0));
5846 inferior_ptid
= ptid_t (pid
);
5848 if (target_is_non_stop_p ())
5850 struct thread_info
*thread
;
5852 /* Get list of threads. */
5853 update_thread_list ();
5855 thread
= first_thread_of_inferior (current_inferior ());
5857 inferior_ptid
= thread
->ptid
;
5859 inferior_ptid
= ptid_t (pid
);
5861 /* Invalidate our notion of the remote current thread. */
5862 record_currthread (rs
, minus_one_ptid
);
5866 /* Now, if we have thread information, update inferior_ptid. */
5867 inferior_ptid
= remote_current_thread (inferior_ptid
);
5869 /* Add the main thread to the thread list. */
5870 thread_info
*thr
= add_thread_silent (inferior_ptid
);
5871 /* Don't consider the thread stopped until we've processed the
5872 saved stop reply. */
5873 set_executing (thr
->ptid
, true);
5876 /* Next, if the target can specify a description, read it. We do
5877 this before anything involving memory or registers. */
5878 target_find_description ();
5880 if (!target_is_non_stop_p ())
5882 /* Use the previously fetched status. */
5883 gdb_assert (wait_status
!= NULL
);
5885 if (target_can_async_p ())
5887 struct notif_event
*reply
5888 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
5890 push_stop_reply ((struct stop_reply
*) reply
);
5896 gdb_assert (wait_status
!= NULL
);
5897 strcpy (rs
->buf
.data (), wait_status
);
5898 rs
->cached_wait_status
= 1;
5902 gdb_assert (wait_status
== NULL
);
5905 /* Implementation of the to_post_attach method. */
5908 extended_remote_target::post_attach (int pid
)
5910 /* Get text, data & bss offsets. */
5913 /* In certain cases GDB might not have had the chance to start
5914 symbol lookup up until now. This could happen if the debugged
5915 binary is not using shared libraries, the vsyscall page is not
5916 present (on Linux) and the binary itself hadn't changed since the
5917 debugging process was started. */
5918 if (symfile_objfile
!= NULL
)
5919 remote_check_symbols();
5923 /* Check for the availability of vCont. This function should also check
5927 remote_target::remote_vcont_probe ()
5929 remote_state
*rs
= get_remote_state ();
5932 strcpy (rs
->buf
.data (), "vCont?");
5934 getpkt (&rs
->buf
, 0);
5935 buf
= rs
->buf
.data ();
5937 /* Make sure that the features we assume are supported. */
5938 if (startswith (buf
, "vCont"))
5941 int support_c
, support_C
;
5943 rs
->supports_vCont
.s
= 0;
5944 rs
->supports_vCont
.S
= 0;
5947 rs
->supports_vCont
.t
= 0;
5948 rs
->supports_vCont
.r
= 0;
5949 while (p
&& *p
== ';')
5952 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5953 rs
->supports_vCont
.s
= 1;
5954 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5955 rs
->supports_vCont
.S
= 1;
5956 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5958 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5960 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5961 rs
->supports_vCont
.t
= 1;
5962 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5963 rs
->supports_vCont
.r
= 1;
5965 p
= strchr (p
, ';');
5968 /* If c, and C are not all supported, we can't use vCont. Clearing
5969 BUF will make packet_ok disable the packet. */
5970 if (!support_c
|| !support_C
)
5974 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
5977 /* Helper function for building "vCont" resumptions. Write a
5978 resumption to P. ENDP points to one-passed-the-end of the buffer
5979 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
5980 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5981 resumed thread should be single-stepped and/or signalled. If PTID
5982 equals minus_one_ptid, then all threads are resumed; if PTID
5983 represents a process, then all threads of the process are resumed;
5984 the thread to be stepped and/or signalled is given in the global
5988 remote_target::append_resumption (char *p
, char *endp
,
5989 ptid_t ptid
, int step
, gdb_signal siggnal
)
5991 struct remote_state
*rs
= get_remote_state ();
5993 if (step
&& siggnal
!= GDB_SIGNAL_0
)
5994 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
5996 /* GDB is willing to range step. */
5997 && use_range_stepping
5998 /* Target supports range stepping. */
5999 && rs
->supports_vCont
.r
6000 /* We don't currently support range stepping multiple
6001 threads with a wildcard (though the protocol allows it,
6002 so stubs shouldn't make an active effort to forbid
6004 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6006 struct thread_info
*tp
;
6008 if (ptid
== minus_one_ptid
)
6010 /* If we don't know about the target thread's tid, then
6011 we're resuming magic_null_ptid (see caller). */
6012 tp
= find_thread_ptid (magic_null_ptid
);
6015 tp
= find_thread_ptid (ptid
);
6016 gdb_assert (tp
!= NULL
);
6018 if (tp
->control
.may_range_step
)
6020 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6022 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6023 phex_nz (tp
->control
.step_range_start
,
6025 phex_nz (tp
->control
.step_range_end
,
6029 p
+= xsnprintf (p
, endp
- p
, ";s");
6032 p
+= xsnprintf (p
, endp
- p
, ";s");
6033 else if (siggnal
!= GDB_SIGNAL_0
)
6034 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6036 p
+= xsnprintf (p
, endp
- p
, ";c");
6038 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6042 /* All (-1) threads of process. */
6043 nptid
= ptid_t (ptid
.pid (), -1, 0);
6045 p
+= xsnprintf (p
, endp
- p
, ":");
6046 p
= write_ptid (p
, endp
, nptid
);
6048 else if (ptid
!= minus_one_ptid
)
6050 p
+= xsnprintf (p
, endp
- p
, ":");
6051 p
= write_ptid (p
, endp
, ptid
);
6057 /* Clear the thread's private info on resume. */
6060 resume_clear_thread_private_info (struct thread_info
*thread
)
6062 if (thread
->priv
!= NULL
)
6064 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6066 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6067 priv
->watch_data_address
= 0;
6071 /* Append a vCont continue-with-signal action for threads that have a
6072 non-zero stop signal. */
6075 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6078 for (thread_info
*thread
: all_non_exited_threads (ptid
))
6079 if (inferior_ptid
!= thread
->ptid
6080 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6082 p
= append_resumption (p
, endp
, thread
->ptid
,
6083 0, thread
->suspend
.stop_signal
);
6084 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6085 resume_clear_thread_private_info (thread
);
6091 /* Set the target running, using the packets that use Hc
6095 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6098 struct remote_state
*rs
= get_remote_state ();
6101 rs
->last_sent_signal
= siggnal
;
6102 rs
->last_sent_step
= step
;
6104 /* The c/s/C/S resume packets use Hc, so set the continue
6106 if (ptid
== minus_one_ptid
)
6107 set_continue_thread (any_thread_ptid
);
6109 set_continue_thread (ptid
);
6111 for (thread_info
*thread
: all_non_exited_threads ())
6112 resume_clear_thread_private_info (thread
);
6114 buf
= rs
->buf
.data ();
6115 if (::execution_direction
== EXEC_REVERSE
)
6117 /* We don't pass signals to the target in reverse exec mode. */
6118 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6119 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6122 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6123 error (_("Remote reverse-step not supported."));
6124 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6125 error (_("Remote reverse-continue not supported."));
6127 strcpy (buf
, step
? "bs" : "bc");
6129 else if (siggnal
!= GDB_SIGNAL_0
)
6131 buf
[0] = step
? 'S' : 'C';
6132 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6133 buf
[2] = tohex (((int) siggnal
) & 0xf);
6137 strcpy (buf
, step
? "s" : "c");
6142 /* Resume the remote inferior by using a "vCont" packet. The thread
6143 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6144 resumed thread should be single-stepped and/or signalled. If PTID
6145 equals minus_one_ptid, then all threads are resumed; the thread to
6146 be stepped and/or signalled is given in the global INFERIOR_PTID.
6147 This function returns non-zero iff it resumes the inferior.
6149 This function issues a strict subset of all possible vCont commands
6153 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6154 enum gdb_signal siggnal
)
6156 struct remote_state
*rs
= get_remote_state ();
6160 /* No reverse execution actions defined for vCont. */
6161 if (::execution_direction
== EXEC_REVERSE
)
6164 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6165 remote_vcont_probe ();
6167 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6170 p
= rs
->buf
.data ();
6171 endp
= p
+ get_remote_packet_size ();
6173 /* If we could generate a wider range of packets, we'd have to worry
6174 about overflowing BUF. Should there be a generic
6175 "multi-part-packet" packet? */
6177 p
+= xsnprintf (p
, endp
- p
, "vCont");
6179 if (ptid
== magic_null_ptid
)
6181 /* MAGIC_NULL_PTID means that we don't have any active threads,
6182 so we don't have any TID numbers the inferior will
6183 understand. Make sure to only send forms that do not specify
6185 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6187 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6189 /* Resume all threads (of all processes, or of a single
6190 process), with preference for INFERIOR_PTID. This assumes
6191 inferior_ptid belongs to the set of all threads we are about
6193 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6195 /* Step inferior_ptid, with or without signal. */
6196 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6199 /* Also pass down any pending signaled resumption for other
6200 threads not the current. */
6201 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6203 /* And continue others without a signal. */
6204 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6208 /* Scheduler locking; resume only PTID. */
6209 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6212 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6215 if (target_is_non_stop_p ())
6217 /* In non-stop, the stub replies to vCont with "OK". The stop
6218 reply will be reported asynchronously by means of a `%Stop'
6220 getpkt (&rs
->buf
, 0);
6221 if (strcmp (rs
->buf
.data (), "OK") != 0)
6222 error (_("Unexpected vCont reply in non-stop mode: %s"),
6229 /* Tell the remote machine to resume. */
6232 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6234 struct remote_state
*rs
= get_remote_state ();
6236 /* When connected in non-stop mode, the core resumes threads
6237 individually. Resuming remote threads directly in target_resume
6238 would thus result in sending one packet per thread. Instead, to
6239 minimize roundtrip latency, here we just store the resume
6240 request; the actual remote resumption will be done in
6241 target_commit_resume / remote_commit_resume, where we'll be able
6242 to do vCont action coalescing. */
6243 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6245 remote_thread_info
*remote_thr
;
6247 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6248 remote_thr
= get_remote_thread_info (inferior_ptid
);
6250 remote_thr
= get_remote_thread_info (ptid
);
6252 remote_thr
->last_resume_step
= step
;
6253 remote_thr
->last_resume_sig
= siggnal
;
6257 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6258 (explained in remote-notif.c:handle_notification) so
6259 remote_notif_process is not called. We need find a place where
6260 it is safe to start a 'vNotif' sequence. It is good to do it
6261 before resuming inferior, because inferior was stopped and no RSP
6262 traffic at that moment. */
6263 if (!target_is_non_stop_p ())
6264 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6266 rs
->last_resume_exec_dir
= ::execution_direction
;
6268 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6269 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6270 remote_resume_with_hc (ptid
, step
, siggnal
);
6272 /* We are about to start executing the inferior, let's register it
6273 with the event loop. NOTE: this is the one place where all the
6274 execution commands end up. We could alternatively do this in each
6275 of the execution commands in infcmd.c. */
6276 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6277 into infcmd.c in order to allow inferior function calls to work
6278 NOT asynchronously. */
6279 if (target_can_async_p ())
6282 /* We've just told the target to resume. The remote server will
6283 wait for the inferior to stop, and then send a stop reply. In
6284 the mean time, we can't start another command/query ourselves
6285 because the stub wouldn't be ready to process it. This applies
6286 only to the base all-stop protocol, however. In non-stop (which
6287 only supports vCont), the stub replies with an "OK", and is
6288 immediate able to process further serial input. */
6289 if (!target_is_non_stop_p ())
6290 rs
->waiting_for_stop_reply
= 1;
6293 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6295 /* Private per-inferior info for target remote processes. */
6297 struct remote_inferior
: public private_inferior
6299 /* Whether we can send a wildcard vCont for this process. */
6300 bool may_wildcard_vcont
= true;
6303 /* Get the remote private inferior data associated to INF. */
6305 static remote_inferior
*
6306 get_remote_inferior (inferior
*inf
)
6308 if (inf
->priv
== NULL
)
6309 inf
->priv
.reset (new remote_inferior
);
6311 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6314 /* Class used to track the construction of a vCont packet in the
6315 outgoing packet buffer. This is used to send multiple vCont
6316 packets if we have more actions than would fit a single packet. */
6321 explicit vcont_builder (remote_target
*remote
)
6328 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6333 /* The remote target. */
6334 remote_target
*m_remote
;
6336 /* Pointer to the first action. P points here if no action has been
6338 char *m_first_action
;
6340 /* Where the next action will be appended. */
6343 /* The end of the buffer. Must never write past this. */
6347 /* Prepare the outgoing buffer for a new vCont packet. */
6350 vcont_builder::restart ()
6352 struct remote_state
*rs
= m_remote
->get_remote_state ();
6354 m_p
= rs
->buf
.data ();
6355 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6356 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6357 m_first_action
= m_p
;
6360 /* If the vCont packet being built has any action, send it to the
6364 vcont_builder::flush ()
6366 struct remote_state
*rs
;
6368 if (m_p
== m_first_action
)
6371 rs
= m_remote
->get_remote_state ();
6372 m_remote
->putpkt (rs
->buf
);
6373 m_remote
->getpkt (&rs
->buf
, 0);
6374 if (strcmp (rs
->buf
.data (), "OK") != 0)
6375 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6378 /* The largest action is range-stepping, with its two addresses. This
6379 is more than sufficient. If a new, bigger action is created, it'll
6380 quickly trigger a failed assertion in append_resumption (and we'll
6382 #define MAX_ACTION_SIZE 200
6384 /* Append a new vCont action in the outgoing packet being built. If
6385 the action doesn't fit the packet along with previous actions, push
6386 what we've got so far to the remote end and start over a new vCont
6387 packet (with the new action). */
6390 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6392 char buf
[MAX_ACTION_SIZE
+ 1];
6394 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6395 ptid
, step
, siggnal
);
6397 /* Check whether this new action would fit in the vCont packet along
6398 with previous actions. If not, send what we've got so far and
6399 start a new vCont packet. */
6400 size_t rsize
= endp
- buf
;
6401 if (rsize
> m_endp
- m_p
)
6406 /* Should now fit. */
6407 gdb_assert (rsize
<= m_endp
- m_p
);
6410 memcpy (m_p
, buf
, rsize
);
6415 /* to_commit_resume implementation. */
6418 remote_target::commit_resume ()
6420 int any_process_wildcard
;
6421 int may_global_wildcard_vcont
;
6423 /* If connected in all-stop mode, we'd send the remote resume
6424 request directly from remote_resume. Likewise if
6425 reverse-debugging, as there are no defined vCont actions for
6426 reverse execution. */
6427 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6430 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6431 instead of resuming all threads of each process individually.
6432 However, if any thread of a process must remain halted, we can't
6433 send wildcard resumes and must send one action per thread.
6435 Care must be taken to not resume threads/processes the server
6436 side already told us are stopped, but the core doesn't know about
6437 yet, because the events are still in the vStopped notification
6440 #1 => vCont s:p1.1;c
6442 #3 <= %Stopped T05 p1.1
6447 #8 (infrun handles the stop for p1.1 and continues stepping)
6448 #9 => vCont s:p1.1;c
6450 The last vCont above would resume thread p1.2 by mistake, because
6451 the server has no idea that the event for p1.2 had not been
6454 The server side must similarly ignore resume actions for the
6455 thread that has a pending %Stopped notification (and any other
6456 threads with events pending), until GDB acks the notification
6457 with vStopped. Otherwise, e.g., the following case is
6460 #1 => g (or any other packet)
6462 #3 <= %Stopped T05 p1.2
6463 #4 => vCont s:p1.1;c
6466 Above, the server must not resume thread p1.2. GDB can't know
6467 that p1.2 stopped until it acks the %Stopped notification, and
6468 since from GDB's perspective all threads should be running, it
6471 Finally, special care must also be given to handling fork/vfork
6472 events. A (v)fork event actually tells us that two processes
6473 stopped -- the parent and the child. Until we follow the fork,
6474 we must not resume the child. Therefore, if we have a pending
6475 fork follow, we must not send a global wildcard resume action
6476 (vCont;c). We can still send process-wide wildcards though. */
6478 /* Start by assuming a global wildcard (vCont;c) is possible. */
6479 may_global_wildcard_vcont
= 1;
6481 /* And assume every process is individually wildcard-able too. */
6482 for (inferior
*inf
: all_non_exited_inferiors ())
6484 remote_inferior
*priv
= get_remote_inferior (inf
);
6486 priv
->may_wildcard_vcont
= true;
6489 /* Check for any pending events (not reported or processed yet) and
6490 disable process and global wildcard resumes appropriately. */
6491 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6493 for (thread_info
*tp
: all_non_exited_threads ())
6495 /* If a thread of a process is not meant to be resumed, then we
6496 can't wildcard that process. */
6499 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6501 /* And if we can't wildcard a process, we can't wildcard
6502 everything either. */
6503 may_global_wildcard_vcont
= 0;
6507 /* If a thread is the parent of an unfollowed fork, then we
6508 can't do a global wildcard, as that would resume the fork
6510 if (is_pending_fork_parent_thread (tp
))
6511 may_global_wildcard_vcont
= 0;
6514 /* Now let's build the vCont packet(s). Actions must be appended
6515 from narrower to wider scopes (thread -> process -> global). If
6516 we end up with too many actions for a single packet vcont_builder
6517 flushes the current vCont packet to the remote side and starts a
6519 struct vcont_builder
vcont_builder (this);
6521 /* Threads first. */
6522 for (thread_info
*tp
: all_non_exited_threads ())
6524 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6526 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6529 gdb_assert (!thread_is_in_step_over_chain (tp
));
6531 if (!remote_thr
->last_resume_step
6532 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6533 && get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6535 /* We'll send a wildcard resume instead. */
6536 remote_thr
->vcont_resumed
= 1;
6540 vcont_builder
.push_action (tp
->ptid
,
6541 remote_thr
->last_resume_step
,
6542 remote_thr
->last_resume_sig
);
6543 remote_thr
->vcont_resumed
= 1;
6546 /* Now check whether we can send any process-wide wildcard. This is
6547 to avoid sending a global wildcard in the case nothing is
6548 supposed to be resumed. */
6549 any_process_wildcard
= 0;
6551 for (inferior
*inf
: all_non_exited_inferiors ())
6553 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6555 any_process_wildcard
= 1;
6560 if (any_process_wildcard
)
6562 /* If all processes are wildcard-able, then send a single "c"
6563 action, otherwise, send an "all (-1) threads of process"
6564 continue action for each running process, if any. */
6565 if (may_global_wildcard_vcont
)
6567 vcont_builder
.push_action (minus_one_ptid
,
6568 false, GDB_SIGNAL_0
);
6572 for (inferior
*inf
: all_non_exited_inferiors ())
6574 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6576 vcont_builder
.push_action (ptid_t (inf
->pid
),
6577 false, GDB_SIGNAL_0
);
6583 vcont_builder
.flush ();
6588 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6589 thread, all threads of a remote process, or all threads of all
6593 remote_target::remote_stop_ns (ptid_t ptid
)
6595 struct remote_state
*rs
= get_remote_state ();
6596 char *p
= rs
->buf
.data ();
6597 char *endp
= p
+ get_remote_packet_size ();
6599 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6600 remote_vcont_probe ();
6602 if (!rs
->supports_vCont
.t
)
6603 error (_("Remote server does not support stopping threads"));
6605 if (ptid
== minus_one_ptid
6606 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6607 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6612 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6615 /* All (-1) threads of process. */
6616 nptid
= ptid_t (ptid
.pid (), -1, 0);
6619 /* Small optimization: if we already have a stop reply for
6620 this thread, no use in telling the stub we want this
6622 if (peek_stop_reply (ptid
))
6628 write_ptid (p
, endp
, nptid
);
6631 /* In non-stop, we get an immediate OK reply. The stop reply will
6632 come in asynchronously by notification. */
6634 getpkt (&rs
->buf
, 0);
6635 if (strcmp (rs
->buf
.data (), "OK") != 0)
6636 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6640 /* All-stop version of target_interrupt. Sends a break or a ^C to
6641 interrupt the remote target. It is undefined which thread of which
6642 process reports the interrupt. */
6645 remote_target::remote_interrupt_as ()
6647 struct remote_state
*rs
= get_remote_state ();
6649 rs
->ctrlc_pending_p
= 1;
6651 /* If the inferior is stopped already, but the core didn't know
6652 about it yet, just ignore the request. The cached wait status
6653 will be collected in remote_wait. */
6654 if (rs
->cached_wait_status
)
6657 /* Send interrupt_sequence to remote target. */
6658 send_interrupt_sequence ();
6661 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6662 the remote target. It is undefined which thread of which process
6663 reports the interrupt. Throws an error if the packet is not
6664 supported by the server. */
6667 remote_target::remote_interrupt_ns ()
6669 struct remote_state
*rs
= get_remote_state ();
6670 char *p
= rs
->buf
.data ();
6671 char *endp
= p
+ get_remote_packet_size ();
6673 xsnprintf (p
, endp
- p
, "vCtrlC");
6675 /* In non-stop, we get an immediate OK reply. The stop reply will
6676 come in asynchronously by notification. */
6678 getpkt (&rs
->buf
, 0);
6680 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6684 case PACKET_UNKNOWN
:
6685 error (_("No support for interrupting the remote target."));
6687 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6691 /* Implement the to_stop function for the remote targets. */
6694 remote_target::stop (ptid_t ptid
)
6697 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6699 if (target_is_non_stop_p ())
6700 remote_stop_ns (ptid
);
6703 /* We don't currently have a way to transparently pause the
6704 remote target in all-stop mode. Interrupt it instead. */
6705 remote_interrupt_as ();
6709 /* Implement the to_interrupt function for the remote targets. */
6712 remote_target::interrupt ()
6715 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6717 if (target_is_non_stop_p ())
6718 remote_interrupt_ns ();
6720 remote_interrupt_as ();
6723 /* Implement the to_pass_ctrlc function for the remote targets. */
6726 remote_target::pass_ctrlc ()
6728 struct remote_state
*rs
= get_remote_state ();
6731 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6733 /* If we're starting up, we're not fully synced yet. Quit
6735 if (rs
->starting_up
)
6737 /* If ^C has already been sent once, offer to disconnect. */
6738 else if (rs
->ctrlc_pending_p
)
6741 target_interrupt ();
6744 /* Ask the user what to do when an interrupt is received. */
6747 remote_target::interrupt_query ()
6749 struct remote_state
*rs
= get_remote_state ();
6751 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6753 if (query (_("The target is not responding to interrupt requests.\n"
6754 "Stop debugging it? ")))
6756 remote_unpush_target ();
6757 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6762 if (query (_("Interrupted while waiting for the program.\n"
6763 "Give up waiting? ")))
6768 /* Enable/disable target terminal ownership. Most targets can use
6769 terminal groups to control terminal ownership. Remote targets are
6770 different in that explicit transfer of ownership to/from GDB/target
6774 remote_target::terminal_inferior ()
6776 /* NOTE: At this point we could also register our selves as the
6777 recipient of all input. Any characters typed could then be
6778 passed on down to the target. */
6782 remote_target::terminal_ours ()
6787 remote_console_output (const char *msg
)
6791 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6794 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6798 fputs_unfiltered (tb
, gdb_stdtarg
);
6800 gdb_flush (gdb_stdtarg
);
6803 struct stop_reply
: public notif_event
6807 /* The identifier of the thread about this event */
6810 /* The remote state this event is associated with. When the remote
6811 connection, represented by a remote_state object, is closed,
6812 all the associated stop_reply events should be released. */
6813 struct remote_state
*rs
;
6815 struct target_waitstatus ws
;
6817 /* The architecture associated with the expedited registers. */
6820 /* Expedited registers. This makes remote debugging a bit more
6821 efficient for those targets that provide critical registers as
6822 part of their normal status mechanism (as another roundtrip to
6823 fetch them is avoided). */
6824 std::vector
<cached_reg_t
> regcache
;
6826 enum target_stop_reason stop_reason
;
6828 CORE_ADDR watch_data_address
;
6833 /* Return the length of the stop reply queue. */
6836 remote_target::stop_reply_queue_length ()
6838 remote_state
*rs
= get_remote_state ();
6839 return rs
->stop_reply_queue
.size ();
6843 remote_notif_stop_parse (remote_target
*remote
,
6844 struct notif_client
*self
, const char *buf
,
6845 struct notif_event
*event
)
6847 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6851 remote_notif_stop_ack (remote_target
*remote
,
6852 struct notif_client
*self
, const char *buf
,
6853 struct notif_event
*event
)
6855 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6858 putpkt (remote
, self
->ack_command
);
6860 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6862 /* We got an unknown stop reply. */
6863 error (_("Unknown stop reply"));
6866 remote
->push_stop_reply (stop_reply
);
6870 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
6871 struct notif_client
*self
)
6873 /* We can't get pending events in remote_notif_process for
6874 notification stop, and we have to do this in remote_wait_ns
6875 instead. If we fetch all queued events from stub, remote stub
6876 may exit and we have no chance to process them back in
6878 remote_state
*rs
= remote
->get_remote_state ();
6879 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
6883 stop_reply::~stop_reply ()
6885 for (cached_reg_t
®
: regcache
)
6889 static notif_event_up
6890 remote_notif_stop_alloc_reply ()
6892 return notif_event_up (new struct stop_reply ());
6895 /* A client of notification Stop. */
6897 struct notif_client notif_client_stop
=
6901 remote_notif_stop_parse
,
6902 remote_notif_stop_ack
,
6903 remote_notif_stop_can_get_pending_events
,
6904 remote_notif_stop_alloc_reply
,
6908 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6909 the pid of the process that owns the threads we want to check, or
6910 -1 if we want to check all threads. */
6913 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6916 if (ws
->kind
== TARGET_WAITKIND_FORKED
6917 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6919 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
6926 /* Return the thread's pending status used to determine whether the
6927 thread is a fork parent stopped at a fork event. */
6929 static struct target_waitstatus
*
6930 thread_pending_fork_status (struct thread_info
*thread
)
6932 if (thread
->suspend
.waitstatus_pending_p
)
6933 return &thread
->suspend
.waitstatus
;
6935 return &thread
->pending_follow
;
6938 /* Determine if THREAD is a pending fork parent thread. */
6941 is_pending_fork_parent_thread (struct thread_info
*thread
)
6943 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6946 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6949 /* If CONTEXT contains any fork child threads that have not been
6950 reported yet, remove them from the CONTEXT list. If such a
6951 thread exists it is because we are stopped at a fork catchpoint
6952 and have not yet called follow_fork, which will set up the
6953 host-side data structures for the new process. */
6956 remote_target::remove_new_fork_children (threads_listing_context
*context
)
6959 struct notif_client
*notif
= ¬if_client_stop
;
6961 /* For any threads stopped at a fork event, remove the corresponding
6962 fork child threads from the CONTEXT list. */
6963 for (thread_info
*thread
: all_non_exited_threads ())
6965 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6967 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
6968 context
->remove_thread (ws
->value
.related_pid
);
6971 /* Check for any pending fork events (not reported or processed yet)
6972 in process PID and remove those fork child threads from the
6973 CONTEXT list as well. */
6974 remote_notif_get_pending_events (notif
);
6975 for (auto &event
: get_remote_state ()->stop_reply_queue
)
6976 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6977 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
6978 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
6979 context
->remove_thread (event
->ws
.value
.related_pid
);
6982 /* Check whether any event pending in the vStopped queue would prevent
6983 a global or process wildcard vCont action. Clear
6984 *may_global_wildcard if we can't do a global wildcard (vCont;c),
6985 and clear the event inferior's may_wildcard_vcont flag if we can't
6986 do a process-wide wildcard resume (vCont;c:pPID.-1). */
6989 remote_target::check_pending_events_prevent_wildcard_vcont
6990 (int *may_global_wildcard
)
6992 struct notif_client
*notif
= ¬if_client_stop
;
6994 remote_notif_get_pending_events (notif
);
6995 for (auto &event
: get_remote_state ()->stop_reply_queue
)
6997 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
6998 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
7001 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7002 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
7003 *may_global_wildcard
= 0;
7005 struct inferior
*inf
= find_inferior_ptid (event
->ptid
);
7007 /* This may be the first time we heard about this process.
7008 Regardless, we must not do a global wildcard resume, otherwise
7009 we'd resume this process too. */
7010 *may_global_wildcard
= 0;
7012 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7016 /* Discard all pending stop replies of inferior INF. */
7019 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7021 struct stop_reply
*reply
;
7022 struct remote_state
*rs
= get_remote_state ();
7023 struct remote_notif_state
*rns
= rs
->notif_state
;
7025 /* This function can be notified when an inferior exists. When the
7026 target is not remote, the notification state is NULL. */
7027 if (rs
->remote_desc
== NULL
)
7030 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7032 /* Discard the in-flight notification. */
7033 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7036 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7039 /* Discard the stop replies we have already pulled with
7041 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7042 rs
->stop_reply_queue
.end (),
7043 [=] (const stop_reply_up
&event
)
7045 return event
->ptid
.pid () == inf
->pid
;
7047 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7050 /* Discard the stop replies for RS in stop_reply_queue. */
7053 remote_target::discard_pending_stop_replies_in_queue ()
7055 remote_state
*rs
= get_remote_state ();
7057 /* Discard the stop replies we have already pulled with
7059 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7060 rs
->stop_reply_queue
.end (),
7061 [=] (const stop_reply_up
&event
)
7063 return event
->rs
== rs
;
7065 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7068 /* Remove the first reply in 'stop_reply_queue' which matches
7072 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7074 remote_state
*rs
= get_remote_state ();
7076 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7077 rs
->stop_reply_queue
.end (),
7078 [=] (const stop_reply_up
&event
)
7080 return event
->ptid
.matches (ptid
);
7082 struct stop_reply
*result
;
7083 if (iter
== rs
->stop_reply_queue
.end ())
7087 result
= iter
->release ();
7088 rs
->stop_reply_queue
.erase (iter
);
7092 fprintf_unfiltered (gdb_stdlog
,
7093 "notif: discard queued event: 'Stop' in %s\n",
7094 target_pid_to_str (ptid
).c_str ());
7099 /* Look for a queued stop reply belonging to PTID. If one is found,
7100 remove it from the queue, and return it. Returns NULL if none is
7101 found. If there are still queued events left to process, tell the
7102 event loop to get back to target_wait soon. */
7105 remote_target::queued_stop_reply (ptid_t ptid
)
7107 remote_state
*rs
= get_remote_state ();
7108 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7110 if (!rs
->stop_reply_queue
.empty ())
7112 /* There's still at least an event left. */
7113 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7119 /* Push a fully parsed stop reply in the stop reply queue. Since we
7120 know that we now have at least one queued event left to pass to the
7121 core side, tell the event loop to get back to target_wait soon. */
7124 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7126 remote_state
*rs
= get_remote_state ();
7127 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7130 fprintf_unfiltered (gdb_stdlog
,
7131 "notif: push 'Stop' %s to queue %d\n",
7132 target_pid_to_str (new_event
->ptid
).c_str (),
7133 int (rs
->stop_reply_queue
.size ()));
7135 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7138 /* Returns true if we have a stop reply for PTID. */
7141 remote_target::peek_stop_reply (ptid_t ptid
)
7143 remote_state
*rs
= get_remote_state ();
7144 for (auto &event
: rs
->stop_reply_queue
)
7145 if (ptid
== event
->ptid
7146 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7151 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7152 starting with P and ending with PEND matches PREFIX. */
7155 strprefix (const char *p
, const char *pend
, const char *prefix
)
7157 for ( ; p
< pend
; p
++, prefix
++)
7160 return *prefix
== '\0';
7163 /* Parse the stop reply in BUF. Either the function succeeds, and the
7164 result is stored in EVENT, or throws an error. */
7167 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7169 remote_arch_state
*rsa
= NULL
;
7174 event
->ptid
= null_ptid
;
7175 event
->rs
= get_remote_state ();
7176 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7177 event
->ws
.value
.integer
= 0;
7178 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7179 event
->regcache
.clear ();
7184 case 'T': /* Status with PC, SP, FP, ... */
7185 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7186 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7188 n... = register number
7189 r... = register contents
7192 p
= &buf
[3]; /* after Txx */
7198 p1
= strchr (p
, ':');
7200 error (_("Malformed packet(a) (missing colon): %s\n\
7204 error (_("Malformed packet(a) (missing register number): %s\n\
7208 /* Some "registers" are actually extended stop information.
7209 Note if you're adding a new entry here: GDB 7.9 and
7210 earlier assume that all register "numbers" that start
7211 with an hex digit are real register numbers. Make sure
7212 the server only sends such a packet if it knows the
7213 client understands it. */
7215 if (strprefix (p
, p1
, "thread"))
7216 event
->ptid
= read_ptid (++p1
, &p
);
7217 else if (strprefix (p
, p1
, "syscall_entry"))
7221 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7222 p
= unpack_varlen_hex (++p1
, &sysno
);
7223 event
->ws
.value
.syscall_number
= (int) sysno
;
7225 else if (strprefix (p
, p1
, "syscall_return"))
7229 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7230 p
= unpack_varlen_hex (++p1
, &sysno
);
7231 event
->ws
.value
.syscall_number
= (int) sysno
;
7233 else if (strprefix (p
, p1
, "watch")
7234 || strprefix (p
, p1
, "rwatch")
7235 || strprefix (p
, p1
, "awatch"))
7237 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7238 p
= unpack_varlen_hex (++p1
, &addr
);
7239 event
->watch_data_address
= (CORE_ADDR
) addr
;
7241 else if (strprefix (p
, p1
, "swbreak"))
7243 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7245 /* Make sure the stub doesn't forget to indicate support
7247 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7248 error (_("Unexpected swbreak stop reason"));
7250 /* The value part is documented as "must be empty",
7251 though we ignore it, in case we ever decide to make
7252 use of it in a backward compatible way. */
7253 p
= strchrnul (p1
+ 1, ';');
7255 else if (strprefix (p
, p1
, "hwbreak"))
7257 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7259 /* Make sure the stub doesn't forget to indicate support
7261 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7262 error (_("Unexpected hwbreak stop reason"));
7265 p
= strchrnul (p1
+ 1, ';');
7267 else if (strprefix (p
, p1
, "library"))
7269 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7270 p
= strchrnul (p1
+ 1, ';');
7272 else if (strprefix (p
, p1
, "replaylog"))
7274 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7275 /* p1 will indicate "begin" or "end", but it makes
7276 no difference for now, so ignore it. */
7277 p
= strchrnul (p1
+ 1, ';');
7279 else if (strprefix (p
, p1
, "core"))
7283 p
= unpack_varlen_hex (++p1
, &c
);
7286 else if (strprefix (p
, p1
, "fork"))
7288 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7289 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7291 else if (strprefix (p
, p1
, "vfork"))
7293 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7294 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7296 else if (strprefix (p
, p1
, "vforkdone"))
7298 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7299 p
= strchrnul (p1
+ 1, ';');
7301 else if (strprefix (p
, p1
, "exec"))
7306 /* Determine the length of the execd pathname. */
7307 p
= unpack_varlen_hex (++p1
, &ignored
);
7308 pathlen
= (p
- p1
) / 2;
7310 /* Save the pathname for event reporting and for
7311 the next run command. */
7312 gdb::unique_xmalloc_ptr
<char[]> pathname
7313 ((char *) xmalloc (pathlen
+ 1));
7314 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7315 pathname
[pathlen
] = '\0';
7317 /* This is freed during event handling. */
7318 event
->ws
.value
.execd_pathname
= pathname
.release ();
7319 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7321 /* Skip the registers included in this packet, since
7322 they may be for an architecture different from the
7323 one used by the original program. */
7326 else if (strprefix (p
, p1
, "create"))
7328 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7329 p
= strchrnul (p1
+ 1, ';');
7338 p
= strchrnul (p1
+ 1, ';');
7343 /* Maybe a real ``P'' register number. */
7344 p_temp
= unpack_varlen_hex (p
, &pnum
);
7345 /* If the first invalid character is the colon, we got a
7346 register number. Otherwise, it's an unknown stop
7350 /* If we haven't parsed the event's thread yet, find
7351 it now, in order to find the architecture of the
7352 reported expedited registers. */
7353 if (event
->ptid
== null_ptid
)
7355 const char *thr
= strstr (p1
+ 1, ";thread:");
7357 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7361 /* Either the current thread hasn't changed,
7362 or the inferior is not multi-threaded.
7363 The event must be for the thread we last
7364 set as (or learned as being) current. */
7365 event
->ptid
= event
->rs
->general_thread
;
7371 inferior
*inf
= (event
->ptid
== null_ptid
7373 : find_inferior_ptid (event
->ptid
));
7374 /* If this is the first time we learn anything
7375 about this process, skip the registers
7376 included in this packet, since we don't yet
7377 know which architecture to use to parse them.
7378 We'll determine the architecture later when
7379 we process the stop reply and retrieve the
7380 target description, via
7381 remote_notice_new_inferior ->
7382 post_create_inferior. */
7385 p
= strchrnul (p1
+ 1, ';');
7390 event
->arch
= inf
->gdbarch
;
7391 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7395 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7396 cached_reg_t cached_reg
;
7399 error (_("Remote sent bad register number %s: %s\n\
7401 hex_string (pnum
), p
, buf
);
7403 cached_reg
.num
= reg
->regnum
;
7404 cached_reg
.data
= (gdb_byte
*)
7405 xmalloc (register_size (event
->arch
, reg
->regnum
));
7408 fieldsize
= hex2bin (p
, cached_reg
.data
,
7409 register_size (event
->arch
, reg
->regnum
));
7411 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7412 warning (_("Remote reply is too short: %s"), buf
);
7414 event
->regcache
.push_back (cached_reg
);
7418 /* Not a number. Silently skip unknown optional
7420 p
= strchrnul (p1
+ 1, ';');
7425 error (_("Remote register badly formatted: %s\nhere: %s"),
7430 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7434 case 'S': /* Old style status, just signal only. */
7438 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7439 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7440 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7441 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7443 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7446 case 'w': /* Thread exited. */
7450 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7451 p
= unpack_varlen_hex (&buf
[1], &value
);
7452 event
->ws
.value
.integer
= value
;
7454 error (_("stop reply packet badly formatted: %s"), buf
);
7455 event
->ptid
= read_ptid (++p
, NULL
);
7458 case 'W': /* Target exited. */
7464 /* GDB used to accept only 2 hex chars here. Stubs should
7465 only send more if they detect GDB supports multi-process
7467 p
= unpack_varlen_hex (&buf
[1], &value
);
7471 /* The remote process exited. */
7472 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7473 event
->ws
.value
.integer
= value
;
7477 /* The remote process exited with a signal. */
7478 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7479 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7480 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7482 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7485 /* If no process is specified, assume inferior_ptid. */
7486 pid
= inferior_ptid
.pid ();
7495 else if (startswith (p
, "process:"))
7499 p
+= sizeof ("process:") - 1;
7500 unpack_varlen_hex (p
, &upid
);
7504 error (_("unknown stop reply packet: %s"), buf
);
7507 error (_("unknown stop reply packet: %s"), buf
);
7508 event
->ptid
= ptid_t (pid
);
7512 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7513 event
->ptid
= minus_one_ptid
;
7517 if (target_is_non_stop_p () && event
->ptid
== null_ptid
)
7518 error (_("No process or thread specified in stop reply: %s"), buf
);
7521 /* When the stub wants to tell GDB about a new notification reply, it
7522 sends a notification (%Stop, for example). Those can come it at
7523 any time, hence, we have to make sure that any pending
7524 putpkt/getpkt sequence we're making is finished, before querying
7525 the stub for more events with the corresponding ack command
7526 (vStopped, for example). E.g., if we started a vStopped sequence
7527 immediately upon receiving the notification, something like this
7535 1.6) <-- (registers reply to step #1.3)
7537 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7540 To solve this, whenever we parse a %Stop notification successfully,
7541 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7542 doing whatever we were doing:
7548 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7549 2.5) <-- (registers reply to step #2.3)
7551 Eventualy after step #2.5, we return to the event loop, which
7552 notices there's an event on the
7553 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7554 associated callback --- the function below. At this point, we're
7555 always safe to start a vStopped sequence. :
7558 2.7) <-- T05 thread:2
7564 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7566 struct remote_state
*rs
= get_remote_state ();
7568 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7571 fprintf_unfiltered (gdb_stdlog
,
7572 "notif: process: '%s' ack pending event\n",
7576 nc
->ack (this, nc
, rs
->buf
.data (),
7577 rs
->notif_state
->pending_event
[nc
->id
]);
7578 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7582 getpkt (&rs
->buf
, 0);
7583 if (strcmp (rs
->buf
.data (), "OK") == 0)
7586 remote_notif_ack (this, nc
, rs
->buf
.data ());
7592 fprintf_unfiltered (gdb_stdlog
,
7593 "notif: process: '%s' no pending reply\n",
7598 /* Wrapper around remote_target::remote_notif_get_pending_events to
7599 avoid having to export the whole remote_target class. */
7602 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7604 remote
->remote_notif_get_pending_events (nc
);
7607 /* Called when it is decided that STOP_REPLY holds the info of the
7608 event that is to be returned to the core. This function always
7609 destroys STOP_REPLY. */
7612 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7613 struct target_waitstatus
*status
)
7617 *status
= stop_reply
->ws
;
7618 ptid
= stop_reply
->ptid
;
7620 /* If no thread/process was reported by the stub, assume the current
7622 if (ptid
== null_ptid
)
7623 ptid
= inferior_ptid
;
7625 if (status
->kind
!= TARGET_WAITKIND_EXITED
7626 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7627 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7629 /* Expedited registers. */
7630 if (!stop_reply
->regcache
.empty ())
7632 struct regcache
*regcache
7633 = get_thread_arch_regcache (ptid
, stop_reply
->arch
);
7635 for (cached_reg_t
®
: stop_reply
->regcache
)
7637 regcache
->raw_supply (reg
.num
, reg
.data
);
7641 stop_reply
->regcache
.clear ();
7644 remote_notice_new_inferior (ptid
, 0);
7645 remote_thread_info
*remote_thr
= get_remote_thread_info (ptid
);
7646 remote_thr
->core
= stop_reply
->core
;
7647 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7648 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7649 remote_thr
->vcont_resumed
= 0;
7656 /* The non-stop mode version of target_wait. */
7659 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7661 struct remote_state
*rs
= get_remote_state ();
7662 struct stop_reply
*stop_reply
;
7666 /* If in non-stop mode, get out of getpkt even if a
7667 notification is received. */
7669 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7672 if (ret
!= -1 && !is_notif
)
7675 case 'E': /* Error of some sort. */
7676 /* We're out of sync with the target now. Did it continue
7677 or not? We can't tell which thread it was in non-stop,
7678 so just ignore this. */
7679 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7681 case 'O': /* Console output. */
7682 remote_console_output (&rs
->buf
[1]);
7685 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7689 /* Acknowledge a pending stop reply that may have arrived in the
7691 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7692 remote_notif_get_pending_events (¬if_client_stop
);
7694 /* If indeed we noticed a stop reply, we're done. */
7695 stop_reply
= queued_stop_reply (ptid
);
7696 if (stop_reply
!= NULL
)
7697 return process_stop_reply (stop_reply
, status
);
7699 /* Still no event. If we're just polling for an event, then
7700 return to the event loop. */
7701 if (options
& TARGET_WNOHANG
)
7703 status
->kind
= TARGET_WAITKIND_IGNORE
;
7704 return minus_one_ptid
;
7707 /* Otherwise do a blocking wait. */
7708 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7712 /* Wait until the remote machine stops, then return, storing status in
7713 STATUS just as `wait' would. */
7716 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
, int options
)
7718 struct remote_state
*rs
= get_remote_state ();
7719 ptid_t event_ptid
= null_ptid
;
7721 struct stop_reply
*stop_reply
;
7725 status
->kind
= TARGET_WAITKIND_IGNORE
;
7726 status
->value
.integer
= 0;
7728 stop_reply
= queued_stop_reply (ptid
);
7729 if (stop_reply
!= NULL
)
7730 return process_stop_reply (stop_reply
, status
);
7732 if (rs
->cached_wait_status
)
7733 /* Use the cached wait status, but only once. */
7734 rs
->cached_wait_status
= 0;
7739 int forever
= ((options
& TARGET_WNOHANG
) == 0
7740 && rs
->wait_forever_enabled_p
);
7742 if (!rs
->waiting_for_stop_reply
)
7744 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7745 return minus_one_ptid
;
7748 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7749 _never_ wait for ever -> test on target_is_async_p().
7750 However, before we do that we need to ensure that the caller
7751 knows how to take the target into/out of async mode. */
7752 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
7754 /* GDB gets a notification. Return to core as this event is
7756 if (ret
!= -1 && is_notif
)
7757 return minus_one_ptid
;
7759 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7760 return minus_one_ptid
;
7763 buf
= rs
->buf
.data ();
7765 /* Assume that the target has acknowledged Ctrl-C unless we receive
7766 an 'F' or 'O' packet. */
7767 if (buf
[0] != 'F' && buf
[0] != 'O')
7768 rs
->ctrlc_pending_p
= 0;
7772 case 'E': /* Error of some sort. */
7773 /* We're out of sync with the target now. Did it continue or
7774 not? Not is more likely, so report a stop. */
7775 rs
->waiting_for_stop_reply
= 0;
7777 warning (_("Remote failure reply: %s"), buf
);
7778 status
->kind
= TARGET_WAITKIND_STOPPED
;
7779 status
->value
.sig
= GDB_SIGNAL_0
;
7781 case 'F': /* File-I/O request. */
7782 /* GDB may access the inferior memory while handling the File-I/O
7783 request, but we don't want GDB accessing memory while waiting
7784 for a stop reply. See the comments in putpkt_binary. Set
7785 waiting_for_stop_reply to 0 temporarily. */
7786 rs
->waiting_for_stop_reply
= 0;
7787 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
7788 rs
->ctrlc_pending_p
= 0;
7789 /* GDB handled the File-I/O request, and the target is running
7790 again. Keep waiting for events. */
7791 rs
->waiting_for_stop_reply
= 1;
7793 case 'N': case 'T': case 'S': case 'X': case 'W':
7795 /* There is a stop reply to handle. */
7796 rs
->waiting_for_stop_reply
= 0;
7799 = (struct stop_reply
*) remote_notif_parse (this,
7803 event_ptid
= process_stop_reply (stop_reply
, status
);
7806 case 'O': /* Console output. */
7807 remote_console_output (buf
+ 1);
7810 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7812 /* Zero length reply means that we tried 'S' or 'C' and the
7813 remote system doesn't support it. */
7814 target_terminal::ours_for_output ();
7816 ("Can't send signals to this remote system. %s not sent.\n",
7817 gdb_signal_to_name (rs
->last_sent_signal
));
7818 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7819 target_terminal::inferior ();
7821 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7827 warning (_("Invalid remote reply: %s"), buf
);
7831 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7832 return minus_one_ptid
;
7833 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7835 /* Nothing interesting happened. If we're doing a non-blocking
7836 poll, we're done. Otherwise, go back to waiting. */
7837 if (options
& TARGET_WNOHANG
)
7838 return minus_one_ptid
;
7842 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7843 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7845 if (event_ptid
!= null_ptid
)
7846 record_currthread (rs
, event_ptid
);
7848 event_ptid
= inferior_ptid
;
7851 /* A process exit. Invalidate our notion of current thread. */
7852 record_currthread (rs
, minus_one_ptid
);
7857 /* Wait until the remote machine stops, then return, storing status in
7858 STATUS just as `wait' would. */
7861 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7865 if (target_is_non_stop_p ())
7866 event_ptid
= wait_ns (ptid
, status
, options
);
7868 event_ptid
= wait_as (ptid
, status
, options
);
7870 if (target_is_async_p ())
7872 remote_state
*rs
= get_remote_state ();
7874 /* If there are are events left in the queue tell the event loop
7876 if (!rs
->stop_reply_queue
.empty ())
7877 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7883 /* Fetch a single register using a 'p' packet. */
7886 remote_target::fetch_register_using_p (struct regcache
*regcache
,
7889 struct gdbarch
*gdbarch
= regcache
->arch ();
7890 struct remote_state
*rs
= get_remote_state ();
7892 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7895 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7898 if (reg
->pnum
== -1)
7901 p
= rs
->buf
.data ();
7903 p
+= hexnumstr (p
, reg
->pnum
);
7906 getpkt (&rs
->buf
, 0);
7908 buf
= rs
->buf
.data ();
7910 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
7914 case PACKET_UNKNOWN
:
7917 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7918 gdbarch_register_name (regcache
->arch (),
7923 /* If this register is unfetchable, tell the regcache. */
7926 regcache
->raw_supply (reg
->regnum
, NULL
);
7930 /* Otherwise, parse and supply the value. */
7936 error (_("fetch_register_using_p: early buf termination"));
7938 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7941 regcache
->raw_supply (reg
->regnum
, regp
);
7945 /* Fetch the registers included in the target's 'g' packet. */
7948 remote_target::send_g_packet ()
7950 struct remote_state
*rs
= get_remote_state ();
7953 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
7955 getpkt (&rs
->buf
, 0);
7956 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
7957 error (_("Could not read registers; remote failure reply '%s'"),
7960 /* We can get out of synch in various cases. If the first character
7961 in the buffer is not a hex character, assume that has happened
7962 and try to fetch another packet to read. */
7963 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
7964 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
7965 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
7966 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
7969 fprintf_unfiltered (gdb_stdlog
,
7970 "Bad register packet; fetching a new packet\n");
7971 getpkt (&rs
->buf
, 0);
7974 buf_len
= strlen (rs
->buf
.data ());
7976 /* Sanity check the received packet. */
7977 if (buf_len
% 2 != 0)
7978 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
7984 remote_target::process_g_packet (struct regcache
*regcache
)
7986 struct gdbarch
*gdbarch
= regcache
->arch ();
7987 struct remote_state
*rs
= get_remote_state ();
7988 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
7993 buf_len
= strlen (rs
->buf
.data ());
7995 /* Further sanity checks, with knowledge of the architecture. */
7996 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
7997 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
7999 rsa
->sizeof_g_packet
, buf_len
/ 2,
8002 /* Save the size of the packet sent to us by the target. It is used
8003 as a heuristic when determining the max size of packets that the
8004 target can safely receive. */
8005 if (rsa
->actual_register_packet_size
== 0)
8006 rsa
->actual_register_packet_size
= buf_len
;
8008 /* If this is smaller than we guessed the 'g' packet would be,
8009 update our records. A 'g' reply that doesn't include a register's
8010 value implies either that the register is not available, or that
8011 the 'p' packet must be used. */
8012 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8014 long sizeof_g_packet
= buf_len
/ 2;
8016 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8018 long offset
= rsa
->regs
[i
].offset
;
8019 long reg_size
= register_size (gdbarch
, i
);
8021 if (rsa
->regs
[i
].pnum
== -1)
8024 if (offset
>= sizeof_g_packet
)
8025 rsa
->regs
[i
].in_g_packet
= 0;
8026 else if (offset
+ reg_size
> sizeof_g_packet
)
8027 error (_("Truncated register %d in remote 'g' packet"), i
);
8029 rsa
->regs
[i
].in_g_packet
= 1;
8032 /* Looks valid enough, we can assume this is the correct length
8033 for a 'g' packet. It's important not to adjust
8034 rsa->sizeof_g_packet if we have truncated registers otherwise
8035 this "if" won't be run the next time the method is called
8036 with a packet of the same size and one of the internal errors
8037 below will trigger instead. */
8038 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8041 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8043 /* Unimplemented registers read as all bits zero. */
8044 memset (regs
, 0, rsa
->sizeof_g_packet
);
8046 /* Reply describes registers byte by byte, each byte encoded as two
8047 hex characters. Suck them all up, then supply them to the
8048 register cacheing/storage mechanism. */
8050 p
= rs
->buf
.data ();
8051 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8053 if (p
[0] == 0 || p
[1] == 0)
8054 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8055 internal_error (__FILE__
, __LINE__
,
8056 _("unexpected end of 'g' packet reply"));
8058 if (p
[0] == 'x' && p
[1] == 'x')
8059 regs
[i
] = 0; /* 'x' */
8061 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8065 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8067 struct packet_reg
*r
= &rsa
->regs
[i
];
8068 long reg_size
= register_size (gdbarch
, i
);
8072 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8073 /* This shouldn't happen - we adjusted in_g_packet above. */
8074 internal_error (__FILE__
, __LINE__
,
8075 _("unexpected end of 'g' packet reply"));
8076 else if (rs
->buf
[r
->offset
* 2] == 'x')
8078 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8079 /* The register isn't available, mark it as such (at
8080 the same time setting the value to zero). */
8081 regcache
->raw_supply (r
->regnum
, NULL
);
8084 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8090 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8093 process_g_packet (regcache
);
8096 /* Make the remote selected traceframe match GDB's selected
8100 remote_target::set_remote_traceframe ()
8103 struct remote_state
*rs
= get_remote_state ();
8105 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8108 /* Avoid recursion, remote_trace_find calls us again. */
8109 rs
->remote_traceframe_number
= get_traceframe_number ();
8111 newnum
= target_trace_find (tfind_number
,
8112 get_traceframe_number (), 0, 0, NULL
);
8114 /* Should not happen. If it does, all bets are off. */
8115 if (newnum
!= get_traceframe_number ())
8116 warning (_("could not set remote traceframe"));
8120 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8122 struct gdbarch
*gdbarch
= regcache
->arch ();
8123 struct remote_state
*rs
= get_remote_state ();
8124 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8127 set_remote_traceframe ();
8128 set_general_thread (regcache
->ptid ());
8132 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8134 gdb_assert (reg
!= NULL
);
8136 /* If this register might be in the 'g' packet, try that first -
8137 we are likely to read more than one register. If this is the
8138 first 'g' packet, we might be overly optimistic about its
8139 contents, so fall back to 'p'. */
8140 if (reg
->in_g_packet
)
8142 fetch_registers_using_g (regcache
);
8143 if (reg
->in_g_packet
)
8147 if (fetch_register_using_p (regcache
, reg
))
8150 /* This register is not available. */
8151 regcache
->raw_supply (reg
->regnum
, NULL
);
8156 fetch_registers_using_g (regcache
);
8158 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8159 if (!rsa
->regs
[i
].in_g_packet
)
8160 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8162 /* This register is not available. */
8163 regcache
->raw_supply (i
, NULL
);
8167 /* Prepare to store registers. Since we may send them all (using a
8168 'G' request), we have to read out the ones we don't want to change
8172 remote_target::prepare_to_store (struct regcache
*regcache
)
8174 struct remote_state
*rs
= get_remote_state ();
8175 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8178 /* Make sure the entire registers array is valid. */
8179 switch (packet_support (PACKET_P
))
8181 case PACKET_DISABLE
:
8182 case PACKET_SUPPORT_UNKNOWN
:
8183 /* Make sure all the necessary registers are cached. */
8184 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8185 if (rsa
->regs
[i
].in_g_packet
)
8186 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8193 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8194 packet was not recognized. */
8197 remote_target::store_register_using_P (const struct regcache
*regcache
,
8200 struct gdbarch
*gdbarch
= regcache
->arch ();
8201 struct remote_state
*rs
= get_remote_state ();
8202 /* Try storing a single register. */
8203 char *buf
= rs
->buf
.data ();
8204 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8207 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8210 if (reg
->pnum
== -1)
8213 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8214 p
= buf
+ strlen (buf
);
8215 regcache
->raw_collect (reg
->regnum
, regp
);
8216 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8218 getpkt (&rs
->buf
, 0);
8220 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8225 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8226 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8227 case PACKET_UNKNOWN
:
8230 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8234 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8235 contents of the register cache buffer. FIXME: ignores errors. */
8238 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8240 struct remote_state
*rs
= get_remote_state ();
8241 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8245 /* Extract all the registers in the regcache copying them into a
8250 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8251 memset (regs
, 0, rsa
->sizeof_g_packet
);
8252 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8254 struct packet_reg
*r
= &rsa
->regs
[i
];
8257 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8261 /* Command describes registers byte by byte,
8262 each byte encoded as two hex characters. */
8263 p
= rs
->buf
.data ();
8265 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8267 getpkt (&rs
->buf
, 0);
8268 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8269 error (_("Could not write registers; remote failure reply '%s'"),
8273 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8274 of the register cache buffer. FIXME: ignores errors. */
8277 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8279 struct gdbarch
*gdbarch
= regcache
->arch ();
8280 struct remote_state
*rs
= get_remote_state ();
8281 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8284 set_remote_traceframe ();
8285 set_general_thread (regcache
->ptid ());
8289 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8291 gdb_assert (reg
!= NULL
);
8293 /* Always prefer to store registers using the 'P' packet if
8294 possible; we often change only a small number of registers.
8295 Sometimes we change a larger number; we'd need help from a
8296 higher layer to know to use 'G'. */
8297 if (store_register_using_P (regcache
, reg
))
8300 /* For now, don't complain if we have no way to write the
8301 register. GDB loses track of unavailable registers too
8302 easily. Some day, this may be an error. We don't have
8303 any way to read the register, either... */
8304 if (!reg
->in_g_packet
)
8307 store_registers_using_G (regcache
);
8311 store_registers_using_G (regcache
);
8313 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8314 if (!rsa
->regs
[i
].in_g_packet
)
8315 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8316 /* See above for why we do not issue an error here. */
8321 /* Return the number of hex digits in num. */
8324 hexnumlen (ULONGEST num
)
8328 for (i
= 0; num
!= 0; i
++)
8331 return std::max (i
, 1);
8334 /* Set BUF to the minimum number of hex digits representing NUM. */
8337 hexnumstr (char *buf
, ULONGEST num
)
8339 int len
= hexnumlen (num
);
8341 return hexnumnstr (buf
, num
, len
);
8345 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8348 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8354 for (i
= width
- 1; i
>= 0; i
--)
8356 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8363 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8366 remote_address_masked (CORE_ADDR addr
)
8368 unsigned int address_size
= remote_address_size
;
8370 /* If "remoteaddresssize" was not set, default to target address size. */
8372 address_size
= gdbarch_addr_bit (target_gdbarch ());
8374 if (address_size
> 0
8375 && address_size
< (sizeof (ULONGEST
) * 8))
8377 /* Only create a mask when that mask can safely be constructed
8378 in a ULONGEST variable. */
8381 mask
= (mask
<< address_size
) - 1;
8387 /* Determine whether the remote target supports binary downloading.
8388 This is accomplished by sending a no-op memory write of zero length
8389 to the target at the specified address. It does not suffice to send
8390 the whole packet, since many stubs strip the eighth bit and
8391 subsequently compute a wrong checksum, which causes real havoc with
8394 NOTE: This can still lose if the serial line is not eight-bit
8395 clean. In cases like this, the user should clear "remote
8399 remote_target::check_binary_download (CORE_ADDR addr
)
8401 struct remote_state
*rs
= get_remote_state ();
8403 switch (packet_support (PACKET_X
))
8405 case PACKET_DISABLE
:
8409 case PACKET_SUPPORT_UNKNOWN
:
8413 p
= rs
->buf
.data ();
8415 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8417 p
+= hexnumstr (p
, (ULONGEST
) 0);
8421 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8422 getpkt (&rs
->buf
, 0);
8424 if (rs
->buf
[0] == '\0')
8427 fprintf_unfiltered (gdb_stdlog
,
8428 "binary downloading NOT "
8429 "supported by target\n");
8430 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8435 fprintf_unfiltered (gdb_stdlog
,
8436 "binary downloading supported by target\n");
8437 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8444 /* Helper function to resize the payload in order to try to get a good
8445 alignment. We try to write an amount of data such that the next write will
8446 start on an address aligned on REMOTE_ALIGN_WRITES. */
8449 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8451 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8454 /* Write memory data directly to the remote machine.
8455 This does not inform the data cache; the data cache uses this.
8456 HEADER is the starting part of the packet.
8457 MEMADDR is the address in the remote memory space.
8458 MYADDR is the address of the buffer in our space.
8459 LEN_UNITS is the number of addressable units to write.
8460 UNIT_SIZE is the length in bytes of an addressable unit.
8461 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8462 should send data as binary ('X'), or hex-encoded ('M').
8464 The function creates packet of the form
8465 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8467 where encoding of <DATA> is terminated by PACKET_FORMAT.
8469 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8472 Return the transferred status, error or OK (an
8473 'enum target_xfer_status' value). Save the number of addressable units
8474 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8476 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8477 exchange between gdb and the stub could look like (?? in place of the
8483 -> $M1000,3:eeeeffffeeee#??
8487 <- eeeeffffeeeedddd */
8490 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8491 const gdb_byte
*myaddr
,
8494 ULONGEST
*xfered_len_units
,
8495 char packet_format
, int use_length
)
8497 struct remote_state
*rs
= get_remote_state ();
8503 int payload_capacity_bytes
;
8504 int payload_length_bytes
;
8506 if (packet_format
!= 'X' && packet_format
!= 'M')
8507 internal_error (__FILE__
, __LINE__
,
8508 _("remote_write_bytes_aux: bad packet format"));
8511 return TARGET_XFER_EOF
;
8513 payload_capacity_bytes
= get_memory_write_packet_size ();
8515 /* The packet buffer will be large enough for the payload;
8516 get_memory_packet_size ensures this. */
8519 /* Compute the size of the actual payload by subtracting out the
8520 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8522 payload_capacity_bytes
-= strlen ("$,:#NN");
8524 /* The comma won't be used. */
8525 payload_capacity_bytes
+= 1;
8526 payload_capacity_bytes
-= strlen (header
);
8527 payload_capacity_bytes
-= hexnumlen (memaddr
);
8529 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8531 strcat (rs
->buf
.data (), header
);
8532 p
= rs
->buf
.data () + strlen (header
);
8534 /* Compute a best guess of the number of bytes actually transfered. */
8535 if (packet_format
== 'X')
8537 /* Best guess at number of bytes that will fit. */
8538 todo_units
= std::min (len_units
,
8539 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8541 payload_capacity_bytes
-= hexnumlen (todo_units
);
8542 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8546 /* Number of bytes that will fit. */
8548 = std::min (len_units
,
8549 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8551 payload_capacity_bytes
-= hexnumlen (todo_units
);
8552 todo_units
= std::min (todo_units
,
8553 (payload_capacity_bytes
/ unit_size
) / 2);
8556 if (todo_units
<= 0)
8557 internal_error (__FILE__
, __LINE__
,
8558 _("minimum packet size too small to write data"));
8560 /* If we already need another packet, then try to align the end
8561 of this packet to a useful boundary. */
8562 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8563 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8565 /* Append "<memaddr>". */
8566 memaddr
= remote_address_masked (memaddr
);
8567 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8574 /* Append the length and retain its location and size. It may need to be
8575 adjusted once the packet body has been created. */
8577 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8585 /* Append the packet body. */
8586 if (packet_format
== 'X')
8588 /* Binary mode. Send target system values byte by byte, in
8589 increasing byte addresses. Only escape certain critical
8591 payload_length_bytes
=
8592 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8593 &units_written
, payload_capacity_bytes
);
8595 /* If not all TODO units fit, then we'll need another packet. Make
8596 a second try to keep the end of the packet aligned. Don't do
8597 this if the packet is tiny. */
8598 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8602 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8604 if (new_todo_units
!= units_written
)
8605 payload_length_bytes
=
8606 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8607 (gdb_byte
*) p
, &units_written
,
8608 payload_capacity_bytes
);
8611 p
+= payload_length_bytes
;
8612 if (use_length
&& units_written
< todo_units
)
8614 /* Escape chars have filled up the buffer prematurely,
8615 and we have actually sent fewer units than planned.
8616 Fix-up the length field of the packet. Use the same
8617 number of characters as before. */
8618 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8620 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8625 /* Normal mode: Send target system values byte by byte, in
8626 increasing byte addresses. Each byte is encoded as a two hex
8628 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8629 units_written
= todo_units
;
8632 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8633 getpkt (&rs
->buf
, 0);
8635 if (rs
->buf
[0] == 'E')
8636 return TARGET_XFER_E_IO
;
8638 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8639 send fewer units than we'd planned. */
8640 *xfered_len_units
= (ULONGEST
) units_written
;
8641 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8644 /* Write memory data directly to the remote machine.
8645 This does not inform the data cache; the data cache uses this.
8646 MEMADDR is the address in the remote memory space.
8647 MYADDR is the address of the buffer in our space.
8648 LEN is the number of bytes.
8650 Return the transferred status, error or OK (an
8651 'enum target_xfer_status' value). Save the number of bytes
8652 transferred in *XFERED_LEN. Only transfer a single packet. */
8655 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8656 ULONGEST len
, int unit_size
,
8657 ULONGEST
*xfered_len
)
8659 const char *packet_format
= NULL
;
8661 /* Check whether the target supports binary download. */
8662 check_binary_download (memaddr
);
8664 switch (packet_support (PACKET_X
))
8667 packet_format
= "X";
8669 case PACKET_DISABLE
:
8670 packet_format
= "M";
8672 case PACKET_SUPPORT_UNKNOWN
:
8673 internal_error (__FILE__
, __LINE__
,
8674 _("remote_write_bytes: bad internal state"));
8676 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8679 return remote_write_bytes_aux (packet_format
,
8680 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8681 packet_format
[0], 1);
8684 /* Read memory data directly from the remote machine.
8685 This does not use the data cache; the data cache uses this.
8686 MEMADDR is the address in the remote memory space.
8687 MYADDR is the address of the buffer in our space.
8688 LEN_UNITS is the number of addressable memory units to read..
8689 UNIT_SIZE is the length in bytes of an addressable unit.
8691 Return the transferred status, error or OK (an
8692 'enum target_xfer_status' value). Save the number of bytes
8693 transferred in *XFERED_LEN_UNITS.
8695 See the comment of remote_write_bytes_aux for an example of
8696 memory read/write exchange between gdb and the stub. */
8699 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8701 int unit_size
, ULONGEST
*xfered_len_units
)
8703 struct remote_state
*rs
= get_remote_state ();
8704 int buf_size_bytes
; /* Max size of packet output buffer. */
8709 buf_size_bytes
= get_memory_read_packet_size ();
8710 /* The packet buffer will be large enough for the payload;
8711 get_memory_packet_size ensures this. */
8713 /* Number of units that will fit. */
8714 todo_units
= std::min (len_units
,
8715 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8717 /* Construct "m"<memaddr>","<len>". */
8718 memaddr
= remote_address_masked (memaddr
);
8719 p
= rs
->buf
.data ();
8721 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8723 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8726 getpkt (&rs
->buf
, 0);
8727 if (rs
->buf
[0] == 'E'
8728 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8729 && rs
->buf
[3] == '\0')
8730 return TARGET_XFER_E_IO
;
8731 /* Reply describes memory byte by byte, each byte encoded as two hex
8733 p
= rs
->buf
.data ();
8734 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8735 /* Return what we have. Let higher layers handle partial reads. */
8736 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8737 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8740 /* Using the set of read-only target sections of remote, read live
8743 For interface/parameters/return description see target.h,
8747 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
8751 ULONGEST
*xfered_len
)
8753 struct target_section
*secp
;
8754 struct target_section_table
*table
;
8756 secp
= target_section_by_addr (this, memaddr
);
8758 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
8760 struct target_section
*p
;
8761 ULONGEST memend
= memaddr
+ len
;
8763 table
= target_get_section_table (this);
8765 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8767 if (memaddr
>= p
->addr
)
8769 if (memend
<= p
->endaddr
)
8771 /* Entire transfer is within this section. */
8772 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8775 else if (memaddr
>= p
->endaddr
)
8777 /* This section ends before the transfer starts. */
8782 /* This section overlaps the transfer. Just do half. */
8783 len
= p
->endaddr
- memaddr
;
8784 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8791 return TARGET_XFER_EOF
;
8794 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8795 first if the requested memory is unavailable in traceframe.
8796 Otherwise, fall back to remote_read_bytes_1. */
8799 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
8800 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8801 ULONGEST
*xfered_len
)
8804 return TARGET_XFER_EOF
;
8806 if (get_traceframe_number () != -1)
8808 std::vector
<mem_range
> available
;
8810 /* If we fail to get the set of available memory, then the
8811 target does not support querying traceframe info, and so we
8812 attempt reading from the traceframe anyway (assuming the
8813 target implements the old QTro packet then). */
8814 if (traceframe_available_memory (&available
, memaddr
, len
))
8816 if (available
.empty () || available
[0].start
!= memaddr
)
8818 enum target_xfer_status res
;
8820 /* Don't read into the traceframe's available
8822 if (!available
.empty ())
8824 LONGEST oldlen
= len
;
8826 len
= available
[0].start
- memaddr
;
8827 gdb_assert (len
<= oldlen
);
8830 /* This goes through the topmost target again. */
8831 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
8832 len
, unit_size
, xfered_len
);
8833 if (res
== TARGET_XFER_OK
)
8834 return TARGET_XFER_OK
;
8837 /* No use trying further, we know some memory starting
8838 at MEMADDR isn't available. */
8840 return (*xfered_len
!= 0) ?
8841 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
8845 /* Don't try to read more than how much is available, in
8846 case the target implements the deprecated QTro packet to
8847 cater for older GDBs (the target's knowledge of read-only
8848 sections may be outdated by now). */
8849 len
= available
[0].length
;
8853 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8858 /* Sends a packet with content determined by the printf format string
8859 FORMAT and the remaining arguments, then gets the reply. Returns
8860 whether the packet was a success, a failure, or unknown. */
8863 remote_target::remote_send_printf (const char *format
, ...)
8865 struct remote_state
*rs
= get_remote_state ();
8866 int max_size
= get_remote_packet_size ();
8869 va_start (ap
, format
);
8872 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
8876 if (size
>= max_size
)
8877 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8879 if (putpkt (rs
->buf
) < 0)
8880 error (_("Communication problem with target."));
8883 getpkt (&rs
->buf
, 0);
8885 return packet_check_result (rs
->buf
);
8888 /* Flash writing can take quite some time. We'll set
8889 effectively infinite timeout for flash operations.
8890 In future, we'll need to decide on a better approach. */
8891 static const int remote_flash_timeout
= 1000;
8894 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
8896 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8897 enum packet_result ret
;
8898 scoped_restore restore_timeout
8899 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8901 ret
= remote_send_printf ("vFlashErase:%s,%s",
8902 phex (address
, addr_size
),
8906 case PACKET_UNKNOWN
:
8907 error (_("Remote target does not support flash erase"));
8909 error (_("Error erasing flash with vFlashErase packet"));
8916 remote_target::remote_flash_write (ULONGEST address
,
8917 ULONGEST length
, ULONGEST
*xfered_len
,
8918 const gdb_byte
*data
)
8920 scoped_restore restore_timeout
8921 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8922 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8927 remote_target::flash_done ()
8931 scoped_restore restore_timeout
8932 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8934 ret
= remote_send_printf ("vFlashDone");
8938 case PACKET_UNKNOWN
:
8939 error (_("Remote target does not support vFlashDone"));
8941 error (_("Error finishing flash operation"));
8948 remote_target::files_info ()
8950 puts_filtered ("Debugging a target over a serial line.\n");
8953 /* Stuff for dealing with the packets which are part of this protocol.
8954 See comment at top of file for details. */
8956 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8957 error to higher layers. Called when a serial error is detected.
8958 The exception message is STRING, followed by a colon and a blank,
8959 the system error message for errno at function entry and final dot
8960 for output compatibility with throw_perror_with_name. */
8963 unpush_and_perror (const char *string
)
8965 int saved_errno
= errno
;
8967 remote_unpush_target ();
8968 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
8969 safe_strerror (saved_errno
));
8972 /* Read a single character from the remote end. The current quit
8973 handler is overridden to avoid quitting in the middle of packet
8974 sequence, as that would break communication with the remote server.
8975 See remote_serial_quit_handler for more detail. */
8978 remote_target::readchar (int timeout
)
8981 struct remote_state
*rs
= get_remote_state ();
8984 scoped_restore restore_quit_target
8985 = make_scoped_restore (&curr_quit_handler_target
, this);
8986 scoped_restore restore_quit
8987 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
8989 rs
->got_ctrlc_during_io
= 0;
8991 ch
= serial_readchar (rs
->remote_desc
, timeout
);
8993 if (rs
->got_ctrlc_during_io
)
9000 switch ((enum serial_rc
) ch
)
9003 remote_unpush_target ();
9004 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9007 unpush_and_perror (_("Remote communication error. "
9008 "Target disconnected."));
9010 case SERIAL_TIMEOUT
:
9016 /* Wrapper for serial_write that closes the target and throws if
9017 writing fails. The current quit handler is overridden to avoid
9018 quitting in the middle of packet sequence, as that would break
9019 communication with the remote server. See
9020 remote_serial_quit_handler for more detail. */
9023 remote_target::remote_serial_write (const char *str
, int len
)
9025 struct remote_state
*rs
= get_remote_state ();
9027 scoped_restore restore_quit_target
9028 = make_scoped_restore (&curr_quit_handler_target
, this);
9029 scoped_restore restore_quit
9030 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9032 rs
->got_ctrlc_during_io
= 0;
9034 if (serial_write (rs
->remote_desc
, str
, len
))
9036 unpush_and_perror (_("Remote communication error. "
9037 "Target disconnected."));
9040 if (rs
->got_ctrlc_during_io
)
9044 /* Return a string representing an escaped version of BUF, of len N.
9045 E.g. \n is converted to \\n, \t to \\t, etc. */
9048 escape_buffer (const char *buf
, int n
)
9052 stb
.putstrn (buf
, n
, '\\');
9053 return std::move (stb
.string ());
9056 /* Display a null-terminated packet on stdout, for debugging, using C
9060 print_packet (const char *buf
)
9062 puts_filtered ("\"");
9063 fputstr_filtered (buf
, '"', gdb_stdout
);
9064 puts_filtered ("\"");
9068 remote_target::putpkt (const char *buf
)
9070 return putpkt_binary (buf
, strlen (buf
));
9073 /* Wrapper around remote_target::putpkt to avoid exporting
9077 putpkt (remote_target
*remote
, const char *buf
)
9079 return remote
->putpkt (buf
);
9082 /* Send a packet to the remote machine, with error checking. The data
9083 of the packet is in BUF. The string in BUF can be at most
9084 get_remote_packet_size () - 5 to account for the $, # and checksum,
9085 and for a possible /0 if we are debugging (remote_debug) and want
9086 to print the sent packet as a string. */
9089 remote_target::putpkt_binary (const char *buf
, int cnt
)
9091 struct remote_state
*rs
= get_remote_state ();
9093 unsigned char csum
= 0;
9094 gdb::def_vector
<char> data (cnt
+ 6);
9095 char *buf2
= data
.data ();
9101 /* Catch cases like trying to read memory or listing threads while
9102 we're waiting for a stop reply. The remote server wouldn't be
9103 ready to handle this request, so we'd hang and timeout. We don't
9104 have to worry about this in synchronous mode, because in that
9105 case it's not possible to issue a command while the target is
9106 running. This is not a problem in non-stop mode, because in that
9107 case, the stub is always ready to process serial input. */
9108 if (!target_is_non_stop_p ()
9109 && target_is_async_p ()
9110 && rs
->waiting_for_stop_reply
)
9112 error (_("Cannot execute this command while the target is running.\n"
9113 "Use the \"interrupt\" command to stop the target\n"
9114 "and then try again."));
9117 /* We're sending out a new packet. Make sure we don't look at a
9118 stale cached response. */
9119 rs
->cached_wait_status
= 0;
9121 /* Copy the packet into buffer BUF2, encapsulating it
9122 and giving it a checksum. */
9127 for (i
= 0; i
< cnt
; i
++)
9133 *p
++ = tohex ((csum
>> 4) & 0xf);
9134 *p
++ = tohex (csum
& 0xf);
9136 /* Send it over and over until we get a positive ack. */
9140 int started_error_output
= 0;
9146 int len
= (int) (p
- buf2
);
9149 = escape_buffer (buf2
, std::min (len
, REMOTE_DEBUG_MAX_CHAR
));
9151 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9153 if (len
> REMOTE_DEBUG_MAX_CHAR
)
9154 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9155 len
- REMOTE_DEBUG_MAX_CHAR
);
9157 fprintf_unfiltered (gdb_stdlog
, "...");
9159 gdb_flush (gdb_stdlog
);
9161 remote_serial_write (buf2
, p
- buf2
);
9163 /* If this is a no acks version of the remote protocol, send the
9164 packet and move on. */
9168 /* Read until either a timeout occurs (-2) or '+' is read.
9169 Handle any notification that arrives in the mean time. */
9172 ch
= readchar (remote_timeout
);
9180 case SERIAL_TIMEOUT
:
9183 if (started_error_output
)
9185 putchar_unfiltered ('\n');
9186 started_error_output
= 0;
9195 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9199 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9201 case SERIAL_TIMEOUT
:
9205 break; /* Retransmit buffer. */
9209 fprintf_unfiltered (gdb_stdlog
,
9210 "Packet instead of Ack, ignoring it\n");
9211 /* It's probably an old response sent because an ACK
9212 was lost. Gobble up the packet and ack it so it
9213 doesn't get retransmitted when we resend this
9216 remote_serial_write ("+", 1);
9217 continue; /* Now, go look for +. */
9224 /* If we got a notification, handle it, and go back to looking
9226 /* We've found the start of a notification. Now
9227 collect the data. */
9228 val
= read_frame (&rs
->buf
);
9233 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9235 fprintf_unfiltered (gdb_stdlog
,
9236 " Notification received: %s\n",
9239 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9240 /* We're in sync now, rewait for the ack. */
9247 if (!started_error_output
)
9249 started_error_output
= 1;
9250 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9252 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9253 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9262 if (!started_error_output
)
9264 started_error_output
= 1;
9265 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9267 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9271 break; /* Here to retransmit. */
9275 /* This is wrong. If doing a long backtrace, the user should be
9276 able to get out next time we call QUIT, without anything as
9277 violent as interrupt_query. If we want to provide a way out of
9278 here without getting to the next QUIT, it should be based on
9279 hitting ^C twice as in remote_wait. */
9291 /* Come here after finding the start of a frame when we expected an
9292 ack. Do our best to discard the rest of this packet. */
9295 remote_target::skip_frame ()
9301 c
= readchar (remote_timeout
);
9304 case SERIAL_TIMEOUT
:
9305 /* Nothing we can do. */
9308 /* Discard the two bytes of checksum and stop. */
9309 c
= readchar (remote_timeout
);
9311 c
= readchar (remote_timeout
);
9314 case '*': /* Run length encoding. */
9315 /* Discard the repeat count. */
9316 c
= readchar (remote_timeout
);
9321 /* A regular character. */
9327 /* Come here after finding the start of the frame. Collect the rest
9328 into *BUF, verifying the checksum, length, and handling run-length
9329 compression. NUL terminate the buffer. If there is not enough room,
9332 Returns -1 on error, number of characters in buffer (ignoring the
9333 trailing NULL) on success. (could be extended to return one of the
9334 SERIAL status indications). */
9337 remote_target::read_frame (gdb::char_vector
*buf_p
)
9342 char *buf
= buf_p
->data ();
9343 struct remote_state
*rs
= get_remote_state ();
9350 c
= readchar (remote_timeout
);
9353 case SERIAL_TIMEOUT
:
9355 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9359 fputs_filtered ("Saw new packet start in middle of old one\n",
9361 return -1; /* Start a new packet, count retries. */
9364 unsigned char pktcsum
;
9370 check_0
= readchar (remote_timeout
);
9372 check_1
= readchar (remote_timeout
);
9374 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9377 fputs_filtered ("Timeout in checksum, retrying\n",
9381 else if (check_0
< 0 || check_1
< 0)
9384 fputs_filtered ("Communication error in checksum\n",
9389 /* Don't recompute the checksum; with no ack packets we
9390 don't have any way to indicate a packet retransmission
9395 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9396 if (csum
== pktcsum
)
9401 std::string str
= escape_buffer (buf
, bc
);
9403 fprintf_unfiltered (gdb_stdlog
,
9404 "Bad checksum, sentsum=0x%x, "
9405 "csum=0x%x, buf=%s\n",
9406 pktcsum
, csum
, str
.c_str ());
9408 /* Number of characters in buffer ignoring trailing
9412 case '*': /* Run length encoding. */
9417 c
= readchar (remote_timeout
);
9419 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9421 /* The character before ``*'' is repeated. */
9423 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9425 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9427 /* Make some more room in the buffer. */
9428 buf_p
->resize (buf_p
->size () + repeat
);
9429 buf
= buf_p
->data ();
9432 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9438 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9442 if (bc
>= buf_p
->size () - 1)
9444 /* Make some more room in the buffer. */
9445 buf_p
->resize (buf_p
->size () * 2);
9446 buf
= buf_p
->data ();
9456 /* Set this to the maximum number of seconds to wait instead of waiting forever
9457 in target_wait(). If this timer times out, then it generates an error and
9458 the command is aborted. This replaces most of the need for timeouts in the
9459 GDB test suite, and makes it possible to distinguish between a hung target
9460 and one with slow communications. */
9462 static int watchdog
= 0;
9464 show_watchdog (struct ui_file
*file
, int from_tty
,
9465 struct cmd_list_element
*c
, const char *value
)
9467 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9470 /* Read a packet from the remote machine, with error checking, and
9471 store it in *BUF. Resize *BUF if necessary to hold the result. If
9472 FOREVER, wait forever rather than timing out; this is used (in
9473 synchronous mode) to wait for a target that is is executing user
9475 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9476 don't have to change all the calls to getpkt to deal with the
9477 return value, because at the moment I don't know what the right
9478 thing to do it for those. */
9481 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9483 getpkt_sane (buf
, forever
);
9487 /* Read a packet from the remote machine, with error checking, and
9488 store it in *BUF. Resize *BUF if necessary to hold the result. If
9489 FOREVER, wait forever rather than timing out; this is used (in
9490 synchronous mode) to wait for a target that is is executing user
9491 code to stop. If FOREVER == 0, this function is allowed to time
9492 out gracefully and return an indication of this to the caller.
9493 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9494 consider receiving a notification enough reason to return to the
9495 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9496 holds a notification or not (a regular packet). */
9499 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9500 int forever
, int expecting_notif
,
9503 struct remote_state
*rs
= get_remote_state ();
9509 /* We're reading a new response. Make sure we don't look at a
9510 previously cached response. */
9511 rs
->cached_wait_status
= 0;
9513 strcpy (buf
->data (), "timeout");
9516 timeout
= watchdog
> 0 ? watchdog
: -1;
9517 else if (expecting_notif
)
9518 timeout
= 0; /* There should already be a char in the buffer. If
9521 timeout
= remote_timeout
;
9525 /* Process any number of notifications, and then return when
9529 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9531 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9533 /* This can loop forever if the remote side sends us
9534 characters continuously, but if it pauses, we'll get
9535 SERIAL_TIMEOUT from readchar because of timeout. Then
9536 we'll count that as a retry.
9538 Note that even when forever is set, we will only wait
9539 forever prior to the start of a packet. After that, we
9540 expect characters to arrive at a brisk pace. They should
9541 show up within remote_timeout intervals. */
9543 c
= readchar (timeout
);
9544 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9546 if (c
== SERIAL_TIMEOUT
)
9548 if (expecting_notif
)
9549 return -1; /* Don't complain, it's normal to not get
9550 anything in this case. */
9552 if (forever
) /* Watchdog went off? Kill the target. */
9554 remote_unpush_target ();
9555 throw_error (TARGET_CLOSE_ERROR
,
9556 _("Watchdog timeout has expired. "
9557 "Target detached."));
9560 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9564 /* We've found the start of a packet or notification.
9565 Now collect the data. */
9566 val
= read_frame (buf
);
9571 remote_serial_write ("-", 1);
9574 if (tries
> MAX_TRIES
)
9576 /* We have tried hard enough, and just can't receive the
9577 packet/notification. Give up. */
9578 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9580 /* Skip the ack char if we're in no-ack mode. */
9581 if (!rs
->noack_mode
)
9582 remote_serial_write ("+", 1);
9586 /* If we got an ordinary packet, return that to our caller. */
9592 = escape_buffer (buf
->data (),
9593 std::min (val
, REMOTE_DEBUG_MAX_CHAR
));
9595 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9598 if (val
> REMOTE_DEBUG_MAX_CHAR
)
9599 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9600 val
- REMOTE_DEBUG_MAX_CHAR
);
9602 fprintf_unfiltered (gdb_stdlog
, "\n");
9605 /* Skip the ack char if we're in no-ack mode. */
9606 if (!rs
->noack_mode
)
9607 remote_serial_write ("+", 1);
9608 if (is_notif
!= NULL
)
9613 /* If we got a notification, handle it, and go back to looking
9617 gdb_assert (c
== '%');
9621 std::string str
= escape_buffer (buf
->data (), val
);
9623 fprintf_unfiltered (gdb_stdlog
,
9624 " Notification received: %s\n",
9627 if (is_notif
!= NULL
)
9630 handle_notification (rs
->notif_state
, buf
->data ());
9632 /* Notifications require no acknowledgement. */
9634 if (expecting_notif
)
9641 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9643 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9647 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9650 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9653 /* Kill any new fork children of process PID that haven't been
9654 processed by follow_fork. */
9657 remote_target::kill_new_fork_children (int pid
)
9659 remote_state
*rs
= get_remote_state ();
9660 struct notif_client
*notif
= ¬if_client_stop
;
9662 /* Kill the fork child threads of any threads in process PID
9663 that are stopped at a fork event. */
9664 for (thread_info
*thread
: all_non_exited_threads ())
9666 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9668 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9670 int child_pid
= ws
->value
.related_pid
.pid ();
9673 res
= remote_vkill (child_pid
);
9675 error (_("Can't kill fork child process %d"), child_pid
);
9679 /* Check for any pending fork events (not reported or processed yet)
9680 in process PID and kill those fork child threads as well. */
9681 remote_notif_get_pending_events (notif
);
9682 for (auto &event
: rs
->stop_reply_queue
)
9683 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9685 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9688 res
= remote_vkill (child_pid
);
9690 error (_("Can't kill fork child process %d"), child_pid
);
9695 /* Target hook to kill the current inferior. */
9698 remote_target::kill ()
9701 int pid
= inferior_ptid
.pid ();
9702 struct remote_state
*rs
= get_remote_state ();
9704 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9706 /* If we're stopped while forking and we haven't followed yet,
9707 kill the child task. We need to do this before killing the
9708 parent task because if this is a vfork then the parent will
9710 kill_new_fork_children (pid
);
9712 res
= remote_vkill (pid
);
9715 target_mourn_inferior (inferior_ptid
);
9720 /* If we are in 'target remote' mode and we are killing the only
9721 inferior, then we will tell gdbserver to exit and unpush the
9723 if (res
== -1 && !remote_multi_process_p (rs
)
9724 && number_of_live_inferiors () == 1)
9728 /* We've killed the remote end, we get to mourn it. If we are
9729 not in extended mode, mourning the inferior also unpushes
9730 remote_ops from the target stack, which closes the remote
9732 target_mourn_inferior (inferior_ptid
);
9737 error (_("Can't kill process"));
9740 /* Send a kill request to the target using the 'vKill' packet. */
9743 remote_target::remote_vkill (int pid
)
9745 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9748 remote_state
*rs
= get_remote_state ();
9750 /* Tell the remote target to detach. */
9751 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
9753 getpkt (&rs
->buf
, 0);
9755 switch (packet_ok (rs
->buf
,
9756 &remote_protocol_packets
[PACKET_vKill
]))
9762 case PACKET_UNKNOWN
:
9765 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9769 /* Send a kill request to the target using the 'k' packet. */
9772 remote_target::remote_kill_k ()
9774 /* Catch errors so the user can quit from gdb even when we
9775 aren't on speaking terms with the remote system. */
9780 catch (const gdb_exception_error
&ex
)
9782 if (ex
.error
== TARGET_CLOSE_ERROR
)
9784 /* If we got an (EOF) error that caused the target
9785 to go away, then we're done, that's what we wanted.
9786 "k" is susceptible to cause a premature EOF, given
9787 that the remote server isn't actually required to
9788 reply to "k", and it can happen that it doesn't
9789 even get to reply ACK to the "k". */
9793 /* Otherwise, something went wrong. We didn't actually kill
9794 the target. Just propagate the exception, and let the
9795 user or higher layers decide what to do. */
9801 remote_target::mourn_inferior ()
9803 struct remote_state
*rs
= get_remote_state ();
9805 /* We're no longer interested in notification events of an inferior
9806 that exited or was killed/detached. */
9807 discard_pending_stop_replies (current_inferior ());
9809 /* In 'target remote' mode with one inferior, we close the connection. */
9810 if (!rs
->extended
&& number_of_live_inferiors () <= 1)
9812 unpush_target (this);
9814 /* remote_close takes care of doing most of the clean up. */
9815 generic_mourn_inferior ();
9819 /* In case we got here due to an error, but we're going to stay
9821 rs
->waiting_for_stop_reply
= 0;
9823 /* If the current general thread belonged to the process we just
9824 detached from or has exited, the remote side current general
9825 thread becomes undefined. Considering a case like this:
9827 - We just got here due to a detach.
9828 - The process that we're detaching from happens to immediately
9829 report a global breakpoint being hit in non-stop mode, in the
9830 same thread we had selected before.
9831 - GDB attaches to this process again.
9832 - This event happens to be the next event we handle.
9834 GDB would consider that the current general thread didn't need to
9835 be set on the stub side (with Hg), since for all it knew,
9836 GENERAL_THREAD hadn't changed.
9838 Notice that although in all-stop mode, the remote server always
9839 sets the current thread to the thread reporting the stop event,
9840 that doesn't happen in non-stop mode; in non-stop, the stub *must
9841 not* change the current thread when reporting a breakpoint hit,
9842 due to the decoupling of event reporting and event handling.
9844 To keep things simple, we always invalidate our notion of the
9846 record_currthread (rs
, minus_one_ptid
);
9848 /* Call common code to mark the inferior as not running. */
9849 generic_mourn_inferior ();
9851 if (!have_inferiors ())
9853 if (!remote_multi_process_p (rs
))
9855 /* Check whether the target is running now - some remote stubs
9856 automatically restart after kill. */
9858 getpkt (&rs
->buf
, 0);
9860 if (rs
->buf
[0] == 'S' || rs
->buf
[0] == 'T')
9862 /* Assume that the target has been restarted. Set
9863 inferior_ptid so that bits of core GDB realizes
9864 there's something here, e.g., so that the user can
9865 say "kill" again. */
9866 inferior_ptid
= magic_null_ptid
;
9873 extended_remote_target::supports_disable_randomization ()
9875 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9879 remote_target::extended_remote_disable_randomization (int val
)
9881 struct remote_state
*rs
= get_remote_state ();
9884 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9885 "QDisableRandomization:%x", val
);
9887 reply
= remote_get_noisy_reply ();
9889 error (_("Target does not support QDisableRandomization."));
9890 if (strcmp (reply
, "OK") != 0)
9891 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9895 remote_target::extended_remote_run (const std::string
&args
)
9897 struct remote_state
*rs
= get_remote_state ();
9899 const char *remote_exec_file
= get_remote_exec_file ();
9901 /* If the user has disabled vRun support, or we have detected that
9902 support is not available, do not try it. */
9903 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9906 strcpy (rs
->buf
.data (), "vRun;");
9907 len
= strlen (rs
->buf
.data ());
9909 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9910 error (_("Remote file name too long for run packet"));
9911 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
9912 strlen (remote_exec_file
));
9918 gdb_argv
argv (args
.c_str ());
9919 for (i
= 0; argv
[i
] != NULL
; i
++)
9921 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9922 error (_("Argument list too long for run packet"));
9923 rs
->buf
[len
++] = ';';
9924 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
9929 rs
->buf
[len
++] = '\0';
9932 getpkt (&rs
->buf
, 0);
9934 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9937 /* We have a wait response. All is well. */
9939 case PACKET_UNKNOWN
:
9942 if (remote_exec_file
[0] == '\0')
9943 error (_("Running the default executable on the remote target failed; "
9944 "try \"set remote exec-file\"?"));
9946 error (_("Running \"%s\" on the remote target failed"),
9949 gdb_assert_not_reached (_("bad switch"));
9953 /* Helper function to send set/unset environment packets. ACTION is
9954 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
9955 or "QEnvironmentUnsetVariable". VALUE is the variable to be
9959 remote_target::send_environment_packet (const char *action
,
9963 remote_state
*rs
= get_remote_state ();
9965 /* Convert the environment variable to an hex string, which
9966 is the best format to be transmitted over the wire. */
9967 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
9970 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9971 "%s:%s", packet
, encoded_value
.c_str ());
9974 getpkt (&rs
->buf
, 0);
9975 if (strcmp (rs
->buf
.data (), "OK") != 0)
9976 warning (_("Unable to %s environment variable '%s' on remote."),
9980 /* Helper function to handle the QEnvironment* packets. */
9983 remote_target::extended_remote_environment_support ()
9985 remote_state
*rs
= get_remote_state ();
9987 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
9989 putpkt ("QEnvironmentReset");
9990 getpkt (&rs
->buf
, 0);
9991 if (strcmp (rs
->buf
.data (), "OK") != 0)
9992 warning (_("Unable to reset environment on remote."));
9995 gdb_environ
*e
= ¤t_inferior ()->environment
;
9997 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
9998 for (const std::string
&el
: e
->user_set_env ())
9999 send_environment_packet ("set", "QEnvironmentHexEncoded",
10002 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
10003 for (const std::string
&el
: e
->user_unset_env ())
10004 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10007 /* Helper function to set the current working directory for the
10008 inferior in the remote target. */
10011 remote_target::extended_remote_set_inferior_cwd ()
10013 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10015 const char *inferior_cwd
= get_inferior_cwd ();
10016 remote_state
*rs
= get_remote_state ();
10018 if (inferior_cwd
!= NULL
)
10020 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10021 strlen (inferior_cwd
));
10023 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10024 "QSetWorkingDir:%s", hexpath
.c_str ());
10028 /* An empty inferior_cwd means that the user wants us to
10029 reset the remote server's inferior's cwd. */
10030 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10031 "QSetWorkingDir:");
10035 getpkt (&rs
->buf
, 0);
10036 if (packet_ok (rs
->buf
,
10037 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10040 Remote replied unexpectedly while setting the inferior's working\n\
10047 /* In the extended protocol we want to be able to do things like
10048 "run" and have them basically work as expected. So we need
10049 a special create_inferior function. We support changing the
10050 executable file and the command line arguments, but not the
10054 extended_remote_target::create_inferior (const char *exec_file
,
10055 const std::string
&args
,
10056 char **env
, int from_tty
)
10060 struct remote_state
*rs
= get_remote_state ();
10061 const char *remote_exec_file
= get_remote_exec_file ();
10063 /* If running asynchronously, register the target file descriptor
10064 with the event loop. */
10065 if (target_can_async_p ())
10068 /* Disable address space randomization if requested (and supported). */
10069 if (supports_disable_randomization ())
10070 extended_remote_disable_randomization (disable_randomization
);
10072 /* If startup-with-shell is on, we inform gdbserver to start the
10073 remote inferior using a shell. */
10074 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10076 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10077 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10079 getpkt (&rs
->buf
, 0);
10080 if (strcmp (rs
->buf
.data (), "OK") != 0)
10082 Remote replied unexpectedly while setting startup-with-shell: %s"),
10086 extended_remote_environment_support ();
10088 extended_remote_set_inferior_cwd ();
10090 /* Now restart the remote server. */
10091 run_worked
= extended_remote_run (args
) != -1;
10094 /* vRun was not supported. Fail if we need it to do what the
10096 if (remote_exec_file
[0])
10097 error (_("Remote target does not support \"set remote exec-file\""));
10098 if (!args
.empty ())
10099 error (_("Remote target does not support \"set args\" or run ARGS"));
10101 /* Fall back to "R". */
10102 extended_remote_restart ();
10105 /* vRun's success return is a stop reply. */
10106 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10107 add_current_inferior_and_thread (stop_reply
);
10109 /* Get updated offsets, if the stub uses qOffsets. */
10114 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10115 the list of conditions (in agent expression bytecode format), if any, the
10116 target needs to evaluate. The output is placed into the packet buffer
10117 started from BUF and ended at BUF_END. */
10120 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10121 struct bp_target_info
*bp_tgt
, char *buf
,
10124 if (bp_tgt
->conditions
.empty ())
10127 buf
+= strlen (buf
);
10128 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10131 /* Send conditions to the target. */
10132 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10134 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10135 buf
+= strlen (buf
);
10136 for (int i
= 0; i
< aexpr
->len
; ++i
)
10137 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10144 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10145 struct bp_target_info
*bp_tgt
, char *buf
)
10147 if (bp_tgt
->tcommands
.empty ())
10150 buf
+= strlen (buf
);
10152 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10153 buf
+= strlen (buf
);
10155 /* Concatenate all the agent expressions that are commands into the
10157 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10159 sprintf (buf
, "X%x,", aexpr
->len
);
10160 buf
+= strlen (buf
);
10161 for (int i
= 0; i
< aexpr
->len
; ++i
)
10162 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10167 /* Insert a breakpoint. On targets that have software breakpoint
10168 support, we ask the remote target to do the work; on targets
10169 which don't, we insert a traditional memory breakpoint. */
10172 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10173 struct bp_target_info
*bp_tgt
)
10175 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10176 If it succeeds, then set the support to PACKET_ENABLE. If it
10177 fails, and the user has explicitly requested the Z support then
10178 report an error, otherwise, mark it disabled and go on. */
10180 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10182 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10183 struct remote_state
*rs
;
10186 /* Make sure the remote is pointing at the right process, if
10188 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10189 set_general_process ();
10191 rs
= get_remote_state ();
10192 p
= rs
->buf
.data ();
10193 endbuf
= p
+ get_remote_packet_size ();
10198 addr
= (ULONGEST
) remote_address_masked (addr
);
10199 p
+= hexnumstr (p
, addr
);
10200 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10202 if (supports_evaluation_of_breakpoint_conditions ())
10203 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10205 if (can_run_breakpoint_commands ())
10206 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10209 getpkt (&rs
->buf
, 0);
10211 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10217 case PACKET_UNKNOWN
:
10222 /* If this breakpoint has target-side commands but this stub doesn't
10223 support Z0 packets, throw error. */
10224 if (!bp_tgt
->tcommands
.empty ())
10225 throw_error (NOT_SUPPORTED_ERROR
, _("\
10226 Target doesn't support breakpoints that have target side commands."));
10228 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10232 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10233 struct bp_target_info
*bp_tgt
,
10234 enum remove_bp_reason reason
)
10236 CORE_ADDR addr
= bp_tgt
->placed_address
;
10237 struct remote_state
*rs
= get_remote_state ();
10239 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10241 char *p
= rs
->buf
.data ();
10242 char *endbuf
= p
+ get_remote_packet_size ();
10244 /* Make sure the remote is pointing at the right process, if
10246 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10247 set_general_process ();
10253 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10254 p
+= hexnumstr (p
, addr
);
10255 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10258 getpkt (&rs
->buf
, 0);
10260 return (rs
->buf
[0] == 'E');
10263 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10266 static enum Z_packet_type
10267 watchpoint_to_Z_packet (int type
)
10272 return Z_PACKET_WRITE_WP
;
10275 return Z_PACKET_READ_WP
;
10278 return Z_PACKET_ACCESS_WP
;
10281 internal_error (__FILE__
, __LINE__
,
10282 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10287 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10288 enum target_hw_bp_type type
, struct expression
*cond
)
10290 struct remote_state
*rs
= get_remote_state ();
10291 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10293 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10295 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10298 /* Make sure the remote is pointing at the right process, if
10300 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10301 set_general_process ();
10303 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10304 p
= strchr (rs
->buf
.data (), '\0');
10305 addr
= remote_address_masked (addr
);
10306 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10307 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10310 getpkt (&rs
->buf
, 0);
10312 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10316 case PACKET_UNKNOWN
:
10321 internal_error (__FILE__
, __LINE__
,
10322 _("remote_insert_watchpoint: reached end of function"));
10326 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10327 CORE_ADDR start
, int length
)
10329 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10331 return diff
< length
;
10336 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10337 enum target_hw_bp_type type
, struct expression
*cond
)
10339 struct remote_state
*rs
= get_remote_state ();
10340 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10342 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10344 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10347 /* Make sure the remote is pointing at the right process, if
10349 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10350 set_general_process ();
10352 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10353 p
= strchr (rs
->buf
.data (), '\0');
10354 addr
= remote_address_masked (addr
);
10355 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10356 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10358 getpkt (&rs
->buf
, 0);
10360 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10363 case PACKET_UNKNOWN
:
10368 internal_error (__FILE__
, __LINE__
,
10369 _("remote_remove_watchpoint: reached end of function"));
10373 static int remote_hw_watchpoint_limit
= -1;
10374 static int remote_hw_watchpoint_length_limit
= -1;
10375 static int remote_hw_breakpoint_limit
= -1;
10378 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10380 if (remote_hw_watchpoint_length_limit
== 0)
10382 else if (remote_hw_watchpoint_length_limit
< 0)
10384 else if (len
<= remote_hw_watchpoint_length_limit
)
10391 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10393 if (type
== bp_hardware_breakpoint
)
10395 if (remote_hw_breakpoint_limit
== 0)
10397 else if (remote_hw_breakpoint_limit
< 0)
10399 else if (cnt
<= remote_hw_breakpoint_limit
)
10404 if (remote_hw_watchpoint_limit
== 0)
10406 else if (remote_hw_watchpoint_limit
< 0)
10410 else if (cnt
<= remote_hw_watchpoint_limit
)
10416 /* The to_stopped_by_sw_breakpoint method of target remote. */
10419 remote_target::stopped_by_sw_breakpoint ()
10421 struct thread_info
*thread
= inferior_thread ();
10423 return (thread
->priv
!= NULL
10424 && (get_remote_thread_info (thread
)->stop_reason
10425 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10428 /* The to_supports_stopped_by_sw_breakpoint method of target
10432 remote_target::supports_stopped_by_sw_breakpoint ()
10434 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10437 /* The to_stopped_by_hw_breakpoint method of target remote. */
10440 remote_target::stopped_by_hw_breakpoint ()
10442 struct thread_info
*thread
= inferior_thread ();
10444 return (thread
->priv
!= NULL
10445 && (get_remote_thread_info (thread
)->stop_reason
10446 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10449 /* The to_supports_stopped_by_hw_breakpoint method of target
10453 remote_target::supports_stopped_by_hw_breakpoint ()
10455 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10459 remote_target::stopped_by_watchpoint ()
10461 struct thread_info
*thread
= inferior_thread ();
10463 return (thread
->priv
!= NULL
10464 && (get_remote_thread_info (thread
)->stop_reason
10465 == TARGET_STOPPED_BY_WATCHPOINT
));
10469 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10471 struct thread_info
*thread
= inferior_thread ();
10473 if (thread
->priv
!= NULL
10474 && (get_remote_thread_info (thread
)->stop_reason
10475 == TARGET_STOPPED_BY_WATCHPOINT
))
10477 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10486 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10487 struct bp_target_info
*bp_tgt
)
10489 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10490 struct remote_state
*rs
;
10494 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10497 /* Make sure the remote is pointing at the right process, if
10499 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10500 set_general_process ();
10502 rs
= get_remote_state ();
10503 p
= rs
->buf
.data ();
10504 endbuf
= p
+ get_remote_packet_size ();
10510 addr
= remote_address_masked (addr
);
10511 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10512 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10514 if (supports_evaluation_of_breakpoint_conditions ())
10515 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10517 if (can_run_breakpoint_commands ())
10518 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10521 getpkt (&rs
->buf
, 0);
10523 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10526 if (rs
->buf
[1] == '.')
10528 message
= strchr (&rs
->buf
[2], '.');
10530 error (_("Remote failure reply: %s"), message
+ 1);
10533 case PACKET_UNKNOWN
:
10538 internal_error (__FILE__
, __LINE__
,
10539 _("remote_insert_hw_breakpoint: reached end of function"));
10544 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10545 struct bp_target_info
*bp_tgt
)
10548 struct remote_state
*rs
= get_remote_state ();
10549 char *p
= rs
->buf
.data ();
10550 char *endbuf
= p
+ get_remote_packet_size ();
10552 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10555 /* Make sure the remote is pointing at the right process, if
10557 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10558 set_general_process ();
10564 addr
= remote_address_masked (bp_tgt
->placed_address
);
10565 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10566 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10569 getpkt (&rs
->buf
, 0);
10571 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10574 case PACKET_UNKNOWN
:
10579 internal_error (__FILE__
, __LINE__
,
10580 _("remote_remove_hw_breakpoint: reached end of function"));
10583 /* Verify memory using the "qCRC:" request. */
10586 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10588 struct remote_state
*rs
= get_remote_state ();
10589 unsigned long host_crc
, target_crc
;
10592 /* It doesn't make sense to use qCRC if the remote target is
10593 connected but not running. */
10594 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10596 enum packet_result result
;
10598 /* Make sure the remote is pointing at the right process. */
10599 set_general_process ();
10601 /* FIXME: assumes lma can fit into long. */
10602 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10603 (long) lma
, (long) size
);
10606 /* Be clever; compute the host_crc before waiting for target
10608 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10610 getpkt (&rs
->buf
, 0);
10612 result
= packet_ok (rs
->buf
,
10613 &remote_protocol_packets
[PACKET_qCRC
]);
10614 if (result
== PACKET_ERROR
)
10616 else if (result
== PACKET_OK
)
10618 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10619 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10621 return (host_crc
== target_crc
);
10625 return simple_verify_memory (this, data
, lma
, size
);
10628 /* compare-sections command
10630 With no arguments, compares each loadable section in the exec bfd
10631 with the same memory range on the target, and reports mismatches.
10632 Useful for verifying the image on the target against the exec file. */
10635 compare_sections_command (const char *args
, int from_tty
)
10638 const char *sectname
;
10639 bfd_size_type size
;
10642 int mismatched
= 0;
10647 error (_("command cannot be used without an exec file"));
10649 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10655 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10657 if (!(s
->flags
& SEC_LOAD
))
10658 continue; /* Skip non-loadable section. */
10660 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10661 continue; /* Skip writeable sections */
10663 size
= bfd_section_size (s
);
10665 continue; /* Skip zero-length section. */
10667 sectname
= bfd_section_name (s
);
10668 if (args
&& strcmp (args
, sectname
) != 0)
10669 continue; /* Not the section selected by user. */
10671 matched
= 1; /* Do this section. */
10674 gdb::byte_vector
sectdata (size
);
10675 bfd_get_section_contents (exec_bfd
, s
, sectdata
.data (), 0, size
);
10677 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10680 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10681 paddress (target_gdbarch (), lma
),
10682 paddress (target_gdbarch (), lma
+ size
));
10684 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10685 paddress (target_gdbarch (), lma
),
10686 paddress (target_gdbarch (), lma
+ size
));
10688 printf_filtered ("matched.\n");
10691 printf_filtered ("MIS-MATCHED!\n");
10695 if (mismatched
> 0)
10696 warning (_("One or more sections of the target image does not match\n\
10697 the loaded file\n"));
10698 if (args
&& !matched
)
10699 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10702 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10703 into remote target. The number of bytes written to the remote
10704 target is returned, or -1 for error. */
10707 remote_target::remote_write_qxfer (const char *object_name
,
10708 const char *annex
, const gdb_byte
*writebuf
,
10709 ULONGEST offset
, LONGEST len
,
10710 ULONGEST
*xfered_len
,
10711 struct packet_config
*packet
)
10715 struct remote_state
*rs
= get_remote_state ();
10716 int max_size
= get_memory_write_packet_size ();
10718 if (packet_config_support (packet
) == PACKET_DISABLE
)
10719 return TARGET_XFER_E_IO
;
10721 /* Insert header. */
10722 i
= snprintf (rs
->buf
.data (), max_size
,
10723 "qXfer:%s:write:%s:%s:",
10724 object_name
, annex
? annex
: "",
10725 phex_nz (offset
, sizeof offset
));
10726 max_size
-= (i
+ 1);
10728 /* Escape as much data as fits into rs->buf. */
10729 buf_len
= remote_escape_output
10730 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10732 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10733 || getpkt_sane (&rs
->buf
, 0) < 0
10734 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10735 return TARGET_XFER_E_IO
;
10737 unpack_varlen_hex (rs
->buf
.data (), &n
);
10740 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10743 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10744 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10745 number of bytes read is returned, or 0 for EOF, or -1 for error.
10746 The number of bytes read may be less than LEN without indicating an
10747 EOF. PACKET is checked and updated to indicate whether the remote
10748 target supports this object. */
10751 remote_target::remote_read_qxfer (const char *object_name
,
10753 gdb_byte
*readbuf
, ULONGEST offset
,
10755 ULONGEST
*xfered_len
,
10756 struct packet_config
*packet
)
10758 struct remote_state
*rs
= get_remote_state ();
10759 LONGEST i
, n
, packet_len
;
10761 if (packet_config_support (packet
) == PACKET_DISABLE
)
10762 return TARGET_XFER_E_IO
;
10764 /* Check whether we've cached an end-of-object packet that matches
10766 if (rs
->finished_object
)
10768 if (strcmp (object_name
, rs
->finished_object
) == 0
10769 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10770 && offset
== rs
->finished_offset
)
10771 return TARGET_XFER_EOF
;
10774 /* Otherwise, we're now reading something different. Discard
10776 xfree (rs
->finished_object
);
10777 xfree (rs
->finished_annex
);
10778 rs
->finished_object
= NULL
;
10779 rs
->finished_annex
= NULL
;
10782 /* Request only enough to fit in a single packet. The actual data
10783 may not, since we don't know how much of it will need to be escaped;
10784 the target is free to respond with slightly less data. We subtract
10785 five to account for the response type and the protocol frame. */
10786 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10787 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
10788 "qXfer:%s:read:%s:%s,%s",
10789 object_name
, annex
? annex
: "",
10790 phex_nz (offset
, sizeof offset
),
10791 phex_nz (n
, sizeof n
));
10792 i
= putpkt (rs
->buf
);
10794 return TARGET_XFER_E_IO
;
10797 packet_len
= getpkt_sane (&rs
->buf
, 0);
10798 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10799 return TARGET_XFER_E_IO
;
10801 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10802 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
10804 /* 'm' means there is (or at least might be) more data after this
10805 batch. That does not make sense unless there's at least one byte
10806 of data in this reply. */
10807 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10808 error (_("Remote qXfer reply contained no data."));
10810 /* Got some data. */
10811 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
10812 packet_len
- 1, readbuf
, n
);
10814 /* 'l' is an EOF marker, possibly including a final block of data,
10815 or possibly empty. If we have the final block of a non-empty
10816 object, record this fact to bypass a subsequent partial read. */
10817 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10819 rs
->finished_object
= xstrdup (object_name
);
10820 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10821 rs
->finished_offset
= offset
+ i
;
10825 return TARGET_XFER_EOF
;
10829 return TARGET_XFER_OK
;
10833 enum target_xfer_status
10834 remote_target::xfer_partial (enum target_object object
,
10835 const char *annex
, gdb_byte
*readbuf
,
10836 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10837 ULONGEST
*xfered_len
)
10839 struct remote_state
*rs
;
10843 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10845 set_remote_traceframe ();
10846 set_general_thread (inferior_ptid
);
10848 rs
= get_remote_state ();
10850 /* Handle memory using the standard memory routines. */
10851 if (object
== TARGET_OBJECT_MEMORY
)
10853 /* If the remote target is connected but not running, we should
10854 pass this request down to a lower stratum (e.g. the executable
10856 if (!target_has_execution
)
10857 return TARGET_XFER_EOF
;
10859 if (writebuf
!= NULL
)
10860 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10863 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
10867 /* Handle extra signal info using qxfer packets. */
10868 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10871 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
10872 xfered_len
, &remote_protocol_packets
10873 [PACKET_qXfer_siginfo_read
]);
10875 return remote_write_qxfer ("siginfo", annex
,
10876 writebuf
, offset
, len
, xfered_len
,
10877 &remote_protocol_packets
10878 [PACKET_qXfer_siginfo_write
]);
10881 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10884 return remote_read_qxfer ("statictrace", annex
,
10885 readbuf
, offset
, len
, xfered_len
,
10886 &remote_protocol_packets
10887 [PACKET_qXfer_statictrace_read
]);
10889 return TARGET_XFER_E_IO
;
10892 /* Only handle flash writes. */
10893 if (writebuf
!= NULL
)
10897 case TARGET_OBJECT_FLASH
:
10898 return remote_flash_write (offset
, len
, xfered_len
,
10902 return TARGET_XFER_E_IO
;
10906 /* Map pre-existing objects onto letters. DO NOT do this for new
10907 objects!!! Instead specify new query packets. */
10910 case TARGET_OBJECT_AVR
:
10914 case TARGET_OBJECT_AUXV
:
10915 gdb_assert (annex
== NULL
);
10916 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
10918 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10920 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10921 return remote_read_qxfer
10922 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
10923 &remote_protocol_packets
[PACKET_qXfer_features
]);
10925 case TARGET_OBJECT_LIBRARIES
:
10926 return remote_read_qxfer
10927 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10928 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10930 case TARGET_OBJECT_LIBRARIES_SVR4
:
10931 return remote_read_qxfer
10932 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10933 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10935 case TARGET_OBJECT_MEMORY_MAP
:
10936 gdb_assert (annex
== NULL
);
10937 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
10939 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10941 case TARGET_OBJECT_OSDATA
:
10942 /* Should only get here if we're connected. */
10943 gdb_assert (rs
->remote_desc
);
10944 return remote_read_qxfer
10945 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
10946 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
10948 case TARGET_OBJECT_THREADS
:
10949 gdb_assert (annex
== NULL
);
10950 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
10952 &remote_protocol_packets
[PACKET_qXfer_threads
]);
10954 case TARGET_OBJECT_TRACEFRAME_INFO
:
10955 gdb_assert (annex
== NULL
);
10956 return remote_read_qxfer
10957 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
10958 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
10960 case TARGET_OBJECT_FDPIC
:
10961 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
10963 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
10965 case TARGET_OBJECT_OPENVMS_UIB
:
10966 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
10968 &remote_protocol_packets
[PACKET_qXfer_uib
]);
10970 case TARGET_OBJECT_BTRACE
:
10971 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
10973 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
10975 case TARGET_OBJECT_BTRACE_CONF
:
10976 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
10978 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
10980 case TARGET_OBJECT_EXEC_FILE
:
10981 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
10983 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
10986 return TARGET_XFER_E_IO
;
10989 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
10990 large enough let the caller deal with it. */
10991 if (len
< get_remote_packet_size ())
10992 return TARGET_XFER_E_IO
;
10993 len
= get_remote_packet_size ();
10995 /* Except for querying the minimum buffer size, target must be open. */
10996 if (!rs
->remote_desc
)
10997 error (_("remote query is only available after target open"));
10999 gdb_assert (annex
!= NULL
);
11000 gdb_assert (readbuf
!= NULL
);
11002 p2
= rs
->buf
.data ();
11004 *p2
++ = query_type
;
11006 /* We used one buffer char for the remote protocol q command and
11007 another for the query type. As the remote protocol encapsulation
11008 uses 4 chars plus one extra in case we are debugging
11009 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11012 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11014 /* Bad caller may have sent forbidden characters. */
11015 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11020 gdb_assert (annex
[i
] == '\0');
11022 i
= putpkt (rs
->buf
);
11024 return TARGET_XFER_E_IO
;
11026 getpkt (&rs
->buf
, 0);
11027 strcpy ((char *) readbuf
, rs
->buf
.data ());
11029 *xfered_len
= strlen ((char *) readbuf
);
11030 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11033 /* Implementation of to_get_memory_xfer_limit. */
11036 remote_target::get_memory_xfer_limit ()
11038 return get_memory_write_packet_size ();
11042 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11043 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11044 CORE_ADDR
*found_addrp
)
11046 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11047 struct remote_state
*rs
= get_remote_state ();
11048 int max_size
= get_memory_write_packet_size ();
11049 struct packet_config
*packet
=
11050 &remote_protocol_packets
[PACKET_qSearch_memory
];
11051 /* Number of packet bytes used to encode the pattern;
11052 this could be more than PATTERN_LEN due to escape characters. */
11053 int escaped_pattern_len
;
11054 /* Amount of pattern that was encodable in the packet. */
11055 int used_pattern_len
;
11058 ULONGEST found_addr
;
11060 /* Don't go to the target if we don't have to. This is done before
11061 checking packet_config_support to avoid the possibility that a
11062 success for this edge case means the facility works in
11064 if (pattern_len
> search_space_len
)
11066 if (pattern_len
== 0)
11068 *found_addrp
= start_addr
;
11072 /* If we already know the packet isn't supported, fall back to the simple
11073 way of searching memory. */
11075 if (packet_config_support (packet
) == PACKET_DISABLE
)
11077 /* Target doesn't provided special support, fall back and use the
11078 standard support (copy memory and do the search here). */
11079 return simple_search_memory (this, start_addr
, search_space_len
,
11080 pattern
, pattern_len
, found_addrp
);
11083 /* Make sure the remote is pointing at the right process. */
11084 set_general_process ();
11086 /* Insert header. */
11087 i
= snprintf (rs
->buf
.data (), max_size
,
11088 "qSearch:memory:%s;%s;",
11089 phex_nz (start_addr
, addr_size
),
11090 phex_nz (search_space_len
, sizeof (search_space_len
)));
11091 max_size
-= (i
+ 1);
11093 /* Escape as much data as fits into rs->buf. */
11094 escaped_pattern_len
=
11095 remote_escape_output (pattern
, pattern_len
, 1,
11096 (gdb_byte
*) rs
->buf
.data () + i
,
11097 &used_pattern_len
, max_size
);
11099 /* Bail if the pattern is too large. */
11100 if (used_pattern_len
!= pattern_len
)
11101 error (_("Pattern is too large to transmit to remote target."));
11103 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11104 || getpkt_sane (&rs
->buf
, 0) < 0
11105 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11107 /* The request may not have worked because the command is not
11108 supported. If so, fall back to the simple way. */
11109 if (packet_config_support (packet
) == PACKET_DISABLE
)
11111 return simple_search_memory (this, start_addr
, search_space_len
,
11112 pattern
, pattern_len
, found_addrp
);
11117 if (rs
->buf
[0] == '0')
11119 else if (rs
->buf
[0] == '1')
11122 if (rs
->buf
[1] != ',')
11123 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11124 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11125 *found_addrp
= found_addr
;
11128 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11134 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11136 struct remote_state
*rs
= get_remote_state ();
11137 char *p
= rs
->buf
.data ();
11139 if (!rs
->remote_desc
)
11140 error (_("remote rcmd is only available after target open"));
11142 /* Send a NULL command across as an empty command. */
11143 if (command
== NULL
)
11146 /* The query prefix. */
11147 strcpy (rs
->buf
.data (), "qRcmd,");
11148 p
= strchr (rs
->buf
.data (), '\0');
11150 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11151 > get_remote_packet_size ())
11152 error (_("\"monitor\" command ``%s'' is too long."), command
);
11154 /* Encode the actual command. */
11155 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11157 if (putpkt (rs
->buf
) < 0)
11158 error (_("Communication problem with target."));
11160 /* get/display the response */
11165 /* XXX - see also remote_get_noisy_reply(). */
11166 QUIT
; /* Allow user to bail out with ^C. */
11168 if (getpkt_sane (&rs
->buf
, 0) == -1)
11170 /* Timeout. Continue to (try to) read responses.
11171 This is better than stopping with an error, assuming the stub
11172 is still executing the (long) monitor command.
11173 If needed, the user can interrupt gdb using C-c, obtaining
11174 an effect similar to stop on timeout. */
11177 buf
= rs
->buf
.data ();
11178 if (buf
[0] == '\0')
11179 error (_("Target does not support this command."));
11180 if (buf
[0] == 'O' && buf
[1] != 'K')
11182 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11185 if (strcmp (buf
, "OK") == 0)
11187 if (strlen (buf
) == 3 && buf
[0] == 'E'
11188 && isdigit (buf
[1]) && isdigit (buf
[2]))
11190 error (_("Protocol error with Rcmd"));
11192 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11194 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11196 fputc_unfiltered (c
, outbuf
);
11202 std::vector
<mem_region
>
11203 remote_target::memory_map ()
11205 std::vector
<mem_region
> result
;
11206 gdb::optional
<gdb::char_vector
> text
11207 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11210 result
= parse_memory_map (text
->data ());
11216 packet_command (const char *args
, int from_tty
)
11218 remote_target
*remote
= get_current_remote_target ();
11220 if (remote
== nullptr)
11221 error (_("command can only be used with remote target"));
11223 remote
->packet_command (args
, from_tty
);
11227 remote_target::packet_command (const char *args
, int from_tty
)
11230 error (_("remote-packet command requires packet text as argument"));
11232 puts_filtered ("sending: ");
11233 print_packet (args
);
11234 puts_filtered ("\n");
11237 remote_state
*rs
= get_remote_state ();
11239 getpkt (&rs
->buf
, 0);
11240 puts_filtered ("received: ");
11241 print_packet (rs
->buf
.data ());
11242 puts_filtered ("\n");
11246 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11248 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11250 static void threadset_test_cmd (char *cmd
, int tty
);
11252 static void threadalive_test (char *cmd
, int tty
);
11254 static void threadlist_test_cmd (char *cmd
, int tty
);
11256 int get_and_display_threadinfo (threadref
*ref
);
11258 static void threadinfo_test_cmd (char *cmd
, int tty
);
11260 static int thread_display_step (threadref
*ref
, void *context
);
11262 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11264 static void init_remote_threadtests (void);
11266 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11269 threadset_test_cmd (const char *cmd
, int tty
)
11271 int sample_thread
= SAMPLE_THREAD
;
11273 printf_filtered (_("Remote threadset test\n"));
11274 set_general_thread (sample_thread
);
11279 threadalive_test (const char *cmd
, int tty
)
11281 int sample_thread
= SAMPLE_THREAD
;
11282 int pid
= inferior_ptid
.pid ();
11283 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11285 if (remote_thread_alive (ptid
))
11286 printf_filtered ("PASS: Thread alive test\n");
11288 printf_filtered ("FAIL: Thread alive test\n");
11291 void output_threadid (char *title
, threadref
*ref
);
11294 output_threadid (char *title
, threadref
*ref
)
11298 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
11300 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11304 threadlist_test_cmd (const char *cmd
, int tty
)
11307 threadref nextthread
;
11308 int done
, result_count
;
11309 threadref threadlist
[3];
11311 printf_filtered ("Remote Threadlist test\n");
11312 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11313 &result_count
, &threadlist
[0]))
11314 printf_filtered ("FAIL: threadlist test\n");
11317 threadref
*scan
= threadlist
;
11318 threadref
*limit
= scan
+ result_count
;
11320 while (scan
< limit
)
11321 output_threadid (" thread ", scan
++);
11326 display_thread_info (struct gdb_ext_thread_info
*info
)
11328 output_threadid ("Threadid: ", &info
->threadid
);
11329 printf_filtered ("Name: %s\n ", info
->shortname
);
11330 printf_filtered ("State: %s\n", info
->display
);
11331 printf_filtered ("other: %s\n\n", info
->more_display
);
11335 get_and_display_threadinfo (threadref
*ref
)
11339 struct gdb_ext_thread_info threadinfo
;
11341 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11342 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11343 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11344 display_thread_info (&threadinfo
);
11349 threadinfo_test_cmd (const char *cmd
, int tty
)
11351 int athread
= SAMPLE_THREAD
;
11355 int_to_threadref (&thread
, athread
);
11356 printf_filtered ("Remote Threadinfo test\n");
11357 if (!get_and_display_threadinfo (&thread
))
11358 printf_filtered ("FAIL cannot get thread info\n");
11362 thread_display_step (threadref
*ref
, void *context
)
11364 /* output_threadid(" threadstep ",ref); *//* simple test */
11365 return get_and_display_threadinfo (ref
);
11369 threadlist_update_test_cmd (const char *cmd
, int tty
)
11371 printf_filtered ("Remote Threadlist update test\n");
11372 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11376 init_remote_threadtests (void)
11378 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11379 _("Fetch and print the remote list of "
11380 "thread identifiers, one pkt only."));
11381 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11382 _("Fetch and display info about one thread."));
11383 add_com ("tset", class_obscure
, threadset_test_cmd
,
11384 _("Test setting to a different thread."));
11385 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11386 _("Iterate through updating all remote thread info."));
11387 add_com ("talive", class_obscure
, threadalive_test
,
11388 _("Remote thread alive test."));
11393 /* Convert a thread ID to a string. */
11396 remote_target::pid_to_str (ptid_t ptid
)
11398 struct remote_state
*rs
= get_remote_state ();
11400 if (ptid
== null_ptid
)
11401 return normal_pid_to_str (ptid
);
11402 else if (ptid
.is_pid ())
11404 /* Printing an inferior target id. */
11406 /* When multi-process extensions are off, there's no way in the
11407 remote protocol to know the remote process id, if there's any
11408 at all. There's one exception --- when we're connected with
11409 target extended-remote, and we manually attached to a process
11410 with "attach PID". We don't record anywhere a flag that
11411 allows us to distinguish that case from the case of
11412 connecting with extended-remote and the stub already being
11413 attached to a process, and reporting yes to qAttached, hence
11414 no smart special casing here. */
11415 if (!remote_multi_process_p (rs
))
11416 return "Remote target";
11418 return normal_pid_to_str (ptid
);
11422 if (magic_null_ptid
== ptid
)
11423 return "Thread <main>";
11424 else if (remote_multi_process_p (rs
))
11425 if (ptid
.lwp () == 0)
11426 return normal_pid_to_str (ptid
);
11428 return string_printf ("Thread %d.%ld",
11429 ptid
.pid (), ptid
.lwp ());
11431 return string_printf ("Thread %ld", ptid
.lwp ());
11435 /* Get the address of the thread local variable in OBJFILE which is
11436 stored at OFFSET within the thread local storage for thread PTID. */
11439 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11442 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11444 struct remote_state
*rs
= get_remote_state ();
11445 char *p
= rs
->buf
.data ();
11446 char *endp
= p
+ get_remote_packet_size ();
11447 enum packet_result result
;
11449 strcpy (p
, "qGetTLSAddr:");
11451 p
= write_ptid (p
, endp
, ptid
);
11453 p
+= hexnumstr (p
, offset
);
11455 p
+= hexnumstr (p
, lm
);
11459 getpkt (&rs
->buf
, 0);
11460 result
= packet_ok (rs
->buf
,
11461 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11462 if (result
== PACKET_OK
)
11466 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11469 else if (result
== PACKET_UNKNOWN
)
11470 throw_error (TLS_GENERIC_ERROR
,
11471 _("Remote target doesn't support qGetTLSAddr packet"));
11473 throw_error (TLS_GENERIC_ERROR
,
11474 _("Remote target failed to process qGetTLSAddr request"));
11477 throw_error (TLS_GENERIC_ERROR
,
11478 _("TLS not supported or disabled on this target"));
11483 /* Provide thread local base, i.e. Thread Information Block address.
11484 Returns 1 if ptid is found and thread_local_base is non zero. */
11487 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11489 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11491 struct remote_state
*rs
= get_remote_state ();
11492 char *p
= rs
->buf
.data ();
11493 char *endp
= p
+ get_remote_packet_size ();
11494 enum packet_result result
;
11496 strcpy (p
, "qGetTIBAddr:");
11498 p
= write_ptid (p
, endp
, ptid
);
11502 getpkt (&rs
->buf
, 0);
11503 result
= packet_ok (rs
->buf
,
11504 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11505 if (result
== PACKET_OK
)
11508 unpack_varlen_hex (rs
->buf
.data (), &val
);
11510 *addr
= (CORE_ADDR
) val
;
11513 else if (result
== PACKET_UNKNOWN
)
11514 error (_("Remote target doesn't support qGetTIBAddr packet"));
11516 error (_("Remote target failed to process qGetTIBAddr request"));
11519 error (_("qGetTIBAddr not supported or disabled on this target"));
11524 /* Support for inferring a target description based on the current
11525 architecture and the size of a 'g' packet. While the 'g' packet
11526 can have any size (since optional registers can be left off the
11527 end), some sizes are easily recognizable given knowledge of the
11528 approximate architecture. */
11530 struct remote_g_packet_guess
11532 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11539 const struct target_desc
*tdesc
;
11542 struct remote_g_packet_data
: public allocate_on_obstack
11544 std::vector
<remote_g_packet_guess
> guesses
;
11547 static struct gdbarch_data
*remote_g_packet_data_handle
;
11550 remote_g_packet_data_init (struct obstack
*obstack
)
11552 return new (obstack
) remote_g_packet_data
;
11556 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11557 const struct target_desc
*tdesc
)
11559 struct remote_g_packet_data
*data
11560 = ((struct remote_g_packet_data
*)
11561 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11563 gdb_assert (tdesc
!= NULL
);
11565 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11566 if (guess
.bytes
== bytes
)
11567 internal_error (__FILE__
, __LINE__
,
11568 _("Duplicate g packet description added for size %d"),
11571 data
->guesses
.emplace_back (bytes
, tdesc
);
11574 /* Return true if remote_read_description would do anything on this target
11575 and architecture, false otherwise. */
11578 remote_read_description_p (struct target_ops
*target
)
11580 struct remote_g_packet_data
*data
11581 = ((struct remote_g_packet_data
*)
11582 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11584 return !data
->guesses
.empty ();
11587 const struct target_desc
*
11588 remote_target::read_description ()
11590 struct remote_g_packet_data
*data
11591 = ((struct remote_g_packet_data
*)
11592 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11594 /* Do not try this during initial connection, when we do not know
11595 whether there is a running but stopped thread. */
11596 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
11597 return beneath ()->read_description ();
11599 if (!data
->guesses
.empty ())
11601 int bytes
= send_g_packet ();
11603 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11604 if (guess
.bytes
== bytes
)
11605 return guess
.tdesc
;
11607 /* We discard the g packet. A minor optimization would be to
11608 hold on to it, and fill the register cache once we have selected
11609 an architecture, but it's too tricky to do safely. */
11612 return beneath ()->read_description ();
11615 /* Remote file transfer support. This is host-initiated I/O, not
11616 target-initiated; for target-initiated, see remote-fileio.c. */
11618 /* If *LEFT is at least the length of STRING, copy STRING to
11619 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11620 decrease *LEFT. Otherwise raise an error. */
11623 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11625 int len
= strlen (string
);
11628 error (_("Packet too long for target."));
11630 memcpy (*buffer
, string
, len
);
11634 /* NUL-terminate the buffer as a convenience, if there is
11640 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11641 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11642 decrease *LEFT. Otherwise raise an error. */
11645 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11648 if (2 * len
> *left
)
11649 error (_("Packet too long for target."));
11651 bin2hex (bytes
, *buffer
, len
);
11652 *buffer
+= 2 * len
;
11655 /* NUL-terminate the buffer as a convenience, if there is
11661 /* If *LEFT is large enough, convert VALUE to hex and add it to
11662 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11663 decrease *LEFT. Otherwise raise an error. */
11666 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11668 int len
= hexnumlen (value
);
11671 error (_("Packet too long for target."));
11673 hexnumstr (*buffer
, value
);
11677 /* NUL-terminate the buffer as a convenience, if there is
11683 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11684 value, *REMOTE_ERRNO to the remote error number or zero if none
11685 was included, and *ATTACHMENT to point to the start of the annex
11686 if any. The length of the packet isn't needed here; there may
11687 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11689 Return 0 if the packet could be parsed, -1 if it could not. If
11690 -1 is returned, the other variables may not be initialized. */
11693 remote_hostio_parse_result (char *buffer
, int *retcode
,
11694 int *remote_errno
, char **attachment
)
11699 *attachment
= NULL
;
11701 if (buffer
[0] != 'F')
11705 *retcode
= strtol (&buffer
[1], &p
, 16);
11706 if (errno
!= 0 || p
== &buffer
[1])
11709 /* Check for ",errno". */
11713 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11714 if (errno
!= 0 || p
+ 1 == p2
)
11719 /* Check for ";attachment". If there is no attachment, the
11720 packet should end here. */
11723 *attachment
= p
+ 1;
11726 else if (*p
== '\0')
11732 /* Send a prepared I/O packet to the target and read its response.
11733 The prepared packet is in the global RS->BUF before this function
11734 is called, and the answer is there when we return.
11736 COMMAND_BYTES is the length of the request to send, which may include
11737 binary data. WHICH_PACKET is the packet configuration to check
11738 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11739 is set to the error number and -1 is returned. Otherwise the value
11740 returned by the function is returned.
11742 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11743 attachment is expected; an error will be reported if there's a
11744 mismatch. If one is found, *ATTACHMENT will be set to point into
11745 the packet buffer and *ATTACHMENT_LEN will be set to the
11746 attachment's length. */
11749 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11750 int *remote_errno
, char **attachment
,
11751 int *attachment_len
)
11753 struct remote_state
*rs
= get_remote_state ();
11754 int ret
, bytes_read
;
11755 char *attachment_tmp
;
11757 if (packet_support (which_packet
) == PACKET_DISABLE
)
11759 *remote_errno
= FILEIO_ENOSYS
;
11763 putpkt_binary (rs
->buf
.data (), command_bytes
);
11764 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11766 /* If it timed out, something is wrong. Don't try to parse the
11768 if (bytes_read
< 0)
11770 *remote_errno
= FILEIO_EINVAL
;
11774 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11777 *remote_errno
= FILEIO_EINVAL
;
11779 case PACKET_UNKNOWN
:
11780 *remote_errno
= FILEIO_ENOSYS
;
11786 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
11789 *remote_errno
= FILEIO_EINVAL
;
11793 /* Make sure we saw an attachment if and only if we expected one. */
11794 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11795 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11797 *remote_errno
= FILEIO_EINVAL
;
11801 /* If an attachment was found, it must point into the packet buffer;
11802 work out how many bytes there were. */
11803 if (attachment_tmp
!= NULL
)
11805 *attachment
= attachment_tmp
;
11806 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
11812 /* See declaration.h. */
11815 readahead_cache::invalidate ()
11820 /* See declaration.h. */
11823 readahead_cache::invalidate_fd (int fd
)
11825 if (this->fd
== fd
)
11829 /* Set the filesystem remote_hostio functions that take FILENAME
11830 arguments will use. Return 0 on success, or -1 if an error
11831 occurs (and set *REMOTE_ERRNO). */
11834 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
11837 struct remote_state
*rs
= get_remote_state ();
11838 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11839 char *p
= rs
->buf
.data ();
11840 int left
= get_remote_packet_size () - 1;
11844 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11847 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11850 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11852 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11853 remote_buffer_add_string (&p
, &left
, arg
);
11855 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
11856 remote_errno
, NULL
, NULL
);
11858 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11862 rs
->fs_pid
= required_pid
;
11867 /* Implementation of to_fileio_open. */
11870 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
11871 int flags
, int mode
, int warn_if_slow
,
11874 struct remote_state
*rs
= get_remote_state ();
11875 char *p
= rs
->buf
.data ();
11876 int left
= get_remote_packet_size () - 1;
11880 static int warning_issued
= 0;
11882 printf_unfiltered (_("Reading %s from remote target...\n"),
11885 if (!warning_issued
)
11887 warning (_("File transfers from remote targets can be slow."
11888 " Use \"set sysroot\" to access files locally"
11890 warning_issued
= 1;
11894 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11897 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11899 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11900 strlen (filename
));
11901 remote_buffer_add_string (&p
, &left
, ",");
11903 remote_buffer_add_int (&p
, &left
, flags
);
11904 remote_buffer_add_string (&p
, &left
, ",");
11906 remote_buffer_add_int (&p
, &left
, mode
);
11908 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
11909 remote_errno
, NULL
, NULL
);
11913 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
11914 int flags
, int mode
, int warn_if_slow
,
11917 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
11921 /* Implementation of to_fileio_pwrite. */
11924 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11925 ULONGEST offset
, int *remote_errno
)
11927 struct remote_state
*rs
= get_remote_state ();
11928 char *p
= rs
->buf
.data ();
11929 int left
= get_remote_packet_size ();
11932 rs
->readahead_cache
.invalidate_fd (fd
);
11934 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11936 remote_buffer_add_int (&p
, &left
, fd
);
11937 remote_buffer_add_string (&p
, &left
, ",");
11939 remote_buffer_add_int (&p
, &left
, offset
);
11940 remote_buffer_add_string (&p
, &left
, ",");
11942 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
11943 (get_remote_packet_size ()
11944 - (p
- rs
->buf
.data ())));
11946 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
11947 remote_errno
, NULL
, NULL
);
11951 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11952 ULONGEST offset
, int *remote_errno
)
11954 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
11957 /* Helper for the implementation of to_fileio_pread. Read the file
11958 from the remote side with vFile:pread. */
11961 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
11962 ULONGEST offset
, int *remote_errno
)
11964 struct remote_state
*rs
= get_remote_state ();
11965 char *p
= rs
->buf
.data ();
11967 int left
= get_remote_packet_size ();
11968 int ret
, attachment_len
;
11971 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
11973 remote_buffer_add_int (&p
, &left
, fd
);
11974 remote_buffer_add_string (&p
, &left
, ",");
11976 remote_buffer_add_int (&p
, &left
, len
);
11977 remote_buffer_add_string (&p
, &left
, ",");
11979 remote_buffer_add_int (&p
, &left
, offset
);
11981 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
11982 remote_errno
, &attachment
,
11988 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11990 if (read_len
!= ret
)
11991 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
11996 /* See declaration.h. */
11999 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12003 && this->offset
<= offset
12004 && offset
< this->offset
+ this->bufsize
)
12006 ULONGEST max
= this->offset
+ this->bufsize
;
12008 if (offset
+ len
> max
)
12009 len
= max
- offset
;
12011 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12018 /* Implementation of to_fileio_pread. */
12021 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12022 ULONGEST offset
, int *remote_errno
)
12025 struct remote_state
*rs
= get_remote_state ();
12026 readahead_cache
*cache
= &rs
->readahead_cache
;
12028 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12031 cache
->hit_count
++;
12034 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12035 pulongest (cache
->hit_count
));
12039 cache
->miss_count
++;
12041 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12042 pulongest (cache
->miss_count
));
12045 cache
->offset
= offset
;
12046 cache
->bufsize
= get_remote_packet_size ();
12047 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12049 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12050 cache
->offset
, remote_errno
);
12053 cache
->invalidate_fd (fd
);
12057 cache
->bufsize
= ret
;
12058 return cache
->pread (fd
, read_buf
, len
, offset
);
12062 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12063 ULONGEST offset
, int *remote_errno
)
12065 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12068 /* Implementation of to_fileio_close. */
12071 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12073 struct remote_state
*rs
= get_remote_state ();
12074 char *p
= rs
->buf
.data ();
12075 int left
= get_remote_packet_size () - 1;
12077 rs
->readahead_cache
.invalidate_fd (fd
);
12079 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12081 remote_buffer_add_int (&p
, &left
, fd
);
12083 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12084 remote_errno
, NULL
, NULL
);
12088 remote_target::fileio_close (int fd
, int *remote_errno
)
12090 return remote_hostio_close (fd
, remote_errno
);
12093 /* Implementation of to_fileio_unlink. */
12096 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12099 struct remote_state
*rs
= get_remote_state ();
12100 char *p
= rs
->buf
.data ();
12101 int left
= get_remote_packet_size () - 1;
12103 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12106 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12108 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12109 strlen (filename
));
12111 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12112 remote_errno
, NULL
, NULL
);
12116 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12119 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12122 /* Implementation of to_fileio_readlink. */
12124 gdb::optional
<std::string
>
12125 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12128 struct remote_state
*rs
= get_remote_state ();
12129 char *p
= rs
->buf
.data ();
12131 int left
= get_remote_packet_size ();
12132 int len
, attachment_len
;
12135 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12138 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12140 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12141 strlen (filename
));
12143 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12144 remote_errno
, &attachment
,
12150 std::string
ret (len
, '\0');
12152 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12153 (gdb_byte
*) &ret
[0], len
);
12154 if (read_len
!= len
)
12155 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12160 /* Implementation of to_fileio_fstat. */
12163 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12165 struct remote_state
*rs
= get_remote_state ();
12166 char *p
= rs
->buf
.data ();
12167 int left
= get_remote_packet_size ();
12168 int attachment_len
, ret
;
12170 struct fio_stat fst
;
12173 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12175 remote_buffer_add_int (&p
, &left
, fd
);
12177 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12178 remote_errno
, &attachment
,
12182 if (*remote_errno
!= FILEIO_ENOSYS
)
12185 /* Strictly we should return -1, ENOSYS here, but when
12186 "set sysroot remote:" was implemented in August 2008
12187 BFD's need for a stat function was sidestepped with
12188 this hack. This was not remedied until March 2015
12189 so we retain the previous behavior to avoid breaking
12192 Note that the memset is a March 2015 addition; older
12193 GDBs set st_size *and nothing else* so the structure
12194 would have garbage in all other fields. This might
12195 break something but retaining the previous behavior
12196 here would be just too wrong. */
12198 memset (st
, 0, sizeof (struct stat
));
12199 st
->st_size
= INT_MAX
;
12203 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12204 (gdb_byte
*) &fst
, sizeof (fst
));
12206 if (read_len
!= ret
)
12207 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12209 if (read_len
!= sizeof (fst
))
12210 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12211 read_len
, (int) sizeof (fst
));
12213 remote_fileio_to_host_stat (&fst
, st
);
12218 /* Implementation of to_filesystem_is_local. */
12221 remote_target::filesystem_is_local ()
12223 /* Valgrind GDB presents itself as a remote target but works
12224 on the local filesystem: it does not implement remote get
12225 and users are not expected to set a sysroot. To handle
12226 this case we treat the remote filesystem as local if the
12227 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12228 does not support vFile:open. */
12229 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12231 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12233 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12235 int fd
, remote_errno
;
12237 /* Try opening a file to probe support. The supplied
12238 filename is irrelevant, we only care about whether
12239 the stub recognizes the packet or not. */
12240 fd
= remote_hostio_open (NULL
, "just probing",
12241 FILEIO_O_RDONLY
, 0700, 0,
12245 remote_hostio_close (fd
, &remote_errno
);
12247 ps
= packet_support (PACKET_vFile_open
);
12250 if (ps
== PACKET_DISABLE
)
12252 static int warning_issued
= 0;
12254 if (!warning_issued
)
12256 warning (_("remote target does not support file"
12257 " transfer, attempting to access files"
12258 " from local filesystem."));
12259 warning_issued
= 1;
12270 remote_fileio_errno_to_host (int errnum
)
12276 case FILEIO_ENOENT
:
12284 case FILEIO_EACCES
:
12286 case FILEIO_EFAULT
:
12290 case FILEIO_EEXIST
:
12292 case FILEIO_ENODEV
:
12294 case FILEIO_ENOTDIR
:
12296 case FILEIO_EISDIR
:
12298 case FILEIO_EINVAL
:
12300 case FILEIO_ENFILE
:
12302 case FILEIO_EMFILE
:
12306 case FILEIO_ENOSPC
:
12308 case FILEIO_ESPIPE
:
12312 case FILEIO_ENOSYS
:
12314 case FILEIO_ENAMETOOLONG
:
12315 return ENAMETOOLONG
;
12321 remote_hostio_error (int errnum
)
12323 int host_error
= remote_fileio_errno_to_host (errnum
);
12325 if (host_error
== -1)
12326 error (_("Unknown remote I/O error %d"), errnum
);
12328 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12331 /* A RAII wrapper around a remote file descriptor. */
12333 class scoped_remote_fd
12336 scoped_remote_fd (remote_target
*remote
, int fd
)
12337 : m_remote (remote
), m_fd (fd
)
12341 ~scoped_remote_fd ()
12348 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12352 /* Swallow exception before it escapes the dtor. If
12353 something goes wrong, likely the connection is gone,
12354 and there's nothing else that can be done. */
12359 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12361 /* Release ownership of the file descriptor, and return it. */
12362 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12369 /* Return the owned file descriptor. */
12370 int get () const noexcept
12376 /* The remote target. */
12377 remote_target
*m_remote
;
12379 /* The owned remote I/O file descriptor. */
12384 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12386 remote_target
*remote
= get_current_remote_target ();
12388 if (remote
== nullptr)
12389 error (_("command can only be used with remote target"));
12391 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12395 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12398 int retcode
, remote_errno
, bytes
, io_size
;
12399 int bytes_in_buffer
;
12403 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12405 perror_with_name (local_file
);
12407 scoped_remote_fd fd
12408 (this, remote_hostio_open (NULL
,
12409 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12411 0700, 0, &remote_errno
));
12412 if (fd
.get () == -1)
12413 remote_hostio_error (remote_errno
);
12415 /* Send up to this many bytes at once. They won't all fit in the
12416 remote packet limit, so we'll transfer slightly fewer. */
12417 io_size
= get_remote_packet_size ();
12418 gdb::byte_vector
buffer (io_size
);
12420 bytes_in_buffer
= 0;
12423 while (bytes_in_buffer
|| !saw_eof
)
12427 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12428 io_size
- bytes_in_buffer
,
12432 if (ferror (file
.get ()))
12433 error (_("Error reading %s."), local_file
);
12436 /* EOF. Unless there is something still in the
12437 buffer from the last iteration, we are done. */
12439 if (bytes_in_buffer
== 0)
12447 bytes
+= bytes_in_buffer
;
12448 bytes_in_buffer
= 0;
12450 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12451 offset
, &remote_errno
);
12454 remote_hostio_error (remote_errno
);
12455 else if (retcode
== 0)
12456 error (_("Remote write of %d bytes returned 0!"), bytes
);
12457 else if (retcode
< bytes
)
12459 /* Short write. Save the rest of the read data for the next
12461 bytes_in_buffer
= bytes
- retcode
;
12462 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12468 if (remote_hostio_close (fd
.release (), &remote_errno
))
12469 remote_hostio_error (remote_errno
);
12472 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12476 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12478 remote_target
*remote
= get_current_remote_target ();
12480 if (remote
== nullptr)
12481 error (_("command can only be used with remote target"));
12483 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12487 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12490 int remote_errno
, bytes
, io_size
;
12493 scoped_remote_fd fd
12494 (this, remote_hostio_open (NULL
,
12495 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12497 if (fd
.get () == -1)
12498 remote_hostio_error (remote_errno
);
12500 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12502 perror_with_name (local_file
);
12504 /* Send up to this many bytes at once. They won't all fit in the
12505 remote packet limit, so we'll transfer slightly fewer. */
12506 io_size
= get_remote_packet_size ();
12507 gdb::byte_vector
buffer (io_size
);
12512 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12515 /* Success, but no bytes, means end-of-file. */
12518 remote_hostio_error (remote_errno
);
12522 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12524 perror_with_name (local_file
);
12527 if (remote_hostio_close (fd
.release (), &remote_errno
))
12528 remote_hostio_error (remote_errno
);
12531 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12535 remote_file_delete (const char *remote_file
, int from_tty
)
12537 remote_target
*remote
= get_current_remote_target ();
12539 if (remote
== nullptr)
12540 error (_("command can only be used with remote target"));
12542 remote
->remote_file_delete (remote_file
, from_tty
);
12546 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12548 int retcode
, remote_errno
;
12550 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12552 remote_hostio_error (remote_errno
);
12555 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12559 remote_put_command (const char *args
, int from_tty
)
12562 error_no_arg (_("file to put"));
12564 gdb_argv
argv (args
);
12565 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12566 error (_("Invalid parameters to remote put"));
12568 remote_file_put (argv
[0], argv
[1], from_tty
);
12572 remote_get_command (const char *args
, int from_tty
)
12575 error_no_arg (_("file to get"));
12577 gdb_argv
argv (args
);
12578 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12579 error (_("Invalid parameters to remote get"));
12581 remote_file_get (argv
[0], argv
[1], from_tty
);
12585 remote_delete_command (const char *args
, int from_tty
)
12588 error_no_arg (_("file to delete"));
12590 gdb_argv
argv (args
);
12591 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12592 error (_("Invalid parameters to remote delete"));
12594 remote_file_delete (argv
[0], from_tty
);
12598 remote_command (const char *args
, int from_tty
)
12600 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12604 remote_target::can_execute_reverse ()
12606 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12607 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12614 remote_target::supports_non_stop ()
12620 remote_target::supports_disable_randomization ()
12622 /* Only supported in extended mode. */
12627 remote_target::supports_multi_process ()
12629 struct remote_state
*rs
= get_remote_state ();
12631 return remote_multi_process_p (rs
);
12635 remote_supports_cond_tracepoints ()
12637 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12641 remote_target::supports_evaluation_of_breakpoint_conditions ()
12643 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12647 remote_supports_fast_tracepoints ()
12649 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12653 remote_supports_static_tracepoints ()
12655 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12659 remote_supports_install_in_trace ()
12661 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12665 remote_target::supports_enable_disable_tracepoint ()
12667 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12672 remote_target::supports_string_tracing ()
12674 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12678 remote_target::can_run_breakpoint_commands ()
12680 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12684 remote_target::trace_init ()
12686 struct remote_state
*rs
= get_remote_state ();
12689 remote_get_noisy_reply ();
12690 if (strcmp (rs
->buf
.data (), "OK") != 0)
12691 error (_("Target does not support this command."));
12694 /* Recursive routine to walk through command list including loops, and
12695 download packets for each command. */
12698 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12699 struct command_line
*cmds
)
12701 struct remote_state
*rs
= get_remote_state ();
12702 struct command_line
*cmd
;
12704 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12706 QUIT
; /* Allow user to bail out with ^C. */
12707 strcpy (rs
->buf
.data (), "QTDPsrc:");
12708 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12709 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12710 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12712 remote_get_noisy_reply ();
12713 if (strcmp (rs
->buf
.data (), "OK"))
12714 warning (_("Target does not support source download."));
12716 if (cmd
->control_type
== while_control
12717 || cmd
->control_type
== while_stepping_control
)
12719 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12721 QUIT
; /* Allow user to bail out with ^C. */
12722 strcpy (rs
->buf
.data (), "QTDPsrc:");
12723 encode_source_string (num
, addr
, "cmd", "end",
12724 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12725 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12727 remote_get_noisy_reply ();
12728 if (strcmp (rs
->buf
.data (), "OK"))
12729 warning (_("Target does not support source download."));
12735 remote_target::download_tracepoint (struct bp_location
*loc
)
12739 std::vector
<std::string
> tdp_actions
;
12740 std::vector
<std::string
> stepping_actions
;
12742 struct breakpoint
*b
= loc
->owner
;
12743 struct tracepoint
*t
= (struct tracepoint
*) b
;
12744 struct remote_state
*rs
= get_remote_state ();
12746 const char *err_msg
= _("Tracepoint packet too large for target.");
12749 /* We use a buffer other than rs->buf because we'll build strings
12750 across multiple statements, and other statements in between could
12752 gdb::char_vector
buf (get_remote_packet_size ());
12754 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12756 tpaddr
= loc
->address
;
12757 sprintf_vma (addrbuf
, tpaddr
);
12758 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12759 b
->number
, addrbuf
, /* address */
12760 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12761 t
->step_count
, t
->pass_count
);
12763 if (ret
< 0 || ret
>= buf
.size ())
12764 error ("%s", err_msg
);
12766 /* Fast tracepoints are mostly handled by the target, but we can
12767 tell the target how big of an instruction block should be moved
12769 if (b
->type
== bp_fast_tracepoint
)
12771 /* Only test for support at download time; we may not know
12772 target capabilities at definition time. */
12773 if (remote_supports_fast_tracepoints ())
12775 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12778 size_left
= buf
.size () - strlen (buf
.data ());
12779 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12781 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12783 if (ret
< 0 || ret
>= size_left
)
12784 error ("%s", err_msg
);
12787 /* If it passed validation at definition but fails now,
12788 something is very wrong. */
12789 internal_error (__FILE__
, __LINE__
,
12790 _("Fast tracepoint not "
12791 "valid during download"));
12794 /* Fast tracepoints are functionally identical to regular
12795 tracepoints, so don't take lack of support as a reason to
12796 give up on the trace run. */
12797 warning (_("Target does not support fast tracepoints, "
12798 "downloading %d as regular tracepoint"), b
->number
);
12800 else if (b
->type
== bp_static_tracepoint
)
12802 /* Only test for support at download time; we may not know
12803 target capabilities at definition time. */
12804 if (remote_supports_static_tracepoints ())
12806 struct static_tracepoint_marker marker
;
12808 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12810 size_left
= buf
.size () - strlen (buf
.data ());
12811 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12814 if (ret
< 0 || ret
>= size_left
)
12815 error ("%s", err_msg
);
12818 error (_("Static tracepoint not valid during download"));
12821 /* Fast tracepoints are functionally identical to regular
12822 tracepoints, so don't take lack of support as a reason
12823 to give up on the trace run. */
12824 error (_("Target does not support static tracepoints"));
12826 /* If the tracepoint has a conditional, make it into an agent
12827 expression and append to the definition. */
12830 /* Only test support at download time, we may not know target
12831 capabilities at definition time. */
12832 if (remote_supports_cond_tracepoints ())
12834 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
12837 size_left
= buf
.size () - strlen (buf
.data ());
12839 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12840 size_left
, ":X%x,", aexpr
->len
);
12842 if (ret
< 0 || ret
>= size_left
)
12843 error ("%s", err_msg
);
12845 size_left
= buf
.size () - strlen (buf
.data ());
12847 /* Two bytes to encode each aexpr byte, plus the terminating
12849 if (aexpr
->len
* 2 + 1 > size_left
)
12850 error ("%s", err_msg
);
12852 pkt
= buf
.data () + strlen (buf
.data ());
12854 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12855 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12859 warning (_("Target does not support conditional tracepoints, "
12860 "ignoring tp %d cond"), b
->number
);
12863 if (b
->commands
|| *default_collect
)
12865 size_left
= buf
.size () - strlen (buf
.data ());
12867 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12870 if (ret
< 0 || ret
>= size_left
)
12871 error ("%s", err_msg
);
12874 putpkt (buf
.data ());
12875 remote_get_noisy_reply ();
12876 if (strcmp (rs
->buf
.data (), "OK"))
12877 error (_("Target does not support tracepoints."));
12879 /* do_single_steps (t); */
12880 for (auto action_it
= tdp_actions
.begin ();
12881 action_it
!= tdp_actions
.end (); action_it
++)
12883 QUIT
; /* Allow user to bail out with ^C. */
12885 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
12886 || !stepping_actions
.empty ());
12888 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
12889 b
->number
, addrbuf
, /* address */
12890 action_it
->c_str (),
12891 has_more
? '-' : 0);
12893 if (ret
< 0 || ret
>= buf
.size ())
12894 error ("%s", err_msg
);
12896 putpkt (buf
.data ());
12897 remote_get_noisy_reply ();
12898 if (strcmp (rs
->buf
.data (), "OK"))
12899 error (_("Error on target while setting tracepoints."));
12902 for (auto action_it
= stepping_actions
.begin ();
12903 action_it
!= stepping_actions
.end (); action_it
++)
12905 QUIT
; /* Allow user to bail out with ^C. */
12907 bool is_first
= action_it
== stepping_actions
.begin ();
12908 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
12910 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
12911 b
->number
, addrbuf
, /* address */
12912 is_first
? "S" : "",
12913 action_it
->c_str (),
12914 has_more
? "-" : "");
12916 if (ret
< 0 || ret
>= buf
.size ())
12917 error ("%s", err_msg
);
12919 putpkt (buf
.data ());
12920 remote_get_noisy_reply ();
12921 if (strcmp (rs
->buf
.data (), "OK"))
12922 error (_("Error on target while setting tracepoints."));
12925 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12927 if (b
->location
!= NULL
)
12929 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12931 if (ret
< 0 || ret
>= buf
.size ())
12932 error ("%s", err_msg
);
12934 encode_source_string (b
->number
, loc
->address
, "at",
12935 event_location_to_string (b
->location
.get ()),
12936 buf
.data () + strlen (buf
.data ()),
12937 buf
.size () - strlen (buf
.data ()));
12938 putpkt (buf
.data ());
12939 remote_get_noisy_reply ();
12940 if (strcmp (rs
->buf
.data (), "OK"))
12941 warning (_("Target does not support source download."));
12943 if (b
->cond_string
)
12945 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12947 if (ret
< 0 || ret
>= buf
.size ())
12948 error ("%s", err_msg
);
12950 encode_source_string (b
->number
, loc
->address
,
12951 "cond", b
->cond_string
,
12952 buf
.data () + strlen (buf
.data ()),
12953 buf
.size () - strlen (buf
.data ()));
12954 putpkt (buf
.data ());
12955 remote_get_noisy_reply ();
12956 if (strcmp (rs
->buf
.data (), "OK"))
12957 warning (_("Target does not support source download."));
12959 remote_download_command_source (b
->number
, loc
->address
,
12960 breakpoint_commands (b
));
12965 remote_target::can_download_tracepoint ()
12967 struct remote_state
*rs
= get_remote_state ();
12968 struct trace_status
*ts
;
12971 /* Don't try to install tracepoints until we've relocated our
12972 symbols, and fetched and merged the target's tracepoint list with
12974 if (rs
->starting_up
)
12977 ts
= current_trace_status ();
12978 status
= get_trace_status (ts
);
12980 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
12983 /* If we are in a tracing experiment, but remote stub doesn't support
12984 installing tracepoint in trace, we have to return. */
12985 if (!remote_supports_install_in_trace ())
12993 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
12995 struct remote_state
*rs
= get_remote_state ();
12998 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
12999 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13001 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13002 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13003 >= get_remote_packet_size ())
13004 error (_("Trace state variable name too long for tsv definition packet"));
13005 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13008 remote_get_noisy_reply ();
13009 if (rs
->buf
[0] == '\0')
13010 error (_("Target does not support this command."));
13011 if (strcmp (rs
->buf
.data (), "OK") != 0)
13012 error (_("Error on target while downloading trace state variable."));
13016 remote_target::enable_tracepoint (struct bp_location
*location
)
13018 struct remote_state
*rs
= get_remote_state ();
13021 sprintf_vma (addr_buf
, location
->address
);
13022 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13023 location
->owner
->number
, addr_buf
);
13025 remote_get_noisy_reply ();
13026 if (rs
->buf
[0] == '\0')
13027 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13028 if (strcmp (rs
->buf
.data (), "OK") != 0)
13029 error (_("Error on target while enabling tracepoint."));
13033 remote_target::disable_tracepoint (struct bp_location
*location
)
13035 struct remote_state
*rs
= get_remote_state ();
13038 sprintf_vma (addr_buf
, location
->address
);
13039 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13040 location
->owner
->number
, addr_buf
);
13042 remote_get_noisy_reply ();
13043 if (rs
->buf
[0] == '\0')
13044 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13045 if (strcmp (rs
->buf
.data (), "OK") != 0)
13046 error (_("Error on target while disabling tracepoint."));
13050 remote_target::trace_set_readonly_regions ()
13053 bfd_size_type size
;
13059 return; /* No information to give. */
13061 struct remote_state
*rs
= get_remote_state ();
13063 strcpy (rs
->buf
.data (), "QTro");
13064 offset
= strlen (rs
->buf
.data ());
13065 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
13067 char tmp1
[40], tmp2
[40];
13070 if ((s
->flags
& SEC_LOAD
) == 0 ||
13071 /* (s->flags & SEC_CODE) == 0 || */
13072 (s
->flags
& SEC_READONLY
) == 0)
13076 vma
= bfd_section_vma (s
);
13077 size
= bfd_section_size (s
);
13078 sprintf_vma (tmp1
, vma
);
13079 sprintf_vma (tmp2
, vma
+ size
);
13080 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13081 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13083 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13085 Too many sections for read-only sections definition packet."));
13088 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13090 offset
+= sec_length
;
13095 getpkt (&rs
->buf
, 0);
13100 remote_target::trace_start ()
13102 struct remote_state
*rs
= get_remote_state ();
13104 putpkt ("QTStart");
13105 remote_get_noisy_reply ();
13106 if (rs
->buf
[0] == '\0')
13107 error (_("Target does not support this command."));
13108 if (strcmp (rs
->buf
.data (), "OK") != 0)
13109 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13113 remote_target::get_trace_status (struct trace_status
*ts
)
13115 /* Initialize it just to avoid a GCC false warning. */
13117 /* FIXME we need to get register block size some other way. */
13118 extern int trace_regblock_size
;
13119 enum packet_result result
;
13120 struct remote_state
*rs
= get_remote_state ();
13122 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13125 trace_regblock_size
13126 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13128 putpkt ("qTStatus");
13132 p
= remote_get_noisy_reply ();
13134 catch (const gdb_exception_error
&ex
)
13136 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13138 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13144 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13146 /* If the remote target doesn't do tracing, flag it. */
13147 if (result
== PACKET_UNKNOWN
)
13150 /* We're working with a live target. */
13151 ts
->filename
= NULL
;
13154 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13156 /* Function 'parse_trace_status' sets default value of each field of
13157 'ts' at first, so we don't have to do it here. */
13158 parse_trace_status (p
, ts
);
13160 return ts
->running
;
13164 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13165 struct uploaded_tp
*utp
)
13167 struct remote_state
*rs
= get_remote_state ();
13169 struct bp_location
*loc
;
13170 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13171 size_t size
= get_remote_packet_size ();
13176 tp
->traceframe_usage
= 0;
13177 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13179 /* If the tracepoint was never downloaded, don't go asking for
13181 if (tp
->number_on_target
== 0)
13183 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13184 phex_nz (loc
->address
, 0));
13186 reply
= remote_get_noisy_reply ();
13187 if (reply
&& *reply
)
13190 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13196 utp
->hit_count
= 0;
13197 utp
->traceframe_usage
= 0;
13198 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13199 phex_nz (utp
->addr
, 0));
13201 reply
= remote_get_noisy_reply ();
13202 if (reply
&& *reply
)
13205 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13211 remote_target::trace_stop ()
13213 struct remote_state
*rs
= get_remote_state ();
13216 remote_get_noisy_reply ();
13217 if (rs
->buf
[0] == '\0')
13218 error (_("Target does not support this command."));
13219 if (strcmp (rs
->buf
.data (), "OK") != 0)
13220 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13224 remote_target::trace_find (enum trace_find_type type
, int num
,
13225 CORE_ADDR addr1
, CORE_ADDR addr2
,
13228 struct remote_state
*rs
= get_remote_state ();
13229 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13231 int target_frameno
= -1, target_tracept
= -1;
13233 /* Lookups other than by absolute frame number depend on the current
13234 trace selected, so make sure it is correct on the remote end
13236 if (type
!= tfind_number
)
13237 set_remote_traceframe ();
13239 p
= rs
->buf
.data ();
13240 strcpy (p
, "QTFrame:");
13241 p
= strchr (p
, '\0');
13245 xsnprintf (p
, endbuf
- p
, "%x", num
);
13248 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13251 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13254 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13255 phex_nz (addr2
, 0));
13257 case tfind_outside
:
13258 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13259 phex_nz (addr2
, 0));
13262 error (_("Unknown trace find type %d"), type
);
13266 reply
= remote_get_noisy_reply ();
13267 if (*reply
== '\0')
13268 error (_("Target does not support this command."));
13270 while (reply
&& *reply
)
13275 target_frameno
= (int) strtol (p
, &reply
, 16);
13277 error (_("Unable to parse trace frame number"));
13278 /* Don't update our remote traceframe number cache on failure
13279 to select a remote traceframe. */
13280 if (target_frameno
== -1)
13285 target_tracept
= (int) strtol (p
, &reply
, 16);
13287 error (_("Unable to parse tracepoint number"));
13289 case 'O': /* "OK"? */
13290 if (reply
[1] == 'K' && reply
[2] == '\0')
13293 error (_("Bogus reply from target: %s"), reply
);
13296 error (_("Bogus reply from target: %s"), reply
);
13299 *tpp
= target_tracept
;
13301 rs
->remote_traceframe_number
= target_frameno
;
13302 return target_frameno
;
13306 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13308 struct remote_state
*rs
= get_remote_state ();
13312 set_remote_traceframe ();
13314 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13316 reply
= remote_get_noisy_reply ();
13317 if (reply
&& *reply
)
13321 unpack_varlen_hex (reply
+ 1, &uval
);
13322 *val
= (LONGEST
) uval
;
13330 remote_target::save_trace_data (const char *filename
)
13332 struct remote_state
*rs
= get_remote_state ();
13335 p
= rs
->buf
.data ();
13336 strcpy (p
, "QTSave:");
13338 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13339 >= get_remote_packet_size ())
13340 error (_("Remote file name too long for trace save packet"));
13341 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13344 reply
= remote_get_noisy_reply ();
13345 if (*reply
== '\0')
13346 error (_("Target does not support this command."));
13347 if (strcmp (reply
, "OK") != 0)
13348 error (_("Bogus reply from target: %s"), reply
);
13352 /* This is basically a memory transfer, but needs to be its own packet
13353 because we don't know how the target actually organizes its trace
13354 memory, plus we want to be able to ask for as much as possible, but
13355 not be unhappy if we don't get as much as we ask for. */
13358 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13360 struct remote_state
*rs
= get_remote_state ();
13365 p
= rs
->buf
.data ();
13366 strcpy (p
, "qTBuffer:");
13368 p
+= hexnumstr (p
, offset
);
13370 p
+= hexnumstr (p
, len
);
13374 reply
= remote_get_noisy_reply ();
13375 if (reply
&& *reply
)
13377 /* 'l' by itself means we're at the end of the buffer and
13378 there is nothing more to get. */
13382 /* Convert the reply into binary. Limit the number of bytes to
13383 convert according to our passed-in buffer size, rather than
13384 what was returned in the packet; if the target is
13385 unexpectedly generous and gives us a bigger reply than we
13386 asked for, we don't want to crash. */
13387 rslt
= hex2bin (reply
, buf
, len
);
13391 /* Something went wrong, flag as an error. */
13396 remote_target::set_disconnected_tracing (int val
)
13398 struct remote_state
*rs
= get_remote_state ();
13400 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13404 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13405 "QTDisconnected:%x", val
);
13407 reply
= remote_get_noisy_reply ();
13408 if (*reply
== '\0')
13409 error (_("Target does not support this command."));
13410 if (strcmp (reply
, "OK") != 0)
13411 error (_("Bogus reply from target: %s"), reply
);
13414 warning (_("Target does not support disconnected tracing."));
13418 remote_target::core_of_thread (ptid_t ptid
)
13420 struct thread_info
*info
= find_thread_ptid (ptid
);
13422 if (info
!= NULL
&& info
->priv
!= NULL
)
13423 return get_remote_thread_info (info
)->core
;
13429 remote_target::set_circular_trace_buffer (int val
)
13431 struct remote_state
*rs
= get_remote_state ();
13434 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13435 "QTBuffer:circular:%x", val
);
13437 reply
= remote_get_noisy_reply ();
13438 if (*reply
== '\0')
13439 error (_("Target does not support this command."));
13440 if (strcmp (reply
, "OK") != 0)
13441 error (_("Bogus reply from target: %s"), reply
);
13445 remote_target::traceframe_info ()
13447 gdb::optional
<gdb::char_vector
> text
13448 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13451 return parse_traceframe_info (text
->data ());
13456 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13457 instruction on which a fast tracepoint may be placed. Returns -1
13458 if the packet is not supported, and 0 if the minimum instruction
13459 length is unknown. */
13462 remote_target::get_min_fast_tracepoint_insn_len ()
13464 struct remote_state
*rs
= get_remote_state ();
13467 /* If we're not debugging a process yet, the IPA can't be
13469 if (!target_has_execution
)
13472 /* Make sure the remote is pointing at the right process. */
13473 set_general_process ();
13475 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13477 reply
= remote_get_noisy_reply ();
13478 if (*reply
== '\0')
13482 ULONGEST min_insn_len
;
13484 unpack_varlen_hex (reply
, &min_insn_len
);
13486 return (int) min_insn_len
;
13491 remote_target::set_trace_buffer_size (LONGEST val
)
13493 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13495 struct remote_state
*rs
= get_remote_state ();
13496 char *buf
= rs
->buf
.data ();
13497 char *endbuf
= buf
+ get_remote_packet_size ();
13498 enum packet_result result
;
13500 gdb_assert (val
>= 0 || val
== -1);
13501 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13502 /* Send -1 as literal "-1" to avoid host size dependency. */
13506 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13509 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13512 remote_get_noisy_reply ();
13513 result
= packet_ok (rs
->buf
,
13514 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13516 if (result
!= PACKET_OK
)
13517 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13522 remote_target::set_trace_notes (const char *user
, const char *notes
,
13523 const char *stop_notes
)
13525 struct remote_state
*rs
= get_remote_state ();
13527 char *buf
= rs
->buf
.data ();
13528 char *endbuf
= buf
+ get_remote_packet_size ();
13531 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13534 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13535 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13541 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13542 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13548 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13549 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13553 /* Ensure the buffer is terminated. */
13557 reply
= remote_get_noisy_reply ();
13558 if (*reply
== '\0')
13561 if (strcmp (reply
, "OK") != 0)
13562 error (_("Bogus reply from target: %s"), reply
);
13568 remote_target::use_agent (bool use
)
13570 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13572 struct remote_state
*rs
= get_remote_state ();
13574 /* If the stub supports QAgent. */
13575 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13577 getpkt (&rs
->buf
, 0);
13579 if (strcmp (rs
->buf
.data (), "OK") == 0)
13590 remote_target::can_use_agent ()
13592 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13595 struct btrace_target_info
13597 /* The ptid of the traced thread. */
13600 /* The obtained branch trace configuration. */
13601 struct btrace_config conf
;
13604 /* Reset our idea of our target's btrace configuration. */
13607 remote_btrace_reset (remote_state
*rs
)
13609 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13612 /* Synchronize the configuration with the target. */
13615 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13617 struct packet_config
*packet
;
13618 struct remote_state
*rs
;
13619 char *buf
, *pos
, *endbuf
;
13621 rs
= get_remote_state ();
13622 buf
= rs
->buf
.data ();
13623 endbuf
= buf
+ get_remote_packet_size ();
13625 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13626 if (packet_config_support (packet
) == PACKET_ENABLE
13627 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13630 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13634 getpkt (&rs
->buf
, 0);
13636 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13638 if (buf
[0] == 'E' && buf
[1] == '.')
13639 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13641 error (_("Failed to configure the BTS buffer size."));
13644 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13647 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13648 if (packet_config_support (packet
) == PACKET_ENABLE
13649 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13652 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13656 getpkt (&rs
->buf
, 0);
13658 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13660 if (buf
[0] == 'E' && buf
[1] == '.')
13661 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13663 error (_("Failed to configure the trace buffer size."));
13666 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13670 /* Read the current thread's btrace configuration from the target and
13671 store it into CONF. */
13674 btrace_read_config (struct btrace_config
*conf
)
13676 gdb::optional
<gdb::char_vector
> xml
13677 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13679 parse_xml_btrace_conf (conf
, xml
->data ());
13682 /* Maybe reopen target btrace. */
13685 remote_target::remote_btrace_maybe_reopen ()
13687 struct remote_state
*rs
= get_remote_state ();
13688 int btrace_target_pushed
= 0;
13689 #if !defined (HAVE_LIBIPT)
13693 /* Don't bother walking the entirety of the remote thread list when
13694 we know the feature isn't supported by the remote. */
13695 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13698 scoped_restore_current_thread restore_thread
;
13700 for (thread_info
*tp
: all_non_exited_threads ())
13702 set_general_thread (tp
->ptid
);
13704 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13705 btrace_read_config (&rs
->btrace_config
);
13707 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13710 #if !defined (HAVE_LIBIPT)
13711 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13716 warning (_("Target is recording using Intel Processor Trace "
13717 "but support was disabled at compile time."));
13722 #endif /* !defined (HAVE_LIBIPT) */
13724 /* Push target, once, but before anything else happens. This way our
13725 changes to the threads will be cleaned up by unpushing the target
13726 in case btrace_read_config () throws. */
13727 if (!btrace_target_pushed
)
13729 btrace_target_pushed
= 1;
13730 record_btrace_push_target ();
13731 printf_filtered (_("Target is recording using %s.\n"),
13732 btrace_format_string (rs
->btrace_config
.format
));
13735 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13736 tp
->btrace
.target
->ptid
= tp
->ptid
;
13737 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13741 /* Enable branch tracing. */
13743 struct btrace_target_info
*
13744 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13746 struct btrace_target_info
*tinfo
= NULL
;
13747 struct packet_config
*packet
= NULL
;
13748 struct remote_state
*rs
= get_remote_state ();
13749 char *buf
= rs
->buf
.data ();
13750 char *endbuf
= buf
+ get_remote_packet_size ();
13752 switch (conf
->format
)
13754 case BTRACE_FORMAT_BTS
:
13755 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13758 case BTRACE_FORMAT_PT
:
13759 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13763 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13764 error (_("Target does not support branch tracing."));
13766 btrace_sync_conf (conf
);
13768 set_general_thread (ptid
);
13770 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13772 getpkt (&rs
->buf
, 0);
13774 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13776 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13777 error (_("Could not enable branch tracing for %s: %s"),
13778 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
13780 error (_("Could not enable branch tracing for %s."),
13781 target_pid_to_str (ptid
).c_str ());
13784 tinfo
= XCNEW (struct btrace_target_info
);
13785 tinfo
->ptid
= ptid
;
13787 /* If we fail to read the configuration, we lose some information, but the
13788 tracing itself is not impacted. */
13791 btrace_read_config (&tinfo
->conf
);
13793 catch (const gdb_exception_error
&err
)
13795 if (err
.message
!= NULL
)
13796 warning ("%s", err
.what ());
13802 /* Disable branch tracing. */
13805 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
13807 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13808 struct remote_state
*rs
= get_remote_state ();
13809 char *buf
= rs
->buf
.data ();
13810 char *endbuf
= buf
+ get_remote_packet_size ();
13812 if (packet_config_support (packet
) != PACKET_ENABLE
)
13813 error (_("Target does not support branch tracing."));
13815 set_general_thread (tinfo
->ptid
);
13817 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13819 getpkt (&rs
->buf
, 0);
13821 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13823 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13824 error (_("Could not disable branch tracing for %s: %s"),
13825 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
13827 error (_("Could not disable branch tracing for %s."),
13828 target_pid_to_str (tinfo
->ptid
).c_str ());
13834 /* Teardown branch tracing. */
13837 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
13839 /* We must not talk to the target during teardown. */
13843 /* Read the branch trace. */
13846 remote_target::read_btrace (struct btrace_data
*btrace
,
13847 struct btrace_target_info
*tinfo
,
13848 enum btrace_read_type type
)
13850 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13853 if (packet_config_support (packet
) != PACKET_ENABLE
)
13854 error (_("Target does not support branch tracing."));
13856 #if !defined(HAVE_LIBEXPAT)
13857 error (_("Cannot process branch tracing result. XML parsing not supported."));
13862 case BTRACE_READ_ALL
:
13865 case BTRACE_READ_NEW
:
13868 case BTRACE_READ_DELTA
:
13872 internal_error (__FILE__
, __LINE__
,
13873 _("Bad branch tracing read type: %u."),
13874 (unsigned int) type
);
13877 gdb::optional
<gdb::char_vector
> xml
13878 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
13880 return BTRACE_ERR_UNKNOWN
;
13882 parse_xml_btrace (btrace
, xml
->data ());
13884 return BTRACE_ERR_NONE
;
13887 const struct btrace_config
*
13888 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
13890 return &tinfo
->conf
;
13894 remote_target::augmented_libraries_svr4_read ()
13896 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13900 /* Implementation of to_load. */
13903 remote_target::load (const char *name
, int from_tty
)
13905 generic_load (name
, from_tty
);
13908 /* Accepts an integer PID; returns a string representing a file that
13909 can be opened on the remote side to get the symbols for the child
13910 process. Returns NULL if the operation is not supported. */
13913 remote_target::pid_to_exec_file (int pid
)
13915 static gdb::optional
<gdb::char_vector
> filename
;
13916 struct inferior
*inf
;
13917 char *annex
= NULL
;
13919 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13922 inf
= find_inferior_pid (pid
);
13924 internal_error (__FILE__
, __LINE__
,
13925 _("not currently attached to process %d"), pid
);
13927 if (!inf
->fake_pid_p
)
13929 const int annex_size
= 9;
13931 annex
= (char *) alloca (annex_size
);
13932 xsnprintf (annex
, annex_size
, "%x", pid
);
13935 filename
= target_read_stralloc (current_top_target (),
13936 TARGET_OBJECT_EXEC_FILE
, annex
);
13938 return filename
? filename
->data () : nullptr;
13941 /* Implement the to_can_do_single_step target_ops method. */
13944 remote_target::can_do_single_step ()
13946 /* We can only tell whether target supports single step or not by
13947 supported s and S vCont actions if the stub supports vContSupported
13948 feature. If the stub doesn't support vContSupported feature,
13949 we have conservatively to think target doesn't supports single
13951 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
13953 struct remote_state
*rs
= get_remote_state ();
13955 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13956 remote_vcont_probe ();
13958 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
13964 /* Implementation of the to_execution_direction method for the remote
13967 enum exec_direction_kind
13968 remote_target::execution_direction ()
13970 struct remote_state
*rs
= get_remote_state ();
13972 return rs
->last_resume_exec_dir
;
13975 /* Return pointer to the thread_info struct which corresponds to
13976 THREAD_HANDLE (having length HANDLE_LEN). */
13979 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
13983 for (thread_info
*tp
: all_non_exited_threads ())
13985 remote_thread_info
*priv
= get_remote_thread_info (tp
);
13987 if (tp
->inf
== inf
&& priv
!= NULL
)
13989 if (handle_len
!= priv
->thread_handle
.size ())
13990 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
13991 handle_len
, priv
->thread_handle
.size ());
13992 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14002 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
14004 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14005 return priv
->thread_handle
;
14009 remote_target::can_async_p ()
14011 struct remote_state
*rs
= get_remote_state ();
14013 /* We don't go async if the user has explicitly prevented it with the
14014 "maint set target-async" command. */
14015 if (!target_async_permitted
)
14018 /* We're async whenever the serial device is. */
14019 return serial_can_async_p (rs
->remote_desc
);
14023 remote_target::is_async_p ()
14025 struct remote_state
*rs
= get_remote_state ();
14027 if (!target_async_permitted
)
14028 /* We only enable async when the user specifically asks for it. */
14031 /* We're async whenever the serial device is. */
14032 return serial_is_async_p (rs
->remote_desc
);
14035 /* Pass the SERIAL event on and up to the client. One day this code
14036 will be able to delay notifying the client of an event until the
14037 point where an entire packet has been received. */
14039 static serial_event_ftype remote_async_serial_handler
;
14042 remote_async_serial_handler (struct serial
*scb
, void *context
)
14044 /* Don't propogate error information up to the client. Instead let
14045 the client find out about the error by querying the target. */
14046 inferior_event_handler (INF_REG_EVENT
, NULL
);
14050 remote_async_inferior_event_handler (gdb_client_data data
)
14052 inferior_event_handler (INF_REG_EVENT
, data
);
14056 remote_target::async (int enable
)
14058 struct remote_state
*rs
= get_remote_state ();
14062 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14064 /* If there are pending events in the stop reply queue tell the
14065 event loop to process them. */
14066 if (!rs
->stop_reply_queue
.empty ())
14067 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14068 /* For simplicity, below we clear the pending events token
14069 without remembering whether it is marked, so here we always
14070 mark it. If there's actually no pending notification to
14071 process, this ends up being a no-op (other than a spurious
14072 event-loop wakeup). */
14073 if (target_is_non_stop_p ())
14074 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14078 serial_async (rs
->remote_desc
, NULL
, NULL
);
14079 /* If the core is disabling async, it doesn't want to be
14080 disturbed with target events. Clear all async event sources
14082 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14083 if (target_is_non_stop_p ())
14084 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14088 /* Implementation of the to_thread_events method. */
14091 remote_target::thread_events (int enable
)
14093 struct remote_state
*rs
= get_remote_state ();
14094 size_t size
= get_remote_packet_size ();
14096 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14099 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14101 getpkt (&rs
->buf
, 0);
14103 switch (packet_ok (rs
->buf
,
14104 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14107 if (strcmp (rs
->buf
.data (), "OK") != 0)
14108 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14111 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14113 case PACKET_UNKNOWN
:
14119 set_remote_cmd (const char *args
, int from_tty
)
14121 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
14125 show_remote_cmd (const char *args
, int from_tty
)
14127 /* We can't just use cmd_show_list here, because we want to skip
14128 the redundant "show remote Z-packet" and the legacy aliases. */
14129 struct cmd_list_element
*list
= remote_show_cmdlist
;
14130 struct ui_out
*uiout
= current_uiout
;
14132 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14133 for (; list
!= NULL
; list
= list
->next
)
14134 if (strcmp (list
->name
, "Z-packet") == 0)
14136 else if (list
->type
== not_set_cmd
)
14137 /* Alias commands are exactly like the original, except they
14138 don't have the normal type. */
14142 ui_out_emit_tuple
option_emitter (uiout
, "option");
14144 uiout
->field_string ("name", list
->name
);
14145 uiout
->text (": ");
14146 if (list
->type
== show_cmd
)
14147 do_show_command (NULL
, from_tty
, list
);
14149 cmd_func (list
, NULL
, from_tty
);
14154 /* Function to be called whenever a new objfile (shlib) is detected. */
14156 remote_new_objfile (struct objfile
*objfile
)
14158 remote_target
*remote
= get_current_remote_target ();
14160 if (remote
!= NULL
) /* Have a remote connection. */
14161 remote
->remote_check_symbols ();
14164 /* Pull all the tracepoints defined on the target and create local
14165 data structures representing them. We don't want to create real
14166 tracepoints yet, we don't want to mess up the user's existing
14170 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14172 struct remote_state
*rs
= get_remote_state ();
14175 /* Ask for a first packet of tracepoint definition. */
14177 getpkt (&rs
->buf
, 0);
14178 p
= rs
->buf
.data ();
14179 while (*p
&& *p
!= 'l')
14181 parse_tracepoint_definition (p
, utpp
);
14182 /* Ask for another packet of tracepoint definition. */
14184 getpkt (&rs
->buf
, 0);
14185 p
= rs
->buf
.data ();
14191 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14193 struct remote_state
*rs
= get_remote_state ();
14196 /* Ask for a first packet of variable definition. */
14198 getpkt (&rs
->buf
, 0);
14199 p
= rs
->buf
.data ();
14200 while (*p
&& *p
!= 'l')
14202 parse_tsv_definition (p
, utsvp
);
14203 /* Ask for another packet of variable definition. */
14205 getpkt (&rs
->buf
, 0);
14206 p
= rs
->buf
.data ();
14211 /* The "set/show range-stepping" show hook. */
14214 show_range_stepping (struct ui_file
*file
, int from_tty
,
14215 struct cmd_list_element
*c
,
14218 fprintf_filtered (file
,
14219 _("Debugger's willingness to use range stepping "
14220 "is %s.\n"), value
);
14223 /* Return true if the vCont;r action is supported by the remote
14227 remote_target::vcont_r_supported ()
14229 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14230 remote_vcont_probe ();
14232 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14233 && get_remote_state ()->supports_vCont
.r
);
14236 /* The "set/show range-stepping" set hook. */
14239 set_range_stepping (const char *ignore_args
, int from_tty
,
14240 struct cmd_list_element
*c
)
14242 /* When enabling, check whether range stepping is actually supported
14243 by the target, and warn if not. */
14244 if (use_range_stepping
)
14246 remote_target
*remote
= get_current_remote_target ();
14248 || !remote
->vcont_r_supported ())
14249 warning (_("Range stepping is not supported by the current target"));
14254 _initialize_remote (void)
14256 struct cmd_list_element
*cmd
;
14257 const char *cmd_name
;
14259 /* architecture specific data */
14260 remote_g_packet_data_handle
=
14261 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14263 add_target (remote_target_info
, remote_target::open
);
14264 add_target (extended_remote_target_info
, extended_remote_target::open
);
14266 /* Hook into new objfile notification. */
14267 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14270 init_remote_threadtests ();
14273 /* set/show remote ... */
14275 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14276 Remote protocol specific variables.\n\
14277 Configure various remote-protocol specific variables such as\n\
14278 the packets being used."),
14279 &remote_set_cmdlist
, "set remote ",
14280 0 /* allow-unknown */, &setlist
);
14281 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14282 Remote protocol specific variables.\n\
14283 Configure various remote-protocol specific variables such as\n\
14284 the packets being used."),
14285 &remote_show_cmdlist
, "show remote ",
14286 0 /* allow-unknown */, &showlist
);
14288 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14289 Compare section data on target to the exec file.\n\
14290 Argument is a single section name (default: all loaded sections).\n\
14291 To compare only read-only loaded sections, specify the -r option."),
14294 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14295 Send an arbitrary packet to a remote target.\n\
14296 maintenance packet TEXT\n\
14297 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14298 this command sends the string TEXT to the inferior, and displays the\n\
14299 response packet. GDB supplies the initial `$' character, and the\n\
14300 terminating `#' character and checksum."),
14303 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14304 Set whether to send break if interrupted."), _("\
14305 Show whether to send break if interrupted."), _("\
14306 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14307 set_remotebreak
, show_remotebreak
,
14308 &setlist
, &showlist
);
14309 cmd_name
= "remotebreak";
14310 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14311 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14312 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14313 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14314 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14316 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14317 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14319 Set interrupt sequence to remote target."), _("\
14320 Show interrupt sequence to remote target."), _("\
14321 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14322 NULL
, show_interrupt_sequence
,
14323 &remote_set_cmdlist
,
14324 &remote_show_cmdlist
);
14326 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14327 &interrupt_on_connect
, _("\
14328 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14329 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14330 If set, interrupt sequence is sent to remote target."),
14332 &remote_set_cmdlist
, &remote_show_cmdlist
);
14334 /* Install commands for configuring memory read/write packets. */
14336 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14337 Set the maximum number of bytes per memory write packet (deprecated)."),
14339 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14340 Show the maximum number of bytes per memory write packet (deprecated)."),
14342 add_cmd ("memory-write-packet-size", no_class
,
14343 set_memory_write_packet_size
, _("\
14344 Set the maximum number of bytes per memory-write packet.\n\
14345 Specify the number of bytes in a packet or 0 (zero) for the\n\
14346 default packet size. The actual limit is further reduced\n\
14347 dependent on the target. Specify ``fixed'' to disable the\n\
14348 further restriction and ``limit'' to enable that restriction."),
14349 &remote_set_cmdlist
);
14350 add_cmd ("memory-read-packet-size", no_class
,
14351 set_memory_read_packet_size
, _("\
14352 Set the maximum number of bytes per memory-read packet.\n\
14353 Specify the number of bytes in a packet or 0 (zero) for the\n\
14354 default packet size. The actual limit is further reduced\n\
14355 dependent on the target. Specify ``fixed'' to disable the\n\
14356 further restriction and ``limit'' to enable that restriction."),
14357 &remote_set_cmdlist
);
14358 add_cmd ("memory-write-packet-size", no_class
,
14359 show_memory_write_packet_size
,
14360 _("Show the maximum number of bytes per memory-write packet."),
14361 &remote_show_cmdlist
);
14362 add_cmd ("memory-read-packet-size", no_class
,
14363 show_memory_read_packet_size
,
14364 _("Show the maximum number of bytes per memory-read packet."),
14365 &remote_show_cmdlist
);
14367 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14368 &remote_hw_watchpoint_limit
, _("\
14369 Set the maximum number of target hardware watchpoints."), _("\
14370 Show the maximum number of target hardware watchpoints."), _("\
14371 Specify \"unlimited\" for unlimited hardware watchpoints."),
14372 NULL
, show_hardware_watchpoint_limit
,
14373 &remote_set_cmdlist
,
14374 &remote_show_cmdlist
);
14375 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14377 &remote_hw_watchpoint_length_limit
, _("\
14378 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14379 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14380 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14381 NULL
, show_hardware_watchpoint_length_limit
,
14382 &remote_set_cmdlist
, &remote_show_cmdlist
);
14383 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14384 &remote_hw_breakpoint_limit
, _("\
14385 Set the maximum number of target hardware breakpoints."), _("\
14386 Show the maximum number of target hardware breakpoints."), _("\
14387 Specify \"unlimited\" for unlimited hardware breakpoints."),
14388 NULL
, show_hardware_breakpoint_limit
,
14389 &remote_set_cmdlist
, &remote_show_cmdlist
);
14391 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14392 &remote_address_size
, _("\
14393 Set the maximum size of the address (in bits) in a memory packet."), _("\
14394 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14396 NULL
, /* FIXME: i18n: */
14397 &setlist
, &showlist
);
14399 init_all_packet_configs ();
14401 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14402 "X", "binary-download", 1);
14404 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14405 "vCont", "verbose-resume", 0);
14407 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14408 "QPassSignals", "pass-signals", 0);
14410 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14411 "QCatchSyscalls", "catch-syscalls", 0);
14413 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14414 "QProgramSignals", "program-signals", 0);
14416 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14417 "QSetWorkingDir", "set-working-dir", 0);
14419 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14420 "QStartupWithShell", "startup-with-shell", 0);
14422 add_packet_config_cmd (&remote_protocol_packets
14423 [PACKET_QEnvironmentHexEncoded
],
14424 "QEnvironmentHexEncoded", "environment-hex-encoded",
14427 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14428 "QEnvironmentReset", "environment-reset",
14431 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14432 "QEnvironmentUnset", "environment-unset",
14435 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14436 "qSymbol", "symbol-lookup", 0);
14438 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14439 "P", "set-register", 1);
14441 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14442 "p", "fetch-register", 1);
14444 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14445 "Z0", "software-breakpoint", 0);
14447 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14448 "Z1", "hardware-breakpoint", 0);
14450 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14451 "Z2", "write-watchpoint", 0);
14453 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14454 "Z3", "read-watchpoint", 0);
14456 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14457 "Z4", "access-watchpoint", 0);
14459 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14460 "qXfer:auxv:read", "read-aux-vector", 0);
14462 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14463 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14465 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14466 "qXfer:features:read", "target-features", 0);
14468 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14469 "qXfer:libraries:read", "library-info", 0);
14471 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14472 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14474 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14475 "qXfer:memory-map:read", "memory-map", 0);
14477 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14478 "qXfer:osdata:read", "osdata", 0);
14480 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14481 "qXfer:threads:read", "threads", 0);
14483 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14484 "qXfer:siginfo:read", "read-siginfo-object", 0);
14486 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14487 "qXfer:siginfo:write", "write-siginfo-object", 0);
14489 add_packet_config_cmd
14490 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14491 "qXfer:traceframe-info:read", "traceframe-info", 0);
14493 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14494 "qXfer:uib:read", "unwind-info-block", 0);
14496 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14497 "qGetTLSAddr", "get-thread-local-storage-address",
14500 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14501 "qGetTIBAddr", "get-thread-information-block-address",
14504 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14505 "bc", "reverse-continue", 0);
14507 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14508 "bs", "reverse-step", 0);
14510 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14511 "qSupported", "supported-packets", 0);
14513 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14514 "qSearch:memory", "search-memory", 0);
14516 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14517 "qTStatus", "trace-status", 0);
14519 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14520 "vFile:setfs", "hostio-setfs", 0);
14522 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14523 "vFile:open", "hostio-open", 0);
14525 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14526 "vFile:pread", "hostio-pread", 0);
14528 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14529 "vFile:pwrite", "hostio-pwrite", 0);
14531 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14532 "vFile:close", "hostio-close", 0);
14534 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14535 "vFile:unlink", "hostio-unlink", 0);
14537 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14538 "vFile:readlink", "hostio-readlink", 0);
14540 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14541 "vFile:fstat", "hostio-fstat", 0);
14543 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14544 "vAttach", "attach", 0);
14546 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14549 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14550 "QStartNoAckMode", "noack", 0);
14552 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14553 "vKill", "kill", 0);
14555 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14556 "qAttached", "query-attached", 0);
14558 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14559 "ConditionalTracepoints",
14560 "conditional-tracepoints", 0);
14562 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14563 "ConditionalBreakpoints",
14564 "conditional-breakpoints", 0);
14566 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14567 "BreakpointCommands",
14568 "breakpoint-commands", 0);
14570 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14571 "FastTracepoints", "fast-tracepoints", 0);
14573 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14574 "TracepointSource", "TracepointSource", 0);
14576 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14577 "QAllow", "allow", 0);
14579 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14580 "StaticTracepoints", "static-tracepoints", 0);
14582 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14583 "InstallInTrace", "install-in-trace", 0);
14585 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14586 "qXfer:statictrace:read", "read-sdata-object", 0);
14588 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14589 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14591 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14592 "QDisableRandomization", "disable-randomization", 0);
14594 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14595 "QAgent", "agent", 0);
14597 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14598 "QTBuffer:size", "trace-buffer-size", 0);
14600 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14601 "Qbtrace:off", "disable-btrace", 0);
14603 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14604 "Qbtrace:bts", "enable-btrace-bts", 0);
14606 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14607 "Qbtrace:pt", "enable-btrace-pt", 0);
14609 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14610 "qXfer:btrace", "read-btrace", 0);
14612 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14613 "qXfer:btrace-conf", "read-btrace-conf", 0);
14615 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14616 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14618 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14619 "multiprocess-feature", "multiprocess-feature", 0);
14621 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14622 "swbreak-feature", "swbreak-feature", 0);
14624 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14625 "hwbreak-feature", "hwbreak-feature", 0);
14627 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14628 "fork-event-feature", "fork-event-feature", 0);
14630 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14631 "vfork-event-feature", "vfork-event-feature", 0);
14633 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14634 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14636 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14637 "vContSupported", "verbose-resume-supported", 0);
14639 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14640 "exec-event-feature", "exec-event-feature", 0);
14642 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14643 "vCtrlC", "ctrl-c", 0);
14645 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14646 "QThreadEvents", "thread-events", 0);
14648 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14649 "N stop reply", "no-resumed-stop-reply", 0);
14651 /* Assert that we've registered "set remote foo-packet" commands
14652 for all packet configs. */
14656 for (i
= 0; i
< PACKET_MAX
; i
++)
14658 /* Ideally all configs would have a command associated. Some
14659 still don't though. */
14664 case PACKET_QNonStop
:
14665 case PACKET_EnableDisableTracepoints_feature
:
14666 case PACKET_tracenz_feature
:
14667 case PACKET_DisconnectedTracing_feature
:
14668 case PACKET_augmented_libraries_svr4_read_feature
:
14670 /* Additions to this list need to be well justified:
14671 pre-existing packets are OK; new packets are not. */
14679 /* This catches both forgetting to add a config command, and
14680 forgetting to remove a packet from the exception list. */
14681 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14685 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14686 Z sub-packet has its own set and show commands, but users may
14687 have sets to this variable in their .gdbinit files (or in their
14689 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14690 &remote_Z_packet_detect
, _("\
14691 Set use of remote protocol `Z' packets."), _("\
14692 Show use of remote protocol `Z' packets."), _("\
14693 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14695 set_remote_protocol_Z_packet_cmd
,
14696 show_remote_protocol_Z_packet_cmd
,
14697 /* FIXME: i18n: Use of remote protocol
14698 `Z' packets is %s. */
14699 &remote_set_cmdlist
, &remote_show_cmdlist
);
14701 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14702 Manipulate files on the remote system.\n\
14703 Transfer files to and from the remote target system."),
14704 &remote_cmdlist
, "remote ",
14705 0 /* allow-unknown */, &cmdlist
);
14707 add_cmd ("put", class_files
, remote_put_command
,
14708 _("Copy a local file to the remote system."),
14711 add_cmd ("get", class_files
, remote_get_command
,
14712 _("Copy a remote file to the local system."),
14715 add_cmd ("delete", class_files
, remote_delete_command
,
14716 _("Delete a remote file."),
14719 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14720 &remote_exec_file_var
, _("\
14721 Set the remote pathname for \"run\"."), _("\
14722 Show the remote pathname for \"run\"."), NULL
,
14723 set_remote_exec_file
,
14724 show_remote_exec_file
,
14725 &remote_set_cmdlist
,
14726 &remote_show_cmdlist
);
14728 add_setshow_boolean_cmd ("range-stepping", class_run
,
14729 &use_range_stepping
, _("\
14730 Enable or disable range stepping."), _("\
14731 Show whether target-assisted range stepping is enabled."), _("\
14732 If on, and the target supports it, when stepping a source line, GDB\n\
14733 tells the target to step the corresponding range of addresses itself instead\n\
14734 of issuing multiple single-steps. This speeds up source level\n\
14735 stepping. If off, GDB always issues single-steps, even if range\n\
14736 stepping is supported by the target. The default is on."),
14737 set_range_stepping
,
14738 show_range_stepping
,
14742 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
14743 Set watchdog timer."), _("\
14744 Show watchdog timer."), _("\
14745 When non-zero, this timeout is used instead of waiting forever for a target\n\
14746 to finish a low-level step or continue operation. If the specified amount\n\
14747 of time passes without a response from the target, an error occurs."),
14750 &setlist
, &showlist
);
14752 /* Eventually initialize fileio. See fileio.c */
14753 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);