1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2020 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"
79 #include <unordered_map>
81 /* The remote target. */
83 static const char remote_doc
[] = N_("\
84 Use a remote computer via a serial line, using a gdb-specific protocol.\n\
85 Specify the serial device it is connected to\n\
86 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
88 #define OPAQUETHREADBYTES 8
90 /* a 64 bit opaque identifier */
91 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
93 struct gdb_ext_thread_info
;
94 struct threads_listing_context
;
95 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
96 struct protocol_feature
;
100 typedef std::unique_ptr
<stop_reply
> stop_reply_up
;
102 /* Generic configuration support for packets the stub optionally
103 supports. Allows the user to specify the use of the packet as well
104 as allowing GDB to auto-detect support in the remote stub. */
108 PACKET_SUPPORT_UNKNOWN
= 0,
113 /* Analyze a packet's return value and update the packet config
123 struct threads_listing_context
;
125 /* Stub vCont actions support.
127 Each field is a boolean flag indicating whether the stub reports
128 support for the corresponding action. */
130 struct vCont_action_support
145 /* About this many threadids fit in a packet. */
147 #define MAXTHREADLISTRESULTS 32
149 /* Data for the vFile:pread readahead cache. */
151 struct readahead_cache
153 /* Invalidate the readahead cache. */
156 /* Invalidate the readahead cache if it is holding data for FD. */
157 void invalidate_fd (int fd
);
159 /* Serve pread from the readahead cache. Returns number of bytes
160 read, or 0 if the request can't be served from the cache. */
161 int pread (int fd
, gdb_byte
*read_buf
, size_t len
, ULONGEST offset
);
163 /* The file descriptor for the file that is being cached. -1 if the
167 /* The offset into the file that the cache buffer corresponds
171 /* The buffer holding the cache contents. */
172 gdb_byte
*buf
= nullptr;
173 /* The buffer's size. We try to read as much as fits into a packet
177 /* Cache hit and miss counters. */
178 ULONGEST hit_count
= 0;
179 ULONGEST miss_count
= 0;
182 /* Description of the remote protocol for a given architecture. */
186 long offset
; /* Offset into G packet. */
187 long regnum
; /* GDB's internal register number. */
188 LONGEST pnum
; /* Remote protocol register number. */
189 int in_g_packet
; /* Always part of G packet. */
190 /* long size in bytes; == register_size (target_gdbarch (), regnum);
192 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
196 struct remote_arch_state
198 explicit remote_arch_state (struct gdbarch
*gdbarch
);
200 /* Description of the remote protocol registers. */
201 long sizeof_g_packet
;
203 /* Description of the remote protocol registers indexed by REGNUM
204 (making an array gdbarch_num_regs in size). */
205 std::unique_ptr
<packet_reg
[]> regs
;
207 /* This is the size (in chars) of the first response to the ``g''
208 packet. It is used as a heuristic when determining the maximum
209 size of memory-read and memory-write packets. A target will
210 typically only reserve a buffer large enough to hold the ``g''
211 packet. The size does not include packet overhead (headers and
213 long actual_register_packet_size
;
215 /* This is the maximum size (in chars) of a non read/write packet.
216 It is also used as a cap on the size of read/write packets. */
217 long remote_packet_size
;
220 /* Description of the remote protocol state for the currently
221 connected target. This is per-target state, and independent of the
222 selected architecture. */
231 /* Get the remote arch state for GDBARCH. */
232 struct remote_arch_state
*get_remote_arch_state (struct gdbarch
*gdbarch
);
236 /* A buffer to use for incoming packets, and its current size. The
237 buffer is grown dynamically for larger incoming packets.
238 Outgoing packets may also be constructed in this buffer.
239 The size of the buffer is always at least REMOTE_PACKET_SIZE;
240 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
242 gdb::char_vector buf
;
244 /* True if we're going through initial connection setup (finding out
245 about the remote side's threads, relocating symbols, etc.). */
246 bool starting_up
= false;
248 /* If we negotiated packet size explicitly (and thus can bypass
249 heuristics for the largest packet size that will not overflow
250 a buffer in the stub), this will be set to that packet size.
251 Otherwise zero, meaning to use the guessed size. */
252 long explicit_packet_size
= 0;
254 /* remote_wait is normally called when the target is running and
255 waits for a stop reply packet. But sometimes we need to call it
256 when the target is already stopped. We can send a "?" packet
257 and have remote_wait read the response. Or, if we already have
258 the response, we can stash it in BUF and tell remote_wait to
259 skip calling getpkt. This flag is set when BUF contains a
260 stop reply packet and the target is not waiting. */
261 int cached_wait_status
= 0;
263 /* True, if in no ack mode. That is, neither GDB nor the stub will
264 expect acks from each other. The connection is assumed to be
266 bool noack_mode
= false;
268 /* True if we're connected in extended remote mode. */
269 bool extended
= false;
271 /* True if we resumed the target and we're waiting for the target to
272 stop. In the mean time, we can't start another command/query.
273 The remote server wouldn't be ready to process it, so we'd
274 timeout waiting for a reply that would never come and eventually
275 we'd close the connection. This can happen in asynchronous mode
276 because we allow GDB commands while the target is running. */
277 bool waiting_for_stop_reply
= false;
279 /* The status of the stub support for the various vCont actions. */
280 vCont_action_support supports_vCont
;
281 /* Whether vCont support was probed already. This is a workaround
282 until packet_support is per-connection. */
283 bool supports_vCont_probed
;
285 /* True if the user has pressed Ctrl-C, but the target hasn't
286 responded to that. */
287 bool ctrlc_pending_p
= false;
289 /* True if we saw a Ctrl-C while reading or writing from/to the
290 remote descriptor. At that point it is not safe to send a remote
291 interrupt packet, so we instead remember we saw the Ctrl-C and
292 process it once we're done with sending/receiving the current
293 packet, which should be shortly. If however that takes too long,
294 and the user presses Ctrl-C again, we offer to disconnect. */
295 bool got_ctrlc_during_io
= false;
297 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
298 remote_open knows that we don't have a file open when the program
300 struct serial
*remote_desc
= nullptr;
302 /* These are the threads which we last sent to the remote system. The
303 TID member will be -1 for all or -2 for not sent yet. */
304 ptid_t general_thread
= null_ptid
;
305 ptid_t continue_thread
= null_ptid
;
307 /* This is the traceframe which we last selected on the remote system.
308 It will be -1 if no traceframe is selected. */
309 int remote_traceframe_number
= -1;
311 char *last_pass_packet
= nullptr;
313 /* The last QProgramSignals packet sent to the target. We bypass
314 sending a new program signals list down to the target if the new
315 packet is exactly the same as the last we sent. IOW, we only let
316 the target know about program signals list changes. */
317 char *last_program_signals_packet
= nullptr;
319 gdb_signal last_sent_signal
= GDB_SIGNAL_0
;
321 bool last_sent_step
= false;
323 /* The execution direction of the last resume we got. */
324 exec_direction_kind last_resume_exec_dir
= EXEC_FORWARD
;
326 char *finished_object
= nullptr;
327 char *finished_annex
= nullptr;
328 ULONGEST finished_offset
= 0;
330 /* Should we try the 'ThreadInfo' query packet?
332 This variable (NOT available to the user: auto-detect only!)
333 determines whether GDB will use the new, simpler "ThreadInfo"
334 query or the older, more complex syntax for thread queries.
335 This is an auto-detect variable (set to true at each connect,
336 and set to false when the target fails to recognize it). */
337 bool use_threadinfo_query
= false;
338 bool use_threadextra_query
= false;
340 threadref echo_nextthread
{};
341 threadref nextthread
{};
342 threadref resultthreadlist
[MAXTHREADLISTRESULTS
] {};
344 /* The state of remote notification. */
345 struct remote_notif_state
*notif_state
= nullptr;
347 /* The branch trace configuration. */
348 struct btrace_config btrace_config
{};
350 /* The argument to the last "vFile:setfs:" packet we sent, used
351 to avoid sending repeated unnecessary "vFile:setfs:" packets.
352 Initialized to -1 to indicate that no "vFile:setfs:" packet
353 has yet been sent. */
356 /* A readahead cache for vFile:pread. Often, reading a binary
357 involves a sequence of small reads. E.g., when parsing an ELF
358 file. A readahead cache helps mostly the case of remote
359 debugging on a connection with higher latency, due to the
360 request/reply nature of the RSP. We only cache data for a single
361 file descriptor at a time. */
362 struct readahead_cache readahead_cache
;
364 /* The list of already fetched and acknowledged stop events. This
365 queue is used for notification Stop, and other notifications
366 don't need queue for their events, because the notification
367 events of Stop can't be consumed immediately, so that events
368 should be queued first, and be consumed by remote_wait_{ns,as}
369 one per time. Other notifications can consume their events
370 immediately, so queue is not needed for them. */
371 std::vector
<stop_reply_up
> stop_reply_queue
;
373 /* Asynchronous signal handle registered as event loop source for
374 when we have pending events ready to be passed to the core. */
375 struct async_event_handler
*remote_async_inferior_event_token
= nullptr;
377 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
378 ``forever'' still use the normal timeout mechanism. This is
379 currently used by the ASYNC code to guarentee that target reads
380 during the initial connect always time-out. Once getpkt has been
381 modified to return a timeout indication and, in turn
382 remote_wait()/wait_for_inferior() have gained a timeout parameter
384 int wait_forever_enabled_p
= 1;
387 /* Mapping of remote protocol data for each gdbarch. Usually there
388 is only one entry here, though we may see more with stubs that
389 support multi-process. */
390 std::unordered_map
<struct gdbarch
*, remote_arch_state
>
394 static const target_info remote_target_info
= {
396 N_("Remote serial target in gdb-specific protocol"),
400 class remote_target
: public process_stratum_target
403 remote_target () = default;
404 ~remote_target () override
;
406 const target_info
&info () const override
407 { return remote_target_info
; }
409 const char *connection_string () override
;
411 thread_control_capabilities
get_thread_control_capabilities () override
412 { return tc_schedlock
; }
414 /* Open a remote connection. */
415 static void open (const char *, int);
417 void close () override
;
419 void detach (inferior
*, int) override
;
420 void disconnect (const char *, int) override
;
422 void commit_resume () override
;
423 void resume (ptid_t
, int, enum gdb_signal
) override
;
424 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
426 void fetch_registers (struct regcache
*, int) override
;
427 void store_registers (struct regcache
*, int) override
;
428 void prepare_to_store (struct regcache
*) override
;
430 void files_info () override
;
432 int insert_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
434 int remove_breakpoint (struct gdbarch
*, struct bp_target_info
*,
435 enum remove_bp_reason
) override
;
438 bool stopped_by_sw_breakpoint () override
;
439 bool supports_stopped_by_sw_breakpoint () override
;
441 bool stopped_by_hw_breakpoint () override
;
443 bool supports_stopped_by_hw_breakpoint () override
;
445 bool stopped_by_watchpoint () override
;
447 bool stopped_data_address (CORE_ADDR
*) override
;
449 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
451 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
453 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
455 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
457 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
459 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
460 struct expression
*) override
;
462 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
463 struct expression
*) override
;
465 void kill () override
;
467 void load (const char *, int) override
;
469 void mourn_inferior () override
;
471 void pass_signals (gdb::array_view
<const unsigned char>) override
;
473 int set_syscall_catchpoint (int, bool, int,
474 gdb::array_view
<const int>) override
;
476 void program_signals (gdb::array_view
<const unsigned char>) override
;
478 bool thread_alive (ptid_t ptid
) override
;
480 const char *thread_name (struct thread_info
*) override
;
482 void update_thread_list () override
;
484 std::string
pid_to_str (ptid_t
) override
;
486 const char *extra_thread_info (struct thread_info
*) override
;
488 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
490 thread_info
*thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
492 inferior
*inf
) override
;
494 gdb::byte_vector
thread_info_to_thread_handle (struct thread_info
*tp
)
497 void stop (ptid_t
) override
;
499 void interrupt () override
;
501 void pass_ctrlc () override
;
503 enum target_xfer_status
xfer_partial (enum target_object object
,
506 const gdb_byte
*writebuf
,
507 ULONGEST offset
, ULONGEST len
,
508 ULONGEST
*xfered_len
) override
;
510 ULONGEST
get_memory_xfer_limit () override
;
512 void rcmd (const char *command
, struct ui_file
*output
) override
;
514 char *pid_to_exec_file (int pid
) override
;
516 void log_command (const char *cmd
) override
518 serial_log_command (this, cmd
);
521 CORE_ADDR
get_thread_local_address (ptid_t ptid
,
522 CORE_ADDR load_module_addr
,
523 CORE_ADDR offset
) override
;
525 bool can_execute_reverse () override
;
527 std::vector
<mem_region
> memory_map () override
;
529 void flash_erase (ULONGEST address
, LONGEST length
) override
;
531 void flash_done () override
;
533 const struct target_desc
*read_description () override
;
535 int search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
536 const gdb_byte
*pattern
, ULONGEST pattern_len
,
537 CORE_ADDR
*found_addrp
) override
;
539 bool can_async_p () override
;
541 bool is_async_p () override
;
543 void async (int) override
;
545 int async_wait_fd () override
;
547 void thread_events (int) override
;
549 int can_do_single_step () override
;
551 void terminal_inferior () override
;
553 void terminal_ours () override
;
555 bool supports_non_stop () override
;
557 bool supports_multi_process () override
;
559 bool supports_disable_randomization () override
;
561 bool filesystem_is_local () override
;
564 int fileio_open (struct inferior
*inf
, const char *filename
,
565 int flags
, int mode
, int warn_if_slow
,
566 int *target_errno
) override
;
568 int fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
569 ULONGEST offset
, int *target_errno
) override
;
571 int fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
572 ULONGEST offset
, int *target_errno
) override
;
574 int fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
) override
;
576 int fileio_close (int fd
, int *target_errno
) override
;
578 int fileio_unlink (struct inferior
*inf
,
579 const char *filename
,
580 int *target_errno
) override
;
582 gdb::optional
<std::string
>
583 fileio_readlink (struct inferior
*inf
,
584 const char *filename
,
585 int *target_errno
) override
;
587 bool supports_enable_disable_tracepoint () override
;
589 bool supports_string_tracing () override
;
591 bool supports_evaluation_of_breakpoint_conditions () override
;
593 bool can_run_breakpoint_commands () override
;
595 void trace_init () override
;
597 void download_tracepoint (struct bp_location
*location
) override
;
599 bool can_download_tracepoint () override
;
601 void download_trace_state_variable (const trace_state_variable
&tsv
) override
;
603 void enable_tracepoint (struct bp_location
*location
) override
;
605 void disable_tracepoint (struct bp_location
*location
) override
;
607 void trace_set_readonly_regions () override
;
609 void trace_start () override
;
611 int get_trace_status (struct trace_status
*ts
) override
;
613 void get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
616 void trace_stop () override
;
618 int trace_find (enum trace_find_type type
, int num
,
619 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
) override
;
621 bool get_trace_state_variable_value (int tsv
, LONGEST
*val
) override
;
623 int save_trace_data (const char *filename
) override
;
625 int upload_tracepoints (struct uploaded_tp
**utpp
) override
;
627 int upload_trace_state_variables (struct uploaded_tsv
**utsvp
) override
;
629 LONGEST
get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
) override
;
631 int get_min_fast_tracepoint_insn_len () override
;
633 void set_disconnected_tracing (int val
) override
;
635 void set_circular_trace_buffer (int val
) override
;
637 void set_trace_buffer_size (LONGEST val
) override
;
639 bool set_trace_notes (const char *user
, const char *notes
,
640 const char *stopnotes
) override
;
642 int core_of_thread (ptid_t ptid
) override
;
644 int verify_memory (const gdb_byte
*data
,
645 CORE_ADDR memaddr
, ULONGEST size
) override
;
648 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
650 void set_permissions () override
;
652 bool static_tracepoint_marker_at (CORE_ADDR
,
653 struct static_tracepoint_marker
*marker
)
656 std::vector
<static_tracepoint_marker
>
657 static_tracepoint_markers_by_strid (const char *id
) override
;
659 traceframe_info_up
traceframe_info () override
;
661 bool use_agent (bool use
) override
;
662 bool can_use_agent () override
;
664 struct btrace_target_info
*enable_btrace (ptid_t ptid
,
665 const struct btrace_config
*conf
) override
;
667 void disable_btrace (struct btrace_target_info
*tinfo
) override
;
669 void teardown_btrace (struct btrace_target_info
*tinfo
) override
;
671 enum btrace_error
read_btrace (struct btrace_data
*data
,
672 struct btrace_target_info
*btinfo
,
673 enum btrace_read_type type
) override
;
675 const struct btrace_config
*btrace_conf (const struct btrace_target_info
*) override
;
676 bool augmented_libraries_svr4_read () override
;
677 bool follow_fork (bool, bool) override
;
678 void follow_exec (struct inferior
*, const char *) override
;
679 int insert_fork_catchpoint (int) override
;
680 int remove_fork_catchpoint (int) override
;
681 int insert_vfork_catchpoint (int) override
;
682 int remove_vfork_catchpoint (int) override
;
683 int insert_exec_catchpoint (int) override
;
684 int remove_exec_catchpoint (int) override
;
685 enum exec_direction_kind
execution_direction () override
;
687 public: /* Remote specific methods. */
689 void remote_download_command_source (int num
, ULONGEST addr
,
690 struct command_line
*cmds
);
692 void remote_file_put (const char *local_file
, const char *remote_file
,
694 void remote_file_get (const char *remote_file
, const char *local_file
,
696 void remote_file_delete (const char *remote_file
, int from_tty
);
698 int remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
699 ULONGEST offset
, int *remote_errno
);
700 int remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
701 ULONGEST offset
, int *remote_errno
);
702 int remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
703 ULONGEST offset
, int *remote_errno
);
705 int remote_hostio_send_command (int command_bytes
, int which_packet
,
706 int *remote_errno
, char **attachment
,
707 int *attachment_len
);
708 int remote_hostio_set_filesystem (struct inferior
*inf
,
710 /* We should get rid of this and use fileio_open directly. */
711 int remote_hostio_open (struct inferior
*inf
, const char *filename
,
712 int flags
, int mode
, int warn_if_slow
,
714 int remote_hostio_close (int fd
, int *remote_errno
);
716 int remote_hostio_unlink (inferior
*inf
, const char *filename
,
719 struct remote_state
*get_remote_state ();
721 long get_remote_packet_size (void);
722 long get_memory_packet_size (struct memory_packet_config
*config
);
724 long get_memory_write_packet_size ();
725 long get_memory_read_packet_size ();
727 char *append_pending_thread_resumptions (char *p
, char *endp
,
729 static void open_1 (const char *name
, int from_tty
, int extended_p
);
730 void start_remote (int from_tty
, int extended_p
);
731 void remote_detach_1 (struct inferior
*inf
, int from_tty
);
733 char *append_resumption (char *p
, char *endp
,
734 ptid_t ptid
, int step
, gdb_signal siggnal
);
735 int remote_resume_with_vcont (ptid_t ptid
, int step
,
738 void add_current_inferior_and_thread (char *wait_status
);
740 ptid_t
wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
742 ptid_t
wait_as (ptid_t ptid
, target_waitstatus
*status
,
745 ptid_t
process_stop_reply (struct stop_reply
*stop_reply
,
746 target_waitstatus
*status
);
748 void remote_notice_new_inferior (ptid_t currthread
, int executing
);
750 void process_initial_stop_replies (int from_tty
);
752 thread_info
*remote_add_thread (ptid_t ptid
, bool running
, bool executing
);
754 void btrace_sync_conf (const btrace_config
*conf
);
756 void remote_btrace_maybe_reopen ();
758 void remove_new_fork_children (threads_listing_context
*context
);
759 void kill_new_fork_children (int pid
);
760 void discard_pending_stop_replies (struct inferior
*inf
);
761 int stop_reply_queue_length ();
763 void check_pending_events_prevent_wildcard_vcont
764 (int *may_global_wildcard_vcont
);
766 void discard_pending_stop_replies_in_queue ();
767 struct stop_reply
*remote_notif_remove_queued_reply (ptid_t ptid
);
768 struct stop_reply
*queued_stop_reply (ptid_t ptid
);
769 int peek_stop_reply (ptid_t ptid
);
770 void remote_parse_stop_reply (const char *buf
, stop_reply
*event
);
772 void remote_stop_ns (ptid_t ptid
);
773 void remote_interrupt_as ();
774 void remote_interrupt_ns ();
776 char *remote_get_noisy_reply ();
777 int remote_query_attached (int pid
);
778 inferior
*remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
781 ptid_t
remote_current_thread (ptid_t oldpid
);
782 ptid_t
get_current_thread (char *wait_status
);
784 void set_thread (ptid_t ptid
, int gen
);
785 void set_general_thread (ptid_t ptid
);
786 void set_continue_thread (ptid_t ptid
);
787 void set_general_process ();
789 char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
791 int remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
792 gdb_ext_thread_info
*info
);
793 int remote_get_threadinfo (threadref
*threadid
, int fieldset
,
794 gdb_ext_thread_info
*info
);
796 int parse_threadlist_response (char *pkt
, int result_limit
,
797 threadref
*original_echo
,
798 threadref
*resultlist
,
800 int remote_get_threadlist (int startflag
, threadref
*nextthread
,
801 int result_limit
, int *done
, int *result_count
,
802 threadref
*threadlist
);
804 int remote_threadlist_iterator (rmt_thread_action stepfunction
,
805 void *context
, int looplimit
);
807 int remote_get_threads_with_ql (threads_listing_context
*context
);
808 int remote_get_threads_with_qxfer (threads_listing_context
*context
);
809 int remote_get_threads_with_qthreadinfo (threads_listing_context
*context
);
811 void extended_remote_restart ();
815 void remote_check_symbols ();
817 void remote_supported_packet (const struct protocol_feature
*feature
,
818 enum packet_support support
,
819 const char *argument
);
821 void remote_query_supported ();
823 void remote_packet_size (const protocol_feature
*feature
,
824 packet_support support
, const char *value
);
826 void remote_serial_quit_handler ();
828 void remote_detach_pid (int pid
);
830 void remote_vcont_probe ();
832 void remote_resume_with_hc (ptid_t ptid
, int step
,
835 void send_interrupt_sequence ();
836 void interrupt_query ();
838 void remote_notif_get_pending_events (notif_client
*nc
);
840 int fetch_register_using_p (struct regcache
*regcache
,
842 int send_g_packet ();
843 void process_g_packet (struct regcache
*regcache
);
844 void fetch_registers_using_g (struct regcache
*regcache
);
845 int store_register_using_P (const struct regcache
*regcache
,
847 void store_registers_using_G (const struct regcache
*regcache
);
849 void set_remote_traceframe ();
851 void check_binary_download (CORE_ADDR addr
);
853 target_xfer_status
remote_write_bytes_aux (const char *header
,
855 const gdb_byte
*myaddr
,
858 ULONGEST
*xfered_len_units
,
862 target_xfer_status
remote_write_bytes (CORE_ADDR memaddr
,
863 const gdb_byte
*myaddr
, ULONGEST len
,
864 int unit_size
, ULONGEST
*xfered_len
);
866 target_xfer_status
remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
868 int unit_size
, ULONGEST
*xfered_len_units
);
870 target_xfer_status
remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
874 ULONGEST
*xfered_len
);
876 target_xfer_status
remote_read_bytes (CORE_ADDR memaddr
,
877 gdb_byte
*myaddr
, ULONGEST len
,
879 ULONGEST
*xfered_len
);
881 packet_result
remote_send_printf (const char *format
, ...)
882 ATTRIBUTE_PRINTF (2, 3);
884 target_xfer_status
remote_flash_write (ULONGEST address
,
885 ULONGEST length
, ULONGEST
*xfered_len
,
886 const gdb_byte
*data
);
888 int readchar (int timeout
);
890 void remote_serial_write (const char *str
, int len
);
892 int putpkt (const char *buf
);
893 int putpkt_binary (const char *buf
, int cnt
);
895 int putpkt (const gdb::char_vector
&buf
)
897 return putpkt (buf
.data ());
901 long read_frame (gdb::char_vector
*buf_p
);
902 void getpkt (gdb::char_vector
*buf
, int forever
);
903 int getpkt_or_notif_sane_1 (gdb::char_vector
*buf
, int forever
,
904 int expecting_notif
, int *is_notif
);
905 int getpkt_sane (gdb::char_vector
*buf
, int forever
);
906 int getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
908 int remote_vkill (int pid
);
909 void remote_kill_k ();
911 void extended_remote_disable_randomization (int val
);
912 int extended_remote_run (const std::string
&args
);
914 void send_environment_packet (const char *action
,
918 void extended_remote_environment_support ();
919 void extended_remote_set_inferior_cwd ();
921 target_xfer_status
remote_write_qxfer (const char *object_name
,
923 const gdb_byte
*writebuf
,
924 ULONGEST offset
, LONGEST len
,
925 ULONGEST
*xfered_len
,
926 struct packet_config
*packet
);
928 target_xfer_status
remote_read_qxfer (const char *object_name
,
930 gdb_byte
*readbuf
, ULONGEST offset
,
932 ULONGEST
*xfered_len
,
933 struct packet_config
*packet
);
935 void push_stop_reply (struct stop_reply
*new_event
);
937 bool vcont_r_supported ();
939 void packet_command (const char *args
, int from_tty
);
941 private: /* data fields */
943 /* The remote state. Don't reference this directly. Use the
944 get_remote_state method instead. */
945 remote_state m_remote_state
;
948 static const target_info extended_remote_target_info
= {
950 N_("Extended remote serial target in gdb-specific protocol"),
954 /* Set up the extended remote target by extending the standard remote
955 target and adding to it. */
957 class extended_remote_target final
: public remote_target
960 const target_info
&info () const override
961 { return extended_remote_target_info
; }
963 /* Open an extended-remote connection. */
964 static void open (const char *, int);
966 bool can_create_inferior () override
{ return true; }
967 void create_inferior (const char *, const std::string
&,
968 char **, int) override
;
970 void detach (inferior
*, int) override
;
972 bool can_attach () override
{ return true; }
973 void attach (const char *, int) override
;
975 void post_attach (int) override
;
976 bool supports_disable_randomization () override
;
979 /* Per-program-space data key. */
980 static const struct program_space_key
<char, gdb::xfree_deleter
<char>>
983 /* The variable registered as the control variable used by the
984 remote exec-file commands. While the remote exec-file setting is
985 per-program-space, the set/show machinery uses this as the
986 location of the remote exec-file value. */
987 static char *remote_exec_file_var
;
989 /* The size to align memory write packets, when practical. The protocol
990 does not guarantee any alignment, and gdb will generate short
991 writes and unaligned writes, but even as a best-effort attempt this
992 can improve bulk transfers. For instance, if a write is misaligned
993 relative to the target's data bus, the stub may need to make an extra
994 round trip fetching data from the target. This doesn't make a
995 huge difference, but it's easy to do, so we try to be helpful.
997 The alignment chosen is arbitrary; usually data bus width is
998 important here, not the possibly larger cache line size. */
999 enum { REMOTE_ALIGN_WRITES
= 16 };
1001 /* Prototypes for local functions. */
1003 static int hexnumlen (ULONGEST num
);
1005 static int stubhex (int ch
);
1007 static int hexnumstr (char *, ULONGEST
);
1009 static int hexnumnstr (char *, ULONGEST
, int);
1011 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
1013 static void print_packet (const char *);
1015 static int stub_unpack_int (char *buff
, int fieldlength
);
1017 struct packet_config
;
1019 static void show_packet_config_cmd (struct packet_config
*config
);
1021 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
1023 struct cmd_list_element
*c
,
1026 static ptid_t
read_ptid (const char *buf
, const char **obuf
);
1028 static void remote_async_inferior_event_handler (gdb_client_data
);
1030 static bool remote_read_description_p (struct target_ops
*target
);
1032 static void remote_console_output (const char *msg
);
1034 static void remote_btrace_reset (remote_state
*rs
);
1036 static void remote_unpush_and_throw (remote_target
*target
);
1040 static struct cmd_list_element
*remote_cmdlist
;
1042 /* For "set remote" and "show remote". */
1044 static struct cmd_list_element
*remote_set_cmdlist
;
1045 static struct cmd_list_element
*remote_show_cmdlist
;
1047 /* Controls whether GDB is willing to use range stepping. */
1049 static bool use_range_stepping
= true;
1051 /* Private data that we'll store in (struct thread_info)->priv. */
1052 struct remote_thread_info
: public private_thread_info
1058 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1059 sequence of bytes. */
1060 gdb::byte_vector thread_handle
;
1062 /* Whether the target stopped for a breakpoint/watchpoint. */
1063 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1065 /* This is set to the data address of the access causing the target
1066 to stop for a watchpoint. */
1067 CORE_ADDR watch_data_address
= 0;
1069 /* Fields used by the vCont action coalescing implemented in
1070 remote_resume / remote_commit_resume. remote_resume stores each
1071 thread's last resume request in these fields, so that a later
1072 remote_commit_resume knows which is the proper action for this
1073 thread to include in the vCont packet. */
1075 /* True if the last target_resume call for this thread was a step
1076 request, false if a continue request. */
1077 int last_resume_step
= 0;
1079 /* The signal specified in the last target_resume call for this
1081 gdb_signal last_resume_sig
= GDB_SIGNAL_0
;
1083 /* Whether this thread was already vCont-resumed on the remote
1085 int vcont_resumed
= 0;
1088 remote_state::remote_state ()
1093 remote_state::~remote_state ()
1095 xfree (this->last_pass_packet
);
1096 xfree (this->last_program_signals_packet
);
1097 xfree (this->finished_object
);
1098 xfree (this->finished_annex
);
1101 /* Utility: generate error from an incoming stub packet. */
1103 trace_error (char *buf
)
1106 return; /* not an error msg */
1109 case '1': /* malformed packet error */
1110 if (*++buf
== '0') /* general case: */
1111 error (_("remote.c: error in outgoing packet."));
1113 error (_("remote.c: error in outgoing packet at field #%ld."),
1114 strtol (buf
, NULL
, 16));
1116 error (_("Target returns error code '%s'."), buf
);
1120 /* Utility: wait for reply from stub, while accepting "O" packets. */
1123 remote_target::remote_get_noisy_reply ()
1125 struct remote_state
*rs
= get_remote_state ();
1127 do /* Loop on reply from remote stub. */
1131 QUIT
; /* Allow user to bail out with ^C. */
1132 getpkt (&rs
->buf
, 0);
1133 buf
= rs
->buf
.data ();
1136 else if (startswith (buf
, "qRelocInsn:"))
1139 CORE_ADDR from
, to
, org_to
;
1141 int adjusted_size
= 0;
1144 p
= buf
+ strlen ("qRelocInsn:");
1145 pp
= unpack_varlen_hex (p
, &ul
);
1147 error (_("invalid qRelocInsn packet: %s"), buf
);
1151 unpack_varlen_hex (p
, &ul
);
1158 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1161 catch (const gdb_exception
&ex
)
1163 if (ex
.error
== MEMORY_ERROR
)
1165 /* Propagate memory errors silently back to the
1166 target. The stub may have limited the range of
1167 addresses we can write to, for example. */
1171 /* Something unexpectedly bad happened. Be verbose
1172 so we can tell what, and propagate the error back
1173 to the stub, so it doesn't get stuck waiting for
1175 exception_fprintf (gdb_stderr
, ex
,
1176 _("warning: relocating instruction: "));
1183 adjusted_size
= to
- org_to
;
1185 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1189 else if (buf
[0] == 'O' && buf
[1] != 'K')
1190 remote_console_output (buf
+ 1); /* 'O' message from stub */
1192 return buf
; /* Here's the actual reply. */
1197 struct remote_arch_state
*
1198 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1200 remote_arch_state
*rsa
;
1202 auto it
= this->m_arch_states
.find (gdbarch
);
1203 if (it
== this->m_arch_states
.end ())
1205 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1206 std::forward_as_tuple (gdbarch
),
1207 std::forward_as_tuple (gdbarch
));
1208 rsa
= &p
.first
->second
;
1210 /* Make sure that the packet buffer is plenty big enough for
1211 this architecture. */
1212 if (this->buf
.size () < rsa
->remote_packet_size
)
1213 this->buf
.resize (2 * rsa
->remote_packet_size
);
1221 /* Fetch the global remote target state. */
1224 remote_target::get_remote_state ()
1226 /* Make sure that the remote architecture state has been
1227 initialized, because doing so might reallocate rs->buf. Any
1228 function which calls getpkt also needs to be mindful of changes
1229 to rs->buf, but this call limits the number of places which run
1231 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1233 return &m_remote_state
;
1236 /* Fetch the remote exec-file from the current program space. */
1239 get_remote_exec_file (void)
1241 char *remote_exec_file
;
1243 remote_exec_file
= remote_pspace_data
.get (current_program_space
);
1244 if (remote_exec_file
== NULL
)
1247 return remote_exec_file
;
1250 /* Set the remote exec file for PSPACE. */
1253 set_pspace_remote_exec_file (struct program_space
*pspace
,
1254 const char *remote_exec_file
)
1256 char *old_file
= remote_pspace_data
.get (pspace
);
1259 remote_pspace_data
.set (pspace
, xstrdup (remote_exec_file
));
1262 /* The "set/show remote exec-file" set command hook. */
1265 set_remote_exec_file (const char *ignored
, int from_tty
,
1266 struct cmd_list_element
*c
)
1268 gdb_assert (remote_exec_file_var
!= NULL
);
1269 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
1272 /* The "set/show remote exec-file" show command hook. */
1275 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1276 struct cmd_list_element
*cmd
, const char *value
)
1278 fprintf_filtered (file
, "%s\n", get_remote_exec_file ());
1282 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1284 int regnum
, num_remote_regs
, offset
;
1285 struct packet_reg
**remote_regs
;
1287 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1289 struct packet_reg
*r
= ®s
[regnum
];
1291 if (register_size (gdbarch
, regnum
) == 0)
1292 /* Do not try to fetch zero-sized (placeholder) registers. */
1295 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1300 /* Define the g/G packet format as the contents of each register
1301 with a remote protocol number, in order of ascending protocol
1304 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1305 for (num_remote_regs
= 0, regnum
= 0;
1306 regnum
< gdbarch_num_regs (gdbarch
);
1308 if (regs
[regnum
].pnum
!= -1)
1309 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1311 std::sort (remote_regs
, remote_regs
+ num_remote_regs
,
1312 [] (const packet_reg
*a
, const packet_reg
*b
)
1313 { return a
->pnum
< b
->pnum
; });
1315 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1317 remote_regs
[regnum
]->in_g_packet
= 1;
1318 remote_regs
[regnum
]->offset
= offset
;
1319 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1325 /* Given the architecture described by GDBARCH, return the remote
1326 protocol register's number and the register's offset in the g/G
1327 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1328 If the target does not have a mapping for REGNUM, return false,
1329 otherwise, return true. */
1332 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1333 int *pnum
, int *poffset
)
1335 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1337 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1339 map_regcache_remote_table (gdbarch
, regs
.data ());
1341 *pnum
= regs
[regnum
].pnum
;
1342 *poffset
= regs
[regnum
].offset
;
1347 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1349 /* Use the architecture to build a regnum<->pnum table, which will be
1350 1:1 unless a feature set specifies otherwise. */
1351 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1353 /* Record the maximum possible size of the g packet - it may turn out
1355 this->sizeof_g_packet
1356 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1358 /* Default maximum number of characters in a packet body. Many
1359 remote stubs have a hardwired buffer size of 400 bytes
1360 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1361 as the maximum packet-size to ensure that the packet and an extra
1362 NUL character can always fit in the buffer. This stops GDB
1363 trashing stubs that try to squeeze an extra NUL into what is
1364 already a full buffer (As of 1999-12-04 that was most stubs). */
1365 this->remote_packet_size
= 400 - 1;
1367 /* This one is filled in when a ``g'' packet is received. */
1368 this->actual_register_packet_size
= 0;
1370 /* Should rsa->sizeof_g_packet needs more space than the
1371 default, adjust the size accordingly. Remember that each byte is
1372 encoded as two characters. 32 is the overhead for the packet
1373 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1374 (``$NN:G...#NN'') is a better guess, the below has been padded a
1376 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1377 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1380 /* Get a pointer to the current remote target. If not connected to a
1381 remote target, return NULL. */
1383 static remote_target
*
1384 get_current_remote_target ()
1386 target_ops
*proc_target
= current_inferior ()->process_target ();
1387 return dynamic_cast<remote_target
*> (proc_target
);
1390 /* Return the current allowed size of a remote packet. This is
1391 inferred from the current architecture, and should be used to
1392 limit the length of outgoing packets. */
1394 remote_target::get_remote_packet_size ()
1396 struct remote_state
*rs
= get_remote_state ();
1397 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1399 if (rs
->explicit_packet_size
)
1400 return rs
->explicit_packet_size
;
1402 return rsa
->remote_packet_size
;
1405 static struct packet_reg
*
1406 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1409 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1413 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1415 gdb_assert (r
->regnum
== regnum
);
1420 static struct packet_reg
*
1421 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1426 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1428 struct packet_reg
*r
= &rsa
->regs
[i
];
1430 if (r
->pnum
== pnum
)
1436 /* Allow the user to specify what sequence to send to the remote
1437 when he requests a program interruption: Although ^C is usually
1438 what remote systems expect (this is the default, here), it is
1439 sometimes preferable to send a break. On other systems such
1440 as the Linux kernel, a break followed by g, which is Magic SysRq g
1441 is required in order to interrupt the execution. */
1442 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1443 const char interrupt_sequence_break
[] = "BREAK";
1444 const char interrupt_sequence_break_g
[] = "BREAK-g";
1445 static const char *const interrupt_sequence_modes
[] =
1447 interrupt_sequence_control_c
,
1448 interrupt_sequence_break
,
1449 interrupt_sequence_break_g
,
1452 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1455 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1456 struct cmd_list_element
*c
,
1459 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1460 fprintf_filtered (file
,
1461 _("Send the ASCII ETX character (Ctrl-c) "
1462 "to the remote target to interrupt the "
1463 "execution of the program.\n"));
1464 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1465 fprintf_filtered (file
,
1466 _("send a break signal to the remote target "
1467 "to interrupt the execution of the program.\n"));
1468 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1469 fprintf_filtered (file
,
1470 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1471 "the remote target to interrupt the execution "
1472 "of Linux kernel.\n"));
1474 internal_error (__FILE__
, __LINE__
,
1475 _("Invalid value for interrupt_sequence_mode: %s."),
1476 interrupt_sequence_mode
);
1479 /* This boolean variable specifies whether interrupt_sequence is sent
1480 to the remote target when gdb connects to it.
1481 This is mostly needed when you debug the Linux kernel: The Linux kernel
1482 expects BREAK g which is Magic SysRq g for connecting gdb. */
1483 static bool interrupt_on_connect
= false;
1485 /* This variable is used to implement the "set/show remotebreak" commands.
1486 Since these commands are now deprecated in favor of "set/show remote
1487 interrupt-sequence", it no longer has any effect on the code. */
1488 static bool remote_break
;
1491 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1494 interrupt_sequence_mode
= interrupt_sequence_break
;
1496 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1500 show_remotebreak (struct ui_file
*file
, int from_tty
,
1501 struct cmd_list_element
*c
,
1506 /* This variable sets the number of bits in an address that are to be
1507 sent in a memory ("M" or "m") packet. Normally, after stripping
1508 leading zeros, the entire address would be sent. This variable
1509 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1510 initial implementation of remote.c restricted the address sent in
1511 memory packets to ``host::sizeof long'' bytes - (typically 32
1512 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1513 address was never sent. Since fixing this bug may cause a break in
1514 some remote targets this variable is principally provided to
1515 facilitate backward compatibility. */
1517 static unsigned int remote_address_size
;
1520 /* User configurable variables for the number of characters in a
1521 memory read/write packet. MIN (rsa->remote_packet_size,
1522 rsa->sizeof_g_packet) is the default. Some targets need smaller
1523 values (fifo overruns, et.al.) and some users need larger values
1524 (speed up transfers). The variables ``preferred_*'' (the user
1525 request), ``current_*'' (what was actually set) and ``forced_*''
1526 (Positive - a soft limit, negative - a hard limit). */
1528 struct memory_packet_config
1535 /* The default max memory-write-packet-size, when the setting is
1536 "fixed". The 16k is historical. (It came from older GDB's using
1537 alloca for buffers and the knowledge (folklore?) that some hosts
1538 don't cope very well with large alloca calls.) */
1539 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1541 /* The minimum remote packet size for memory transfers. Ensures we
1542 can write at least one byte. */
1543 #define MIN_MEMORY_PACKET_SIZE 20
1545 /* Get the memory packet size, assuming it is fixed. */
1548 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1550 gdb_assert (config
->fixed_p
);
1552 if (config
->size
<= 0)
1553 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1555 return config
->size
;
1558 /* Compute the current size of a read/write packet. Since this makes
1559 use of ``actual_register_packet_size'' the computation is dynamic. */
1562 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1564 struct remote_state
*rs
= get_remote_state ();
1565 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1568 if (config
->fixed_p
)
1569 what_they_get
= get_fixed_memory_packet_size (config
);
1572 what_they_get
= get_remote_packet_size ();
1573 /* Limit the packet to the size specified by the user. */
1574 if (config
->size
> 0
1575 && what_they_get
> config
->size
)
1576 what_they_get
= config
->size
;
1578 /* Limit it to the size of the targets ``g'' response unless we have
1579 permission from the stub to use a larger packet size. */
1580 if (rs
->explicit_packet_size
== 0
1581 && rsa
->actual_register_packet_size
> 0
1582 && what_they_get
> rsa
->actual_register_packet_size
)
1583 what_they_get
= rsa
->actual_register_packet_size
;
1585 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1586 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1588 /* Make sure there is room in the global buffer for this packet
1589 (including its trailing NUL byte). */
1590 if (rs
->buf
.size () < what_they_get
+ 1)
1591 rs
->buf
.resize (2 * what_they_get
);
1593 return what_they_get
;
1596 /* Update the size of a read/write packet. If they user wants
1597 something really big then do a sanity check. */
1600 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1602 int fixed_p
= config
->fixed_p
;
1603 long size
= config
->size
;
1606 error (_("Argument required (integer, `fixed' or `limited')."));
1607 else if (strcmp (args
, "hard") == 0
1608 || strcmp (args
, "fixed") == 0)
1610 else if (strcmp (args
, "soft") == 0
1611 || strcmp (args
, "limit") == 0)
1617 size
= strtoul (args
, &end
, 0);
1619 error (_("Invalid %s (bad syntax)."), config
->name
);
1621 /* Instead of explicitly capping the size of a packet to or
1622 disallowing it, the user is allowed to set the size to
1623 something arbitrarily large. */
1627 if (fixed_p
&& !config
->fixed_p
)
1629 /* So that the query shows the correct value. */
1630 long query_size
= (size
<= 0
1631 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1634 if (! query (_("The target may not be able to correctly handle a %s\n"
1635 "of %ld bytes. Change the packet size? "),
1636 config
->name
, query_size
))
1637 error (_("Packet size not changed."));
1639 /* Update the config. */
1640 config
->fixed_p
= fixed_p
;
1641 config
->size
= size
;
1645 show_memory_packet_size (struct memory_packet_config
*config
)
1647 if (config
->size
== 0)
1648 printf_filtered (_("The %s is 0 (default). "), config
->name
);
1650 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1651 if (config
->fixed_p
)
1652 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1653 get_fixed_memory_packet_size (config
));
1656 remote_target
*remote
= get_current_remote_target ();
1659 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1660 remote
->get_memory_packet_size (config
));
1662 puts_filtered ("The actual limit will be further reduced "
1663 "dependent on the target.\n");
1667 /* FIXME: needs to be per-remote-target. */
1668 static struct memory_packet_config memory_write_packet_config
=
1670 "memory-write-packet-size",
1674 set_memory_write_packet_size (const char *args
, int from_tty
)
1676 set_memory_packet_size (args
, &memory_write_packet_config
);
1680 show_memory_write_packet_size (const char *args
, int from_tty
)
1682 show_memory_packet_size (&memory_write_packet_config
);
1685 /* Show the number of hardware watchpoints that can be used. */
1688 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1689 struct cmd_list_element
*c
,
1692 fprintf_filtered (file
, _("The maximum number of target hardware "
1693 "watchpoints is %s.\n"), value
);
1696 /* Show the length limit (in bytes) for hardware watchpoints. */
1699 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1700 struct cmd_list_element
*c
,
1703 fprintf_filtered (file
, _("The maximum length (in bytes) of a target "
1704 "hardware watchpoint is %s.\n"), value
);
1707 /* Show the number of hardware breakpoints that can be used. */
1710 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1711 struct cmd_list_element
*c
,
1714 fprintf_filtered (file
, _("The maximum number of target hardware "
1715 "breakpoints is %s.\n"), value
);
1718 /* Controls the maximum number of characters to display in the debug output
1719 for each remote packet. The remaining characters are omitted. */
1721 static int remote_packet_max_chars
= 512;
1723 /* Show the maximum number of characters to display for each remote packet
1724 when remote debugging is enabled. */
1727 show_remote_packet_max_chars (struct ui_file
*file
, int from_tty
,
1728 struct cmd_list_element
*c
,
1731 fprintf_filtered (file
, _("Number of remote packet characters to "
1732 "display is %s.\n"), value
);
1736 remote_target::get_memory_write_packet_size ()
1738 return get_memory_packet_size (&memory_write_packet_config
);
1741 /* FIXME: needs to be per-remote-target. */
1742 static struct memory_packet_config memory_read_packet_config
=
1744 "memory-read-packet-size",
1748 set_memory_read_packet_size (const char *args
, int from_tty
)
1750 set_memory_packet_size (args
, &memory_read_packet_config
);
1754 show_memory_read_packet_size (const char *args
, int from_tty
)
1756 show_memory_packet_size (&memory_read_packet_config
);
1760 remote_target::get_memory_read_packet_size ()
1762 long size
= get_memory_packet_size (&memory_read_packet_config
);
1764 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1765 extra buffer size argument before the memory read size can be
1766 increased beyond this. */
1767 if (size
> get_remote_packet_size ())
1768 size
= get_remote_packet_size ();
1774 struct packet_config
1779 /* If auto, GDB auto-detects support for this packet or feature,
1780 either through qSupported, or by trying the packet and looking
1781 at the response. If true, GDB assumes the target supports this
1782 packet. If false, the packet is disabled. Configs that don't
1783 have an associated command always have this set to auto. */
1784 enum auto_boolean detect
;
1786 /* Does the target support this packet? */
1787 enum packet_support support
;
1790 static enum packet_support
packet_config_support (struct packet_config
*config
);
1791 static enum packet_support
packet_support (int packet
);
1794 show_packet_config_cmd (struct packet_config
*config
)
1796 const char *support
= "internal-error";
1798 switch (packet_config_support (config
))
1801 support
= "enabled";
1803 case PACKET_DISABLE
:
1804 support
= "disabled";
1806 case PACKET_SUPPORT_UNKNOWN
:
1807 support
= "unknown";
1810 switch (config
->detect
)
1812 case AUTO_BOOLEAN_AUTO
:
1813 printf_filtered (_("Support for the `%s' packet "
1814 "is auto-detected, currently %s.\n"),
1815 config
->name
, support
);
1817 case AUTO_BOOLEAN_TRUE
:
1818 case AUTO_BOOLEAN_FALSE
:
1819 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1820 config
->name
, support
);
1826 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1827 const char *title
, int legacy
)
1833 config
->name
= name
;
1834 config
->title
= title
;
1835 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1837 show_doc
= xstrprintf ("Show current use of remote "
1838 "protocol `%s' (%s) packet.",
1840 /* set/show TITLE-packet {auto,on,off} */
1841 cmd_name
= xstrprintf ("%s-packet", title
);
1842 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1843 &config
->detect
, set_doc
,
1844 show_doc
, NULL
, /* help_doc */
1846 show_remote_protocol_packet_cmd
,
1847 &remote_set_cmdlist
, &remote_show_cmdlist
);
1848 /* The command code copies the documentation strings. */
1851 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1856 legacy_name
= xstrprintf ("%s-packet", name
);
1857 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1858 &remote_set_cmdlist
);
1859 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1860 &remote_show_cmdlist
);
1864 static enum packet_result
1865 packet_check_result (const char *buf
)
1869 /* The stub recognized the packet request. Check that the
1870 operation succeeded. */
1872 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1874 /* "Enn" - definitely an error. */
1875 return PACKET_ERROR
;
1877 /* Always treat "E." as an error. This will be used for
1878 more verbose error messages, such as E.memtypes. */
1879 if (buf
[0] == 'E' && buf
[1] == '.')
1880 return PACKET_ERROR
;
1882 /* The packet may or may not be OK. Just assume it is. */
1886 /* The stub does not support the packet. */
1887 return PACKET_UNKNOWN
;
1890 static enum packet_result
1891 packet_check_result (const gdb::char_vector
&buf
)
1893 return packet_check_result (buf
.data ());
1896 static enum packet_result
1897 packet_ok (const char *buf
, struct packet_config
*config
)
1899 enum packet_result result
;
1901 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1902 && config
->support
== PACKET_DISABLE
)
1903 internal_error (__FILE__
, __LINE__
,
1904 _("packet_ok: attempt to use a disabled packet"));
1906 result
= packet_check_result (buf
);
1911 /* The stub recognized the packet request. */
1912 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1915 fprintf_unfiltered (gdb_stdlog
,
1916 "Packet %s (%s) is supported\n",
1917 config
->name
, config
->title
);
1918 config
->support
= PACKET_ENABLE
;
1921 case PACKET_UNKNOWN
:
1922 /* The stub does not support the packet. */
1923 if (config
->detect
== AUTO_BOOLEAN_AUTO
1924 && config
->support
== PACKET_ENABLE
)
1926 /* If the stub previously indicated that the packet was
1927 supported then there is a protocol error. */
1928 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1929 config
->name
, config
->title
);
1931 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
1933 /* The user set it wrong. */
1934 error (_("Enabled packet %s (%s) not recognized by stub"),
1935 config
->name
, config
->title
);
1939 fprintf_unfiltered (gdb_stdlog
,
1940 "Packet %s (%s) is NOT supported\n",
1941 config
->name
, config
->title
);
1942 config
->support
= PACKET_DISABLE
;
1949 static enum packet_result
1950 packet_ok (const gdb::char_vector
&buf
, struct packet_config
*config
)
1952 return packet_ok (buf
.data (), config
);
1969 PACKET_vFile_pwrite
,
1971 PACKET_vFile_unlink
,
1972 PACKET_vFile_readlink
,
1975 PACKET_qXfer_features
,
1976 PACKET_qXfer_exec_file
,
1977 PACKET_qXfer_libraries
,
1978 PACKET_qXfer_libraries_svr4
,
1979 PACKET_qXfer_memory_map
,
1980 PACKET_qXfer_osdata
,
1981 PACKET_qXfer_threads
,
1982 PACKET_qXfer_statictrace_read
,
1983 PACKET_qXfer_traceframe_info
,
1989 PACKET_QPassSignals
,
1990 PACKET_QCatchSyscalls
,
1991 PACKET_QProgramSignals
,
1992 PACKET_QSetWorkingDir
,
1993 PACKET_QStartupWithShell
,
1994 PACKET_QEnvironmentHexEncoded
,
1995 PACKET_QEnvironmentReset
,
1996 PACKET_QEnvironmentUnset
,
1998 PACKET_qSearch_memory
,
2001 PACKET_QStartNoAckMode
,
2003 PACKET_qXfer_siginfo_read
,
2004 PACKET_qXfer_siginfo_write
,
2007 /* Support for conditional tracepoints. */
2008 PACKET_ConditionalTracepoints
,
2010 /* Support for target-side breakpoint conditions. */
2011 PACKET_ConditionalBreakpoints
,
2013 /* Support for target-side breakpoint commands. */
2014 PACKET_BreakpointCommands
,
2016 /* Support for fast tracepoints. */
2017 PACKET_FastTracepoints
,
2019 /* Support for static tracepoints. */
2020 PACKET_StaticTracepoints
,
2022 /* Support for installing tracepoints while a trace experiment is
2024 PACKET_InstallInTrace
,
2028 PACKET_TracepointSource
,
2031 PACKET_QDisableRandomization
,
2033 PACKET_QTBuffer_size
,
2037 PACKET_qXfer_btrace
,
2039 /* Support for the QNonStop packet. */
2042 /* Support for the QThreadEvents packet. */
2043 PACKET_QThreadEvents
,
2045 /* Support for multi-process extensions. */
2046 PACKET_multiprocess_feature
,
2048 /* Support for enabling and disabling tracepoints while a trace
2049 experiment is running. */
2050 PACKET_EnableDisableTracepoints_feature
,
2052 /* Support for collecting strings using the tracenz bytecode. */
2053 PACKET_tracenz_feature
,
2055 /* Support for continuing to run a trace experiment while GDB is
2057 PACKET_DisconnectedTracing_feature
,
2059 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2060 PACKET_augmented_libraries_svr4_read_feature
,
2062 /* Support for the qXfer:btrace-conf:read packet. */
2063 PACKET_qXfer_btrace_conf
,
2065 /* Support for the Qbtrace-conf:bts:size packet. */
2066 PACKET_Qbtrace_conf_bts_size
,
2068 /* Support for swbreak+ feature. */
2069 PACKET_swbreak_feature
,
2071 /* Support for hwbreak+ feature. */
2072 PACKET_hwbreak_feature
,
2074 /* Support for fork events. */
2075 PACKET_fork_event_feature
,
2077 /* Support for vfork events. */
2078 PACKET_vfork_event_feature
,
2080 /* Support for the Qbtrace-conf:pt:size packet. */
2081 PACKET_Qbtrace_conf_pt_size
,
2083 /* Support for exec events. */
2084 PACKET_exec_event_feature
,
2086 /* Support for query supported vCont actions. */
2087 PACKET_vContSupported
,
2089 /* Support remote CTRL-C. */
2092 /* Support TARGET_WAITKIND_NO_RESUMED. */
2098 /* FIXME: needs to be per-remote-target. Ignoring this for now,
2099 assuming all remote targets are the same server (thus all support
2100 the same packets). */
2101 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
2103 /* Returns the packet's corresponding "set remote foo-packet" command
2104 state. See struct packet_config for more details. */
2106 static enum auto_boolean
2107 packet_set_cmd_state (int packet
)
2109 return remote_protocol_packets
[packet
].detect
;
2112 /* Returns whether a given packet or feature is supported. This takes
2113 into account the state of the corresponding "set remote foo-packet"
2114 command, which may be used to bypass auto-detection. */
2116 static enum packet_support
2117 packet_config_support (struct packet_config
*config
)
2119 switch (config
->detect
)
2121 case AUTO_BOOLEAN_TRUE
:
2122 return PACKET_ENABLE
;
2123 case AUTO_BOOLEAN_FALSE
:
2124 return PACKET_DISABLE
;
2125 case AUTO_BOOLEAN_AUTO
:
2126 return config
->support
;
2128 gdb_assert_not_reached (_("bad switch"));
2132 /* Same as packet_config_support, but takes the packet's enum value as
2135 static enum packet_support
2136 packet_support (int packet
)
2138 struct packet_config
*config
= &remote_protocol_packets
[packet
];
2140 return packet_config_support (config
);
2144 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
2145 struct cmd_list_element
*c
,
2148 struct packet_config
*packet
;
2150 for (packet
= remote_protocol_packets
;
2151 packet
< &remote_protocol_packets
[PACKET_MAX
];
2154 if (&packet
->detect
== c
->var
)
2156 show_packet_config_cmd (packet
);
2160 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
2164 /* Should we try one of the 'Z' requests? */
2168 Z_PACKET_SOFTWARE_BP
,
2169 Z_PACKET_HARDWARE_BP
,
2176 /* For compatibility with older distributions. Provide a ``set remote
2177 Z-packet ...'' command that updates all the Z packet types. */
2179 static enum auto_boolean remote_Z_packet_detect
;
2182 set_remote_protocol_Z_packet_cmd (const char *args
, int from_tty
,
2183 struct cmd_list_element
*c
)
2187 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2188 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
2192 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
2193 struct cmd_list_element
*c
,
2198 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2200 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
2204 /* Returns true if the multi-process extensions are in effect. */
2207 remote_multi_process_p (struct remote_state
*rs
)
2209 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
2212 /* Returns true if fork events are supported. */
2215 remote_fork_event_p (struct remote_state
*rs
)
2217 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
2220 /* Returns true if vfork events are supported. */
2223 remote_vfork_event_p (struct remote_state
*rs
)
2225 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
2228 /* Returns true if exec events are supported. */
2231 remote_exec_event_p (struct remote_state
*rs
)
2233 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
2236 /* Insert fork catchpoint target routine. If fork events are enabled
2237 then return success, nothing more to do. */
2240 remote_target::insert_fork_catchpoint (int pid
)
2242 struct remote_state
*rs
= get_remote_state ();
2244 return !remote_fork_event_p (rs
);
2247 /* Remove fork catchpoint target routine. Nothing to do, just
2251 remote_target::remove_fork_catchpoint (int pid
)
2256 /* Insert vfork catchpoint target routine. If vfork events are enabled
2257 then return success, nothing more to do. */
2260 remote_target::insert_vfork_catchpoint (int pid
)
2262 struct remote_state
*rs
= get_remote_state ();
2264 return !remote_vfork_event_p (rs
);
2267 /* Remove vfork catchpoint target routine. Nothing to do, just
2271 remote_target::remove_vfork_catchpoint (int pid
)
2276 /* Insert exec catchpoint target routine. If exec events are
2277 enabled, just return success. */
2280 remote_target::insert_exec_catchpoint (int pid
)
2282 struct remote_state
*rs
= get_remote_state ();
2284 return !remote_exec_event_p (rs
);
2287 /* Remove exec catchpoint target routine. Nothing to do, just
2291 remote_target::remove_exec_catchpoint (int pid
)
2298 /* Take advantage of the fact that the TID field is not used, to tag
2299 special ptids with it set to != 0. */
2300 static const ptid_t
magic_null_ptid (42000, -1, 1);
2301 static const ptid_t
not_sent_ptid (42000, -2, 1);
2302 static const ptid_t
any_thread_ptid (42000, 0, 1);
2304 /* Find out if the stub attached to PID (and hence GDB should offer to
2305 detach instead of killing it when bailing out). */
2308 remote_target::remote_query_attached (int pid
)
2310 struct remote_state
*rs
= get_remote_state ();
2311 size_t size
= get_remote_packet_size ();
2313 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
2316 if (remote_multi_process_p (rs
))
2317 xsnprintf (rs
->buf
.data (), size
, "qAttached:%x", pid
);
2319 xsnprintf (rs
->buf
.data (), size
, "qAttached");
2322 getpkt (&rs
->buf
, 0);
2324 switch (packet_ok (rs
->buf
,
2325 &remote_protocol_packets
[PACKET_qAttached
]))
2328 if (strcmp (rs
->buf
.data (), "1") == 0)
2332 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
2334 case PACKET_UNKNOWN
:
2341 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2342 has been invented by GDB, instead of reported by the target. Since
2343 we can be connected to a remote system before before knowing about
2344 any inferior, mark the target with execution when we find the first
2345 inferior. If ATTACHED is 1, then we had just attached to this
2346 inferior. If it is 0, then we just created this inferior. If it
2347 is -1, then try querying the remote stub to find out if it had
2348 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2349 attempt to open this inferior's executable as the main executable
2350 if no main executable is open already. */
2353 remote_target::remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
2356 struct inferior
*inf
;
2358 /* Check whether this process we're learning about is to be
2359 considered attached, or if is to be considered to have been
2360 spawned by the stub. */
2362 attached
= remote_query_attached (pid
);
2364 if (gdbarch_has_global_solist (target_gdbarch ()))
2366 /* If the target shares code across all inferiors, then every
2367 attach adds a new inferior. */
2368 inf
= add_inferior (pid
);
2370 /* ... and every inferior is bound to the same program space.
2371 However, each inferior may still have its own address
2373 inf
->aspace
= maybe_new_address_space ();
2374 inf
->pspace
= current_program_space
;
2378 /* In the traditional debugging scenario, there's a 1-1 match
2379 between program/address spaces. We simply bind the inferior
2380 to the program space's address space. */
2381 inf
= current_inferior ();
2383 /* However, if the current inferior is already bound to a
2384 process, find some other empty inferior. */
2388 for (inferior
*it
: all_inferiors ())
2397 /* Since all inferiors were already bound to a process, add
2399 inf
= add_inferior_with_spaces ();
2401 switch_to_inferior_no_thread (inf
);
2403 inferior_appeared (inf
, pid
);
2406 inf
->attach_flag
= attached
;
2407 inf
->fake_pid_p
= fake_pid_p
;
2409 /* If no main executable is currently open then attempt to
2410 open the file that was executed to create this inferior. */
2411 if (try_open_exec
&& get_exec_file (0) == NULL
)
2412 exec_file_locate_attach (pid
, 0, 1);
2414 /* Check for exec file mismatch, and let the user solve it. */
2415 validate_exec_file (1);
2420 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2421 static remote_thread_info
*get_remote_thread_info (remote_target
*target
,
2424 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2425 according to RUNNING. */
2428 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
)
2430 struct remote_state
*rs
= get_remote_state ();
2431 struct thread_info
*thread
;
2433 /* GDB historically didn't pull threads in the initial connection
2434 setup. If the remote target doesn't even have a concept of
2435 threads (e.g., a bare-metal target), even if internally we
2436 consider that a single-threaded target, mentioning a new thread
2437 might be confusing to the user. Be silent then, preserving the
2438 age old behavior. */
2439 if (rs
->starting_up
)
2440 thread
= add_thread_silent (this, ptid
);
2442 thread
= add_thread (this, ptid
);
2444 get_remote_thread_info (thread
)->vcont_resumed
= executing
;
2445 set_executing (this, ptid
, executing
);
2446 set_running (this, ptid
, running
);
2451 /* Come here when we learn about a thread id from the remote target.
2452 It may be the first time we hear about such thread, so take the
2453 opportunity to add it to GDB's thread list. In case this is the
2454 first time we're noticing its corresponding inferior, add it to
2455 GDB's inferior list as well. EXECUTING indicates whether the
2456 thread is (internally) executing or stopped. */
2459 remote_target::remote_notice_new_inferior (ptid_t currthread
, int executing
)
2461 /* In non-stop mode, we assume new found threads are (externally)
2462 running until proven otherwise with a stop reply. In all-stop,
2463 we can only get here if all threads are stopped. */
2464 int running
= target_is_non_stop_p () ? 1 : 0;
2466 /* If this is a new thread, add it to GDB's thread list.
2467 If we leave it up to WFI to do this, bad things will happen. */
2469 thread_info
*tp
= find_thread_ptid (this, currthread
);
2470 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2472 /* We're seeing an event on a thread id we knew had exited.
2473 This has to be a new thread reusing the old id. Add it. */
2474 remote_add_thread (currthread
, running
, executing
);
2478 if (!in_thread_list (this, currthread
))
2480 struct inferior
*inf
= NULL
;
2481 int pid
= currthread
.pid ();
2483 if (inferior_ptid
.is_pid ()
2484 && pid
== inferior_ptid
.pid ())
2486 /* inferior_ptid has no thread member yet. This can happen
2487 with the vAttach -> remote_wait,"TAAthread:" path if the
2488 stub doesn't support qC. This is the first stop reported
2489 after an attach, so this is the main thread. Update the
2490 ptid in the thread list. */
2491 if (in_thread_list (this, ptid_t (pid
)))
2492 thread_change_ptid (this, inferior_ptid
, currthread
);
2495 remote_add_thread (currthread
, running
, executing
);
2496 inferior_ptid
= currthread
;
2501 if (magic_null_ptid
== inferior_ptid
)
2503 /* inferior_ptid is not set yet. This can happen with the
2504 vRun -> remote_wait,"TAAthread:" path if the stub
2505 doesn't support qC. This is the first stop reported
2506 after an attach, so this is the main thread. Update the
2507 ptid in the thread list. */
2508 thread_change_ptid (this, inferior_ptid
, currthread
);
2512 /* When connecting to a target remote, or to a target
2513 extended-remote which already was debugging an inferior, we
2514 may not know about it yet. Add it before adding its child
2515 thread, so notifications are emitted in a sensible order. */
2516 if (find_inferior_pid (this, currthread
.pid ()) == NULL
)
2518 struct remote_state
*rs
= get_remote_state ();
2519 bool fake_pid_p
= !remote_multi_process_p (rs
);
2521 inf
= remote_add_inferior (fake_pid_p
,
2522 currthread
.pid (), -1, 1);
2525 /* This is really a new thread. Add it. */
2526 thread_info
*new_thr
2527 = remote_add_thread (currthread
, running
, executing
);
2529 /* If we found a new inferior, let the common code do whatever
2530 it needs to with it (e.g., read shared libraries, insert
2531 breakpoints), unless we're just setting up an all-stop
2535 struct remote_state
*rs
= get_remote_state ();
2537 if (!rs
->starting_up
)
2538 notice_new_inferior (new_thr
, executing
, 0);
2543 /* Return THREAD's private thread data, creating it if necessary. */
2545 static remote_thread_info
*
2546 get_remote_thread_info (thread_info
*thread
)
2548 gdb_assert (thread
!= NULL
);
2550 if (thread
->priv
== NULL
)
2551 thread
->priv
.reset (new remote_thread_info
);
2553 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2556 /* Return PTID's private thread data, creating it if necessary. */
2558 static remote_thread_info
*
2559 get_remote_thread_info (remote_target
*target
, ptid_t ptid
)
2561 thread_info
*thr
= find_thread_ptid (target
, ptid
);
2562 return get_remote_thread_info (thr
);
2565 /* Call this function as a result of
2566 1) A halt indication (T packet) containing a thread id
2567 2) A direct query of currthread
2568 3) Successful execution of set thread */
2571 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2573 rs
->general_thread
= currthread
;
2576 /* If 'QPassSignals' is supported, tell the remote stub what signals
2577 it can simply pass through to the inferior without reporting. */
2580 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2582 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2584 char *pass_packet
, *p
;
2586 struct remote_state
*rs
= get_remote_state ();
2588 gdb_assert (pass_signals
.size () < 256);
2589 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2591 if (pass_signals
[i
])
2594 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2595 strcpy (pass_packet
, "QPassSignals:");
2596 p
= pass_packet
+ strlen (pass_packet
);
2597 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2599 if (pass_signals
[i
])
2602 *p
++ = tohex (i
>> 4);
2603 *p
++ = tohex (i
& 15);
2612 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2614 putpkt (pass_packet
);
2615 getpkt (&rs
->buf
, 0);
2616 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2617 if (rs
->last_pass_packet
)
2618 xfree (rs
->last_pass_packet
);
2619 rs
->last_pass_packet
= pass_packet
;
2622 xfree (pass_packet
);
2626 /* If 'QCatchSyscalls' is supported, tell the remote stub
2627 to report syscalls to GDB. */
2630 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2631 gdb::array_view
<const int> syscall_counts
)
2633 const char *catch_packet
;
2634 enum packet_result result
;
2637 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2639 /* Not supported. */
2643 if (needed
&& any_count
== 0)
2645 /* Count how many syscalls are to be caught. */
2646 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2648 if (syscall_counts
[i
] != 0)
2655 fprintf_unfiltered (gdb_stdlog
,
2656 "remote_set_syscall_catchpoint "
2657 "pid %d needed %d any_count %d n_sysno %d\n",
2658 pid
, needed
, any_count
, n_sysno
);
2661 std::string built_packet
;
2664 /* Prepare a packet with the sysno list, assuming max 8+1
2665 characters for a sysno. If the resulting packet size is too
2666 big, fallback on the non-selective packet. */
2667 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2668 built_packet
.reserve (maxpktsz
);
2669 built_packet
= "QCatchSyscalls:1";
2672 /* Add in each syscall to be caught. */
2673 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2675 if (syscall_counts
[i
] != 0)
2676 string_appendf (built_packet
, ";%zx", i
);
2679 if (built_packet
.size () > get_remote_packet_size ())
2681 /* catch_packet too big. Fallback to less efficient
2682 non selective mode, with GDB doing the filtering. */
2683 catch_packet
= "QCatchSyscalls:1";
2686 catch_packet
= built_packet
.c_str ();
2689 catch_packet
= "QCatchSyscalls:0";
2691 struct remote_state
*rs
= get_remote_state ();
2693 putpkt (catch_packet
);
2694 getpkt (&rs
->buf
, 0);
2695 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2696 if (result
== PACKET_OK
)
2702 /* If 'QProgramSignals' is supported, tell the remote stub what
2703 signals it should pass through to the inferior when detaching. */
2706 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2708 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2712 struct remote_state
*rs
= get_remote_state ();
2714 gdb_assert (signals
.size () < 256);
2715 for (size_t i
= 0; i
< signals
.size (); i
++)
2720 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2721 strcpy (packet
, "QProgramSignals:");
2722 p
= packet
+ strlen (packet
);
2723 for (size_t i
= 0; i
< signals
.size (); i
++)
2725 if (signal_pass_state (i
))
2728 *p
++ = tohex (i
>> 4);
2729 *p
++ = tohex (i
& 15);
2738 if (!rs
->last_program_signals_packet
2739 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2742 getpkt (&rs
->buf
, 0);
2743 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2744 xfree (rs
->last_program_signals_packet
);
2745 rs
->last_program_signals_packet
= packet
;
2752 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2753 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2754 thread. If GEN is set, set the general thread, if not, then set
2755 the step/continue thread. */
2757 remote_target::set_thread (ptid_t ptid
, int gen
)
2759 struct remote_state
*rs
= get_remote_state ();
2760 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2761 char *buf
= rs
->buf
.data ();
2762 char *endbuf
= buf
+ get_remote_packet_size ();
2768 *buf
++ = gen
? 'g' : 'c';
2769 if (ptid
== magic_null_ptid
)
2770 xsnprintf (buf
, endbuf
- buf
, "0");
2771 else if (ptid
== any_thread_ptid
)
2772 xsnprintf (buf
, endbuf
- buf
, "0");
2773 else if (ptid
== minus_one_ptid
)
2774 xsnprintf (buf
, endbuf
- buf
, "-1");
2776 write_ptid (buf
, endbuf
, ptid
);
2778 getpkt (&rs
->buf
, 0);
2780 rs
->general_thread
= ptid
;
2782 rs
->continue_thread
= ptid
;
2786 remote_target::set_general_thread (ptid_t ptid
)
2788 set_thread (ptid
, 1);
2792 remote_target::set_continue_thread (ptid_t ptid
)
2794 set_thread (ptid
, 0);
2797 /* Change the remote current process. Which thread within the process
2798 ends up selected isn't important, as long as it is the same process
2799 as what INFERIOR_PTID points to.
2801 This comes from that fact that there is no explicit notion of
2802 "selected process" in the protocol. The selected process for
2803 general operations is the process the selected general thread
2807 remote_target::set_general_process ()
2809 struct remote_state
*rs
= get_remote_state ();
2811 /* If the remote can't handle multiple processes, don't bother. */
2812 if (!remote_multi_process_p (rs
))
2815 /* We only need to change the remote current thread if it's pointing
2816 at some other process. */
2817 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2818 set_general_thread (inferior_ptid
);
2822 /* Return nonzero if this is the main thread that we made up ourselves
2823 to model non-threaded targets as single-threaded. */
2826 remote_thread_always_alive (ptid_t ptid
)
2828 if (ptid
== magic_null_ptid
)
2829 /* The main thread is always alive. */
2832 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2833 /* The main thread is always alive. This can happen after a
2834 vAttach, if the remote side doesn't support
2841 /* Return nonzero if the thread PTID is still alive on the remote
2845 remote_target::thread_alive (ptid_t ptid
)
2847 struct remote_state
*rs
= get_remote_state ();
2850 /* Check if this is a thread that we made up ourselves to model
2851 non-threaded targets as single-threaded. */
2852 if (remote_thread_always_alive (ptid
))
2855 p
= rs
->buf
.data ();
2856 endp
= p
+ get_remote_packet_size ();
2859 write_ptid (p
, endp
, ptid
);
2862 getpkt (&rs
->buf
, 0);
2863 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2866 /* Return a pointer to a thread name if we know it and NULL otherwise.
2867 The thread_info object owns the memory for the name. */
2870 remote_target::thread_name (struct thread_info
*info
)
2872 if (info
->priv
!= NULL
)
2874 const std::string
&name
= get_remote_thread_info (info
)->name
;
2875 return !name
.empty () ? name
.c_str () : NULL
;
2881 /* About these extended threadlist and threadinfo packets. They are
2882 variable length packets but, the fields within them are often fixed
2883 length. They are redundant enough to send over UDP as is the
2884 remote protocol in general. There is a matching unit test module
2887 /* WARNING: This threadref data structure comes from the remote O.S.,
2888 libstub protocol encoding, and remote.c. It is not particularly
2891 /* Right now, the internal structure is int. We want it to be bigger.
2892 Plan to fix this. */
2894 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2896 /* gdb_ext_thread_info is an internal GDB data structure which is
2897 equivalent to the reply of the remote threadinfo packet. */
2899 struct gdb_ext_thread_info
2901 threadref threadid
; /* External form of thread reference. */
2902 int active
; /* Has state interesting to GDB?
2904 char display
[256]; /* Brief state display, name,
2905 blocked/suspended. */
2906 char shortname
[32]; /* To be used to name threads. */
2907 char more_display
[256]; /* Long info, statistics, queue depth,
2911 /* The volume of remote transfers can be limited by submitting
2912 a mask containing bits specifying the desired information.
2913 Use a union of these values as the 'selection' parameter to
2914 get_thread_info. FIXME: Make these TAG names more thread specific. */
2916 #define TAG_THREADID 1
2917 #define TAG_EXISTS 2
2918 #define TAG_DISPLAY 4
2919 #define TAG_THREADNAME 8
2920 #define TAG_MOREDISPLAY 16
2922 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2924 static char *unpack_nibble (char *buf
, int *val
);
2926 static char *unpack_byte (char *buf
, int *value
);
2928 static char *pack_int (char *buf
, int value
);
2930 static char *unpack_int (char *buf
, int *value
);
2932 static char *unpack_string (char *src
, char *dest
, int length
);
2934 static char *pack_threadid (char *pkt
, threadref
*id
);
2936 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2938 void int_to_threadref (threadref
*id
, int value
);
2940 static int threadref_to_int (threadref
*ref
);
2942 static void copy_threadref (threadref
*dest
, threadref
*src
);
2944 static int threadmatch (threadref
*dest
, threadref
*src
);
2946 static char *pack_threadinfo_request (char *pkt
, int mode
,
2949 static char *pack_threadlist_request (char *pkt
, int startflag
,
2951 threadref
*nextthread
);
2953 static int remote_newthread_step (threadref
*ref
, void *context
);
2956 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2957 buffer we're allowed to write to. Returns
2958 BUF+CHARACTERS_WRITTEN. */
2961 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2964 struct remote_state
*rs
= get_remote_state ();
2966 if (remote_multi_process_p (rs
))
2970 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2972 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2976 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2978 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2983 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2984 last parsed char. Returns null_ptid if no thread id is found, and
2985 throws an error if the thread id has an invalid format. */
2988 read_ptid (const char *buf
, const char **obuf
)
2990 const char *p
= buf
;
2992 ULONGEST pid
= 0, tid
= 0;
2996 /* Multi-process ptid. */
2997 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2999 error (_("invalid remote ptid: %s"), p
);
3002 pp
= unpack_varlen_hex (p
+ 1, &tid
);
3005 return ptid_t (pid
, tid
, 0);
3008 /* No multi-process. Just a tid. */
3009 pp
= unpack_varlen_hex (p
, &tid
);
3011 /* Return null_ptid when no thread id is found. */
3019 /* Since the stub is not sending a process id, then default to
3020 what's in inferior_ptid, unless it's null at this point. If so,
3021 then since there's no way to know the pid of the reported
3022 threads, use the magic number. */
3023 if (inferior_ptid
== null_ptid
)
3024 pid
= magic_null_ptid
.pid ();
3026 pid
= inferior_ptid
.pid ();
3030 return ptid_t (pid
, tid
, 0);
3036 if (ch
>= 'a' && ch
<= 'f')
3037 return ch
- 'a' + 10;
3038 if (ch
>= '0' && ch
<= '9')
3040 if (ch
>= 'A' && ch
<= 'F')
3041 return ch
- 'A' + 10;
3046 stub_unpack_int (char *buff
, int fieldlength
)
3053 nibble
= stubhex (*buff
++);
3057 retval
= retval
<< 4;
3063 unpack_nibble (char *buf
, int *val
)
3065 *val
= fromhex (*buf
++);
3070 unpack_byte (char *buf
, int *value
)
3072 *value
= stub_unpack_int (buf
, 2);
3077 pack_int (char *buf
, int value
)
3079 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3080 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3081 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3082 buf
= pack_hex_byte (buf
, (value
& 0xff));
3087 unpack_int (char *buf
, int *value
)
3089 *value
= stub_unpack_int (buf
, 8);
3093 #if 0 /* Currently unused, uncomment when needed. */
3094 static char *pack_string (char *pkt
, char *string
);
3097 pack_string (char *pkt
, char *string
)
3102 len
= strlen (string
);
3104 len
= 200; /* Bigger than most GDB packets, junk??? */
3105 pkt
= pack_hex_byte (pkt
, len
);
3109 if ((ch
== '\0') || (ch
== '#'))
3110 ch
= '*'; /* Protect encapsulation. */
3115 #endif /* 0 (unused) */
3118 unpack_string (char *src
, char *dest
, int length
)
3127 pack_threadid (char *pkt
, threadref
*id
)
3130 unsigned char *altid
;
3132 altid
= (unsigned char *) id
;
3133 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3135 pkt
= pack_hex_byte (pkt
, *altid
++);
3141 unpack_threadid (char *inbuf
, threadref
*id
)
3144 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3147 altref
= (char *) id
;
3149 while (inbuf
< limit
)
3151 x
= stubhex (*inbuf
++);
3152 y
= stubhex (*inbuf
++);
3153 *altref
++ = (x
<< 4) | y
;
3158 /* Externally, threadrefs are 64 bits but internally, they are still
3159 ints. This is due to a mismatch of specifications. We would like
3160 to use 64bit thread references internally. This is an adapter
3164 int_to_threadref (threadref
*id
, int value
)
3166 unsigned char *scan
;
3168 scan
= (unsigned char *) id
;
3174 *scan
++ = (value
>> 24) & 0xff;
3175 *scan
++ = (value
>> 16) & 0xff;
3176 *scan
++ = (value
>> 8) & 0xff;
3177 *scan
++ = (value
& 0xff);
3181 threadref_to_int (threadref
*ref
)
3184 unsigned char *scan
;
3190 value
= (value
<< 8) | ((*scan
++) & 0xff);
3195 copy_threadref (threadref
*dest
, threadref
*src
)
3198 unsigned char *csrc
, *cdest
;
3200 csrc
= (unsigned char *) src
;
3201 cdest
= (unsigned char *) dest
;
3208 threadmatch (threadref
*dest
, threadref
*src
)
3210 /* Things are broken right now, so just assume we got a match. */
3212 unsigned char *srcp
, *destp
;
3214 srcp
= (char *) src
;
3215 destp
= (char *) dest
;
3219 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3226 threadid:1, # always request threadid
3233 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3236 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3238 *pkt
++ = 'q'; /* Info Query */
3239 *pkt
++ = 'P'; /* process or thread info */
3240 pkt
= pack_int (pkt
, mode
); /* mode */
3241 pkt
= pack_threadid (pkt
, id
); /* threadid */
3242 *pkt
= '\0'; /* terminate */
3246 /* These values tag the fields in a thread info response packet. */
3247 /* Tagging the fields allows us to request specific fields and to
3248 add more fields as time goes by. */
3250 #define TAG_THREADID 1 /* Echo the thread identifier. */
3251 #define TAG_EXISTS 2 /* Is this process defined enough to
3252 fetch registers and its stack? */
3253 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3254 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3255 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3259 remote_target::remote_unpack_thread_info_response (char *pkt
,
3260 threadref
*expectedref
,
3261 gdb_ext_thread_info
*info
)
3263 struct remote_state
*rs
= get_remote_state ();
3267 char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3270 /* info->threadid = 0; FIXME: implement zero_threadref. */
3272 info
->display
[0] = '\0';
3273 info
->shortname
[0] = '\0';
3274 info
->more_display
[0] = '\0';
3276 /* Assume the characters indicating the packet type have been
3278 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3279 pkt
= unpack_threadid (pkt
, &ref
);
3282 warning (_("Incomplete response to threadinfo request."));
3283 if (!threadmatch (&ref
, expectedref
))
3284 { /* This is an answer to a different request. */
3285 warning (_("ERROR RMT Thread info mismatch."));
3288 copy_threadref (&info
->threadid
, &ref
);
3290 /* Loop on tagged fields , try to bail if something goes wrong. */
3292 /* Packets are terminated with nulls. */
3293 while ((pkt
< limit
) && mask
&& *pkt
)
3295 pkt
= unpack_int (pkt
, &tag
); /* tag */
3296 pkt
= unpack_byte (pkt
, &length
); /* length */
3297 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3299 warning (_("ERROR RMT: threadinfo tag mismatch."));
3303 if (tag
== TAG_THREADID
)
3307 warning (_("ERROR RMT: length of threadid is not 16."));
3311 pkt
= unpack_threadid (pkt
, &ref
);
3312 mask
= mask
& ~TAG_THREADID
;
3315 if (tag
== TAG_EXISTS
)
3317 info
->active
= stub_unpack_int (pkt
, length
);
3319 mask
= mask
& ~(TAG_EXISTS
);
3322 warning (_("ERROR RMT: 'exists' length too long."));
3328 if (tag
== TAG_THREADNAME
)
3330 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3331 mask
= mask
& ~TAG_THREADNAME
;
3334 if (tag
== TAG_DISPLAY
)
3336 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3337 mask
= mask
& ~TAG_DISPLAY
;
3340 if (tag
== TAG_MOREDISPLAY
)
3342 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3343 mask
= mask
& ~TAG_MOREDISPLAY
;
3346 warning (_("ERROR RMT: unknown thread info tag."));
3347 break; /* Not a tag we know about. */
3353 remote_target::remote_get_threadinfo (threadref
*threadid
,
3355 gdb_ext_thread_info
*info
)
3357 struct remote_state
*rs
= get_remote_state ();
3360 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3362 getpkt (&rs
->buf
, 0);
3364 if (rs
->buf
[0] == '\0')
3367 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3372 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3375 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3376 threadref
*nextthread
)
3378 *pkt
++ = 'q'; /* info query packet */
3379 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3380 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3381 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3382 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3387 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3390 remote_target::parse_threadlist_response (char *pkt
, int result_limit
,
3391 threadref
*original_echo
,
3392 threadref
*resultlist
,
3395 struct remote_state
*rs
= get_remote_state ();
3397 int count
, resultcount
, done
;
3400 /* Assume the 'q' and 'M chars have been stripped. */
3401 limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3402 /* done parse past here */
3403 pkt
= unpack_byte (pkt
, &count
); /* count field */
3404 pkt
= unpack_nibble (pkt
, &done
);
3405 /* The first threadid is the argument threadid. */
3406 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3407 while ((count
-- > 0) && (pkt
< limit
))
3409 pkt
= unpack_threadid (pkt
, resultlist
++);
3410 if (resultcount
++ >= result_limit
)
3418 /* Fetch the next batch of threads from the remote. Returns -1 if the
3419 qL packet is not supported, 0 on error and 1 on success. */
3422 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3423 int result_limit
, int *done
, int *result_count
,
3424 threadref
*threadlist
)
3426 struct remote_state
*rs
= get_remote_state ();
3429 /* Truncate result limit to be smaller than the packet size. */
3430 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3431 >= get_remote_packet_size ())
3432 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3434 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3437 getpkt (&rs
->buf
, 0);
3438 if (rs
->buf
[0] == '\0')
3440 /* Packet not supported. */
3445 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3446 &rs
->echo_nextthread
, threadlist
, done
);
3448 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3450 /* FIXME: This is a good reason to drop the packet. */
3451 /* Possibly, there is a duplicate response. */
3453 retransmit immediatly - race conditions
3454 retransmit after timeout - yes
3456 wait for packet, then exit
3458 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3459 return 0; /* I choose simply exiting. */
3461 if (*result_count
<= 0)
3465 warning (_("RMT ERROR : failed to get remote thread list."));
3468 return result
; /* break; */
3470 if (*result_count
> result_limit
)
3473 warning (_("RMT ERROR: threadlist response longer than requested."));
3479 /* Fetch the list of remote threads, with the qL packet, and call
3480 STEPFUNCTION for each thread found. Stops iterating and returns 1
3481 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3482 STEPFUNCTION returns false. If the packet is not supported,
3486 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3487 void *context
, int looplimit
)
3489 struct remote_state
*rs
= get_remote_state ();
3490 int done
, i
, result_count
;
3498 if (loopcount
++ > looplimit
)
3501 warning (_("Remote fetch threadlist -infinite loop-."));
3504 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3505 MAXTHREADLISTRESULTS
,
3506 &done
, &result_count
,
3507 rs
->resultthreadlist
);
3510 /* Clear for later iterations. */
3512 /* Setup to resume next batch of thread references, set nextthread. */
3513 if (result_count
>= 1)
3514 copy_threadref (&rs
->nextthread
,
3515 &rs
->resultthreadlist
[result_count
- 1]);
3517 while (result_count
--)
3519 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3529 /* A thread found on the remote target. */
3533 explicit thread_item (ptid_t ptid_
)
3537 thread_item (thread_item
&&other
) = default;
3538 thread_item
&operator= (thread_item
&&other
) = default;
3540 DISABLE_COPY_AND_ASSIGN (thread_item
);
3542 /* The thread's PTID. */
3545 /* The thread's extra info. */
3548 /* The thread's name. */
3551 /* The core the thread was running on. -1 if not known. */
3554 /* The thread handle associated with the thread. */
3555 gdb::byte_vector thread_handle
;
3558 /* Context passed around to the various methods listing remote
3559 threads. As new threads are found, they're added to the ITEMS
3562 struct threads_listing_context
3564 /* Return true if this object contains an entry for a thread with ptid
3567 bool contains_thread (ptid_t ptid
) const
3569 auto match_ptid
= [&] (const thread_item
&item
)
3571 return item
.ptid
== ptid
;
3574 auto it
= std::find_if (this->items
.begin (),
3578 return it
!= this->items
.end ();
3581 /* Remove the thread with ptid PTID. */
3583 void remove_thread (ptid_t ptid
)
3585 auto match_ptid
= [&] (const thread_item
&item
)
3587 return item
.ptid
== ptid
;
3590 auto it
= std::remove_if (this->items
.begin (),
3594 if (it
!= this->items
.end ())
3595 this->items
.erase (it
);
3598 /* The threads found on the remote target. */
3599 std::vector
<thread_item
> items
;
3603 remote_newthread_step (threadref
*ref
, void *data
)
3605 struct threads_listing_context
*context
3606 = (struct threads_listing_context
*) data
;
3607 int pid
= inferior_ptid
.pid ();
3608 int lwp
= threadref_to_int (ref
);
3609 ptid_t
ptid (pid
, lwp
);
3611 context
->items
.emplace_back (ptid
);
3613 return 1; /* continue iterator */
3616 #define CRAZY_MAX_THREADS 1000
3619 remote_target::remote_current_thread (ptid_t oldpid
)
3621 struct remote_state
*rs
= get_remote_state ();
3624 getpkt (&rs
->buf
, 0);
3625 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3630 result
= read_ptid (&rs
->buf
[2], &obuf
);
3631 if (*obuf
!= '\0' && remote_debug
)
3632 fprintf_unfiltered (gdb_stdlog
,
3633 "warning: garbage in qC reply\n");
3641 /* List remote threads using the deprecated qL packet. */
3644 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3646 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3647 CRAZY_MAX_THREADS
) >= 0)
3653 #if defined(HAVE_LIBEXPAT)
3656 start_thread (struct gdb_xml_parser
*parser
,
3657 const struct gdb_xml_element
*element
,
3659 std::vector
<gdb_xml_value
> &attributes
)
3661 struct threads_listing_context
*data
3662 = (struct threads_listing_context
*) user_data
;
3663 struct gdb_xml_value
*attr
;
3665 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3666 ptid_t ptid
= read_ptid (id
, NULL
);
3668 data
->items
.emplace_back (ptid
);
3669 thread_item
&item
= data
->items
.back ();
3671 attr
= xml_find_attribute (attributes
, "core");
3673 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3675 attr
= xml_find_attribute (attributes
, "name");
3677 item
.name
= (const char *) attr
->value
.get ();
3679 attr
= xml_find_attribute (attributes
, "handle");
3681 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3685 end_thread (struct gdb_xml_parser
*parser
,
3686 const struct gdb_xml_element
*element
,
3687 void *user_data
, const char *body_text
)
3689 struct threads_listing_context
*data
3690 = (struct threads_listing_context
*) user_data
;
3692 if (body_text
!= NULL
&& *body_text
!= '\0')
3693 data
->items
.back ().extra
= body_text
;
3696 const struct gdb_xml_attribute thread_attributes
[] = {
3697 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3698 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3699 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3700 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3701 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3704 const struct gdb_xml_element thread_children
[] = {
3705 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3708 const struct gdb_xml_element threads_children
[] = {
3709 { "thread", thread_attributes
, thread_children
,
3710 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3711 start_thread
, end_thread
},
3712 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3715 const struct gdb_xml_element threads_elements
[] = {
3716 { "threads", NULL
, threads_children
,
3717 GDB_XML_EF_NONE
, NULL
, NULL
},
3718 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3723 /* List remote threads using qXfer:threads:read. */
3726 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3728 #if defined(HAVE_LIBEXPAT)
3729 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3731 gdb::optional
<gdb::char_vector
> xml
3732 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3734 if (xml
&& (*xml
)[0] != '\0')
3736 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3737 threads_elements
, xml
->data (), context
);
3747 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3750 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3752 struct remote_state
*rs
= get_remote_state ();
3754 if (rs
->use_threadinfo_query
)
3758 putpkt ("qfThreadInfo");
3759 getpkt (&rs
->buf
, 0);
3760 bufp
= rs
->buf
.data ();
3761 if (bufp
[0] != '\0') /* q packet recognized */
3763 while (*bufp
++ == 'm') /* reply contains one or more TID */
3767 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3768 context
->items
.emplace_back (ptid
);
3770 while (*bufp
++ == ','); /* comma-separated list */
3771 putpkt ("qsThreadInfo");
3772 getpkt (&rs
->buf
, 0);
3773 bufp
= rs
->buf
.data ();
3779 /* Packet not recognized. */
3780 rs
->use_threadinfo_query
= 0;
3787 /* Implement the to_update_thread_list function for the remote
3791 remote_target::update_thread_list ()
3793 struct threads_listing_context context
;
3796 /* We have a few different mechanisms to fetch the thread list. Try
3797 them all, starting with the most preferred one first, falling
3798 back to older methods. */
3799 if (remote_get_threads_with_qxfer (&context
)
3800 || remote_get_threads_with_qthreadinfo (&context
)
3801 || remote_get_threads_with_ql (&context
))
3805 if (context
.items
.empty ()
3806 && remote_thread_always_alive (inferior_ptid
))
3808 /* Some targets don't really support threads, but still
3809 reply an (empty) thread list in response to the thread
3810 listing packets, instead of replying "packet not
3811 supported". Exit early so we don't delete the main
3816 /* CONTEXT now holds the current thread list on the remote
3817 target end. Delete GDB-side threads no longer found on the
3819 for (thread_info
*tp
: all_threads_safe ())
3821 if (tp
->inf
->process_target () != this)
3824 if (!context
.contains_thread (tp
->ptid
))
3831 /* Remove any unreported fork child threads from CONTEXT so
3832 that we don't interfere with follow fork, which is where
3833 creation of such threads is handled. */
3834 remove_new_fork_children (&context
);
3836 /* And now add threads we don't know about yet to our list. */
3837 for (thread_item
&item
: context
.items
)
3839 if (item
.ptid
!= null_ptid
)
3841 /* In non-stop mode, we assume new found threads are
3842 executing until proven otherwise with a stop reply.
3843 In all-stop, we can only get here if all threads are
3845 int executing
= target_is_non_stop_p () ? 1 : 0;
3847 remote_notice_new_inferior (item
.ptid
, executing
);
3849 thread_info
*tp
= find_thread_ptid (this, item
.ptid
);
3850 remote_thread_info
*info
= get_remote_thread_info (tp
);
3851 info
->core
= item
.core
;
3852 info
->extra
= std::move (item
.extra
);
3853 info
->name
= std::move (item
.name
);
3854 info
->thread_handle
= std::move (item
.thread_handle
);
3861 /* If no thread listing method is supported, then query whether
3862 each known thread is alive, one by one, with the T packet.
3863 If the target doesn't support threads at all, then this is a
3864 no-op. See remote_thread_alive. */
3870 * Collect a descriptive string about the given thread.
3871 * The target may say anything it wants to about the thread
3872 * (typically info about its blocked / runnable state, name, etc.).
3873 * This string will appear in the info threads display.
3875 * Optional: targets are not required to implement this function.
3879 remote_target::extra_thread_info (thread_info
*tp
)
3881 struct remote_state
*rs
= get_remote_state ();
3884 struct gdb_ext_thread_info threadinfo
;
3886 if (rs
->remote_desc
== 0) /* paranoia */
3887 internal_error (__FILE__
, __LINE__
,
3888 _("remote_threads_extra_info"));
3890 if (tp
->ptid
== magic_null_ptid
3891 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
3892 /* This is the main thread which was added by GDB. The remote
3893 server doesn't know about it. */
3896 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
3898 /* If already have cached info, use it. */
3899 if (!extra
.empty ())
3900 return extra
.c_str ();
3902 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3904 /* If we're using qXfer:threads:read, then the extra info is
3905 included in the XML. So if we didn't have anything cached,
3906 it's because there's really no extra info. */
3910 if (rs
->use_threadextra_query
)
3912 char *b
= rs
->buf
.data ();
3913 char *endb
= b
+ get_remote_packet_size ();
3915 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3917 write_ptid (b
, endb
, tp
->ptid
);
3920 getpkt (&rs
->buf
, 0);
3921 if (rs
->buf
[0] != 0)
3923 extra
.resize (strlen (rs
->buf
.data ()) / 2);
3924 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
3925 return extra
.c_str ();
3929 /* If the above query fails, fall back to the old method. */
3930 rs
->use_threadextra_query
= 0;
3931 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3932 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3933 int_to_threadref (&id
, tp
->ptid
.lwp ());
3934 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3935 if (threadinfo
.active
)
3937 if (*threadinfo
.shortname
)
3938 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
3939 if (*threadinfo
.display
)
3941 if (!extra
.empty ())
3943 string_appendf (extra
, " State: %s", threadinfo
.display
);
3945 if (*threadinfo
.more_display
)
3947 if (!extra
.empty ())
3949 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
3951 return extra
.c_str ();
3958 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
3959 struct static_tracepoint_marker
*marker
)
3961 struct remote_state
*rs
= get_remote_state ();
3962 char *p
= rs
->buf
.data ();
3964 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3966 p
+= hexnumstr (p
, addr
);
3968 getpkt (&rs
->buf
, 0);
3969 p
= rs
->buf
.data ();
3972 error (_("Remote failure reply: %s"), p
);
3976 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
3983 std::vector
<static_tracepoint_marker
>
3984 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
3986 struct remote_state
*rs
= get_remote_state ();
3987 std::vector
<static_tracepoint_marker
> markers
;
3989 static_tracepoint_marker marker
;
3991 /* Ask for a first packet of static tracepoint marker
3994 getpkt (&rs
->buf
, 0);
3995 p
= rs
->buf
.data ();
3997 error (_("Remote failure reply: %s"), p
);
4003 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
4005 if (strid
== NULL
|| marker
.str_id
== strid
)
4006 markers
.push_back (std::move (marker
));
4008 while (*p
++ == ','); /* comma-separated list */
4009 /* Ask for another packet of static tracepoint definition. */
4011 getpkt (&rs
->buf
, 0);
4012 p
= rs
->buf
.data ();
4019 /* Implement the to_get_ada_task_ptid function for the remote targets. */
4022 remote_target::get_ada_task_ptid (long lwp
, long thread
)
4024 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
4028 /* Restart the remote side; this is an extended protocol operation. */
4031 remote_target::extended_remote_restart ()
4033 struct remote_state
*rs
= get_remote_state ();
4035 /* Send the restart command; for reasons I don't understand the
4036 remote side really expects a number after the "R". */
4037 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
4040 remote_fileio_reset ();
4043 /* Clean up connection to a remote debugger. */
4046 remote_target::close ()
4048 /* Make sure we leave stdin registered in the event loop. */
4051 trace_reset_local_state ();
4056 remote_target::~remote_target ()
4058 struct remote_state
*rs
= get_remote_state ();
4060 /* Check for NULL because we may get here with a partially
4061 constructed target/connection. */
4062 if (rs
->remote_desc
== nullptr)
4065 serial_close (rs
->remote_desc
);
4067 /* We are destroying the remote target, so we should discard
4068 everything of this target. */
4069 discard_pending_stop_replies_in_queue ();
4071 if (rs
->remote_async_inferior_event_token
)
4072 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4074 delete rs
->notif_state
;
4077 /* Query the remote side for the text, data and bss offsets. */
4080 remote_target::get_offsets ()
4082 struct remote_state
*rs
= get_remote_state ();
4085 int lose
, num_segments
= 0, do_sections
, do_segments
;
4086 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4087 struct symfile_segment_data
*data
;
4089 if (symfile_objfile
== NULL
)
4092 putpkt ("qOffsets");
4093 getpkt (&rs
->buf
, 0);
4094 buf
= rs
->buf
.data ();
4096 if (buf
[0] == '\000')
4097 return; /* Return silently. Stub doesn't support
4101 warning (_("Remote failure reply: %s"), buf
);
4105 /* Pick up each field in turn. This used to be done with scanf, but
4106 scanf will make trouble if CORE_ADDR size doesn't match
4107 conversion directives correctly. The following code will work
4108 with any size of CORE_ADDR. */
4109 text_addr
= data_addr
= bss_addr
= 0;
4113 if (startswith (ptr
, "Text="))
4116 /* Don't use strtol, could lose on big values. */
4117 while (*ptr
&& *ptr
!= ';')
4118 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4120 if (startswith (ptr
, ";Data="))
4123 while (*ptr
&& *ptr
!= ';')
4124 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4129 if (!lose
&& startswith (ptr
, ";Bss="))
4132 while (*ptr
&& *ptr
!= ';')
4133 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4135 if (bss_addr
!= data_addr
)
4136 warning (_("Target reported unsupported offsets: %s"), buf
);
4141 else if (startswith (ptr
, "TextSeg="))
4144 /* Don't use strtol, could lose on big values. */
4145 while (*ptr
&& *ptr
!= ';')
4146 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4149 if (startswith (ptr
, ";DataSeg="))
4152 while (*ptr
&& *ptr
!= ';')
4153 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4161 error (_("Malformed response to offset query, %s"), buf
);
4162 else if (*ptr
!= '\0')
4163 warning (_("Target reported unsupported offsets: %s"), buf
);
4165 section_offsets offs
= symfile_objfile
->section_offsets
;
4167 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
4168 do_segments
= (data
!= NULL
);
4169 do_sections
= num_segments
== 0;
4171 if (num_segments
> 0)
4173 segments
[0] = text_addr
;
4174 segments
[1] = data_addr
;
4176 /* If we have two segments, we can still try to relocate everything
4177 by assuming that the .text and .data offsets apply to the whole
4178 text and data segments. Convert the offsets given in the packet
4179 to base addresses for symfile_map_offsets_to_segments. */
4180 else if (data
&& data
->num_segments
== 2)
4182 segments
[0] = data
->segment_bases
[0] + text_addr
;
4183 segments
[1] = data
->segment_bases
[1] + data_addr
;
4186 /* If the object file has only one segment, assume that it is text
4187 rather than data; main programs with no writable data are rare,
4188 but programs with no code are useless. Of course the code might
4189 have ended up in the data segment... to detect that we would need
4190 the permissions here. */
4191 else if (data
&& data
->num_segments
== 1)
4193 segments
[0] = data
->segment_bases
[0] + text_addr
;
4196 /* There's no way to relocate by segment. */
4202 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
4203 offs
, num_segments
, segments
);
4205 if (ret
== 0 && !do_sections
)
4206 error (_("Can not handle qOffsets TextSeg "
4207 "response with this symbol file"));
4214 free_symfile_segment_data (data
);
4218 offs
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
4220 /* This is a temporary kludge to force data and bss to use the
4221 same offsets because that's what nlmconv does now. The real
4222 solution requires changes to the stub and remote.c that I
4223 don't have time to do right now. */
4225 offs
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
4226 offs
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
4229 objfile_relocate (symfile_objfile
, offs
);
4232 /* Send interrupt_sequence to remote target. */
4235 remote_target::send_interrupt_sequence ()
4237 struct remote_state
*rs
= get_remote_state ();
4239 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4240 remote_serial_write ("\x03", 1);
4241 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4242 serial_send_break (rs
->remote_desc
);
4243 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4245 serial_send_break (rs
->remote_desc
);
4246 remote_serial_write ("g", 1);
4249 internal_error (__FILE__
, __LINE__
,
4250 _("Invalid value for interrupt_sequence_mode: %s."),
4251 interrupt_sequence_mode
);
4255 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4256 and extract the PTID. Returns NULL_PTID if not found. */
4259 stop_reply_extract_thread (char *stop_reply
)
4261 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4265 /* Txx r:val ; r:val (...) */
4268 /* Look for "register" named "thread". */
4273 p1
= strchr (p
, ':');
4277 if (strncmp (p
, "thread", p1
- p
) == 0)
4278 return read_ptid (++p1
, &p
);
4280 p1
= strchr (p
, ';');
4292 /* Determine the remote side's current thread. If we have a stop
4293 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4294 "thread" register we can extract the current thread from. If not,
4295 ask the remote which is the current thread with qC. The former
4296 method avoids a roundtrip. */
4299 remote_target::get_current_thread (char *wait_status
)
4301 ptid_t ptid
= null_ptid
;
4303 /* Note we don't use remote_parse_stop_reply as that makes use of
4304 the target architecture, which we haven't yet fully determined at
4306 if (wait_status
!= NULL
)
4307 ptid
= stop_reply_extract_thread (wait_status
);
4308 if (ptid
== null_ptid
)
4309 ptid
= remote_current_thread (inferior_ptid
);
4314 /* Query the remote target for which is the current thread/process,
4315 add it to our tables, and update INFERIOR_PTID. The caller is
4316 responsible for setting the state such that the remote end is ready
4317 to return the current thread.
4319 This function is called after handling the '?' or 'vRun' packets,
4320 whose response is a stop reply from which we can also try
4321 extracting the thread. If the target doesn't support the explicit
4322 qC query, we infer the current thread from that stop reply, passed
4323 in in WAIT_STATUS, which may be NULL. */
4326 remote_target::add_current_inferior_and_thread (char *wait_status
)
4328 struct remote_state
*rs
= get_remote_state ();
4329 bool fake_pid_p
= false;
4331 inferior_ptid
= null_ptid
;
4333 /* Now, if we have thread information, update inferior_ptid. */
4334 ptid_t curr_ptid
= get_current_thread (wait_status
);
4336 if (curr_ptid
!= null_ptid
)
4338 if (!remote_multi_process_p (rs
))
4343 /* Without this, some commands which require an active target
4344 (such as kill) won't work. This variable serves (at least)
4345 double duty as both the pid of the target process (if it has
4346 such), and as a flag indicating that a target is active. */
4347 curr_ptid
= magic_null_ptid
;
4351 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4353 /* Add the main thread and switch to it. Don't try reading
4354 registers yet, since we haven't fetched the target description
4356 thread_info
*tp
= add_thread_silent (this, curr_ptid
);
4357 switch_to_thread_no_regs (tp
);
4360 /* Print info about a thread that was found already stopped on
4364 print_one_stopped_thread (struct thread_info
*thread
)
4366 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4368 switch_to_thread (thread
);
4369 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4370 set_current_sal_from_frame (get_current_frame ());
4372 thread
->suspend
.waitstatus_pending_p
= 0;
4374 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4376 enum gdb_signal sig
= ws
->value
.sig
;
4378 if (signal_print_state (sig
))
4379 gdb::observers::signal_received
.notify (sig
);
4381 gdb::observers::normal_stop
.notify (NULL
, 1);
4384 /* Process all initial stop replies the remote side sent in response
4385 to the ? packet. These indicate threads that were already stopped
4386 on initial connection. We mark these threads as stopped and print
4387 their current frame before giving the user the prompt. */
4390 remote_target::process_initial_stop_replies (int from_tty
)
4392 int pending_stop_replies
= stop_reply_queue_length ();
4393 struct thread_info
*selected
= NULL
;
4394 struct thread_info
*lowest_stopped
= NULL
;
4395 struct thread_info
*first
= NULL
;
4397 /* Consume the initial pending events. */
4398 while (pending_stop_replies
-- > 0)
4400 ptid_t waiton_ptid
= minus_one_ptid
;
4402 struct target_waitstatus ws
;
4403 int ignore_event
= 0;
4405 memset (&ws
, 0, sizeof (ws
));
4406 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4408 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4412 case TARGET_WAITKIND_IGNORE
:
4413 case TARGET_WAITKIND_NO_RESUMED
:
4414 case TARGET_WAITKIND_SIGNALLED
:
4415 case TARGET_WAITKIND_EXITED
:
4416 /* We shouldn't see these, but if we do, just ignore. */
4418 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
4422 case TARGET_WAITKIND_EXECD
:
4423 xfree (ws
.value
.execd_pathname
);
4432 thread_info
*evthread
= find_thread_ptid (this, event_ptid
);
4434 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4436 enum gdb_signal sig
= ws
.value
.sig
;
4438 /* Stubs traditionally report SIGTRAP as initial signal,
4439 instead of signal 0. Suppress it. */
4440 if (sig
== GDB_SIGNAL_TRAP
)
4442 evthread
->suspend
.stop_signal
= sig
;
4446 evthread
->suspend
.waitstatus
= ws
;
4448 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4449 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4450 evthread
->suspend
.waitstatus_pending_p
= 1;
4452 set_executing (this, event_ptid
, false);
4453 set_running (this, event_ptid
, false);
4454 get_remote_thread_info (evthread
)->vcont_resumed
= 0;
4457 /* "Notice" the new inferiors before anything related to
4458 registers/memory. */
4459 for (inferior
*inf
: all_non_exited_inferiors (this))
4461 inf
->needs_setup
= 1;
4465 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4466 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4471 /* If all-stop on top of non-stop, pause all threads. Note this
4472 records the threads' stop pc, so must be done after "noticing"
4476 stop_all_threads ();
4478 /* If all threads of an inferior were already stopped, we
4479 haven't setup the inferior yet. */
4480 for (inferior
*inf
: all_non_exited_inferiors (this))
4482 if (inf
->needs_setup
)
4484 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4485 switch_to_thread_no_regs (thread
);
4491 /* Now go over all threads that are stopped, and print their current
4492 frame. If all-stop, then if there's a signalled thread, pick
4494 for (thread_info
*thread
: all_non_exited_threads (this))
4500 thread
->set_running (false);
4501 else if (thread
->state
!= THREAD_STOPPED
)
4504 if (selected
== NULL
4505 && thread
->suspend
.waitstatus_pending_p
)
4508 if (lowest_stopped
== NULL
4509 || thread
->inf
->num
< lowest_stopped
->inf
->num
4510 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4511 lowest_stopped
= thread
;
4514 print_one_stopped_thread (thread
);
4517 /* In all-stop, we only print the status of one thread, and leave
4518 others with their status pending. */
4521 thread_info
*thread
= selected
;
4523 thread
= lowest_stopped
;
4527 print_one_stopped_thread (thread
);
4530 /* For "info program". */
4531 thread_info
*thread
= inferior_thread ();
4532 if (thread
->state
== THREAD_STOPPED
)
4533 set_last_target_status (this, inferior_ptid
, thread
->suspend
.waitstatus
);
4536 /* Start the remote connection and sync state. */
4539 remote_target::start_remote (int from_tty
, int extended_p
)
4541 struct remote_state
*rs
= get_remote_state ();
4542 struct packet_config
*noack_config
;
4543 char *wait_status
= NULL
;
4545 /* Signal other parts that we're going through the initial setup,
4546 and so things may not be stable yet. E.g., we don't try to
4547 install tracepoints until we've relocated symbols. Also, a
4548 Ctrl-C before we're connected and synced up can't interrupt the
4549 target. Instead, it offers to drop the (potentially wedged)
4551 rs
->starting_up
= 1;
4555 if (interrupt_on_connect
)
4556 send_interrupt_sequence ();
4558 /* Ack any packet which the remote side has already sent. */
4559 remote_serial_write ("+", 1);
4561 /* The first packet we send to the target is the optional "supported
4562 packets" request. If the target can answer this, it will tell us
4563 which later probes to skip. */
4564 remote_query_supported ();
4566 /* If the stub wants to get a QAllow, compose one and send it. */
4567 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4570 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4571 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4572 as a reply to known packet. For packet "vFile:setfs:" it is an
4573 invalid reply and GDB would return error in
4574 remote_hostio_set_filesystem, making remote files access impossible.
4575 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4576 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4578 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4580 putpkt (v_mustreplyempty
);
4581 getpkt (&rs
->buf
, 0);
4582 if (strcmp (rs
->buf
.data (), "OK") == 0)
4583 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4584 else if (strcmp (rs
->buf
.data (), "") != 0)
4585 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4589 /* Next, we possibly activate noack mode.
4591 If the QStartNoAckMode packet configuration is set to AUTO,
4592 enable noack mode if the stub reported a wish for it with
4595 If set to TRUE, then enable noack mode even if the stub didn't
4596 report it in qSupported. If the stub doesn't reply OK, the
4597 session ends with an error.
4599 If FALSE, then don't activate noack mode, regardless of what the
4600 stub claimed should be the default with qSupported. */
4602 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4603 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4605 putpkt ("QStartNoAckMode");
4606 getpkt (&rs
->buf
, 0);
4607 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4613 /* Tell the remote that we are using the extended protocol. */
4615 getpkt (&rs
->buf
, 0);
4618 /* Let the target know which signals it is allowed to pass down to
4620 update_signals_program_target ();
4622 /* Next, if the target can specify a description, read it. We do
4623 this before anything involving memory or registers. */
4624 target_find_description ();
4626 /* Next, now that we know something about the target, update the
4627 address spaces in the program spaces. */
4628 update_address_spaces ();
4630 /* On OSs where the list of libraries is global to all
4631 processes, we fetch them early. */
4632 if (gdbarch_has_global_solist (target_gdbarch ()))
4633 solib_add (NULL
, from_tty
, auto_solib_add
);
4635 if (target_is_non_stop_p ())
4637 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4638 error (_("Non-stop mode requested, but remote "
4639 "does not support non-stop"));
4641 putpkt ("QNonStop:1");
4642 getpkt (&rs
->buf
, 0);
4644 if (strcmp (rs
->buf
.data (), "OK") != 0)
4645 error (_("Remote refused setting non-stop mode with: %s"),
4648 /* Find about threads and processes the stub is already
4649 controlling. We default to adding them in the running state.
4650 The '?' query below will then tell us about which threads are
4652 this->update_thread_list ();
4654 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4656 /* Don't assume that the stub can operate in all-stop mode.
4657 Request it explicitly. */
4658 putpkt ("QNonStop:0");
4659 getpkt (&rs
->buf
, 0);
4661 if (strcmp (rs
->buf
.data (), "OK") != 0)
4662 error (_("Remote refused setting all-stop mode with: %s"),
4666 /* Upload TSVs regardless of whether the target is running or not. The
4667 remote stub, such as GDBserver, may have some predefined or builtin
4668 TSVs, even if the target is not running. */
4669 if (get_trace_status (current_trace_status ()) != -1)
4671 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4673 upload_trace_state_variables (&uploaded_tsvs
);
4674 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4677 /* Check whether the target is running now. */
4679 getpkt (&rs
->buf
, 0);
4681 if (!target_is_non_stop_p ())
4683 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4686 error (_("The target is not running (try extended-remote?)"));
4688 /* We're connected, but not running. Drop out before we
4689 call start_remote. */
4690 rs
->starting_up
= 0;
4695 /* Save the reply for later. */
4696 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4697 strcpy (wait_status
, rs
->buf
.data ());
4700 /* Fetch thread list. */
4701 target_update_thread_list ();
4703 /* Let the stub know that we want it to return the thread. */
4704 set_continue_thread (minus_one_ptid
);
4706 if (thread_count (this) == 0)
4708 /* Target has no concept of threads at all. GDB treats
4709 non-threaded target as single-threaded; add a main
4711 add_current_inferior_and_thread (wait_status
);
4715 /* We have thread information; select the thread the target
4716 says should be current. If we're reconnecting to a
4717 multi-threaded program, this will ideally be the thread
4718 that last reported an event before GDB disconnected. */
4719 ptid_t curr_thread
= get_current_thread (wait_status
);
4720 if (curr_thread
== null_ptid
)
4722 /* Odd... The target was able to list threads, but not
4723 tell us which thread was current (no "thread"
4724 register in T stop reply?). Just pick the first
4725 thread in the thread list then. */
4728 fprintf_unfiltered (gdb_stdlog
,
4729 "warning: couldn't determine remote "
4730 "current thread; picking first in list.\n");
4732 for (thread_info
*tp
: all_non_exited_threads (this,
4735 switch_to_thread (tp
);
4740 switch_to_thread (find_thread_ptid (this, curr_thread
));
4743 /* init_wait_for_inferior should be called before get_offsets in order
4744 to manage `inserted' flag in bp loc in a correct state.
4745 breakpoint_init_inferior, called from init_wait_for_inferior, set
4746 `inserted' flag to 0, while before breakpoint_re_set, called from
4747 start_remote, set `inserted' flag to 1. In the initialization of
4748 inferior, breakpoint_init_inferior should be called first, and then
4749 breakpoint_re_set can be called. If this order is broken, state of
4750 `inserted' flag is wrong, and cause some problems on breakpoint
4752 init_wait_for_inferior ();
4754 get_offsets (); /* Get text, data & bss offsets. */
4756 /* If we could not find a description using qXfer, and we know
4757 how to do it some other way, try again. This is not
4758 supported for non-stop; it could be, but it is tricky if
4759 there are no stopped threads when we connect. */
4760 if (remote_read_description_p (this)
4761 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4763 target_clear_description ();
4764 target_find_description ();
4767 /* Use the previously fetched status. */
4768 gdb_assert (wait_status
!= NULL
);
4769 strcpy (rs
->buf
.data (), wait_status
);
4770 rs
->cached_wait_status
= 1;
4772 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4776 /* Clear WFI global state. Do this before finding about new
4777 threads and inferiors, and setting the current inferior.
4778 Otherwise we would clear the proceed status of the current
4779 inferior when we want its stop_soon state to be preserved
4780 (see notice_new_inferior). */
4781 init_wait_for_inferior ();
4783 /* In non-stop, we will either get an "OK", meaning that there
4784 are no stopped threads at this time; or, a regular stop
4785 reply. In the latter case, there may be more than one thread
4786 stopped --- we pull them all out using the vStopped
4788 if (strcmp (rs
->buf
.data (), "OK") != 0)
4790 struct notif_client
*notif
= ¬if_client_stop
;
4792 /* remote_notif_get_pending_replies acks this one, and gets
4794 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4795 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4796 remote_notif_get_pending_events (notif
);
4799 if (thread_count (this) == 0)
4802 error (_("The target is not running (try extended-remote?)"));
4804 /* We're connected, but not running. Drop out before we
4805 call start_remote. */
4806 rs
->starting_up
= 0;
4810 /* In non-stop mode, any cached wait status will be stored in
4811 the stop reply queue. */
4812 gdb_assert (wait_status
== NULL
);
4814 /* Report all signals during attach/startup. */
4817 /* If there are already stopped threads, mark them stopped and
4818 report their stops before giving the prompt to the user. */
4819 process_initial_stop_replies (from_tty
);
4821 if (target_can_async_p ())
4825 /* If we connected to a live target, do some additional setup. */
4826 if (target_has_execution
)
4828 if (symfile_objfile
) /* No use without a symbol-file. */
4829 remote_check_symbols ();
4832 /* Possibly the target has been engaged in a trace run started
4833 previously; find out where things are at. */
4834 if (get_trace_status (current_trace_status ()) != -1)
4836 struct uploaded_tp
*uploaded_tps
= NULL
;
4838 if (current_trace_status ()->running
)
4839 printf_filtered (_("Trace is already running on the target.\n"));
4841 upload_tracepoints (&uploaded_tps
);
4843 merge_uploaded_tracepoints (&uploaded_tps
);
4846 /* Possibly the target has been engaged in a btrace record started
4847 previously; find out where things are at. */
4848 remote_btrace_maybe_reopen ();
4850 /* The thread and inferior lists are now synchronized with the
4851 target, our symbols have been relocated, and we're merged the
4852 target's tracepoints with ours. We're done with basic start
4854 rs
->starting_up
= 0;
4856 /* Maybe breakpoints are global and need to be inserted now. */
4857 if (breakpoints_should_be_inserted_now ())
4858 insert_breakpoints ();
4862 remote_target::connection_string ()
4864 remote_state
*rs
= get_remote_state ();
4866 if (rs
->remote_desc
->name
!= NULL
)
4867 return rs
->remote_desc
->name
;
4872 /* Open a connection to a remote debugger.
4873 NAME is the filename used for communication. */
4876 remote_target::open (const char *name
, int from_tty
)
4878 open_1 (name
, from_tty
, 0);
4881 /* Open a connection to a remote debugger using the extended
4882 remote gdb protocol. NAME is the filename used for communication. */
4885 extended_remote_target::open (const char *name
, int from_tty
)
4887 open_1 (name
, from_tty
, 1 /*extended_p */);
4890 /* Reset all packets back to "unknown support". Called when opening a
4891 new connection to a remote target. */
4894 reset_all_packet_configs_support (void)
4898 for (i
= 0; i
< PACKET_MAX
; i
++)
4899 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4902 /* Initialize all packet configs. */
4905 init_all_packet_configs (void)
4909 for (i
= 0; i
< PACKET_MAX
; i
++)
4911 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4912 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4916 /* Symbol look-up. */
4919 remote_target::remote_check_symbols ()
4924 /* The remote side has no concept of inferiors that aren't running
4925 yet, it only knows about running processes. If we're connected
4926 but our current inferior is not running, we should not invite the
4927 remote target to request symbol lookups related to its
4928 (unrelated) current process. */
4929 if (!target_has_execution
)
4932 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4935 /* Make sure the remote is pointing at the right process. Note
4936 there's no way to select "no process". */
4937 set_general_process ();
4939 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4940 because we need both at the same time. */
4941 gdb::char_vector
msg (get_remote_packet_size ());
4942 gdb::char_vector
reply (get_remote_packet_size ());
4944 /* Invite target to request symbol lookups. */
4946 putpkt ("qSymbol::");
4948 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4950 while (startswith (reply
.data (), "qSymbol:"))
4952 struct bound_minimal_symbol sym
;
4955 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
4958 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
4959 if (sym
.minsym
== NULL
)
4960 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
4964 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4965 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4967 /* If this is a function address, return the start of code
4968 instead of any data function descriptor. */
4969 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4971 current_top_target ());
4973 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4974 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4977 putpkt (msg
.data ());
4982 static struct serial
*
4983 remote_serial_open (const char *name
)
4985 static int udp_warning
= 0;
4987 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4988 of in ser-tcp.c, because it is the remote protocol assuming that the
4989 serial connection is reliable and not the serial connection promising
4991 if (!udp_warning
&& startswith (name
, "udp:"))
4993 warning (_("The remote protocol may be unreliable over UDP.\n"
4994 "Some events may be lost, rendering further debugging "
4999 return serial_open (name
);
5002 /* Inform the target of our permission settings. The permission flags
5003 work without this, but if the target knows the settings, it can do
5004 a couple things. First, it can add its own check, to catch cases
5005 that somehow manage to get by the permissions checks in target
5006 methods. Second, if the target is wired to disallow particular
5007 settings (for instance, a system in the field that is not set up to
5008 be able to stop at a breakpoint), it can object to any unavailable
5012 remote_target::set_permissions ()
5014 struct remote_state
*rs
= get_remote_state ();
5016 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
5017 "WriteReg:%x;WriteMem:%x;"
5018 "InsertBreak:%x;InsertTrace:%x;"
5019 "InsertFastTrace:%x;Stop:%x",
5020 may_write_registers
, may_write_memory
,
5021 may_insert_breakpoints
, may_insert_tracepoints
,
5022 may_insert_fast_tracepoints
, may_stop
);
5024 getpkt (&rs
->buf
, 0);
5026 /* If the target didn't like the packet, warn the user. Do not try
5027 to undo the user's settings, that would just be maddening. */
5028 if (strcmp (rs
->buf
.data (), "OK") != 0)
5029 warning (_("Remote refused setting permissions with: %s"),
5033 /* This type describes each known response to the qSupported
5035 struct protocol_feature
5037 /* The name of this protocol feature. */
5040 /* The default for this protocol feature. */
5041 enum packet_support default_support
;
5043 /* The function to call when this feature is reported, or after
5044 qSupported processing if the feature is not supported.
5045 The first argument points to this structure. The second
5046 argument indicates whether the packet requested support be
5047 enabled, disabled, or probed (or the default, if this function
5048 is being called at the end of processing and this feature was
5049 not reported). The third argument may be NULL; if not NULL, it
5050 is a NUL-terminated string taken from the packet following
5051 this feature's name and an equals sign. */
5052 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5053 enum packet_support
, const char *);
5055 /* The corresponding packet for this feature. Only used if
5056 FUNC is remote_supported_packet. */
5061 remote_supported_packet (remote_target
*remote
,
5062 const struct protocol_feature
*feature
,
5063 enum packet_support support
,
5064 const char *argument
)
5068 warning (_("Remote qSupported response supplied an unexpected value for"
5069 " \"%s\"."), feature
->name
);
5073 remote_protocol_packets
[feature
->packet
].support
= support
;
5077 remote_target::remote_packet_size (const protocol_feature
*feature
,
5078 enum packet_support support
, const char *value
)
5080 struct remote_state
*rs
= get_remote_state ();
5085 if (support
!= PACKET_ENABLE
)
5088 if (value
== NULL
|| *value
== '\0')
5090 warning (_("Remote target reported \"%s\" without a size."),
5096 packet_size
= strtol (value
, &value_end
, 16);
5097 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5099 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5100 feature
->name
, value
);
5104 /* Record the new maximum packet size. */
5105 rs
->explicit_packet_size
= packet_size
;
5109 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5110 enum packet_support support
, const char *value
)
5112 remote
->remote_packet_size (feature
, support
, value
);
5115 static const struct protocol_feature remote_protocol_features
[] = {
5116 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5117 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5118 PACKET_qXfer_auxv
},
5119 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5120 PACKET_qXfer_exec_file
},
5121 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5122 PACKET_qXfer_features
},
5123 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5124 PACKET_qXfer_libraries
},
5125 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5126 PACKET_qXfer_libraries_svr4
},
5127 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5128 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5129 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5130 PACKET_qXfer_memory_map
},
5131 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5132 PACKET_qXfer_osdata
},
5133 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5134 PACKET_qXfer_threads
},
5135 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5136 PACKET_qXfer_traceframe_info
},
5137 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5138 PACKET_QPassSignals
},
5139 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5140 PACKET_QCatchSyscalls
},
5141 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5142 PACKET_QProgramSignals
},
5143 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5144 PACKET_QSetWorkingDir
},
5145 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5146 PACKET_QStartupWithShell
},
5147 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5148 PACKET_QEnvironmentHexEncoded
},
5149 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5150 PACKET_QEnvironmentReset
},
5151 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5152 PACKET_QEnvironmentUnset
},
5153 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5154 PACKET_QStartNoAckMode
},
5155 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5156 PACKET_multiprocess_feature
},
5157 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5158 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5159 PACKET_qXfer_siginfo_read
},
5160 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5161 PACKET_qXfer_siginfo_write
},
5162 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5163 PACKET_ConditionalTracepoints
},
5164 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5165 PACKET_ConditionalBreakpoints
},
5166 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5167 PACKET_BreakpointCommands
},
5168 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5169 PACKET_FastTracepoints
},
5170 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5171 PACKET_StaticTracepoints
},
5172 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5173 PACKET_InstallInTrace
},
5174 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5175 PACKET_DisconnectedTracing_feature
},
5176 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5178 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5180 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5181 PACKET_TracepointSource
},
5182 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5184 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5185 PACKET_EnableDisableTracepoints_feature
},
5186 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5187 PACKET_qXfer_fdpic
},
5188 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5190 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5191 PACKET_QDisableRandomization
},
5192 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5193 { "QTBuffer:size", PACKET_DISABLE
,
5194 remote_supported_packet
, PACKET_QTBuffer_size
},
5195 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5196 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5197 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5198 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5199 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5200 PACKET_qXfer_btrace
},
5201 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5202 PACKET_qXfer_btrace_conf
},
5203 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5204 PACKET_Qbtrace_conf_bts_size
},
5205 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5206 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5207 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5208 PACKET_fork_event_feature
},
5209 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5210 PACKET_vfork_event_feature
},
5211 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5212 PACKET_exec_event_feature
},
5213 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5214 PACKET_Qbtrace_conf_pt_size
},
5215 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5216 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5217 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5220 static char *remote_support_xml
;
5222 /* Register string appended to "xmlRegisters=" in qSupported query. */
5225 register_remote_support_xml (const char *xml
)
5227 #if defined(HAVE_LIBEXPAT)
5228 if (remote_support_xml
== NULL
)
5229 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5232 char *copy
= xstrdup (remote_support_xml
+ 13);
5234 char *p
= strtok_r (copy
, ",", &saveptr
);
5238 if (strcmp (p
, xml
) == 0)
5245 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5248 remote_support_xml
= reconcat (remote_support_xml
,
5249 remote_support_xml
, ",", xml
,
5256 remote_query_supported_append (std::string
*msg
, const char *append
)
5260 msg
->append (append
);
5264 remote_target::remote_query_supported ()
5266 struct remote_state
*rs
= get_remote_state ();
5269 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5271 /* The packet support flags are handled differently for this packet
5272 than for most others. We treat an error, a disabled packet, and
5273 an empty response identically: any features which must be reported
5274 to be used will be automatically disabled. An empty buffer
5275 accomplishes this, since that is also the representation for a list
5276 containing no features. */
5279 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5283 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5284 remote_query_supported_append (&q
, "multiprocess+");
5286 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5287 remote_query_supported_append (&q
, "swbreak+");
5288 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5289 remote_query_supported_append (&q
, "hwbreak+");
5291 remote_query_supported_append (&q
, "qRelocInsn+");
5293 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5294 != AUTO_BOOLEAN_FALSE
)
5295 remote_query_supported_append (&q
, "fork-events+");
5296 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5297 != AUTO_BOOLEAN_FALSE
)
5298 remote_query_supported_append (&q
, "vfork-events+");
5299 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5300 != AUTO_BOOLEAN_FALSE
)
5301 remote_query_supported_append (&q
, "exec-events+");
5303 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5304 remote_query_supported_append (&q
, "vContSupported+");
5306 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5307 remote_query_supported_append (&q
, "QThreadEvents+");
5309 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5310 remote_query_supported_append (&q
, "no-resumed+");
5312 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5313 the qSupported:xmlRegisters=i386 handling. */
5314 if (remote_support_xml
!= NULL
5315 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5316 remote_query_supported_append (&q
, remote_support_xml
);
5318 q
= "qSupported:" + q
;
5319 putpkt (q
.c_str ());
5321 getpkt (&rs
->buf
, 0);
5323 /* If an error occured, warn, but do not return - just reset the
5324 buffer to empty and go on to disable features. */
5325 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5328 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5333 memset (seen
, 0, sizeof (seen
));
5335 next
= rs
->buf
.data ();
5338 enum packet_support is_supported
;
5339 char *p
, *end
, *name_end
, *value
;
5341 /* First separate out this item from the rest of the packet. If
5342 there's another item after this, we overwrite the separator
5343 (terminated strings are much easier to work with). */
5345 end
= strchr (p
, ';');
5348 end
= p
+ strlen (p
);
5358 warning (_("empty item in \"qSupported\" response"));
5363 name_end
= strchr (p
, '=');
5366 /* This is a name=value entry. */
5367 is_supported
= PACKET_ENABLE
;
5368 value
= name_end
+ 1;
5377 is_supported
= PACKET_ENABLE
;
5381 is_supported
= PACKET_DISABLE
;
5385 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5389 warning (_("unrecognized item \"%s\" "
5390 "in \"qSupported\" response"), p
);
5396 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5397 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5399 const struct protocol_feature
*feature
;
5402 feature
= &remote_protocol_features
[i
];
5403 feature
->func (this, feature
, is_supported
, value
);
5408 /* If we increased the packet size, make sure to increase the global
5409 buffer size also. We delay this until after parsing the entire
5410 qSupported packet, because this is the same buffer we were
5412 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5413 rs
->buf
.resize (rs
->explicit_packet_size
);
5415 /* Handle the defaults for unmentioned features. */
5416 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5419 const struct protocol_feature
*feature
;
5421 feature
= &remote_protocol_features
[i
];
5422 feature
->func (this, feature
, feature
->default_support
, NULL
);
5426 /* Serial QUIT handler for the remote serial descriptor.
5428 Defers handling a Ctrl-C until we're done with the current
5429 command/response packet sequence, unless:
5431 - We're setting up the connection. Don't send a remote interrupt
5432 request, as we're not fully synced yet. Quit immediately
5435 - The target has been resumed in the foreground
5436 (target_terminal::is_ours is false) with a synchronous resume
5437 packet, and we're blocked waiting for the stop reply, thus a
5438 Ctrl-C should be immediately sent to the target.
5440 - We get a second Ctrl-C while still within the same serial read or
5441 write. In that case the serial is seemingly wedged --- offer to
5444 - We see a second Ctrl-C without target response, after having
5445 previously interrupted the target. In that case the target/stub
5446 is probably wedged --- offer to quit/disconnect.
5450 remote_target::remote_serial_quit_handler ()
5452 struct remote_state
*rs
= get_remote_state ();
5454 if (check_quit_flag ())
5456 /* If we're starting up, we're not fully synced yet. Quit
5458 if (rs
->starting_up
)
5460 else if (rs
->got_ctrlc_during_io
)
5462 if (query (_("The target is not responding to GDB commands.\n"
5463 "Stop debugging it? ")))
5464 remote_unpush_and_throw (this);
5466 /* If ^C has already been sent once, offer to disconnect. */
5467 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5469 /* All-stop protocol, and blocked waiting for stop reply. Send
5470 an interrupt request. */
5471 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5472 target_interrupt ();
5474 rs
->got_ctrlc_during_io
= 1;
5478 /* The remote_target that is current while the quit handler is
5479 overridden with remote_serial_quit_handler. */
5480 static remote_target
*curr_quit_handler_target
;
5483 remote_serial_quit_handler ()
5485 curr_quit_handler_target
->remote_serial_quit_handler ();
5488 /* Remove the remote target from the target stack of each inferior
5489 that is using it. Upper targets depend on it so remove them
5493 remote_unpush_target (remote_target
*target
)
5495 /* We have to unpush the target from all inferiors, even those that
5497 scoped_restore_current_inferior restore_current_inferior
;
5499 for (inferior
*inf
: all_inferiors (target
))
5501 switch_to_inferior_no_thread (inf
);
5502 pop_all_targets_at_and_above (process_stratum
);
5503 generic_mourn_inferior ();
5508 remote_unpush_and_throw (remote_target
*target
)
5510 remote_unpush_target (target
);
5511 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5515 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5517 remote_target
*curr_remote
= get_current_remote_target ();
5520 error (_("To open a remote debug connection, you need to specify what\n"
5521 "serial device is attached to the remote system\n"
5522 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5524 /* If we're connected to a running target, target_preopen will kill it.
5525 Ask this question first, before target_preopen has a chance to kill
5527 if (curr_remote
!= NULL
&& !target_has_execution
)
5530 && !query (_("Already connected to a remote target. Disconnect? ")))
5531 error (_("Still connected."));
5534 /* Here the possibly existing remote target gets unpushed. */
5535 target_preopen (from_tty
);
5537 remote_fileio_reset ();
5538 reopen_exec_file ();
5541 remote_target
*remote
5542 = (extended_p
? new extended_remote_target () : new remote_target ());
5543 target_ops_up
target_holder (remote
);
5545 remote_state
*rs
= remote
->get_remote_state ();
5547 /* See FIXME above. */
5548 if (!target_async_permitted
)
5549 rs
->wait_forever_enabled_p
= 1;
5551 rs
->remote_desc
= remote_serial_open (name
);
5552 if (!rs
->remote_desc
)
5553 perror_with_name (name
);
5555 if (baud_rate
!= -1)
5557 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5559 /* The requested speed could not be set. Error out to
5560 top level after closing remote_desc. Take care to
5561 set remote_desc to NULL to avoid closing remote_desc
5563 serial_close (rs
->remote_desc
);
5564 rs
->remote_desc
= NULL
;
5565 perror_with_name (name
);
5569 serial_setparity (rs
->remote_desc
, serial_parity
);
5570 serial_raw (rs
->remote_desc
);
5572 /* If there is something sitting in the buffer we might take it as a
5573 response to a command, which would be bad. */
5574 serial_flush_input (rs
->remote_desc
);
5578 puts_filtered ("Remote debugging using ");
5579 puts_filtered (name
);
5580 puts_filtered ("\n");
5583 /* Switch to using the remote target now. */
5584 push_target (std::move (target_holder
));
5586 /* Register extra event sources in the event loop. */
5587 rs
->remote_async_inferior_event_token
5588 = create_async_event_handler (remote_async_inferior_event_handler
,
5590 rs
->notif_state
= remote_notif_state_allocate (remote
);
5592 /* Reset the target state; these things will be queried either by
5593 remote_query_supported or as they are needed. */
5594 reset_all_packet_configs_support ();
5595 rs
->cached_wait_status
= 0;
5596 rs
->explicit_packet_size
= 0;
5598 rs
->extended
= extended_p
;
5599 rs
->waiting_for_stop_reply
= 0;
5600 rs
->ctrlc_pending_p
= 0;
5601 rs
->got_ctrlc_during_io
= 0;
5603 rs
->general_thread
= not_sent_ptid
;
5604 rs
->continue_thread
= not_sent_ptid
;
5605 rs
->remote_traceframe_number
= -1;
5607 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5609 /* Probe for ability to use "ThreadInfo" query, as required. */
5610 rs
->use_threadinfo_query
= 1;
5611 rs
->use_threadextra_query
= 1;
5613 rs
->readahead_cache
.invalidate ();
5615 if (target_async_permitted
)
5617 /* FIXME: cagney/1999-09-23: During the initial connection it is
5618 assumed that the target is already ready and able to respond to
5619 requests. Unfortunately remote_start_remote() eventually calls
5620 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5621 around this. Eventually a mechanism that allows
5622 wait_for_inferior() to expect/get timeouts will be
5624 rs
->wait_forever_enabled_p
= 0;
5627 /* First delete any symbols previously loaded from shared libraries. */
5628 no_shared_libraries (NULL
, 0);
5630 /* Start the remote connection. If error() or QUIT, discard this
5631 target (we'd otherwise be in an inconsistent state) and then
5632 propogate the error on up the exception chain. This ensures that
5633 the caller doesn't stumble along blindly assuming that the
5634 function succeeded. The CLI doesn't have this problem but other
5635 UI's, such as MI do.
5637 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5638 this function should return an error indication letting the
5639 caller restore the previous state. Unfortunately the command
5640 ``target remote'' is directly wired to this function making that
5641 impossible. On a positive note, the CLI side of this problem has
5642 been fixed - the function set_cmd_context() makes it possible for
5643 all the ``target ....'' commands to share a common callback
5644 function. See cli-dump.c. */
5649 remote
->start_remote (from_tty
, extended_p
);
5651 catch (const gdb_exception
&ex
)
5653 /* Pop the partially set up target - unless something else did
5654 already before throwing the exception. */
5655 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5656 remote_unpush_target (remote
);
5661 remote_btrace_reset (rs
);
5663 if (target_async_permitted
)
5664 rs
->wait_forever_enabled_p
= 1;
5667 /* Detach the specified process. */
5670 remote_target::remote_detach_pid (int pid
)
5672 struct remote_state
*rs
= get_remote_state ();
5674 /* This should not be necessary, but the handling for D;PID in
5675 GDBserver versions prior to 8.2 incorrectly assumes that the
5676 selected process points to the same process we're detaching,
5677 leading to misbehavior (and possibly GDBserver crashing) when it
5678 does not. Since it's easy and cheap, work around it by forcing
5679 GDBserver to select GDB's current process. */
5680 set_general_process ();
5682 if (remote_multi_process_p (rs
))
5683 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5685 strcpy (rs
->buf
.data (), "D");
5688 getpkt (&rs
->buf
, 0);
5690 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5692 else if (rs
->buf
[0] == '\0')
5693 error (_("Remote doesn't know how to detach"));
5695 error (_("Can't detach process."));
5698 /* This detaches a program to which we previously attached, using
5699 inferior_ptid to identify the process. After this is done, GDB
5700 can be used to debug some other program. We better not have left
5701 any breakpoints in the target program or it'll die when it hits
5705 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5707 int pid
= inferior_ptid
.pid ();
5708 struct remote_state
*rs
= get_remote_state ();
5711 if (!target_has_execution
)
5712 error (_("No process to detach from."));
5714 target_announce_detach (from_tty
);
5716 /* Tell the remote target to detach. */
5717 remote_detach_pid (pid
);
5719 /* Exit only if this is the only active inferior. */
5720 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors (this) == 1)
5721 puts_filtered (_("Ending remote debugging.\n"));
5723 thread_info
*tp
= find_thread_ptid (this, inferior_ptid
);
5725 /* Check to see if we are detaching a fork parent. Note that if we
5726 are detaching a fork child, tp == NULL. */
5727 is_fork_parent
= (tp
!= NULL
5728 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5730 /* If doing detach-on-fork, we don't mourn, because that will delete
5731 breakpoints that should be available for the followed inferior. */
5732 if (!is_fork_parent
)
5734 /* Save the pid as a string before mourning, since that will
5735 unpush the remote target, and we need the string after. */
5736 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5738 target_mourn_inferior (inferior_ptid
);
5739 if (print_inferior_events
)
5740 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5741 inf
->num
, infpid
.c_str ());
5745 inferior_ptid
= null_ptid
;
5746 detach_inferior (current_inferior ());
5751 remote_target::detach (inferior
*inf
, int from_tty
)
5753 remote_detach_1 (inf
, from_tty
);
5757 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5759 remote_detach_1 (inf
, from_tty
);
5762 /* Target follow-fork function for remote targets. On entry, and
5763 at return, the current inferior is the fork parent.
5765 Note that although this is currently only used for extended-remote,
5766 it is named remote_follow_fork in anticipation of using it for the
5767 remote target as well. */
5770 remote_target::follow_fork (bool follow_child
, bool detach_fork
)
5772 struct remote_state
*rs
= get_remote_state ();
5773 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5775 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5776 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5778 /* When following the parent and detaching the child, we detach
5779 the child here. For the case of following the child and
5780 detaching the parent, the detach is done in the target-
5781 independent follow fork code in infrun.c. We can't use
5782 target_detach when detaching an unfollowed child because
5783 the client side doesn't know anything about the child. */
5784 if (detach_fork
&& !follow_child
)
5786 /* Detach the fork child. */
5790 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5791 child_pid
= child_ptid
.pid ();
5793 remote_detach_pid (child_pid
);
5800 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5801 in the program space of the new inferior. On entry and at return the
5802 current inferior is the exec'ing inferior. INF is the new exec'd
5803 inferior, which may be the same as the exec'ing inferior unless
5804 follow-exec-mode is "new". */
5807 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5809 /* We know that this is a target file name, so if it has the "target:"
5810 prefix we strip it off before saving it in the program space. */
5811 if (is_target_filename (execd_pathname
))
5812 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5814 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5817 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5820 remote_target::disconnect (const char *args
, int from_tty
)
5823 error (_("Argument given to \"disconnect\" when remotely debugging."));
5825 /* Make sure we unpush even the extended remote targets. Calling
5826 target_mourn_inferior won't unpush, and
5827 remote_target::mourn_inferior won't unpush if there is more than
5828 one inferior left. */
5829 remote_unpush_target (this);
5832 puts_filtered ("Ending remote debugging.\n");
5835 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5836 be chatty about it. */
5839 extended_remote_target::attach (const char *args
, int from_tty
)
5841 struct remote_state
*rs
= get_remote_state ();
5843 char *wait_status
= NULL
;
5845 pid
= parse_pid_to_attach (args
);
5847 /* Remote PID can be freely equal to getpid, do not check it here the same
5848 way as in other targets. */
5850 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5851 error (_("This target does not support attaching to a process"));
5855 const char *exec_file
= get_exec_file (0);
5858 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5859 target_pid_to_str (ptid_t (pid
)).c_str ());
5861 printf_unfiltered (_("Attaching to %s\n"),
5862 target_pid_to_str (ptid_t (pid
)).c_str ());
5865 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5867 getpkt (&rs
->buf
, 0);
5869 switch (packet_ok (rs
->buf
,
5870 &remote_protocol_packets
[PACKET_vAttach
]))
5873 if (!target_is_non_stop_p ())
5875 /* Save the reply for later. */
5876 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5877 strcpy (wait_status
, rs
->buf
.data ());
5879 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5880 error (_("Attaching to %s failed with: %s"),
5881 target_pid_to_str (ptid_t (pid
)).c_str (),
5884 case PACKET_UNKNOWN
:
5885 error (_("This target does not support attaching to a process"));
5887 error (_("Attaching to %s failed"),
5888 target_pid_to_str (ptid_t (pid
)).c_str ());
5891 set_current_inferior (remote_add_inferior (false, pid
, 1, 0));
5893 inferior_ptid
= ptid_t (pid
);
5895 if (target_is_non_stop_p ())
5897 struct thread_info
*thread
;
5899 /* Get list of threads. */
5900 update_thread_list ();
5902 thread
= first_thread_of_inferior (current_inferior ());
5904 inferior_ptid
= thread
->ptid
;
5906 inferior_ptid
= ptid_t (pid
);
5908 /* Invalidate our notion of the remote current thread. */
5909 record_currthread (rs
, minus_one_ptid
);
5913 /* Now, if we have thread information, update inferior_ptid. */
5914 inferior_ptid
= remote_current_thread (inferior_ptid
);
5916 /* Add the main thread to the thread list. */
5917 thread_info
*thr
= add_thread_silent (this, inferior_ptid
);
5918 /* Don't consider the thread stopped until we've processed the
5919 saved stop reply. */
5920 set_executing (this, thr
->ptid
, true);
5923 /* Next, if the target can specify a description, read it. We do
5924 this before anything involving memory or registers. */
5925 target_find_description ();
5927 if (!target_is_non_stop_p ())
5929 /* Use the previously fetched status. */
5930 gdb_assert (wait_status
!= NULL
);
5932 if (target_can_async_p ())
5934 struct notif_event
*reply
5935 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
5937 push_stop_reply ((struct stop_reply
*) reply
);
5943 gdb_assert (wait_status
!= NULL
);
5944 strcpy (rs
->buf
.data (), wait_status
);
5945 rs
->cached_wait_status
= 1;
5949 gdb_assert (wait_status
== NULL
);
5952 /* Implementation of the to_post_attach method. */
5955 extended_remote_target::post_attach (int pid
)
5957 /* Get text, data & bss offsets. */
5960 /* In certain cases GDB might not have had the chance to start
5961 symbol lookup up until now. This could happen if the debugged
5962 binary is not using shared libraries, the vsyscall page is not
5963 present (on Linux) and the binary itself hadn't changed since the
5964 debugging process was started. */
5965 if (symfile_objfile
!= NULL
)
5966 remote_check_symbols();
5970 /* Check for the availability of vCont. This function should also check
5974 remote_target::remote_vcont_probe ()
5976 remote_state
*rs
= get_remote_state ();
5979 strcpy (rs
->buf
.data (), "vCont?");
5981 getpkt (&rs
->buf
, 0);
5982 buf
= rs
->buf
.data ();
5984 /* Make sure that the features we assume are supported. */
5985 if (startswith (buf
, "vCont"))
5988 int support_c
, support_C
;
5990 rs
->supports_vCont
.s
= 0;
5991 rs
->supports_vCont
.S
= 0;
5994 rs
->supports_vCont
.t
= 0;
5995 rs
->supports_vCont
.r
= 0;
5996 while (p
&& *p
== ';')
5999 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6000 rs
->supports_vCont
.s
= 1;
6001 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6002 rs
->supports_vCont
.S
= 1;
6003 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6005 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6007 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6008 rs
->supports_vCont
.t
= 1;
6009 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6010 rs
->supports_vCont
.r
= 1;
6012 p
= strchr (p
, ';');
6015 /* If c, and C are not all supported, we can't use vCont. Clearing
6016 BUF will make packet_ok disable the packet. */
6017 if (!support_c
|| !support_C
)
6021 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
6022 rs
->supports_vCont_probed
= true;
6025 /* Helper function for building "vCont" resumptions. Write a
6026 resumption to P. ENDP points to one-passed-the-end of the buffer
6027 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
6028 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
6029 resumed thread should be single-stepped and/or signalled. If PTID
6030 equals minus_one_ptid, then all threads are resumed; if PTID
6031 represents a process, then all threads of the process are resumed;
6032 the thread to be stepped and/or signalled is given in the global
6036 remote_target::append_resumption (char *p
, char *endp
,
6037 ptid_t ptid
, int step
, gdb_signal siggnal
)
6039 struct remote_state
*rs
= get_remote_state ();
6041 if (step
&& siggnal
!= GDB_SIGNAL_0
)
6042 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
6044 /* GDB is willing to range step. */
6045 && use_range_stepping
6046 /* Target supports range stepping. */
6047 && rs
->supports_vCont
.r
6048 /* We don't currently support range stepping multiple
6049 threads with a wildcard (though the protocol allows it,
6050 so stubs shouldn't make an active effort to forbid
6052 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6054 struct thread_info
*tp
;
6056 if (ptid
== minus_one_ptid
)
6058 /* If we don't know about the target thread's tid, then
6059 we're resuming magic_null_ptid (see caller). */
6060 tp
= find_thread_ptid (this, magic_null_ptid
);
6063 tp
= find_thread_ptid (this, ptid
);
6064 gdb_assert (tp
!= NULL
);
6066 if (tp
->control
.may_range_step
)
6068 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6070 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6071 phex_nz (tp
->control
.step_range_start
,
6073 phex_nz (tp
->control
.step_range_end
,
6077 p
+= xsnprintf (p
, endp
- p
, ";s");
6080 p
+= xsnprintf (p
, endp
- p
, ";s");
6081 else if (siggnal
!= GDB_SIGNAL_0
)
6082 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6084 p
+= xsnprintf (p
, endp
- p
, ";c");
6086 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6090 /* All (-1) threads of process. */
6091 nptid
= ptid_t (ptid
.pid (), -1, 0);
6093 p
+= xsnprintf (p
, endp
- p
, ":");
6094 p
= write_ptid (p
, endp
, nptid
);
6096 else if (ptid
!= minus_one_ptid
)
6098 p
+= xsnprintf (p
, endp
- p
, ":");
6099 p
= write_ptid (p
, endp
, ptid
);
6105 /* Clear the thread's private info on resume. */
6108 resume_clear_thread_private_info (struct thread_info
*thread
)
6110 if (thread
->priv
!= NULL
)
6112 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6114 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6115 priv
->watch_data_address
= 0;
6119 /* Append a vCont continue-with-signal action for threads that have a
6120 non-zero stop signal. */
6123 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6126 for (thread_info
*thread
: all_non_exited_threads (this, ptid
))
6127 if (inferior_ptid
!= thread
->ptid
6128 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6130 p
= append_resumption (p
, endp
, thread
->ptid
,
6131 0, thread
->suspend
.stop_signal
);
6132 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6133 resume_clear_thread_private_info (thread
);
6139 /* Set the target running, using the packets that use Hc
6143 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6146 struct remote_state
*rs
= get_remote_state ();
6149 rs
->last_sent_signal
= siggnal
;
6150 rs
->last_sent_step
= step
;
6152 /* The c/s/C/S resume packets use Hc, so set the continue
6154 if (ptid
== minus_one_ptid
)
6155 set_continue_thread (any_thread_ptid
);
6157 set_continue_thread (ptid
);
6159 for (thread_info
*thread
: all_non_exited_threads (this))
6160 resume_clear_thread_private_info (thread
);
6162 buf
= rs
->buf
.data ();
6163 if (::execution_direction
== EXEC_REVERSE
)
6165 /* We don't pass signals to the target in reverse exec mode. */
6166 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6167 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6170 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6171 error (_("Remote reverse-step not supported."));
6172 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6173 error (_("Remote reverse-continue not supported."));
6175 strcpy (buf
, step
? "bs" : "bc");
6177 else if (siggnal
!= GDB_SIGNAL_0
)
6179 buf
[0] = step
? 'S' : 'C';
6180 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6181 buf
[2] = tohex (((int) siggnal
) & 0xf);
6185 strcpy (buf
, step
? "s" : "c");
6190 /* Resume the remote inferior by using a "vCont" packet. The thread
6191 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6192 resumed thread should be single-stepped and/or signalled. If PTID
6193 equals minus_one_ptid, then all threads are resumed; the thread to
6194 be stepped and/or signalled is given in the global INFERIOR_PTID.
6195 This function returns non-zero iff it resumes the inferior.
6197 This function issues a strict subset of all possible vCont commands
6201 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6202 enum gdb_signal siggnal
)
6204 struct remote_state
*rs
= get_remote_state ();
6208 /* No reverse execution actions defined for vCont. */
6209 if (::execution_direction
== EXEC_REVERSE
)
6212 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6213 remote_vcont_probe ();
6215 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6218 p
= rs
->buf
.data ();
6219 endp
= p
+ get_remote_packet_size ();
6221 /* If we could generate a wider range of packets, we'd have to worry
6222 about overflowing BUF. Should there be a generic
6223 "multi-part-packet" packet? */
6225 p
+= xsnprintf (p
, endp
- p
, "vCont");
6227 if (ptid
== magic_null_ptid
)
6229 /* MAGIC_NULL_PTID means that we don't have any active threads,
6230 so we don't have any TID numbers the inferior will
6231 understand. Make sure to only send forms that do not specify
6233 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6235 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6237 /* Resume all threads (of all processes, or of a single
6238 process), with preference for INFERIOR_PTID. This assumes
6239 inferior_ptid belongs to the set of all threads we are about
6241 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6243 /* Step inferior_ptid, with or without signal. */
6244 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6247 /* Also pass down any pending signaled resumption for other
6248 threads not the current. */
6249 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6251 /* And continue others without a signal. */
6252 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6256 /* Scheduler locking; resume only PTID. */
6257 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6260 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6263 if (target_is_non_stop_p ())
6265 /* In non-stop, the stub replies to vCont with "OK". The stop
6266 reply will be reported asynchronously by means of a `%Stop'
6268 getpkt (&rs
->buf
, 0);
6269 if (strcmp (rs
->buf
.data (), "OK") != 0)
6270 error (_("Unexpected vCont reply in non-stop mode: %s"),
6277 /* Tell the remote machine to resume. */
6280 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6282 struct remote_state
*rs
= get_remote_state ();
6284 /* When connected in non-stop mode, the core resumes threads
6285 individually. Resuming remote threads directly in target_resume
6286 would thus result in sending one packet per thread. Instead, to
6287 minimize roundtrip latency, here we just store the resume
6288 request; the actual remote resumption will be done in
6289 target_commit_resume / remote_commit_resume, where we'll be able
6290 to do vCont action coalescing. */
6291 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6293 remote_thread_info
*remote_thr
;
6295 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6296 remote_thr
= get_remote_thread_info (this, inferior_ptid
);
6298 remote_thr
= get_remote_thread_info (this, ptid
);
6300 remote_thr
->last_resume_step
= step
;
6301 remote_thr
->last_resume_sig
= siggnal
;
6305 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6306 (explained in remote-notif.c:handle_notification) so
6307 remote_notif_process is not called. We need find a place where
6308 it is safe to start a 'vNotif' sequence. It is good to do it
6309 before resuming inferior, because inferior was stopped and no RSP
6310 traffic at that moment. */
6311 if (!target_is_non_stop_p ())
6312 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6314 rs
->last_resume_exec_dir
= ::execution_direction
;
6316 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6317 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6318 remote_resume_with_hc (ptid
, step
, siggnal
);
6320 /* We are about to start executing the inferior, let's register it
6321 with the event loop. NOTE: this is the one place where all the
6322 execution commands end up. We could alternatively do this in each
6323 of the execution commands in infcmd.c. */
6324 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6325 into infcmd.c in order to allow inferior function calls to work
6326 NOT asynchronously. */
6327 if (target_can_async_p ())
6330 /* We've just told the target to resume. The remote server will
6331 wait for the inferior to stop, and then send a stop reply. In
6332 the mean time, we can't start another command/query ourselves
6333 because the stub wouldn't be ready to process it. This applies
6334 only to the base all-stop protocol, however. In non-stop (which
6335 only supports vCont), the stub replies with an "OK", and is
6336 immediate able to process further serial input. */
6337 if (!target_is_non_stop_p ())
6338 rs
->waiting_for_stop_reply
= 1;
6341 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6343 /* Private per-inferior info for target remote processes. */
6345 struct remote_inferior
: public private_inferior
6347 /* Whether we can send a wildcard vCont for this process. */
6348 bool may_wildcard_vcont
= true;
6351 /* Get the remote private inferior data associated to INF. */
6353 static remote_inferior
*
6354 get_remote_inferior (inferior
*inf
)
6356 if (inf
->priv
== NULL
)
6357 inf
->priv
.reset (new remote_inferior
);
6359 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6362 /* Class used to track the construction of a vCont packet in the
6363 outgoing packet buffer. This is used to send multiple vCont
6364 packets if we have more actions than would fit a single packet. */
6369 explicit vcont_builder (remote_target
*remote
)
6376 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6381 /* The remote target. */
6382 remote_target
*m_remote
;
6384 /* Pointer to the first action. P points here if no action has been
6386 char *m_first_action
;
6388 /* Where the next action will be appended. */
6391 /* The end of the buffer. Must never write past this. */
6395 /* Prepare the outgoing buffer for a new vCont packet. */
6398 vcont_builder::restart ()
6400 struct remote_state
*rs
= m_remote
->get_remote_state ();
6402 m_p
= rs
->buf
.data ();
6403 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6404 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6405 m_first_action
= m_p
;
6408 /* If the vCont packet being built has any action, send it to the
6412 vcont_builder::flush ()
6414 struct remote_state
*rs
;
6416 if (m_p
== m_first_action
)
6419 rs
= m_remote
->get_remote_state ();
6420 m_remote
->putpkt (rs
->buf
);
6421 m_remote
->getpkt (&rs
->buf
, 0);
6422 if (strcmp (rs
->buf
.data (), "OK") != 0)
6423 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6426 /* The largest action is range-stepping, with its two addresses. This
6427 is more than sufficient. If a new, bigger action is created, it'll
6428 quickly trigger a failed assertion in append_resumption (and we'll
6430 #define MAX_ACTION_SIZE 200
6432 /* Append a new vCont action in the outgoing packet being built. If
6433 the action doesn't fit the packet along with previous actions, push
6434 what we've got so far to the remote end and start over a new vCont
6435 packet (with the new action). */
6438 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6440 char buf
[MAX_ACTION_SIZE
+ 1];
6442 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6443 ptid
, step
, siggnal
);
6445 /* Check whether this new action would fit in the vCont packet along
6446 with previous actions. If not, send what we've got so far and
6447 start a new vCont packet. */
6448 size_t rsize
= endp
- buf
;
6449 if (rsize
> m_endp
- m_p
)
6454 /* Should now fit. */
6455 gdb_assert (rsize
<= m_endp
- m_p
);
6458 memcpy (m_p
, buf
, rsize
);
6463 /* to_commit_resume implementation. */
6466 remote_target::commit_resume ()
6468 int any_process_wildcard
;
6469 int may_global_wildcard_vcont
;
6471 /* If connected in all-stop mode, we'd send the remote resume
6472 request directly from remote_resume. Likewise if
6473 reverse-debugging, as there are no defined vCont actions for
6474 reverse execution. */
6475 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6478 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6479 instead of resuming all threads of each process individually.
6480 However, if any thread of a process must remain halted, we can't
6481 send wildcard resumes and must send one action per thread.
6483 Care must be taken to not resume threads/processes the server
6484 side already told us are stopped, but the core doesn't know about
6485 yet, because the events are still in the vStopped notification
6488 #1 => vCont s:p1.1;c
6490 #3 <= %Stopped T05 p1.1
6495 #8 (infrun handles the stop for p1.1 and continues stepping)
6496 #9 => vCont s:p1.1;c
6498 The last vCont above would resume thread p1.2 by mistake, because
6499 the server has no idea that the event for p1.2 had not been
6502 The server side must similarly ignore resume actions for the
6503 thread that has a pending %Stopped notification (and any other
6504 threads with events pending), until GDB acks the notification
6505 with vStopped. Otherwise, e.g., the following case is
6508 #1 => g (or any other packet)
6510 #3 <= %Stopped T05 p1.2
6511 #4 => vCont s:p1.1;c
6514 Above, the server must not resume thread p1.2. GDB can't know
6515 that p1.2 stopped until it acks the %Stopped notification, and
6516 since from GDB's perspective all threads should be running, it
6519 Finally, special care must also be given to handling fork/vfork
6520 events. A (v)fork event actually tells us that two processes
6521 stopped -- the parent and the child. Until we follow the fork,
6522 we must not resume the child. Therefore, if we have a pending
6523 fork follow, we must not send a global wildcard resume action
6524 (vCont;c). We can still send process-wide wildcards though. */
6526 /* Start by assuming a global wildcard (vCont;c) is possible. */
6527 may_global_wildcard_vcont
= 1;
6529 /* And assume every process is individually wildcard-able too. */
6530 for (inferior
*inf
: all_non_exited_inferiors (this))
6532 remote_inferior
*priv
= get_remote_inferior (inf
);
6534 priv
->may_wildcard_vcont
= true;
6537 /* Check for any pending events (not reported or processed yet) and
6538 disable process and global wildcard resumes appropriately. */
6539 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6541 for (thread_info
*tp
: all_non_exited_threads (this))
6543 /* If a thread of a process is not meant to be resumed, then we
6544 can't wildcard that process. */
6547 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6549 /* And if we can't wildcard a process, we can't wildcard
6550 everything either. */
6551 may_global_wildcard_vcont
= 0;
6555 /* If a thread is the parent of an unfollowed fork, then we
6556 can't do a global wildcard, as that would resume the fork
6558 if (is_pending_fork_parent_thread (tp
))
6559 may_global_wildcard_vcont
= 0;
6562 /* Now let's build the vCont packet(s). Actions must be appended
6563 from narrower to wider scopes (thread -> process -> global). If
6564 we end up with too many actions for a single packet vcont_builder
6565 flushes the current vCont packet to the remote side and starts a
6567 struct vcont_builder
vcont_builder (this);
6569 /* Threads first. */
6570 for (thread_info
*tp
: all_non_exited_threads (this))
6572 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6574 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6577 gdb_assert (!thread_is_in_step_over_chain (tp
));
6579 if (!remote_thr
->last_resume_step
6580 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6581 && get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6583 /* We'll send a wildcard resume instead. */
6584 remote_thr
->vcont_resumed
= 1;
6588 vcont_builder
.push_action (tp
->ptid
,
6589 remote_thr
->last_resume_step
,
6590 remote_thr
->last_resume_sig
);
6591 remote_thr
->vcont_resumed
= 1;
6594 /* Now check whether we can send any process-wide wildcard. This is
6595 to avoid sending a global wildcard in the case nothing is
6596 supposed to be resumed. */
6597 any_process_wildcard
= 0;
6599 for (inferior
*inf
: all_non_exited_inferiors (this))
6601 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6603 any_process_wildcard
= 1;
6608 if (any_process_wildcard
)
6610 /* If all processes are wildcard-able, then send a single "c"
6611 action, otherwise, send an "all (-1) threads of process"
6612 continue action for each running process, if any. */
6613 if (may_global_wildcard_vcont
)
6615 vcont_builder
.push_action (minus_one_ptid
,
6616 false, GDB_SIGNAL_0
);
6620 for (inferior
*inf
: all_non_exited_inferiors (this))
6622 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6624 vcont_builder
.push_action (ptid_t (inf
->pid
),
6625 false, GDB_SIGNAL_0
);
6631 vcont_builder
.flush ();
6636 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6637 thread, all threads of a remote process, or all threads of all
6641 remote_target::remote_stop_ns (ptid_t ptid
)
6643 struct remote_state
*rs
= get_remote_state ();
6644 char *p
= rs
->buf
.data ();
6645 char *endp
= p
+ get_remote_packet_size ();
6647 /* FIXME: This supports_vCont_probed check is a workaround until
6648 packet_support is per-connection. */
6649 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
6650 || !rs
->supports_vCont_probed
)
6651 remote_vcont_probe ();
6653 if (!rs
->supports_vCont
.t
)
6654 error (_("Remote server does not support stopping threads"));
6656 if (ptid
== minus_one_ptid
6657 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6658 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6663 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6666 /* All (-1) threads of process. */
6667 nptid
= ptid_t (ptid
.pid (), -1, 0);
6670 /* Small optimization: if we already have a stop reply for
6671 this thread, no use in telling the stub we want this
6673 if (peek_stop_reply (ptid
))
6679 write_ptid (p
, endp
, nptid
);
6682 /* In non-stop, we get an immediate OK reply. The stop reply will
6683 come in asynchronously by notification. */
6685 getpkt (&rs
->buf
, 0);
6686 if (strcmp (rs
->buf
.data (), "OK") != 0)
6687 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6691 /* All-stop version of target_interrupt. Sends a break or a ^C to
6692 interrupt the remote target. It is undefined which thread of which
6693 process reports the interrupt. */
6696 remote_target::remote_interrupt_as ()
6698 struct remote_state
*rs
= get_remote_state ();
6700 rs
->ctrlc_pending_p
= 1;
6702 /* If the inferior is stopped already, but the core didn't know
6703 about it yet, just ignore the request. The cached wait status
6704 will be collected in remote_wait. */
6705 if (rs
->cached_wait_status
)
6708 /* Send interrupt_sequence to remote target. */
6709 send_interrupt_sequence ();
6712 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6713 the remote target. It is undefined which thread of which process
6714 reports the interrupt. Throws an error if the packet is not
6715 supported by the server. */
6718 remote_target::remote_interrupt_ns ()
6720 struct remote_state
*rs
= get_remote_state ();
6721 char *p
= rs
->buf
.data ();
6722 char *endp
= p
+ get_remote_packet_size ();
6724 xsnprintf (p
, endp
- p
, "vCtrlC");
6726 /* In non-stop, we get an immediate OK reply. The stop reply will
6727 come in asynchronously by notification. */
6729 getpkt (&rs
->buf
, 0);
6731 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6735 case PACKET_UNKNOWN
:
6736 error (_("No support for interrupting the remote target."));
6738 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6742 /* Implement the to_stop function for the remote targets. */
6745 remote_target::stop (ptid_t ptid
)
6748 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6750 if (target_is_non_stop_p ())
6751 remote_stop_ns (ptid
);
6754 /* We don't currently have a way to transparently pause the
6755 remote target in all-stop mode. Interrupt it instead. */
6756 remote_interrupt_as ();
6760 /* Implement the to_interrupt function for the remote targets. */
6763 remote_target::interrupt ()
6766 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6768 if (target_is_non_stop_p ())
6769 remote_interrupt_ns ();
6771 remote_interrupt_as ();
6774 /* Implement the to_pass_ctrlc function for the remote targets. */
6777 remote_target::pass_ctrlc ()
6779 struct remote_state
*rs
= get_remote_state ();
6782 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6784 /* If we're starting up, we're not fully synced yet. Quit
6786 if (rs
->starting_up
)
6788 /* If ^C has already been sent once, offer to disconnect. */
6789 else if (rs
->ctrlc_pending_p
)
6792 target_interrupt ();
6795 /* Ask the user what to do when an interrupt is received. */
6798 remote_target::interrupt_query ()
6800 struct remote_state
*rs
= get_remote_state ();
6802 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6804 if (query (_("The target is not responding to interrupt requests.\n"
6805 "Stop debugging it? ")))
6807 remote_unpush_target (this);
6808 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6813 if (query (_("Interrupted while waiting for the program.\n"
6814 "Give up waiting? ")))
6819 /* Enable/disable target terminal ownership. Most targets can use
6820 terminal groups to control terminal ownership. Remote targets are
6821 different in that explicit transfer of ownership to/from GDB/target
6825 remote_target::terminal_inferior ()
6827 /* NOTE: At this point we could also register our selves as the
6828 recipient of all input. Any characters typed could then be
6829 passed on down to the target. */
6833 remote_target::terminal_ours ()
6838 remote_console_output (const char *msg
)
6842 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6845 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6849 gdb_stdtarg
->puts (tb
);
6851 gdb_stdtarg
->flush ();
6854 struct stop_reply
: public notif_event
6858 /* The identifier of the thread about this event */
6861 /* The remote state this event is associated with. When the remote
6862 connection, represented by a remote_state object, is closed,
6863 all the associated stop_reply events should be released. */
6864 struct remote_state
*rs
;
6866 struct target_waitstatus ws
;
6868 /* The architecture associated with the expedited registers. */
6871 /* Expedited registers. This makes remote debugging a bit more
6872 efficient for those targets that provide critical registers as
6873 part of their normal status mechanism (as another roundtrip to
6874 fetch them is avoided). */
6875 std::vector
<cached_reg_t
> regcache
;
6877 enum target_stop_reason stop_reason
;
6879 CORE_ADDR watch_data_address
;
6884 /* Return the length of the stop reply queue. */
6887 remote_target::stop_reply_queue_length ()
6889 remote_state
*rs
= get_remote_state ();
6890 return rs
->stop_reply_queue
.size ();
6894 remote_notif_stop_parse (remote_target
*remote
,
6895 struct notif_client
*self
, const char *buf
,
6896 struct notif_event
*event
)
6898 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6902 remote_notif_stop_ack (remote_target
*remote
,
6903 struct notif_client
*self
, const char *buf
,
6904 struct notif_event
*event
)
6906 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6909 putpkt (remote
, self
->ack_command
);
6911 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6913 /* We got an unknown stop reply. */
6914 error (_("Unknown stop reply"));
6917 remote
->push_stop_reply (stop_reply
);
6921 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
6922 struct notif_client
*self
)
6924 /* We can't get pending events in remote_notif_process for
6925 notification stop, and we have to do this in remote_wait_ns
6926 instead. If we fetch all queued events from stub, remote stub
6927 may exit and we have no chance to process them back in
6929 remote_state
*rs
= remote
->get_remote_state ();
6930 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
6934 stop_reply::~stop_reply ()
6936 for (cached_reg_t
®
: regcache
)
6940 static notif_event_up
6941 remote_notif_stop_alloc_reply ()
6943 return notif_event_up (new struct stop_reply ());
6946 /* A client of notification Stop. */
6948 struct notif_client notif_client_stop
=
6952 remote_notif_stop_parse
,
6953 remote_notif_stop_ack
,
6954 remote_notif_stop_can_get_pending_events
,
6955 remote_notif_stop_alloc_reply
,
6959 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6960 the pid of the process that owns the threads we want to check, or
6961 -1 if we want to check all threads. */
6964 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6967 if (ws
->kind
== TARGET_WAITKIND_FORKED
6968 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6970 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
6977 /* Return the thread's pending status used to determine whether the
6978 thread is a fork parent stopped at a fork event. */
6980 static struct target_waitstatus
*
6981 thread_pending_fork_status (struct thread_info
*thread
)
6983 if (thread
->suspend
.waitstatus_pending_p
)
6984 return &thread
->suspend
.waitstatus
;
6986 return &thread
->pending_follow
;
6989 /* Determine if THREAD is a pending fork parent thread. */
6992 is_pending_fork_parent_thread (struct thread_info
*thread
)
6994 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6997 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
7000 /* If CONTEXT contains any fork child threads that have not been
7001 reported yet, remove them from the CONTEXT list. If such a
7002 thread exists it is because we are stopped at a fork catchpoint
7003 and have not yet called follow_fork, which will set up the
7004 host-side data structures for the new process. */
7007 remote_target::remove_new_fork_children (threads_listing_context
*context
)
7010 struct notif_client
*notif
= ¬if_client_stop
;
7012 /* For any threads stopped at a fork event, remove the corresponding
7013 fork child threads from the CONTEXT list. */
7014 for (thread_info
*thread
: all_non_exited_threads (this))
7016 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
7018 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
7019 context
->remove_thread (ws
->value
.related_pid
);
7022 /* Check for any pending fork events (not reported or processed yet)
7023 in process PID and remove those fork child threads from the
7024 CONTEXT list as well. */
7025 remote_notif_get_pending_events (notif
);
7026 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7027 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7028 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
7029 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
7030 context
->remove_thread (event
->ws
.value
.related_pid
);
7033 /* Check whether any event pending in the vStopped queue would prevent
7034 a global or process wildcard vCont action. Clear
7035 *may_global_wildcard if we can't do a global wildcard (vCont;c),
7036 and clear the event inferior's may_wildcard_vcont flag if we can't
7037 do a process-wide wildcard resume (vCont;c:pPID.-1). */
7040 remote_target::check_pending_events_prevent_wildcard_vcont
7041 (int *may_global_wildcard
)
7043 struct notif_client
*notif
= ¬if_client_stop
;
7045 remote_notif_get_pending_events (notif
);
7046 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7048 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
7049 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
7052 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7053 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
7054 *may_global_wildcard
= 0;
7056 struct inferior
*inf
= find_inferior_ptid (this, event
->ptid
);
7058 /* This may be the first time we heard about this process.
7059 Regardless, we must not do a global wildcard resume, otherwise
7060 we'd resume this process too. */
7061 *may_global_wildcard
= 0;
7063 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7067 /* Discard all pending stop replies of inferior INF. */
7070 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7072 struct stop_reply
*reply
;
7073 struct remote_state
*rs
= get_remote_state ();
7074 struct remote_notif_state
*rns
= rs
->notif_state
;
7076 /* This function can be notified when an inferior exists. When the
7077 target is not remote, the notification state is NULL. */
7078 if (rs
->remote_desc
== NULL
)
7081 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7083 /* Discard the in-flight notification. */
7084 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7087 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7090 /* Discard the stop replies we have already pulled with
7092 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7093 rs
->stop_reply_queue
.end (),
7094 [=] (const stop_reply_up
&event
)
7096 return event
->ptid
.pid () == inf
->pid
;
7098 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7101 /* Discard the stop replies for RS in stop_reply_queue. */
7104 remote_target::discard_pending_stop_replies_in_queue ()
7106 remote_state
*rs
= get_remote_state ();
7108 /* Discard the stop replies we have already pulled with
7110 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7111 rs
->stop_reply_queue
.end (),
7112 [=] (const stop_reply_up
&event
)
7114 return event
->rs
== rs
;
7116 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7119 /* Remove the first reply in 'stop_reply_queue' which matches
7123 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7125 remote_state
*rs
= get_remote_state ();
7127 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7128 rs
->stop_reply_queue
.end (),
7129 [=] (const stop_reply_up
&event
)
7131 return event
->ptid
.matches (ptid
);
7133 struct stop_reply
*result
;
7134 if (iter
== rs
->stop_reply_queue
.end ())
7138 result
= iter
->release ();
7139 rs
->stop_reply_queue
.erase (iter
);
7143 fprintf_unfiltered (gdb_stdlog
,
7144 "notif: discard queued event: 'Stop' in %s\n",
7145 target_pid_to_str (ptid
).c_str ());
7150 /* Look for a queued stop reply belonging to PTID. If one is found,
7151 remove it from the queue, and return it. Returns NULL if none is
7152 found. If there are still queued events left to process, tell the
7153 event loop to get back to target_wait soon. */
7156 remote_target::queued_stop_reply (ptid_t ptid
)
7158 remote_state
*rs
= get_remote_state ();
7159 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7161 if (!rs
->stop_reply_queue
.empty ())
7163 /* There's still at least an event left. */
7164 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7170 /* Push a fully parsed stop reply in the stop reply queue. Since we
7171 know that we now have at least one queued event left to pass to the
7172 core side, tell the event loop to get back to target_wait soon. */
7175 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7177 remote_state
*rs
= get_remote_state ();
7178 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7181 fprintf_unfiltered (gdb_stdlog
,
7182 "notif: push 'Stop' %s to queue %d\n",
7183 target_pid_to_str (new_event
->ptid
).c_str (),
7184 int (rs
->stop_reply_queue
.size ()));
7186 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7189 /* Returns true if we have a stop reply for PTID. */
7192 remote_target::peek_stop_reply (ptid_t ptid
)
7194 remote_state
*rs
= get_remote_state ();
7195 for (auto &event
: rs
->stop_reply_queue
)
7196 if (ptid
== event
->ptid
7197 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7202 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7203 starting with P and ending with PEND matches PREFIX. */
7206 strprefix (const char *p
, const char *pend
, const char *prefix
)
7208 for ( ; p
< pend
; p
++, prefix
++)
7211 return *prefix
== '\0';
7214 /* Parse the stop reply in BUF. Either the function succeeds, and the
7215 result is stored in EVENT, or throws an error. */
7218 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7220 remote_arch_state
*rsa
= NULL
;
7225 event
->ptid
= null_ptid
;
7226 event
->rs
= get_remote_state ();
7227 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7228 event
->ws
.value
.integer
= 0;
7229 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7230 event
->regcache
.clear ();
7235 case 'T': /* Status with PC, SP, FP, ... */
7236 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7237 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7239 n... = register number
7240 r... = register contents
7243 p
= &buf
[3]; /* after Txx */
7249 p1
= strchr (p
, ':');
7251 error (_("Malformed packet(a) (missing colon): %s\n\
7255 error (_("Malformed packet(a) (missing register number): %s\n\
7259 /* Some "registers" are actually extended stop information.
7260 Note if you're adding a new entry here: GDB 7.9 and
7261 earlier assume that all register "numbers" that start
7262 with an hex digit are real register numbers. Make sure
7263 the server only sends such a packet if it knows the
7264 client understands it. */
7266 if (strprefix (p
, p1
, "thread"))
7267 event
->ptid
= read_ptid (++p1
, &p
);
7268 else if (strprefix (p
, p1
, "syscall_entry"))
7272 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7273 p
= unpack_varlen_hex (++p1
, &sysno
);
7274 event
->ws
.value
.syscall_number
= (int) sysno
;
7276 else if (strprefix (p
, p1
, "syscall_return"))
7280 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7281 p
= unpack_varlen_hex (++p1
, &sysno
);
7282 event
->ws
.value
.syscall_number
= (int) sysno
;
7284 else if (strprefix (p
, p1
, "watch")
7285 || strprefix (p
, p1
, "rwatch")
7286 || strprefix (p
, p1
, "awatch"))
7288 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7289 p
= unpack_varlen_hex (++p1
, &addr
);
7290 event
->watch_data_address
= (CORE_ADDR
) addr
;
7292 else if (strprefix (p
, p1
, "swbreak"))
7294 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7296 /* Make sure the stub doesn't forget to indicate support
7298 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7299 error (_("Unexpected swbreak stop reason"));
7301 /* The value part is documented as "must be empty",
7302 though we ignore it, in case we ever decide to make
7303 use of it in a backward compatible way. */
7304 p
= strchrnul (p1
+ 1, ';');
7306 else if (strprefix (p
, p1
, "hwbreak"))
7308 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7310 /* Make sure the stub doesn't forget to indicate support
7312 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7313 error (_("Unexpected hwbreak stop reason"));
7316 p
= strchrnul (p1
+ 1, ';');
7318 else if (strprefix (p
, p1
, "library"))
7320 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7321 p
= strchrnul (p1
+ 1, ';');
7323 else if (strprefix (p
, p1
, "replaylog"))
7325 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7326 /* p1 will indicate "begin" or "end", but it makes
7327 no difference for now, so ignore it. */
7328 p
= strchrnul (p1
+ 1, ';');
7330 else if (strprefix (p
, p1
, "core"))
7334 p
= unpack_varlen_hex (++p1
, &c
);
7337 else if (strprefix (p
, p1
, "fork"))
7339 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7340 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7342 else if (strprefix (p
, p1
, "vfork"))
7344 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7345 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7347 else if (strprefix (p
, p1
, "vforkdone"))
7349 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7350 p
= strchrnul (p1
+ 1, ';');
7352 else if (strprefix (p
, p1
, "exec"))
7357 /* Determine the length of the execd pathname. */
7358 p
= unpack_varlen_hex (++p1
, &ignored
);
7359 pathlen
= (p
- p1
) / 2;
7361 /* Save the pathname for event reporting and for
7362 the next run command. */
7363 gdb::unique_xmalloc_ptr
<char[]> pathname
7364 ((char *) xmalloc (pathlen
+ 1));
7365 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7366 pathname
[pathlen
] = '\0';
7368 /* This is freed during event handling. */
7369 event
->ws
.value
.execd_pathname
= pathname
.release ();
7370 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7372 /* Skip the registers included in this packet, since
7373 they may be for an architecture different from the
7374 one used by the original program. */
7377 else if (strprefix (p
, p1
, "create"))
7379 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7380 p
= strchrnul (p1
+ 1, ';');
7389 p
= strchrnul (p1
+ 1, ';');
7394 /* Maybe a real ``P'' register number. */
7395 p_temp
= unpack_varlen_hex (p
, &pnum
);
7396 /* If the first invalid character is the colon, we got a
7397 register number. Otherwise, it's an unknown stop
7401 /* If we haven't parsed the event's thread yet, find
7402 it now, in order to find the architecture of the
7403 reported expedited registers. */
7404 if (event
->ptid
== null_ptid
)
7406 /* If there is no thread-id information then leave
7407 the event->ptid as null_ptid. Later in
7408 process_stop_reply we will pick a suitable
7410 const char *thr
= strstr (p1
+ 1, ";thread:");
7412 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7419 = (event
->ptid
== null_ptid
7421 : find_inferior_ptid (this, event
->ptid
));
7422 /* If this is the first time we learn anything
7423 about this process, skip the registers
7424 included in this packet, since we don't yet
7425 know which architecture to use to parse them.
7426 We'll determine the architecture later when
7427 we process the stop reply and retrieve the
7428 target description, via
7429 remote_notice_new_inferior ->
7430 post_create_inferior. */
7433 p
= strchrnul (p1
+ 1, ';');
7438 event
->arch
= inf
->gdbarch
;
7439 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7443 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7444 cached_reg_t cached_reg
;
7447 error (_("Remote sent bad register number %s: %s\n\
7449 hex_string (pnum
), p
, buf
);
7451 cached_reg
.num
= reg
->regnum
;
7452 cached_reg
.data
= (gdb_byte
*)
7453 xmalloc (register_size (event
->arch
, reg
->regnum
));
7456 fieldsize
= hex2bin (p
, cached_reg
.data
,
7457 register_size (event
->arch
, reg
->regnum
));
7459 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7460 warning (_("Remote reply is too short: %s"), buf
);
7462 event
->regcache
.push_back (cached_reg
);
7466 /* Not a number. Silently skip unknown optional
7468 p
= strchrnul (p1
+ 1, ';');
7473 error (_("Remote register badly formatted: %s\nhere: %s"),
7478 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7482 case 'S': /* Old style status, just signal only. */
7486 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7487 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7488 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7489 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7491 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7494 case 'w': /* Thread exited. */
7498 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7499 p
= unpack_varlen_hex (&buf
[1], &value
);
7500 event
->ws
.value
.integer
= value
;
7502 error (_("stop reply packet badly formatted: %s"), buf
);
7503 event
->ptid
= read_ptid (++p
, NULL
);
7506 case 'W': /* Target exited. */
7511 /* GDB used to accept only 2 hex chars here. Stubs should
7512 only send more if they detect GDB supports multi-process
7514 p
= unpack_varlen_hex (&buf
[1], &value
);
7518 /* The remote process exited. */
7519 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7520 event
->ws
.value
.integer
= value
;
7524 /* The remote process exited with a signal. */
7525 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7526 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7527 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7529 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7532 /* If no process is specified, return null_ptid, and let the
7533 caller figure out the right process to use. */
7543 else if (startswith (p
, "process:"))
7547 p
+= sizeof ("process:") - 1;
7548 unpack_varlen_hex (p
, &upid
);
7552 error (_("unknown stop reply packet: %s"), buf
);
7555 error (_("unknown stop reply packet: %s"), buf
);
7556 event
->ptid
= ptid_t (pid
);
7560 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7561 event
->ptid
= minus_one_ptid
;
7566 /* When the stub wants to tell GDB about a new notification reply, it
7567 sends a notification (%Stop, for example). Those can come it at
7568 any time, hence, we have to make sure that any pending
7569 putpkt/getpkt sequence we're making is finished, before querying
7570 the stub for more events with the corresponding ack command
7571 (vStopped, for example). E.g., if we started a vStopped sequence
7572 immediately upon receiving the notification, something like this
7580 1.6) <-- (registers reply to step #1.3)
7582 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7585 To solve this, whenever we parse a %Stop notification successfully,
7586 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7587 doing whatever we were doing:
7593 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7594 2.5) <-- (registers reply to step #2.3)
7596 Eventually after step #2.5, we return to the event loop, which
7597 notices there's an event on the
7598 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7599 associated callback --- the function below. At this point, we're
7600 always safe to start a vStopped sequence. :
7603 2.7) <-- T05 thread:2
7609 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7611 struct remote_state
*rs
= get_remote_state ();
7613 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7616 fprintf_unfiltered (gdb_stdlog
,
7617 "notif: process: '%s' ack pending event\n",
7621 nc
->ack (this, nc
, rs
->buf
.data (),
7622 rs
->notif_state
->pending_event
[nc
->id
]);
7623 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7627 getpkt (&rs
->buf
, 0);
7628 if (strcmp (rs
->buf
.data (), "OK") == 0)
7631 remote_notif_ack (this, nc
, rs
->buf
.data ());
7637 fprintf_unfiltered (gdb_stdlog
,
7638 "notif: process: '%s' no pending reply\n",
7643 /* Wrapper around remote_target::remote_notif_get_pending_events to
7644 avoid having to export the whole remote_target class. */
7647 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7649 remote
->remote_notif_get_pending_events (nc
);
7652 /* Called when it is decided that STOP_REPLY holds the info of the
7653 event that is to be returned to the core. This function always
7654 destroys STOP_REPLY. */
7657 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7658 struct target_waitstatus
*status
)
7662 *status
= stop_reply
->ws
;
7663 ptid
= stop_reply
->ptid
;
7665 /* If no thread/process was reported by the stub then use the first
7666 non-exited thread in the current target. */
7667 if (ptid
== null_ptid
)
7669 /* Some stop events apply to all threads in an inferior, while others
7670 only apply to a single thread. */
7671 bool is_stop_for_all_threads
7672 = (status
->kind
== TARGET_WAITKIND_EXITED
7673 || status
->kind
== TARGET_WAITKIND_SIGNALLED
);
7675 for (thread_info
*thr
: all_non_exited_threads (this))
7677 if (ptid
!= null_ptid
7678 && (!is_stop_for_all_threads
7679 || ptid
.pid () != thr
->ptid
.pid ()))
7681 static bool warned
= false;
7685 /* If you are seeing this warning then the remote target
7686 has stopped without specifying a thread-id, but the
7687 target does have multiple threads (or inferiors), and
7688 so GDB is having to guess which thread stopped.
7690 Examples of what might cause this are the target
7691 sending and 'S' stop packet, or a 'T' stop packet and
7692 not including a thread-id.
7694 Additionally, the target might send a 'W' or 'X
7695 packet without including a process-id, when the target
7696 has multiple running inferiors. */
7697 if (is_stop_for_all_threads
)
7698 warning (_("multi-inferior target stopped without "
7699 "sending a process-id, using first "
7700 "non-exited inferior"));
7702 warning (_("multi-threaded target stopped without "
7703 "sending a thread-id, using first "
7704 "non-exited thread"));
7710 /* If this is a stop for all threads then don't use a particular
7711 threads ptid, instead create a new ptid where only the pid
7713 if (is_stop_for_all_threads
)
7714 ptid
= ptid_t (thr
->ptid
.pid ());
7718 gdb_assert (ptid
!= null_ptid
);
7721 if (status
->kind
!= TARGET_WAITKIND_EXITED
7722 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7723 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7725 /* Expedited registers. */
7726 if (!stop_reply
->regcache
.empty ())
7728 struct regcache
*regcache
7729 = get_thread_arch_regcache (this, ptid
, stop_reply
->arch
);
7731 for (cached_reg_t
®
: stop_reply
->regcache
)
7733 regcache
->raw_supply (reg
.num
, reg
.data
);
7737 stop_reply
->regcache
.clear ();
7740 remote_notice_new_inferior (ptid
, 0);
7741 remote_thread_info
*remote_thr
= get_remote_thread_info (this, ptid
);
7742 remote_thr
->core
= stop_reply
->core
;
7743 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7744 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7745 remote_thr
->vcont_resumed
= 0;
7752 /* The non-stop mode version of target_wait. */
7755 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7757 struct remote_state
*rs
= get_remote_state ();
7758 struct stop_reply
*stop_reply
;
7762 /* If in non-stop mode, get out of getpkt even if a
7763 notification is received. */
7765 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7768 if (ret
!= -1 && !is_notif
)
7771 case 'E': /* Error of some sort. */
7772 /* We're out of sync with the target now. Did it continue
7773 or not? We can't tell which thread it was in non-stop,
7774 so just ignore this. */
7775 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7777 case 'O': /* Console output. */
7778 remote_console_output (&rs
->buf
[1]);
7781 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7785 /* Acknowledge a pending stop reply that may have arrived in the
7787 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7788 remote_notif_get_pending_events (¬if_client_stop
);
7790 /* If indeed we noticed a stop reply, we're done. */
7791 stop_reply
= queued_stop_reply (ptid
);
7792 if (stop_reply
!= NULL
)
7793 return process_stop_reply (stop_reply
, status
);
7795 /* Still no event. If we're just polling for an event, then
7796 return to the event loop. */
7797 if (options
& TARGET_WNOHANG
)
7799 status
->kind
= TARGET_WAITKIND_IGNORE
;
7800 return minus_one_ptid
;
7803 /* Otherwise do a blocking wait. */
7804 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7808 /* Return the first resumed thread. */
7811 first_remote_resumed_thread (remote_target
*target
)
7813 for (thread_info
*tp
: all_non_exited_threads (target
, minus_one_ptid
))
7819 /* Wait until the remote machine stops, then return, storing status in
7820 STATUS just as `wait' would. */
7823 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
, int options
)
7825 struct remote_state
*rs
= get_remote_state ();
7826 ptid_t event_ptid
= null_ptid
;
7828 struct stop_reply
*stop_reply
;
7832 status
->kind
= TARGET_WAITKIND_IGNORE
;
7833 status
->value
.integer
= 0;
7835 stop_reply
= queued_stop_reply (ptid
);
7836 if (stop_reply
!= NULL
)
7837 return process_stop_reply (stop_reply
, status
);
7839 if (rs
->cached_wait_status
)
7840 /* Use the cached wait status, but only once. */
7841 rs
->cached_wait_status
= 0;
7846 int forever
= ((options
& TARGET_WNOHANG
) == 0
7847 && rs
->wait_forever_enabled_p
);
7849 if (!rs
->waiting_for_stop_reply
)
7851 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7852 return minus_one_ptid
;
7855 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7856 _never_ wait for ever -> test on target_is_async_p().
7857 However, before we do that we need to ensure that the caller
7858 knows how to take the target into/out of async mode. */
7859 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
7861 /* GDB gets a notification. Return to core as this event is
7863 if (ret
!= -1 && is_notif
)
7864 return minus_one_ptid
;
7866 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7867 return minus_one_ptid
;
7870 buf
= rs
->buf
.data ();
7872 /* Assume that the target has acknowledged Ctrl-C unless we receive
7873 an 'F' or 'O' packet. */
7874 if (buf
[0] != 'F' && buf
[0] != 'O')
7875 rs
->ctrlc_pending_p
= 0;
7879 case 'E': /* Error of some sort. */
7880 /* We're out of sync with the target now. Did it continue or
7881 not? Not is more likely, so report a stop. */
7882 rs
->waiting_for_stop_reply
= 0;
7884 warning (_("Remote failure reply: %s"), buf
);
7885 status
->kind
= TARGET_WAITKIND_STOPPED
;
7886 status
->value
.sig
= GDB_SIGNAL_0
;
7888 case 'F': /* File-I/O request. */
7889 /* GDB may access the inferior memory while handling the File-I/O
7890 request, but we don't want GDB accessing memory while waiting
7891 for a stop reply. See the comments in putpkt_binary. Set
7892 waiting_for_stop_reply to 0 temporarily. */
7893 rs
->waiting_for_stop_reply
= 0;
7894 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
7895 rs
->ctrlc_pending_p
= 0;
7896 /* GDB handled the File-I/O request, and the target is running
7897 again. Keep waiting for events. */
7898 rs
->waiting_for_stop_reply
= 1;
7900 case 'N': case 'T': case 'S': case 'X': case 'W':
7902 /* There is a stop reply to handle. */
7903 rs
->waiting_for_stop_reply
= 0;
7906 = (struct stop_reply
*) remote_notif_parse (this,
7910 event_ptid
= process_stop_reply (stop_reply
, status
);
7913 case 'O': /* Console output. */
7914 remote_console_output (buf
+ 1);
7917 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7919 /* Zero length reply means that we tried 'S' or 'C' and the
7920 remote system doesn't support it. */
7921 target_terminal::ours_for_output ();
7923 ("Can't send signals to this remote system. %s not sent.\n",
7924 gdb_signal_to_name (rs
->last_sent_signal
));
7925 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7926 target_terminal::inferior ();
7928 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7934 warning (_("Invalid remote reply: %s"), buf
);
7938 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7939 return minus_one_ptid
;
7940 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7942 /* Nothing interesting happened. If we're doing a non-blocking
7943 poll, we're done. Otherwise, go back to waiting. */
7944 if (options
& TARGET_WNOHANG
)
7945 return minus_one_ptid
;
7949 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7950 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7952 if (event_ptid
!= null_ptid
)
7953 record_currthread (rs
, event_ptid
);
7955 event_ptid
= first_remote_resumed_thread (this);
7959 /* A process exit. Invalidate our notion of current thread. */
7960 record_currthread (rs
, minus_one_ptid
);
7961 /* It's possible that the packet did not include a pid. */
7962 if (event_ptid
== null_ptid
)
7963 event_ptid
= first_remote_resumed_thread (this);
7964 /* EVENT_PTID could still be NULL_PTID. Double-check. */
7965 if (event_ptid
== null_ptid
)
7966 event_ptid
= magic_null_ptid
;
7972 /* Wait until the remote machine stops, then return, storing status in
7973 STATUS just as `wait' would. */
7976 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7980 if (target_is_non_stop_p ())
7981 event_ptid
= wait_ns (ptid
, status
, options
);
7983 event_ptid
= wait_as (ptid
, status
, options
);
7985 if (target_is_async_p ())
7987 remote_state
*rs
= get_remote_state ();
7989 /* If there are are events left in the queue tell the event loop
7991 if (!rs
->stop_reply_queue
.empty ())
7992 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7998 /* Fetch a single register using a 'p' packet. */
8001 remote_target::fetch_register_using_p (struct regcache
*regcache
,
8004 struct gdbarch
*gdbarch
= regcache
->arch ();
8005 struct remote_state
*rs
= get_remote_state ();
8007 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8010 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
8013 if (reg
->pnum
== -1)
8016 p
= rs
->buf
.data ();
8018 p
+= hexnumstr (p
, reg
->pnum
);
8021 getpkt (&rs
->buf
, 0);
8023 buf
= rs
->buf
.data ();
8025 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
8029 case PACKET_UNKNOWN
:
8032 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
8033 gdbarch_register_name (regcache
->arch (),
8038 /* If this register is unfetchable, tell the regcache. */
8041 regcache
->raw_supply (reg
->regnum
, NULL
);
8045 /* Otherwise, parse and supply the value. */
8051 error (_("fetch_register_using_p: early buf termination"));
8053 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8056 regcache
->raw_supply (reg
->regnum
, regp
);
8060 /* Fetch the registers included in the target's 'g' packet. */
8063 remote_target::send_g_packet ()
8065 struct remote_state
*rs
= get_remote_state ();
8068 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
8070 getpkt (&rs
->buf
, 0);
8071 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8072 error (_("Could not read registers; remote failure reply '%s'"),
8075 /* We can get out of synch in various cases. If the first character
8076 in the buffer is not a hex character, assume that has happened
8077 and try to fetch another packet to read. */
8078 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
8079 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
8080 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
8081 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
8084 fprintf_unfiltered (gdb_stdlog
,
8085 "Bad register packet; fetching a new packet\n");
8086 getpkt (&rs
->buf
, 0);
8089 buf_len
= strlen (rs
->buf
.data ());
8091 /* Sanity check the received packet. */
8092 if (buf_len
% 2 != 0)
8093 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
8099 remote_target::process_g_packet (struct regcache
*regcache
)
8101 struct gdbarch
*gdbarch
= regcache
->arch ();
8102 struct remote_state
*rs
= get_remote_state ();
8103 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8108 buf_len
= strlen (rs
->buf
.data ());
8110 /* Further sanity checks, with knowledge of the architecture. */
8111 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
8112 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8114 rsa
->sizeof_g_packet
, buf_len
/ 2,
8117 /* Save the size of the packet sent to us by the target. It is used
8118 as a heuristic when determining the max size of packets that the
8119 target can safely receive. */
8120 if (rsa
->actual_register_packet_size
== 0)
8121 rsa
->actual_register_packet_size
= buf_len
;
8123 /* If this is smaller than we guessed the 'g' packet would be,
8124 update our records. A 'g' reply that doesn't include a register's
8125 value implies either that the register is not available, or that
8126 the 'p' packet must be used. */
8127 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8129 long sizeof_g_packet
= buf_len
/ 2;
8131 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8133 long offset
= rsa
->regs
[i
].offset
;
8134 long reg_size
= register_size (gdbarch
, i
);
8136 if (rsa
->regs
[i
].pnum
== -1)
8139 if (offset
>= sizeof_g_packet
)
8140 rsa
->regs
[i
].in_g_packet
= 0;
8141 else if (offset
+ reg_size
> sizeof_g_packet
)
8142 error (_("Truncated register %d in remote 'g' packet"), i
);
8144 rsa
->regs
[i
].in_g_packet
= 1;
8147 /* Looks valid enough, we can assume this is the correct length
8148 for a 'g' packet. It's important not to adjust
8149 rsa->sizeof_g_packet if we have truncated registers otherwise
8150 this "if" won't be run the next time the method is called
8151 with a packet of the same size and one of the internal errors
8152 below will trigger instead. */
8153 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8156 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8158 /* Unimplemented registers read as all bits zero. */
8159 memset (regs
, 0, rsa
->sizeof_g_packet
);
8161 /* Reply describes registers byte by byte, each byte encoded as two
8162 hex characters. Suck them all up, then supply them to the
8163 register cacheing/storage mechanism. */
8165 p
= rs
->buf
.data ();
8166 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8168 if (p
[0] == 0 || p
[1] == 0)
8169 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8170 internal_error (__FILE__
, __LINE__
,
8171 _("unexpected end of 'g' packet reply"));
8173 if (p
[0] == 'x' && p
[1] == 'x')
8174 regs
[i
] = 0; /* 'x' */
8176 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8180 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8182 struct packet_reg
*r
= &rsa
->regs
[i
];
8183 long reg_size
= register_size (gdbarch
, i
);
8187 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8188 /* This shouldn't happen - we adjusted in_g_packet above. */
8189 internal_error (__FILE__
, __LINE__
,
8190 _("unexpected end of 'g' packet reply"));
8191 else if (rs
->buf
[r
->offset
* 2] == 'x')
8193 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8194 /* The register isn't available, mark it as such (at
8195 the same time setting the value to zero). */
8196 regcache
->raw_supply (r
->regnum
, NULL
);
8199 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8205 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8208 process_g_packet (regcache
);
8211 /* Make the remote selected traceframe match GDB's selected
8215 remote_target::set_remote_traceframe ()
8218 struct remote_state
*rs
= get_remote_state ();
8220 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8223 /* Avoid recursion, remote_trace_find calls us again. */
8224 rs
->remote_traceframe_number
= get_traceframe_number ();
8226 newnum
= target_trace_find (tfind_number
,
8227 get_traceframe_number (), 0, 0, NULL
);
8229 /* Should not happen. If it does, all bets are off. */
8230 if (newnum
!= get_traceframe_number ())
8231 warning (_("could not set remote traceframe"));
8235 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8237 struct gdbarch
*gdbarch
= regcache
->arch ();
8238 struct remote_state
*rs
= get_remote_state ();
8239 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8242 set_remote_traceframe ();
8243 set_general_thread (regcache
->ptid ());
8247 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8249 gdb_assert (reg
!= NULL
);
8251 /* If this register might be in the 'g' packet, try that first -
8252 we are likely to read more than one register. If this is the
8253 first 'g' packet, we might be overly optimistic about its
8254 contents, so fall back to 'p'. */
8255 if (reg
->in_g_packet
)
8257 fetch_registers_using_g (regcache
);
8258 if (reg
->in_g_packet
)
8262 if (fetch_register_using_p (regcache
, reg
))
8265 /* This register is not available. */
8266 regcache
->raw_supply (reg
->regnum
, NULL
);
8271 fetch_registers_using_g (regcache
);
8273 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8274 if (!rsa
->regs
[i
].in_g_packet
)
8275 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8277 /* This register is not available. */
8278 regcache
->raw_supply (i
, NULL
);
8282 /* Prepare to store registers. Since we may send them all (using a
8283 'G' request), we have to read out the ones we don't want to change
8287 remote_target::prepare_to_store (struct regcache
*regcache
)
8289 struct remote_state
*rs
= get_remote_state ();
8290 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8293 /* Make sure the entire registers array is valid. */
8294 switch (packet_support (PACKET_P
))
8296 case PACKET_DISABLE
:
8297 case PACKET_SUPPORT_UNKNOWN
:
8298 /* Make sure all the necessary registers are cached. */
8299 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8300 if (rsa
->regs
[i
].in_g_packet
)
8301 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8308 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8309 packet was not recognized. */
8312 remote_target::store_register_using_P (const struct regcache
*regcache
,
8315 struct gdbarch
*gdbarch
= regcache
->arch ();
8316 struct remote_state
*rs
= get_remote_state ();
8317 /* Try storing a single register. */
8318 char *buf
= rs
->buf
.data ();
8319 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8322 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8325 if (reg
->pnum
== -1)
8328 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8329 p
= buf
+ strlen (buf
);
8330 regcache
->raw_collect (reg
->regnum
, regp
);
8331 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8333 getpkt (&rs
->buf
, 0);
8335 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8340 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8341 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8342 case PACKET_UNKNOWN
:
8345 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8349 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8350 contents of the register cache buffer. FIXME: ignores errors. */
8353 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8355 struct remote_state
*rs
= get_remote_state ();
8356 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8360 /* Extract all the registers in the regcache copying them into a
8365 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8366 memset (regs
, 0, rsa
->sizeof_g_packet
);
8367 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8369 struct packet_reg
*r
= &rsa
->regs
[i
];
8372 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8376 /* Command describes registers byte by byte,
8377 each byte encoded as two hex characters. */
8378 p
= rs
->buf
.data ();
8380 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8382 getpkt (&rs
->buf
, 0);
8383 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8384 error (_("Could not write registers; remote failure reply '%s'"),
8388 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8389 of the register cache buffer. FIXME: ignores errors. */
8392 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8394 struct gdbarch
*gdbarch
= regcache
->arch ();
8395 struct remote_state
*rs
= get_remote_state ();
8396 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8399 set_remote_traceframe ();
8400 set_general_thread (regcache
->ptid ());
8404 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8406 gdb_assert (reg
!= NULL
);
8408 /* Always prefer to store registers using the 'P' packet if
8409 possible; we often change only a small number of registers.
8410 Sometimes we change a larger number; we'd need help from a
8411 higher layer to know to use 'G'. */
8412 if (store_register_using_P (regcache
, reg
))
8415 /* For now, don't complain if we have no way to write the
8416 register. GDB loses track of unavailable registers too
8417 easily. Some day, this may be an error. We don't have
8418 any way to read the register, either... */
8419 if (!reg
->in_g_packet
)
8422 store_registers_using_G (regcache
);
8426 store_registers_using_G (regcache
);
8428 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8429 if (!rsa
->regs
[i
].in_g_packet
)
8430 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8431 /* See above for why we do not issue an error here. */
8436 /* Return the number of hex digits in num. */
8439 hexnumlen (ULONGEST num
)
8443 for (i
= 0; num
!= 0; i
++)
8446 return std::max (i
, 1);
8449 /* Set BUF to the minimum number of hex digits representing NUM. */
8452 hexnumstr (char *buf
, ULONGEST num
)
8454 int len
= hexnumlen (num
);
8456 return hexnumnstr (buf
, num
, len
);
8460 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8463 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8469 for (i
= width
- 1; i
>= 0; i
--)
8471 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8478 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8481 remote_address_masked (CORE_ADDR addr
)
8483 unsigned int address_size
= remote_address_size
;
8485 /* If "remoteaddresssize" was not set, default to target address size. */
8487 address_size
= gdbarch_addr_bit (target_gdbarch ());
8489 if (address_size
> 0
8490 && address_size
< (sizeof (ULONGEST
) * 8))
8492 /* Only create a mask when that mask can safely be constructed
8493 in a ULONGEST variable. */
8496 mask
= (mask
<< address_size
) - 1;
8502 /* Determine whether the remote target supports binary downloading.
8503 This is accomplished by sending a no-op memory write of zero length
8504 to the target at the specified address. It does not suffice to send
8505 the whole packet, since many stubs strip the eighth bit and
8506 subsequently compute a wrong checksum, which causes real havoc with
8509 NOTE: This can still lose if the serial line is not eight-bit
8510 clean. In cases like this, the user should clear "remote
8514 remote_target::check_binary_download (CORE_ADDR addr
)
8516 struct remote_state
*rs
= get_remote_state ();
8518 switch (packet_support (PACKET_X
))
8520 case PACKET_DISABLE
:
8524 case PACKET_SUPPORT_UNKNOWN
:
8528 p
= rs
->buf
.data ();
8530 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8532 p
+= hexnumstr (p
, (ULONGEST
) 0);
8536 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8537 getpkt (&rs
->buf
, 0);
8539 if (rs
->buf
[0] == '\0')
8542 fprintf_unfiltered (gdb_stdlog
,
8543 "binary downloading NOT "
8544 "supported by target\n");
8545 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8550 fprintf_unfiltered (gdb_stdlog
,
8551 "binary downloading supported by target\n");
8552 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8559 /* Helper function to resize the payload in order to try to get a good
8560 alignment. We try to write an amount of data such that the next write will
8561 start on an address aligned on REMOTE_ALIGN_WRITES. */
8564 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8566 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8569 /* Write memory data directly to the remote machine.
8570 This does not inform the data cache; the data cache uses this.
8571 HEADER is the starting part of the packet.
8572 MEMADDR is the address in the remote memory space.
8573 MYADDR is the address of the buffer in our space.
8574 LEN_UNITS is the number of addressable units to write.
8575 UNIT_SIZE is the length in bytes of an addressable unit.
8576 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8577 should send data as binary ('X'), or hex-encoded ('M').
8579 The function creates packet of the form
8580 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8582 where encoding of <DATA> is terminated by PACKET_FORMAT.
8584 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8587 Return the transferred status, error or OK (an
8588 'enum target_xfer_status' value). Save the number of addressable units
8589 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8591 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8592 exchange between gdb and the stub could look like (?? in place of the
8598 -> $M1000,3:eeeeffffeeee#??
8602 <- eeeeffffeeeedddd */
8605 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8606 const gdb_byte
*myaddr
,
8609 ULONGEST
*xfered_len_units
,
8610 char packet_format
, int use_length
)
8612 struct remote_state
*rs
= get_remote_state ();
8618 int payload_capacity_bytes
;
8619 int payload_length_bytes
;
8621 if (packet_format
!= 'X' && packet_format
!= 'M')
8622 internal_error (__FILE__
, __LINE__
,
8623 _("remote_write_bytes_aux: bad packet format"));
8626 return TARGET_XFER_EOF
;
8628 payload_capacity_bytes
= get_memory_write_packet_size ();
8630 /* The packet buffer will be large enough for the payload;
8631 get_memory_packet_size ensures this. */
8634 /* Compute the size of the actual payload by subtracting out the
8635 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8637 payload_capacity_bytes
-= strlen ("$,:#NN");
8639 /* The comma won't be used. */
8640 payload_capacity_bytes
+= 1;
8641 payload_capacity_bytes
-= strlen (header
);
8642 payload_capacity_bytes
-= hexnumlen (memaddr
);
8644 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8646 strcat (rs
->buf
.data (), header
);
8647 p
= rs
->buf
.data () + strlen (header
);
8649 /* Compute a best guess of the number of bytes actually transfered. */
8650 if (packet_format
== 'X')
8652 /* Best guess at number of bytes that will fit. */
8653 todo_units
= std::min (len_units
,
8654 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8656 payload_capacity_bytes
-= hexnumlen (todo_units
);
8657 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8661 /* Number of bytes that will fit. */
8663 = std::min (len_units
,
8664 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8666 payload_capacity_bytes
-= hexnumlen (todo_units
);
8667 todo_units
= std::min (todo_units
,
8668 (payload_capacity_bytes
/ unit_size
) / 2);
8671 if (todo_units
<= 0)
8672 internal_error (__FILE__
, __LINE__
,
8673 _("minimum packet size too small to write data"));
8675 /* If we already need another packet, then try to align the end
8676 of this packet to a useful boundary. */
8677 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8678 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8680 /* Append "<memaddr>". */
8681 memaddr
= remote_address_masked (memaddr
);
8682 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8689 /* Append the length and retain its location and size. It may need to be
8690 adjusted once the packet body has been created. */
8692 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8700 /* Append the packet body. */
8701 if (packet_format
== 'X')
8703 /* Binary mode. Send target system values byte by byte, in
8704 increasing byte addresses. Only escape certain critical
8706 payload_length_bytes
=
8707 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8708 &units_written
, payload_capacity_bytes
);
8710 /* If not all TODO units fit, then we'll need another packet. Make
8711 a second try to keep the end of the packet aligned. Don't do
8712 this if the packet is tiny. */
8713 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8717 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8719 if (new_todo_units
!= units_written
)
8720 payload_length_bytes
=
8721 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8722 (gdb_byte
*) p
, &units_written
,
8723 payload_capacity_bytes
);
8726 p
+= payload_length_bytes
;
8727 if (use_length
&& units_written
< todo_units
)
8729 /* Escape chars have filled up the buffer prematurely,
8730 and we have actually sent fewer units than planned.
8731 Fix-up the length field of the packet. Use the same
8732 number of characters as before. */
8733 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8735 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8740 /* Normal mode: Send target system values byte by byte, in
8741 increasing byte addresses. Each byte is encoded as a two hex
8743 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8744 units_written
= todo_units
;
8747 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8748 getpkt (&rs
->buf
, 0);
8750 if (rs
->buf
[0] == 'E')
8751 return TARGET_XFER_E_IO
;
8753 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8754 send fewer units than we'd planned. */
8755 *xfered_len_units
= (ULONGEST
) units_written
;
8756 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8759 /* Write memory data directly to the remote machine.
8760 This does not inform the data cache; the data cache uses this.
8761 MEMADDR is the address in the remote memory space.
8762 MYADDR is the address of the buffer in our space.
8763 LEN is the number of bytes.
8765 Return the transferred status, error or OK (an
8766 'enum target_xfer_status' value). Save the number of bytes
8767 transferred in *XFERED_LEN. Only transfer a single packet. */
8770 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8771 ULONGEST len
, int unit_size
,
8772 ULONGEST
*xfered_len
)
8774 const char *packet_format
= NULL
;
8776 /* Check whether the target supports binary download. */
8777 check_binary_download (memaddr
);
8779 switch (packet_support (PACKET_X
))
8782 packet_format
= "X";
8784 case PACKET_DISABLE
:
8785 packet_format
= "M";
8787 case PACKET_SUPPORT_UNKNOWN
:
8788 internal_error (__FILE__
, __LINE__
,
8789 _("remote_write_bytes: bad internal state"));
8791 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8794 return remote_write_bytes_aux (packet_format
,
8795 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8796 packet_format
[0], 1);
8799 /* Read memory data directly from the remote machine.
8800 This does not use the data cache; the data cache uses this.
8801 MEMADDR is the address in the remote memory space.
8802 MYADDR is the address of the buffer in our space.
8803 LEN_UNITS is the number of addressable memory units to read..
8804 UNIT_SIZE is the length in bytes of an addressable unit.
8806 Return the transferred status, error or OK (an
8807 'enum target_xfer_status' value). Save the number of bytes
8808 transferred in *XFERED_LEN_UNITS.
8810 See the comment of remote_write_bytes_aux for an example of
8811 memory read/write exchange between gdb and the stub. */
8814 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8816 int unit_size
, ULONGEST
*xfered_len_units
)
8818 struct remote_state
*rs
= get_remote_state ();
8819 int buf_size_bytes
; /* Max size of packet output buffer. */
8824 buf_size_bytes
= get_memory_read_packet_size ();
8825 /* The packet buffer will be large enough for the payload;
8826 get_memory_packet_size ensures this. */
8828 /* Number of units that will fit. */
8829 todo_units
= std::min (len_units
,
8830 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8832 /* Construct "m"<memaddr>","<len>". */
8833 memaddr
= remote_address_masked (memaddr
);
8834 p
= rs
->buf
.data ();
8836 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8838 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8841 getpkt (&rs
->buf
, 0);
8842 if (rs
->buf
[0] == 'E'
8843 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8844 && rs
->buf
[3] == '\0')
8845 return TARGET_XFER_E_IO
;
8846 /* Reply describes memory byte by byte, each byte encoded as two hex
8848 p
= rs
->buf
.data ();
8849 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8850 /* Return what we have. Let higher layers handle partial reads. */
8851 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8852 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8855 /* Using the set of read-only target sections of remote, read live
8858 For interface/parameters/return description see target.h,
8862 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
8866 ULONGEST
*xfered_len
)
8868 struct target_section
*secp
;
8869 struct target_section_table
*table
;
8871 secp
= target_section_by_addr (this, memaddr
);
8873 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
8875 struct target_section
*p
;
8876 ULONGEST memend
= memaddr
+ len
;
8878 table
= target_get_section_table (this);
8880 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8882 if (memaddr
>= p
->addr
)
8884 if (memend
<= p
->endaddr
)
8886 /* Entire transfer is within this section. */
8887 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8890 else if (memaddr
>= p
->endaddr
)
8892 /* This section ends before the transfer starts. */
8897 /* This section overlaps the transfer. Just do half. */
8898 len
= p
->endaddr
- memaddr
;
8899 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8906 return TARGET_XFER_EOF
;
8909 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8910 first if the requested memory is unavailable in traceframe.
8911 Otherwise, fall back to remote_read_bytes_1. */
8914 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
8915 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8916 ULONGEST
*xfered_len
)
8919 return TARGET_XFER_EOF
;
8921 if (get_traceframe_number () != -1)
8923 std::vector
<mem_range
> available
;
8925 /* If we fail to get the set of available memory, then the
8926 target does not support querying traceframe info, and so we
8927 attempt reading from the traceframe anyway (assuming the
8928 target implements the old QTro packet then). */
8929 if (traceframe_available_memory (&available
, memaddr
, len
))
8931 if (available
.empty () || available
[0].start
!= memaddr
)
8933 enum target_xfer_status res
;
8935 /* Don't read into the traceframe's available
8937 if (!available
.empty ())
8939 LONGEST oldlen
= len
;
8941 len
= available
[0].start
- memaddr
;
8942 gdb_assert (len
<= oldlen
);
8945 /* This goes through the topmost target again. */
8946 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
8947 len
, unit_size
, xfered_len
);
8948 if (res
== TARGET_XFER_OK
)
8949 return TARGET_XFER_OK
;
8952 /* No use trying further, we know some memory starting
8953 at MEMADDR isn't available. */
8955 return (*xfered_len
!= 0) ?
8956 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
8960 /* Don't try to read more than how much is available, in
8961 case the target implements the deprecated QTro packet to
8962 cater for older GDBs (the target's knowledge of read-only
8963 sections may be outdated by now). */
8964 len
= available
[0].length
;
8968 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8973 /* Sends a packet with content determined by the printf format string
8974 FORMAT and the remaining arguments, then gets the reply. Returns
8975 whether the packet was a success, a failure, or unknown. */
8978 remote_target::remote_send_printf (const char *format
, ...)
8980 struct remote_state
*rs
= get_remote_state ();
8981 int max_size
= get_remote_packet_size ();
8984 va_start (ap
, format
);
8987 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
8991 if (size
>= max_size
)
8992 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8994 if (putpkt (rs
->buf
) < 0)
8995 error (_("Communication problem with target."));
8998 getpkt (&rs
->buf
, 0);
9000 return packet_check_result (rs
->buf
);
9003 /* Flash writing can take quite some time. We'll set
9004 effectively infinite timeout for flash operations.
9005 In future, we'll need to decide on a better approach. */
9006 static const int remote_flash_timeout
= 1000;
9009 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
9011 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
9012 enum packet_result ret
;
9013 scoped_restore restore_timeout
9014 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9016 ret
= remote_send_printf ("vFlashErase:%s,%s",
9017 phex (address
, addr_size
),
9021 case PACKET_UNKNOWN
:
9022 error (_("Remote target does not support flash erase"));
9024 error (_("Error erasing flash with vFlashErase packet"));
9031 remote_target::remote_flash_write (ULONGEST address
,
9032 ULONGEST length
, ULONGEST
*xfered_len
,
9033 const gdb_byte
*data
)
9035 scoped_restore restore_timeout
9036 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9037 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
9042 remote_target::flash_done ()
9046 scoped_restore restore_timeout
9047 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9049 ret
= remote_send_printf ("vFlashDone");
9053 case PACKET_UNKNOWN
:
9054 error (_("Remote target does not support vFlashDone"));
9056 error (_("Error finishing flash operation"));
9063 remote_target::files_info ()
9065 puts_filtered ("Debugging a target over a serial line.\n");
9068 /* Stuff for dealing with the packets which are part of this protocol.
9069 See comment at top of file for details. */
9071 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
9072 error to higher layers. Called when a serial error is detected.
9073 The exception message is STRING, followed by a colon and a blank,
9074 the system error message for errno at function entry and final dot
9075 for output compatibility with throw_perror_with_name. */
9078 unpush_and_perror (remote_target
*target
, const char *string
)
9080 int saved_errno
= errno
;
9082 remote_unpush_target (target
);
9083 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
9084 safe_strerror (saved_errno
));
9087 /* Read a single character from the remote end. The current quit
9088 handler is overridden to avoid quitting in the middle of packet
9089 sequence, as that would break communication with the remote server.
9090 See remote_serial_quit_handler for more detail. */
9093 remote_target::readchar (int timeout
)
9096 struct remote_state
*rs
= get_remote_state ();
9099 scoped_restore restore_quit_target
9100 = make_scoped_restore (&curr_quit_handler_target
, this);
9101 scoped_restore restore_quit
9102 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9104 rs
->got_ctrlc_during_io
= 0;
9106 ch
= serial_readchar (rs
->remote_desc
, timeout
);
9108 if (rs
->got_ctrlc_during_io
)
9115 switch ((enum serial_rc
) ch
)
9118 remote_unpush_target (this);
9119 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9122 unpush_and_perror (this, _("Remote communication error. "
9123 "Target disconnected."));
9125 case SERIAL_TIMEOUT
:
9131 /* Wrapper for serial_write that closes the target and throws if
9132 writing fails. The current quit handler is overridden to avoid
9133 quitting in the middle of packet sequence, as that would break
9134 communication with the remote server. See
9135 remote_serial_quit_handler for more detail. */
9138 remote_target::remote_serial_write (const char *str
, int len
)
9140 struct remote_state
*rs
= get_remote_state ();
9142 scoped_restore restore_quit_target
9143 = make_scoped_restore (&curr_quit_handler_target
, this);
9144 scoped_restore restore_quit
9145 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9147 rs
->got_ctrlc_during_io
= 0;
9149 if (serial_write (rs
->remote_desc
, str
, len
))
9151 unpush_and_perror (this, _("Remote communication error. "
9152 "Target disconnected."));
9155 if (rs
->got_ctrlc_during_io
)
9159 /* Return a string representing an escaped version of BUF, of len N.
9160 E.g. \n is converted to \\n, \t to \\t, etc. */
9163 escape_buffer (const char *buf
, int n
)
9167 stb
.putstrn (buf
, n
, '\\');
9168 return std::move (stb
.string ());
9171 /* Display a null-terminated packet on stdout, for debugging, using C
9175 print_packet (const char *buf
)
9177 puts_filtered ("\"");
9178 fputstr_filtered (buf
, '"', gdb_stdout
);
9179 puts_filtered ("\"");
9183 remote_target::putpkt (const char *buf
)
9185 return putpkt_binary (buf
, strlen (buf
));
9188 /* Wrapper around remote_target::putpkt to avoid exporting
9192 putpkt (remote_target
*remote
, const char *buf
)
9194 return remote
->putpkt (buf
);
9197 /* Send a packet to the remote machine, with error checking. The data
9198 of the packet is in BUF. The string in BUF can be at most
9199 get_remote_packet_size () - 5 to account for the $, # and checksum,
9200 and for a possible /0 if we are debugging (remote_debug) and want
9201 to print the sent packet as a string. */
9204 remote_target::putpkt_binary (const char *buf
, int cnt
)
9206 struct remote_state
*rs
= get_remote_state ();
9208 unsigned char csum
= 0;
9209 gdb::def_vector
<char> data (cnt
+ 6);
9210 char *buf2
= data
.data ();
9216 /* Catch cases like trying to read memory or listing threads while
9217 we're waiting for a stop reply. The remote server wouldn't be
9218 ready to handle this request, so we'd hang and timeout. We don't
9219 have to worry about this in synchronous mode, because in that
9220 case it's not possible to issue a command while the target is
9221 running. This is not a problem in non-stop mode, because in that
9222 case, the stub is always ready to process serial input. */
9223 if (!target_is_non_stop_p ()
9224 && target_is_async_p ()
9225 && rs
->waiting_for_stop_reply
)
9227 error (_("Cannot execute this command while the target is running.\n"
9228 "Use the \"interrupt\" command to stop the target\n"
9229 "and then try again."));
9232 /* We're sending out a new packet. Make sure we don't look at a
9233 stale cached response. */
9234 rs
->cached_wait_status
= 0;
9236 /* Copy the packet into buffer BUF2, encapsulating it
9237 and giving it a checksum. */
9242 for (i
= 0; i
< cnt
; i
++)
9248 *p
++ = tohex ((csum
>> 4) & 0xf);
9249 *p
++ = tohex (csum
& 0xf);
9251 /* Send it over and over until we get a positive ack. */
9255 int started_error_output
= 0;
9261 int len
= (int) (p
- buf2
);
9264 if (remote_packet_max_chars
< 0)
9267 max_chars
= remote_packet_max_chars
;
9270 = escape_buffer (buf2
, std::min (len
, max_chars
));
9272 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9274 if (len
> max_chars
)
9275 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9278 fprintf_unfiltered (gdb_stdlog
, "...");
9280 gdb_flush (gdb_stdlog
);
9282 remote_serial_write (buf2
, p
- buf2
);
9284 /* If this is a no acks version of the remote protocol, send the
9285 packet and move on. */
9289 /* Read until either a timeout occurs (-2) or '+' is read.
9290 Handle any notification that arrives in the mean time. */
9293 ch
= readchar (remote_timeout
);
9301 case SERIAL_TIMEOUT
:
9304 if (started_error_output
)
9306 putchar_unfiltered ('\n');
9307 started_error_output
= 0;
9316 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9320 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9322 case SERIAL_TIMEOUT
:
9326 break; /* Retransmit buffer. */
9330 fprintf_unfiltered (gdb_stdlog
,
9331 "Packet instead of Ack, ignoring it\n");
9332 /* It's probably an old response sent because an ACK
9333 was lost. Gobble up the packet and ack it so it
9334 doesn't get retransmitted when we resend this
9337 remote_serial_write ("+", 1);
9338 continue; /* Now, go look for +. */
9345 /* If we got a notification, handle it, and go back to looking
9347 /* We've found the start of a notification. Now
9348 collect the data. */
9349 val
= read_frame (&rs
->buf
);
9354 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9356 fprintf_unfiltered (gdb_stdlog
,
9357 " Notification received: %s\n",
9360 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9361 /* We're in sync now, rewait for the ack. */
9368 if (!started_error_output
)
9370 started_error_output
= 1;
9371 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9373 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9374 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9383 if (!started_error_output
)
9385 started_error_output
= 1;
9386 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9388 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9392 break; /* Here to retransmit. */
9396 /* This is wrong. If doing a long backtrace, the user should be
9397 able to get out next time we call QUIT, without anything as
9398 violent as interrupt_query. If we want to provide a way out of
9399 here without getting to the next QUIT, it should be based on
9400 hitting ^C twice as in remote_wait. */
9412 /* Come here after finding the start of a frame when we expected an
9413 ack. Do our best to discard the rest of this packet. */
9416 remote_target::skip_frame ()
9422 c
= readchar (remote_timeout
);
9425 case SERIAL_TIMEOUT
:
9426 /* Nothing we can do. */
9429 /* Discard the two bytes of checksum and stop. */
9430 c
= readchar (remote_timeout
);
9432 c
= readchar (remote_timeout
);
9435 case '*': /* Run length encoding. */
9436 /* Discard the repeat count. */
9437 c
= readchar (remote_timeout
);
9442 /* A regular character. */
9448 /* Come here after finding the start of the frame. Collect the rest
9449 into *BUF, verifying the checksum, length, and handling run-length
9450 compression. NUL terminate the buffer. If there is not enough room,
9453 Returns -1 on error, number of characters in buffer (ignoring the
9454 trailing NULL) on success. (could be extended to return one of the
9455 SERIAL status indications). */
9458 remote_target::read_frame (gdb::char_vector
*buf_p
)
9463 char *buf
= buf_p
->data ();
9464 struct remote_state
*rs
= get_remote_state ();
9471 c
= readchar (remote_timeout
);
9474 case SERIAL_TIMEOUT
:
9476 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9480 fputs_filtered ("Saw new packet start in middle of old one\n",
9482 return -1; /* Start a new packet, count retries. */
9485 unsigned char pktcsum
;
9491 check_0
= readchar (remote_timeout
);
9493 check_1
= readchar (remote_timeout
);
9495 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9498 fputs_filtered ("Timeout in checksum, retrying\n",
9502 else if (check_0
< 0 || check_1
< 0)
9505 fputs_filtered ("Communication error in checksum\n",
9510 /* Don't recompute the checksum; with no ack packets we
9511 don't have any way to indicate a packet retransmission
9516 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9517 if (csum
== pktcsum
)
9522 std::string str
= escape_buffer (buf
, bc
);
9524 fprintf_unfiltered (gdb_stdlog
,
9525 "Bad checksum, sentsum=0x%x, "
9526 "csum=0x%x, buf=%s\n",
9527 pktcsum
, csum
, str
.c_str ());
9529 /* Number of characters in buffer ignoring trailing
9533 case '*': /* Run length encoding. */
9538 c
= readchar (remote_timeout
);
9540 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9542 /* The character before ``*'' is repeated. */
9544 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9546 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9548 /* Make some more room in the buffer. */
9549 buf_p
->resize (buf_p
->size () + repeat
);
9550 buf
= buf_p
->data ();
9553 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9559 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9563 if (bc
>= buf_p
->size () - 1)
9565 /* Make some more room in the buffer. */
9566 buf_p
->resize (buf_p
->size () * 2);
9567 buf
= buf_p
->data ();
9577 /* Set this to the maximum number of seconds to wait instead of waiting forever
9578 in target_wait(). If this timer times out, then it generates an error and
9579 the command is aborted. This replaces most of the need for timeouts in the
9580 GDB test suite, and makes it possible to distinguish between a hung target
9581 and one with slow communications. */
9583 static int watchdog
= 0;
9585 show_watchdog (struct ui_file
*file
, int from_tty
,
9586 struct cmd_list_element
*c
, const char *value
)
9588 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9591 /* Read a packet from the remote machine, with error checking, and
9592 store it in *BUF. Resize *BUF if necessary to hold the result. If
9593 FOREVER, wait forever rather than timing out; this is used (in
9594 synchronous mode) to wait for a target that is is executing user
9596 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9597 don't have to change all the calls to getpkt to deal with the
9598 return value, because at the moment I don't know what the right
9599 thing to do it for those. */
9602 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9604 getpkt_sane (buf
, forever
);
9608 /* Read a packet from the remote machine, with error checking, and
9609 store it in *BUF. Resize *BUF if necessary to hold the result. If
9610 FOREVER, wait forever rather than timing out; this is used (in
9611 synchronous mode) to wait for a target that is is executing user
9612 code to stop. If FOREVER == 0, this function is allowed to time
9613 out gracefully and return an indication of this to the caller.
9614 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9615 consider receiving a notification enough reason to return to the
9616 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9617 holds a notification or not (a regular packet). */
9620 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9621 int forever
, int expecting_notif
,
9624 struct remote_state
*rs
= get_remote_state ();
9630 /* We're reading a new response. Make sure we don't look at a
9631 previously cached response. */
9632 rs
->cached_wait_status
= 0;
9634 strcpy (buf
->data (), "timeout");
9637 timeout
= watchdog
> 0 ? watchdog
: -1;
9638 else if (expecting_notif
)
9639 timeout
= 0; /* There should already be a char in the buffer. If
9642 timeout
= remote_timeout
;
9646 /* Process any number of notifications, and then return when
9650 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9652 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9654 /* This can loop forever if the remote side sends us
9655 characters continuously, but if it pauses, we'll get
9656 SERIAL_TIMEOUT from readchar because of timeout. Then
9657 we'll count that as a retry.
9659 Note that even when forever is set, we will only wait
9660 forever prior to the start of a packet. After that, we
9661 expect characters to arrive at a brisk pace. They should
9662 show up within remote_timeout intervals. */
9664 c
= readchar (timeout
);
9665 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9667 if (c
== SERIAL_TIMEOUT
)
9669 if (expecting_notif
)
9670 return -1; /* Don't complain, it's normal to not get
9671 anything in this case. */
9673 if (forever
) /* Watchdog went off? Kill the target. */
9675 remote_unpush_target (this);
9676 throw_error (TARGET_CLOSE_ERROR
,
9677 _("Watchdog timeout has expired. "
9678 "Target detached."));
9681 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9685 /* We've found the start of a packet or notification.
9686 Now collect the data. */
9687 val
= read_frame (buf
);
9692 remote_serial_write ("-", 1);
9695 if (tries
> MAX_TRIES
)
9697 /* We have tried hard enough, and just can't receive the
9698 packet/notification. Give up. */
9699 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9701 /* Skip the ack char if we're in no-ack mode. */
9702 if (!rs
->noack_mode
)
9703 remote_serial_write ("+", 1);
9707 /* If we got an ordinary packet, return that to our caller. */
9714 if (remote_packet_max_chars
< 0)
9717 max_chars
= remote_packet_max_chars
;
9720 = escape_buffer (buf
->data (),
9721 std::min (val
, max_chars
));
9723 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9726 if (val
> max_chars
)
9727 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9730 fprintf_unfiltered (gdb_stdlog
, "\n");
9733 /* Skip the ack char if we're in no-ack mode. */
9734 if (!rs
->noack_mode
)
9735 remote_serial_write ("+", 1);
9736 if (is_notif
!= NULL
)
9741 /* If we got a notification, handle it, and go back to looking
9745 gdb_assert (c
== '%');
9749 std::string str
= escape_buffer (buf
->data (), val
);
9751 fprintf_unfiltered (gdb_stdlog
,
9752 " Notification received: %s\n",
9755 if (is_notif
!= NULL
)
9758 handle_notification (rs
->notif_state
, buf
->data ());
9760 /* Notifications require no acknowledgement. */
9762 if (expecting_notif
)
9769 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9771 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9775 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9778 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9781 /* Kill any new fork children of process PID that haven't been
9782 processed by follow_fork. */
9785 remote_target::kill_new_fork_children (int pid
)
9787 remote_state
*rs
= get_remote_state ();
9788 struct notif_client
*notif
= ¬if_client_stop
;
9790 /* Kill the fork child threads of any threads in process PID
9791 that are stopped at a fork event. */
9792 for (thread_info
*thread
: all_non_exited_threads (this))
9794 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9796 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9798 int child_pid
= ws
->value
.related_pid
.pid ();
9801 res
= remote_vkill (child_pid
);
9803 error (_("Can't kill fork child process %d"), child_pid
);
9807 /* Check for any pending fork events (not reported or processed yet)
9808 in process PID and kill those fork child threads as well. */
9809 remote_notif_get_pending_events (notif
);
9810 for (auto &event
: rs
->stop_reply_queue
)
9811 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9813 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9816 res
= remote_vkill (child_pid
);
9818 error (_("Can't kill fork child process %d"), child_pid
);
9823 /* Target hook to kill the current inferior. */
9826 remote_target::kill ()
9829 int pid
= inferior_ptid
.pid ();
9830 struct remote_state
*rs
= get_remote_state ();
9832 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9834 /* If we're stopped while forking and we haven't followed yet,
9835 kill the child task. We need to do this before killing the
9836 parent task because if this is a vfork then the parent will
9838 kill_new_fork_children (pid
);
9840 res
= remote_vkill (pid
);
9843 target_mourn_inferior (inferior_ptid
);
9848 /* If we are in 'target remote' mode and we are killing the only
9849 inferior, then we will tell gdbserver to exit and unpush the
9851 if (res
== -1 && !remote_multi_process_p (rs
)
9852 && number_of_live_inferiors (this) == 1)
9856 /* We've killed the remote end, we get to mourn it. If we are
9857 not in extended mode, mourning the inferior also unpushes
9858 remote_ops from the target stack, which closes the remote
9860 target_mourn_inferior (inferior_ptid
);
9865 error (_("Can't kill process"));
9868 /* Send a kill request to the target using the 'vKill' packet. */
9871 remote_target::remote_vkill (int pid
)
9873 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9876 remote_state
*rs
= get_remote_state ();
9878 /* Tell the remote target to detach. */
9879 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
9881 getpkt (&rs
->buf
, 0);
9883 switch (packet_ok (rs
->buf
,
9884 &remote_protocol_packets
[PACKET_vKill
]))
9890 case PACKET_UNKNOWN
:
9893 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9897 /* Send a kill request to the target using the 'k' packet. */
9900 remote_target::remote_kill_k ()
9902 /* Catch errors so the user can quit from gdb even when we
9903 aren't on speaking terms with the remote system. */
9908 catch (const gdb_exception_error
&ex
)
9910 if (ex
.error
== TARGET_CLOSE_ERROR
)
9912 /* If we got an (EOF) error that caused the target
9913 to go away, then we're done, that's what we wanted.
9914 "k" is susceptible to cause a premature EOF, given
9915 that the remote server isn't actually required to
9916 reply to "k", and it can happen that it doesn't
9917 even get to reply ACK to the "k". */
9921 /* Otherwise, something went wrong. We didn't actually kill
9922 the target. Just propagate the exception, and let the
9923 user or higher layers decide what to do. */
9929 remote_target::mourn_inferior ()
9931 struct remote_state
*rs
= get_remote_state ();
9933 /* We're no longer interested in notification events of an inferior
9934 that exited or was killed/detached. */
9935 discard_pending_stop_replies (current_inferior ());
9937 /* In 'target remote' mode with one inferior, we close the connection. */
9938 if (!rs
->extended
&& number_of_live_inferiors (this) <= 1)
9940 remote_unpush_target (this);
9944 /* In case we got here due to an error, but we're going to stay
9946 rs
->waiting_for_stop_reply
= 0;
9948 /* If the current general thread belonged to the process we just
9949 detached from or has exited, the remote side current general
9950 thread becomes undefined. Considering a case like this:
9952 - We just got here due to a detach.
9953 - The process that we're detaching from happens to immediately
9954 report a global breakpoint being hit in non-stop mode, in the
9955 same thread we had selected before.
9956 - GDB attaches to this process again.
9957 - This event happens to be the next event we handle.
9959 GDB would consider that the current general thread didn't need to
9960 be set on the stub side (with Hg), since for all it knew,
9961 GENERAL_THREAD hadn't changed.
9963 Notice that although in all-stop mode, the remote server always
9964 sets the current thread to the thread reporting the stop event,
9965 that doesn't happen in non-stop mode; in non-stop, the stub *must
9966 not* change the current thread when reporting a breakpoint hit,
9967 due to the decoupling of event reporting and event handling.
9969 To keep things simple, we always invalidate our notion of the
9971 record_currthread (rs
, minus_one_ptid
);
9973 /* Call common code to mark the inferior as not running. */
9974 generic_mourn_inferior ();
9978 extended_remote_target::supports_disable_randomization ()
9980 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9984 remote_target::extended_remote_disable_randomization (int val
)
9986 struct remote_state
*rs
= get_remote_state ();
9989 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9990 "QDisableRandomization:%x", val
);
9992 reply
= remote_get_noisy_reply ();
9994 error (_("Target does not support QDisableRandomization."));
9995 if (strcmp (reply
, "OK") != 0)
9996 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
10000 remote_target::extended_remote_run (const std::string
&args
)
10002 struct remote_state
*rs
= get_remote_state ();
10004 const char *remote_exec_file
= get_remote_exec_file ();
10006 /* If the user has disabled vRun support, or we have detected that
10007 support is not available, do not try it. */
10008 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
10011 strcpy (rs
->buf
.data (), "vRun;");
10012 len
= strlen (rs
->buf
.data ());
10014 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
10015 error (_("Remote file name too long for run packet"));
10016 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
10017 strlen (remote_exec_file
));
10019 if (!args
.empty ())
10023 gdb_argv
argv (args
.c_str ());
10024 for (i
= 0; argv
[i
] != NULL
; i
++)
10026 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
10027 error (_("Argument list too long for run packet"));
10028 rs
->buf
[len
++] = ';';
10029 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
10034 rs
->buf
[len
++] = '\0';
10037 getpkt (&rs
->buf
, 0);
10039 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
10042 /* We have a wait response. All is well. */
10044 case PACKET_UNKNOWN
:
10047 if (remote_exec_file
[0] == '\0')
10048 error (_("Running the default executable on the remote target failed; "
10049 "try \"set remote exec-file\"?"));
10051 error (_("Running \"%s\" on the remote target failed"),
10054 gdb_assert_not_reached (_("bad switch"));
10058 /* Helper function to send set/unset environment packets. ACTION is
10059 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
10060 or "QEnvironmentUnsetVariable". VALUE is the variable to be
10064 remote_target::send_environment_packet (const char *action
,
10065 const char *packet
,
10068 remote_state
*rs
= get_remote_state ();
10070 /* Convert the environment variable to an hex string, which
10071 is the best format to be transmitted over the wire. */
10072 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
10075 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10076 "%s:%s", packet
, encoded_value
.c_str ());
10079 getpkt (&rs
->buf
, 0);
10080 if (strcmp (rs
->buf
.data (), "OK") != 0)
10081 warning (_("Unable to %s environment variable '%s' on remote."),
10085 /* Helper function to handle the QEnvironment* packets. */
10088 remote_target::extended_remote_environment_support ()
10090 remote_state
*rs
= get_remote_state ();
10092 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
10094 putpkt ("QEnvironmentReset");
10095 getpkt (&rs
->buf
, 0);
10096 if (strcmp (rs
->buf
.data (), "OK") != 0)
10097 warning (_("Unable to reset environment on remote."));
10100 gdb_environ
*e
= ¤t_inferior ()->environment
;
10102 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
10103 for (const std::string
&el
: e
->user_set_env ())
10104 send_environment_packet ("set", "QEnvironmentHexEncoded",
10107 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
10108 for (const std::string
&el
: e
->user_unset_env ())
10109 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10112 /* Helper function to set the current working directory for the
10113 inferior in the remote target. */
10116 remote_target::extended_remote_set_inferior_cwd ()
10118 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10120 const char *inferior_cwd
= get_inferior_cwd ();
10121 remote_state
*rs
= get_remote_state ();
10123 if (inferior_cwd
!= NULL
)
10125 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10126 strlen (inferior_cwd
));
10128 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10129 "QSetWorkingDir:%s", hexpath
.c_str ());
10133 /* An empty inferior_cwd means that the user wants us to
10134 reset the remote server's inferior's cwd. */
10135 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10136 "QSetWorkingDir:");
10140 getpkt (&rs
->buf
, 0);
10141 if (packet_ok (rs
->buf
,
10142 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10145 Remote replied unexpectedly while setting the inferior's working\n\
10152 /* In the extended protocol we want to be able to do things like
10153 "run" and have them basically work as expected. So we need
10154 a special create_inferior function. We support changing the
10155 executable file and the command line arguments, but not the
10159 extended_remote_target::create_inferior (const char *exec_file
,
10160 const std::string
&args
,
10161 char **env
, int from_tty
)
10165 struct remote_state
*rs
= get_remote_state ();
10166 const char *remote_exec_file
= get_remote_exec_file ();
10168 /* If running asynchronously, register the target file descriptor
10169 with the event loop. */
10170 if (target_can_async_p ())
10173 /* Disable address space randomization if requested (and supported). */
10174 if (supports_disable_randomization ())
10175 extended_remote_disable_randomization (disable_randomization
);
10177 /* If startup-with-shell is on, we inform gdbserver to start the
10178 remote inferior using a shell. */
10179 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10181 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10182 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10184 getpkt (&rs
->buf
, 0);
10185 if (strcmp (rs
->buf
.data (), "OK") != 0)
10187 Remote replied unexpectedly while setting startup-with-shell: %s"),
10191 extended_remote_environment_support ();
10193 extended_remote_set_inferior_cwd ();
10195 /* Now restart the remote server. */
10196 run_worked
= extended_remote_run (args
) != -1;
10199 /* vRun was not supported. Fail if we need it to do what the
10201 if (remote_exec_file
[0])
10202 error (_("Remote target does not support \"set remote exec-file\""));
10203 if (!args
.empty ())
10204 error (_("Remote target does not support \"set args\" or run ARGS"));
10206 /* Fall back to "R". */
10207 extended_remote_restart ();
10210 /* vRun's success return is a stop reply. */
10211 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10212 add_current_inferior_and_thread (stop_reply
);
10214 /* Get updated offsets, if the stub uses qOffsets. */
10219 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10220 the list of conditions (in agent expression bytecode format), if any, the
10221 target needs to evaluate. The output is placed into the packet buffer
10222 started from BUF and ended at BUF_END. */
10225 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10226 struct bp_target_info
*bp_tgt
, char *buf
,
10229 if (bp_tgt
->conditions
.empty ())
10232 buf
+= strlen (buf
);
10233 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10236 /* Send conditions to the target. */
10237 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10239 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10240 buf
+= strlen (buf
);
10241 for (int i
= 0; i
< aexpr
->len
; ++i
)
10242 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10249 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10250 struct bp_target_info
*bp_tgt
, char *buf
)
10252 if (bp_tgt
->tcommands
.empty ())
10255 buf
+= strlen (buf
);
10257 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10258 buf
+= strlen (buf
);
10260 /* Concatenate all the agent expressions that are commands into the
10262 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10264 sprintf (buf
, "X%x,", aexpr
->len
);
10265 buf
+= strlen (buf
);
10266 for (int i
= 0; i
< aexpr
->len
; ++i
)
10267 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10272 /* Insert a breakpoint. On targets that have software breakpoint
10273 support, we ask the remote target to do the work; on targets
10274 which don't, we insert a traditional memory breakpoint. */
10277 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10278 struct bp_target_info
*bp_tgt
)
10280 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10281 If it succeeds, then set the support to PACKET_ENABLE. If it
10282 fails, and the user has explicitly requested the Z support then
10283 report an error, otherwise, mark it disabled and go on. */
10285 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10287 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10288 struct remote_state
*rs
;
10291 /* Make sure the remote is pointing at the right process, if
10293 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10294 set_general_process ();
10296 rs
= get_remote_state ();
10297 p
= rs
->buf
.data ();
10298 endbuf
= p
+ get_remote_packet_size ();
10303 addr
= (ULONGEST
) remote_address_masked (addr
);
10304 p
+= hexnumstr (p
, addr
);
10305 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10307 if (supports_evaluation_of_breakpoint_conditions ())
10308 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10310 if (can_run_breakpoint_commands ())
10311 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10314 getpkt (&rs
->buf
, 0);
10316 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10322 case PACKET_UNKNOWN
:
10327 /* If this breakpoint has target-side commands but this stub doesn't
10328 support Z0 packets, throw error. */
10329 if (!bp_tgt
->tcommands
.empty ())
10330 throw_error (NOT_SUPPORTED_ERROR
, _("\
10331 Target doesn't support breakpoints that have target side commands."));
10333 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10337 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10338 struct bp_target_info
*bp_tgt
,
10339 enum remove_bp_reason reason
)
10341 CORE_ADDR addr
= bp_tgt
->placed_address
;
10342 struct remote_state
*rs
= get_remote_state ();
10344 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10346 char *p
= rs
->buf
.data ();
10347 char *endbuf
= p
+ get_remote_packet_size ();
10349 /* Make sure the remote is pointing at the right process, if
10351 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10352 set_general_process ();
10358 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10359 p
+= hexnumstr (p
, addr
);
10360 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10363 getpkt (&rs
->buf
, 0);
10365 return (rs
->buf
[0] == 'E');
10368 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10371 static enum Z_packet_type
10372 watchpoint_to_Z_packet (int type
)
10377 return Z_PACKET_WRITE_WP
;
10380 return Z_PACKET_READ_WP
;
10383 return Z_PACKET_ACCESS_WP
;
10386 internal_error (__FILE__
, __LINE__
,
10387 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10392 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10393 enum target_hw_bp_type type
, struct expression
*cond
)
10395 struct remote_state
*rs
= get_remote_state ();
10396 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10398 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10400 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10403 /* Make sure the remote is pointing at the right process, if
10405 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10406 set_general_process ();
10408 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10409 p
= strchr (rs
->buf
.data (), '\0');
10410 addr
= remote_address_masked (addr
);
10411 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10412 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10415 getpkt (&rs
->buf
, 0);
10417 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10421 case PACKET_UNKNOWN
:
10426 internal_error (__FILE__
, __LINE__
,
10427 _("remote_insert_watchpoint: reached end of function"));
10431 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10432 CORE_ADDR start
, int length
)
10434 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10436 return diff
< length
;
10441 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10442 enum target_hw_bp_type type
, struct expression
*cond
)
10444 struct remote_state
*rs
= get_remote_state ();
10445 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10447 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10449 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10452 /* Make sure the remote is pointing at the right process, if
10454 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10455 set_general_process ();
10457 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10458 p
= strchr (rs
->buf
.data (), '\0');
10459 addr
= remote_address_masked (addr
);
10460 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10461 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10463 getpkt (&rs
->buf
, 0);
10465 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10468 case PACKET_UNKNOWN
:
10473 internal_error (__FILE__
, __LINE__
,
10474 _("remote_remove_watchpoint: reached end of function"));
10478 static int remote_hw_watchpoint_limit
= -1;
10479 static int remote_hw_watchpoint_length_limit
= -1;
10480 static int remote_hw_breakpoint_limit
= -1;
10483 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10485 if (remote_hw_watchpoint_length_limit
== 0)
10487 else if (remote_hw_watchpoint_length_limit
< 0)
10489 else if (len
<= remote_hw_watchpoint_length_limit
)
10496 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10498 if (type
== bp_hardware_breakpoint
)
10500 if (remote_hw_breakpoint_limit
== 0)
10502 else if (remote_hw_breakpoint_limit
< 0)
10504 else if (cnt
<= remote_hw_breakpoint_limit
)
10509 if (remote_hw_watchpoint_limit
== 0)
10511 else if (remote_hw_watchpoint_limit
< 0)
10515 else if (cnt
<= remote_hw_watchpoint_limit
)
10521 /* The to_stopped_by_sw_breakpoint method of target remote. */
10524 remote_target::stopped_by_sw_breakpoint ()
10526 struct thread_info
*thread
= inferior_thread ();
10528 return (thread
->priv
!= NULL
10529 && (get_remote_thread_info (thread
)->stop_reason
10530 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10533 /* The to_supports_stopped_by_sw_breakpoint method of target
10537 remote_target::supports_stopped_by_sw_breakpoint ()
10539 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10542 /* The to_stopped_by_hw_breakpoint method of target remote. */
10545 remote_target::stopped_by_hw_breakpoint ()
10547 struct thread_info
*thread
= inferior_thread ();
10549 return (thread
->priv
!= NULL
10550 && (get_remote_thread_info (thread
)->stop_reason
10551 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10554 /* The to_supports_stopped_by_hw_breakpoint method of target
10558 remote_target::supports_stopped_by_hw_breakpoint ()
10560 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10564 remote_target::stopped_by_watchpoint ()
10566 struct thread_info
*thread
= inferior_thread ();
10568 return (thread
->priv
!= NULL
10569 && (get_remote_thread_info (thread
)->stop_reason
10570 == TARGET_STOPPED_BY_WATCHPOINT
));
10574 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10576 struct thread_info
*thread
= inferior_thread ();
10578 if (thread
->priv
!= NULL
10579 && (get_remote_thread_info (thread
)->stop_reason
10580 == TARGET_STOPPED_BY_WATCHPOINT
))
10582 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10591 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10592 struct bp_target_info
*bp_tgt
)
10594 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10595 struct remote_state
*rs
;
10599 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10602 /* Make sure the remote is pointing at the right process, if
10604 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10605 set_general_process ();
10607 rs
= get_remote_state ();
10608 p
= rs
->buf
.data ();
10609 endbuf
= p
+ get_remote_packet_size ();
10615 addr
= remote_address_masked (addr
);
10616 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10617 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10619 if (supports_evaluation_of_breakpoint_conditions ())
10620 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10622 if (can_run_breakpoint_commands ())
10623 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10626 getpkt (&rs
->buf
, 0);
10628 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10631 if (rs
->buf
[1] == '.')
10633 message
= strchr (&rs
->buf
[2], '.');
10635 error (_("Remote failure reply: %s"), message
+ 1);
10638 case PACKET_UNKNOWN
:
10643 internal_error (__FILE__
, __LINE__
,
10644 _("remote_insert_hw_breakpoint: reached end of function"));
10649 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10650 struct bp_target_info
*bp_tgt
)
10653 struct remote_state
*rs
= get_remote_state ();
10654 char *p
= rs
->buf
.data ();
10655 char *endbuf
= p
+ get_remote_packet_size ();
10657 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10660 /* Make sure the remote is pointing at the right process, if
10662 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10663 set_general_process ();
10669 addr
= remote_address_masked (bp_tgt
->placed_address
);
10670 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10671 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10674 getpkt (&rs
->buf
, 0);
10676 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10679 case PACKET_UNKNOWN
:
10684 internal_error (__FILE__
, __LINE__
,
10685 _("remote_remove_hw_breakpoint: reached end of function"));
10688 /* Verify memory using the "qCRC:" request. */
10691 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10693 struct remote_state
*rs
= get_remote_state ();
10694 unsigned long host_crc
, target_crc
;
10697 /* It doesn't make sense to use qCRC if the remote target is
10698 connected but not running. */
10699 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10701 enum packet_result result
;
10703 /* Make sure the remote is pointing at the right process. */
10704 set_general_process ();
10706 /* FIXME: assumes lma can fit into long. */
10707 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10708 (long) lma
, (long) size
);
10711 /* Be clever; compute the host_crc before waiting for target
10713 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10715 getpkt (&rs
->buf
, 0);
10717 result
= packet_ok (rs
->buf
,
10718 &remote_protocol_packets
[PACKET_qCRC
]);
10719 if (result
== PACKET_ERROR
)
10721 else if (result
== PACKET_OK
)
10723 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10724 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10726 return (host_crc
== target_crc
);
10730 return simple_verify_memory (this, data
, lma
, size
);
10733 /* compare-sections command
10735 With no arguments, compares each loadable section in the exec bfd
10736 with the same memory range on the target, and reports mismatches.
10737 Useful for verifying the image on the target against the exec file. */
10740 compare_sections_command (const char *args
, int from_tty
)
10743 const char *sectname
;
10744 bfd_size_type size
;
10747 int mismatched
= 0;
10752 error (_("command cannot be used without an exec file"));
10754 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10760 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10762 if (!(s
->flags
& SEC_LOAD
))
10763 continue; /* Skip non-loadable section. */
10765 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10766 continue; /* Skip writeable sections */
10768 size
= bfd_section_size (s
);
10770 continue; /* Skip zero-length section. */
10772 sectname
= bfd_section_name (s
);
10773 if (args
&& strcmp (args
, sectname
) != 0)
10774 continue; /* Not the section selected by user. */
10776 matched
= 1; /* Do this section. */
10779 gdb::byte_vector
sectdata (size
);
10780 bfd_get_section_contents (exec_bfd
, s
, sectdata
.data (), 0, size
);
10782 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10785 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10786 paddress (target_gdbarch (), lma
),
10787 paddress (target_gdbarch (), lma
+ size
));
10789 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10790 paddress (target_gdbarch (), lma
),
10791 paddress (target_gdbarch (), lma
+ size
));
10793 printf_filtered ("matched.\n");
10796 printf_filtered ("MIS-MATCHED!\n");
10800 if (mismatched
> 0)
10801 warning (_("One or more sections of the target image does not match\n\
10802 the loaded file\n"));
10803 if (args
&& !matched
)
10804 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10807 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10808 into remote target. The number of bytes written to the remote
10809 target is returned, or -1 for error. */
10812 remote_target::remote_write_qxfer (const char *object_name
,
10813 const char *annex
, const gdb_byte
*writebuf
,
10814 ULONGEST offset
, LONGEST len
,
10815 ULONGEST
*xfered_len
,
10816 struct packet_config
*packet
)
10820 struct remote_state
*rs
= get_remote_state ();
10821 int max_size
= get_memory_write_packet_size ();
10823 if (packet_config_support (packet
) == PACKET_DISABLE
)
10824 return TARGET_XFER_E_IO
;
10826 /* Insert header. */
10827 i
= snprintf (rs
->buf
.data (), max_size
,
10828 "qXfer:%s:write:%s:%s:",
10829 object_name
, annex
? annex
: "",
10830 phex_nz (offset
, sizeof offset
));
10831 max_size
-= (i
+ 1);
10833 /* Escape as much data as fits into rs->buf. */
10834 buf_len
= remote_escape_output
10835 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10837 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10838 || getpkt_sane (&rs
->buf
, 0) < 0
10839 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10840 return TARGET_XFER_E_IO
;
10842 unpack_varlen_hex (rs
->buf
.data (), &n
);
10845 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10848 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10849 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10850 number of bytes read is returned, or 0 for EOF, or -1 for error.
10851 The number of bytes read may be less than LEN without indicating an
10852 EOF. PACKET is checked and updated to indicate whether the remote
10853 target supports this object. */
10856 remote_target::remote_read_qxfer (const char *object_name
,
10858 gdb_byte
*readbuf
, ULONGEST offset
,
10860 ULONGEST
*xfered_len
,
10861 struct packet_config
*packet
)
10863 struct remote_state
*rs
= get_remote_state ();
10864 LONGEST i
, n
, packet_len
;
10866 if (packet_config_support (packet
) == PACKET_DISABLE
)
10867 return TARGET_XFER_E_IO
;
10869 /* Check whether we've cached an end-of-object packet that matches
10871 if (rs
->finished_object
)
10873 if (strcmp (object_name
, rs
->finished_object
) == 0
10874 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10875 && offset
== rs
->finished_offset
)
10876 return TARGET_XFER_EOF
;
10879 /* Otherwise, we're now reading something different. Discard
10881 xfree (rs
->finished_object
);
10882 xfree (rs
->finished_annex
);
10883 rs
->finished_object
= NULL
;
10884 rs
->finished_annex
= NULL
;
10887 /* Request only enough to fit in a single packet. The actual data
10888 may not, since we don't know how much of it will need to be escaped;
10889 the target is free to respond with slightly less data. We subtract
10890 five to account for the response type and the protocol frame. */
10891 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10892 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
10893 "qXfer:%s:read:%s:%s,%s",
10894 object_name
, annex
? annex
: "",
10895 phex_nz (offset
, sizeof offset
),
10896 phex_nz (n
, sizeof n
));
10897 i
= putpkt (rs
->buf
);
10899 return TARGET_XFER_E_IO
;
10902 packet_len
= getpkt_sane (&rs
->buf
, 0);
10903 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10904 return TARGET_XFER_E_IO
;
10906 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10907 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
10909 /* 'm' means there is (or at least might be) more data after this
10910 batch. That does not make sense unless there's at least one byte
10911 of data in this reply. */
10912 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10913 error (_("Remote qXfer reply contained no data."));
10915 /* Got some data. */
10916 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
10917 packet_len
- 1, readbuf
, n
);
10919 /* 'l' is an EOF marker, possibly including a final block of data,
10920 or possibly empty. If we have the final block of a non-empty
10921 object, record this fact to bypass a subsequent partial read. */
10922 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10924 rs
->finished_object
= xstrdup (object_name
);
10925 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10926 rs
->finished_offset
= offset
+ i
;
10930 return TARGET_XFER_EOF
;
10934 return TARGET_XFER_OK
;
10938 enum target_xfer_status
10939 remote_target::xfer_partial (enum target_object object
,
10940 const char *annex
, gdb_byte
*readbuf
,
10941 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10942 ULONGEST
*xfered_len
)
10944 struct remote_state
*rs
;
10948 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10950 set_remote_traceframe ();
10951 set_general_thread (inferior_ptid
);
10953 rs
= get_remote_state ();
10955 /* Handle memory using the standard memory routines. */
10956 if (object
== TARGET_OBJECT_MEMORY
)
10958 /* If the remote target is connected but not running, we should
10959 pass this request down to a lower stratum (e.g. the executable
10961 if (!target_has_execution
)
10962 return TARGET_XFER_EOF
;
10964 if (writebuf
!= NULL
)
10965 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10968 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
10972 /* Handle extra signal info using qxfer packets. */
10973 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10976 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
10977 xfered_len
, &remote_protocol_packets
10978 [PACKET_qXfer_siginfo_read
]);
10980 return remote_write_qxfer ("siginfo", annex
,
10981 writebuf
, offset
, len
, xfered_len
,
10982 &remote_protocol_packets
10983 [PACKET_qXfer_siginfo_write
]);
10986 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10989 return remote_read_qxfer ("statictrace", annex
,
10990 readbuf
, offset
, len
, xfered_len
,
10991 &remote_protocol_packets
10992 [PACKET_qXfer_statictrace_read
]);
10994 return TARGET_XFER_E_IO
;
10997 /* Only handle flash writes. */
10998 if (writebuf
!= NULL
)
11002 case TARGET_OBJECT_FLASH
:
11003 return remote_flash_write (offset
, len
, xfered_len
,
11007 return TARGET_XFER_E_IO
;
11011 /* Map pre-existing objects onto letters. DO NOT do this for new
11012 objects!!! Instead specify new query packets. */
11015 case TARGET_OBJECT_AVR
:
11019 case TARGET_OBJECT_AUXV
:
11020 gdb_assert (annex
== NULL
);
11021 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
11023 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
11025 case TARGET_OBJECT_AVAILABLE_FEATURES
:
11026 return remote_read_qxfer
11027 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
11028 &remote_protocol_packets
[PACKET_qXfer_features
]);
11030 case TARGET_OBJECT_LIBRARIES
:
11031 return remote_read_qxfer
11032 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
11033 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
11035 case TARGET_OBJECT_LIBRARIES_SVR4
:
11036 return remote_read_qxfer
11037 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
11038 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
11040 case TARGET_OBJECT_MEMORY_MAP
:
11041 gdb_assert (annex
== NULL
);
11042 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
11044 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
11046 case TARGET_OBJECT_OSDATA
:
11047 /* Should only get here if we're connected. */
11048 gdb_assert (rs
->remote_desc
);
11049 return remote_read_qxfer
11050 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
11051 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
11053 case TARGET_OBJECT_THREADS
:
11054 gdb_assert (annex
== NULL
);
11055 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
11057 &remote_protocol_packets
[PACKET_qXfer_threads
]);
11059 case TARGET_OBJECT_TRACEFRAME_INFO
:
11060 gdb_assert (annex
== NULL
);
11061 return remote_read_qxfer
11062 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
11063 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
11065 case TARGET_OBJECT_FDPIC
:
11066 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
11068 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
11070 case TARGET_OBJECT_OPENVMS_UIB
:
11071 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
11073 &remote_protocol_packets
[PACKET_qXfer_uib
]);
11075 case TARGET_OBJECT_BTRACE
:
11076 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
11078 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
11080 case TARGET_OBJECT_BTRACE_CONF
:
11081 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
11083 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
11085 case TARGET_OBJECT_EXEC_FILE
:
11086 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
11088 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
11091 return TARGET_XFER_E_IO
;
11094 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
11095 large enough let the caller deal with it. */
11096 if (len
< get_remote_packet_size ())
11097 return TARGET_XFER_E_IO
;
11098 len
= get_remote_packet_size ();
11100 /* Except for querying the minimum buffer size, target must be open. */
11101 if (!rs
->remote_desc
)
11102 error (_("remote query is only available after target open"));
11104 gdb_assert (annex
!= NULL
);
11105 gdb_assert (readbuf
!= NULL
);
11107 p2
= rs
->buf
.data ();
11109 *p2
++ = query_type
;
11111 /* We used one buffer char for the remote protocol q command and
11112 another for the query type. As the remote protocol encapsulation
11113 uses 4 chars plus one extra in case we are debugging
11114 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11117 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11119 /* Bad caller may have sent forbidden characters. */
11120 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11125 gdb_assert (annex
[i
] == '\0');
11127 i
= putpkt (rs
->buf
);
11129 return TARGET_XFER_E_IO
;
11131 getpkt (&rs
->buf
, 0);
11132 strcpy ((char *) readbuf
, rs
->buf
.data ());
11134 *xfered_len
= strlen ((char *) readbuf
);
11135 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11138 /* Implementation of to_get_memory_xfer_limit. */
11141 remote_target::get_memory_xfer_limit ()
11143 return get_memory_write_packet_size ();
11147 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11148 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11149 CORE_ADDR
*found_addrp
)
11151 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11152 struct remote_state
*rs
= get_remote_state ();
11153 int max_size
= get_memory_write_packet_size ();
11154 struct packet_config
*packet
=
11155 &remote_protocol_packets
[PACKET_qSearch_memory
];
11156 /* Number of packet bytes used to encode the pattern;
11157 this could be more than PATTERN_LEN due to escape characters. */
11158 int escaped_pattern_len
;
11159 /* Amount of pattern that was encodable in the packet. */
11160 int used_pattern_len
;
11163 ULONGEST found_addr
;
11165 /* Don't go to the target if we don't have to. This is done before
11166 checking packet_config_support to avoid the possibility that a
11167 success for this edge case means the facility works in
11169 if (pattern_len
> search_space_len
)
11171 if (pattern_len
== 0)
11173 *found_addrp
= start_addr
;
11177 /* If we already know the packet isn't supported, fall back to the simple
11178 way of searching memory. */
11180 if (packet_config_support (packet
) == PACKET_DISABLE
)
11182 /* Target doesn't provided special support, fall back and use the
11183 standard support (copy memory and do the search here). */
11184 return simple_search_memory (this, start_addr
, search_space_len
,
11185 pattern
, pattern_len
, found_addrp
);
11188 /* Make sure the remote is pointing at the right process. */
11189 set_general_process ();
11191 /* Insert header. */
11192 i
= snprintf (rs
->buf
.data (), max_size
,
11193 "qSearch:memory:%s;%s;",
11194 phex_nz (start_addr
, addr_size
),
11195 phex_nz (search_space_len
, sizeof (search_space_len
)));
11196 max_size
-= (i
+ 1);
11198 /* Escape as much data as fits into rs->buf. */
11199 escaped_pattern_len
=
11200 remote_escape_output (pattern
, pattern_len
, 1,
11201 (gdb_byte
*) rs
->buf
.data () + i
,
11202 &used_pattern_len
, max_size
);
11204 /* Bail if the pattern is too large. */
11205 if (used_pattern_len
!= pattern_len
)
11206 error (_("Pattern is too large to transmit to remote target."));
11208 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11209 || getpkt_sane (&rs
->buf
, 0) < 0
11210 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11212 /* The request may not have worked because the command is not
11213 supported. If so, fall back to the simple way. */
11214 if (packet_config_support (packet
) == PACKET_DISABLE
)
11216 return simple_search_memory (this, start_addr
, search_space_len
,
11217 pattern
, pattern_len
, found_addrp
);
11222 if (rs
->buf
[0] == '0')
11224 else if (rs
->buf
[0] == '1')
11227 if (rs
->buf
[1] != ',')
11228 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11229 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11230 *found_addrp
= found_addr
;
11233 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11239 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11241 struct remote_state
*rs
= get_remote_state ();
11242 char *p
= rs
->buf
.data ();
11244 if (!rs
->remote_desc
)
11245 error (_("remote rcmd is only available after target open"));
11247 /* Send a NULL command across as an empty command. */
11248 if (command
== NULL
)
11251 /* The query prefix. */
11252 strcpy (rs
->buf
.data (), "qRcmd,");
11253 p
= strchr (rs
->buf
.data (), '\0');
11255 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11256 > get_remote_packet_size ())
11257 error (_("\"monitor\" command ``%s'' is too long."), command
);
11259 /* Encode the actual command. */
11260 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11262 if (putpkt (rs
->buf
) < 0)
11263 error (_("Communication problem with target."));
11265 /* get/display the response */
11270 /* XXX - see also remote_get_noisy_reply(). */
11271 QUIT
; /* Allow user to bail out with ^C. */
11273 if (getpkt_sane (&rs
->buf
, 0) == -1)
11275 /* Timeout. Continue to (try to) read responses.
11276 This is better than stopping with an error, assuming the stub
11277 is still executing the (long) monitor command.
11278 If needed, the user can interrupt gdb using C-c, obtaining
11279 an effect similar to stop on timeout. */
11282 buf
= rs
->buf
.data ();
11283 if (buf
[0] == '\0')
11284 error (_("Target does not support this command."));
11285 if (buf
[0] == 'O' && buf
[1] != 'K')
11287 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11290 if (strcmp (buf
, "OK") == 0)
11292 if (strlen (buf
) == 3 && buf
[0] == 'E'
11293 && isdigit (buf
[1]) && isdigit (buf
[2]))
11295 error (_("Protocol error with Rcmd"));
11297 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11299 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11301 fputc_unfiltered (c
, outbuf
);
11307 std::vector
<mem_region
>
11308 remote_target::memory_map ()
11310 std::vector
<mem_region
> result
;
11311 gdb::optional
<gdb::char_vector
> text
11312 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11315 result
= parse_memory_map (text
->data ());
11321 packet_command (const char *args
, int from_tty
)
11323 remote_target
*remote
= get_current_remote_target ();
11325 if (remote
== nullptr)
11326 error (_("command can only be used with remote target"));
11328 remote
->packet_command (args
, from_tty
);
11332 remote_target::packet_command (const char *args
, int from_tty
)
11335 error (_("remote-packet command requires packet text as argument"));
11337 puts_filtered ("sending: ");
11338 print_packet (args
);
11339 puts_filtered ("\n");
11342 remote_state
*rs
= get_remote_state ();
11344 getpkt (&rs
->buf
, 0);
11345 puts_filtered ("received: ");
11346 print_packet (rs
->buf
.data ());
11347 puts_filtered ("\n");
11351 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11353 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11355 static void threadset_test_cmd (char *cmd
, int tty
);
11357 static void threadalive_test (char *cmd
, int tty
);
11359 static void threadlist_test_cmd (char *cmd
, int tty
);
11361 int get_and_display_threadinfo (threadref
*ref
);
11363 static void threadinfo_test_cmd (char *cmd
, int tty
);
11365 static int thread_display_step (threadref
*ref
, void *context
);
11367 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11369 static void init_remote_threadtests (void);
11371 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11374 threadset_test_cmd (const char *cmd
, int tty
)
11376 int sample_thread
= SAMPLE_THREAD
;
11378 printf_filtered (_("Remote threadset test\n"));
11379 set_general_thread (sample_thread
);
11384 threadalive_test (const char *cmd
, int tty
)
11386 int sample_thread
= SAMPLE_THREAD
;
11387 int pid
= inferior_ptid
.pid ();
11388 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11390 if (remote_thread_alive (ptid
))
11391 printf_filtered ("PASS: Thread alive test\n");
11393 printf_filtered ("FAIL: Thread alive test\n");
11396 void output_threadid (char *title
, threadref
*ref
);
11399 output_threadid (char *title
, threadref
*ref
)
11403 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11405 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11409 threadlist_test_cmd (const char *cmd
, int tty
)
11412 threadref nextthread
;
11413 int done
, result_count
;
11414 threadref threadlist
[3];
11416 printf_filtered ("Remote Threadlist test\n");
11417 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11418 &result_count
, &threadlist
[0]))
11419 printf_filtered ("FAIL: threadlist test\n");
11422 threadref
*scan
= threadlist
;
11423 threadref
*limit
= scan
+ result_count
;
11425 while (scan
< limit
)
11426 output_threadid (" thread ", scan
++);
11431 display_thread_info (struct gdb_ext_thread_info
*info
)
11433 output_threadid ("Threadid: ", &info
->threadid
);
11434 printf_filtered ("Name: %s\n ", info
->shortname
);
11435 printf_filtered ("State: %s\n", info
->display
);
11436 printf_filtered ("other: %s\n\n", info
->more_display
);
11440 get_and_display_threadinfo (threadref
*ref
)
11444 struct gdb_ext_thread_info threadinfo
;
11446 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11447 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11448 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11449 display_thread_info (&threadinfo
);
11454 threadinfo_test_cmd (const char *cmd
, int tty
)
11456 int athread
= SAMPLE_THREAD
;
11460 int_to_threadref (&thread
, athread
);
11461 printf_filtered ("Remote Threadinfo test\n");
11462 if (!get_and_display_threadinfo (&thread
))
11463 printf_filtered ("FAIL cannot get thread info\n");
11467 thread_display_step (threadref
*ref
, void *context
)
11469 /* output_threadid(" threadstep ",ref); *//* simple test */
11470 return get_and_display_threadinfo (ref
);
11474 threadlist_update_test_cmd (const char *cmd
, int tty
)
11476 printf_filtered ("Remote Threadlist update test\n");
11477 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11481 init_remote_threadtests (void)
11483 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11484 _("Fetch and print the remote list of "
11485 "thread identifiers, one pkt only."));
11486 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11487 _("Fetch and display info about one thread."));
11488 add_com ("tset", class_obscure
, threadset_test_cmd
,
11489 _("Test setting to a different thread."));
11490 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11491 _("Iterate through updating all remote thread info."));
11492 add_com ("talive", class_obscure
, threadalive_test
,
11493 _("Remote thread alive test."));
11498 /* Convert a thread ID to a string. */
11501 remote_target::pid_to_str (ptid_t ptid
)
11503 struct remote_state
*rs
= get_remote_state ();
11505 if (ptid
== null_ptid
)
11506 return normal_pid_to_str (ptid
);
11507 else if (ptid
.is_pid ())
11509 /* Printing an inferior target id. */
11511 /* When multi-process extensions are off, there's no way in the
11512 remote protocol to know the remote process id, if there's any
11513 at all. There's one exception --- when we're connected with
11514 target extended-remote, and we manually attached to a process
11515 with "attach PID". We don't record anywhere a flag that
11516 allows us to distinguish that case from the case of
11517 connecting with extended-remote and the stub already being
11518 attached to a process, and reporting yes to qAttached, hence
11519 no smart special casing here. */
11520 if (!remote_multi_process_p (rs
))
11521 return "Remote target";
11523 return normal_pid_to_str (ptid
);
11527 if (magic_null_ptid
== ptid
)
11528 return "Thread <main>";
11529 else if (remote_multi_process_p (rs
))
11530 if (ptid
.lwp () == 0)
11531 return normal_pid_to_str (ptid
);
11533 return string_printf ("Thread %d.%ld",
11534 ptid
.pid (), ptid
.lwp ());
11536 return string_printf ("Thread %ld", ptid
.lwp ());
11540 /* Get the address of the thread local variable in OBJFILE which is
11541 stored at OFFSET within the thread local storage for thread PTID. */
11544 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11547 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11549 struct remote_state
*rs
= get_remote_state ();
11550 char *p
= rs
->buf
.data ();
11551 char *endp
= p
+ get_remote_packet_size ();
11552 enum packet_result result
;
11554 strcpy (p
, "qGetTLSAddr:");
11556 p
= write_ptid (p
, endp
, ptid
);
11558 p
+= hexnumstr (p
, offset
);
11560 p
+= hexnumstr (p
, lm
);
11564 getpkt (&rs
->buf
, 0);
11565 result
= packet_ok (rs
->buf
,
11566 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11567 if (result
== PACKET_OK
)
11571 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11574 else if (result
== PACKET_UNKNOWN
)
11575 throw_error (TLS_GENERIC_ERROR
,
11576 _("Remote target doesn't support qGetTLSAddr packet"));
11578 throw_error (TLS_GENERIC_ERROR
,
11579 _("Remote target failed to process qGetTLSAddr request"));
11582 throw_error (TLS_GENERIC_ERROR
,
11583 _("TLS not supported or disabled on this target"));
11588 /* Provide thread local base, i.e. Thread Information Block address.
11589 Returns 1 if ptid is found and thread_local_base is non zero. */
11592 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11594 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11596 struct remote_state
*rs
= get_remote_state ();
11597 char *p
= rs
->buf
.data ();
11598 char *endp
= p
+ get_remote_packet_size ();
11599 enum packet_result result
;
11601 strcpy (p
, "qGetTIBAddr:");
11603 p
= write_ptid (p
, endp
, ptid
);
11607 getpkt (&rs
->buf
, 0);
11608 result
= packet_ok (rs
->buf
,
11609 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11610 if (result
== PACKET_OK
)
11613 unpack_varlen_hex (rs
->buf
.data (), &val
);
11615 *addr
= (CORE_ADDR
) val
;
11618 else if (result
== PACKET_UNKNOWN
)
11619 error (_("Remote target doesn't support qGetTIBAddr packet"));
11621 error (_("Remote target failed to process qGetTIBAddr request"));
11624 error (_("qGetTIBAddr not supported or disabled on this target"));
11629 /* Support for inferring a target description based on the current
11630 architecture and the size of a 'g' packet. While the 'g' packet
11631 can have any size (since optional registers can be left off the
11632 end), some sizes are easily recognizable given knowledge of the
11633 approximate architecture. */
11635 struct remote_g_packet_guess
11637 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11644 const struct target_desc
*tdesc
;
11647 struct remote_g_packet_data
: public allocate_on_obstack
11649 std::vector
<remote_g_packet_guess
> guesses
;
11652 static struct gdbarch_data
*remote_g_packet_data_handle
;
11655 remote_g_packet_data_init (struct obstack
*obstack
)
11657 return new (obstack
) remote_g_packet_data
;
11661 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11662 const struct target_desc
*tdesc
)
11664 struct remote_g_packet_data
*data
11665 = ((struct remote_g_packet_data
*)
11666 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11668 gdb_assert (tdesc
!= NULL
);
11670 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11671 if (guess
.bytes
== bytes
)
11672 internal_error (__FILE__
, __LINE__
,
11673 _("Duplicate g packet description added for size %d"),
11676 data
->guesses
.emplace_back (bytes
, tdesc
);
11679 /* Return true if remote_read_description would do anything on this target
11680 and architecture, false otherwise. */
11683 remote_read_description_p (struct target_ops
*target
)
11685 struct remote_g_packet_data
*data
11686 = ((struct remote_g_packet_data
*)
11687 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11689 return !data
->guesses
.empty ();
11692 const struct target_desc
*
11693 remote_target::read_description ()
11695 struct remote_g_packet_data
*data
11696 = ((struct remote_g_packet_data
*)
11697 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11699 /* Do not try this during initial connection, when we do not know
11700 whether there is a running but stopped thread. */
11701 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
11702 return beneath ()->read_description ();
11704 if (!data
->guesses
.empty ())
11706 int bytes
= send_g_packet ();
11708 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11709 if (guess
.bytes
== bytes
)
11710 return guess
.tdesc
;
11712 /* We discard the g packet. A minor optimization would be to
11713 hold on to it, and fill the register cache once we have selected
11714 an architecture, but it's too tricky to do safely. */
11717 return beneath ()->read_description ();
11720 /* Remote file transfer support. This is host-initiated I/O, not
11721 target-initiated; for target-initiated, see remote-fileio.c. */
11723 /* If *LEFT is at least the length of STRING, copy STRING to
11724 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11725 decrease *LEFT. Otherwise raise an error. */
11728 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11730 int len
= strlen (string
);
11733 error (_("Packet too long for target."));
11735 memcpy (*buffer
, string
, len
);
11739 /* NUL-terminate the buffer as a convenience, if there is
11745 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11746 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11747 decrease *LEFT. Otherwise raise an error. */
11750 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11753 if (2 * len
> *left
)
11754 error (_("Packet too long for target."));
11756 bin2hex (bytes
, *buffer
, len
);
11757 *buffer
+= 2 * len
;
11760 /* NUL-terminate the buffer as a convenience, if there is
11766 /* If *LEFT is large enough, convert VALUE to hex and add it to
11767 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11768 decrease *LEFT. Otherwise raise an error. */
11771 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11773 int len
= hexnumlen (value
);
11776 error (_("Packet too long for target."));
11778 hexnumstr (*buffer
, value
);
11782 /* NUL-terminate the buffer as a convenience, if there is
11788 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11789 value, *REMOTE_ERRNO to the remote error number or zero if none
11790 was included, and *ATTACHMENT to point to the start of the annex
11791 if any. The length of the packet isn't needed here; there may
11792 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11794 Return 0 if the packet could be parsed, -1 if it could not. If
11795 -1 is returned, the other variables may not be initialized. */
11798 remote_hostio_parse_result (char *buffer
, int *retcode
,
11799 int *remote_errno
, char **attachment
)
11804 *attachment
= NULL
;
11806 if (buffer
[0] != 'F')
11810 *retcode
= strtol (&buffer
[1], &p
, 16);
11811 if (errno
!= 0 || p
== &buffer
[1])
11814 /* Check for ",errno". */
11818 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11819 if (errno
!= 0 || p
+ 1 == p2
)
11824 /* Check for ";attachment". If there is no attachment, the
11825 packet should end here. */
11828 *attachment
= p
+ 1;
11831 else if (*p
== '\0')
11837 /* Send a prepared I/O packet to the target and read its response.
11838 The prepared packet is in the global RS->BUF before this function
11839 is called, and the answer is there when we return.
11841 COMMAND_BYTES is the length of the request to send, which may include
11842 binary data. WHICH_PACKET is the packet configuration to check
11843 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11844 is set to the error number and -1 is returned. Otherwise the value
11845 returned by the function is returned.
11847 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11848 attachment is expected; an error will be reported if there's a
11849 mismatch. If one is found, *ATTACHMENT will be set to point into
11850 the packet buffer and *ATTACHMENT_LEN will be set to the
11851 attachment's length. */
11854 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11855 int *remote_errno
, char **attachment
,
11856 int *attachment_len
)
11858 struct remote_state
*rs
= get_remote_state ();
11859 int ret
, bytes_read
;
11860 char *attachment_tmp
;
11862 if (packet_support (which_packet
) == PACKET_DISABLE
)
11864 *remote_errno
= FILEIO_ENOSYS
;
11868 putpkt_binary (rs
->buf
.data (), command_bytes
);
11869 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11871 /* If it timed out, something is wrong. Don't try to parse the
11873 if (bytes_read
< 0)
11875 *remote_errno
= FILEIO_EINVAL
;
11879 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11882 *remote_errno
= FILEIO_EINVAL
;
11884 case PACKET_UNKNOWN
:
11885 *remote_errno
= FILEIO_ENOSYS
;
11891 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
11894 *remote_errno
= FILEIO_EINVAL
;
11898 /* Make sure we saw an attachment if and only if we expected one. */
11899 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11900 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11902 *remote_errno
= FILEIO_EINVAL
;
11906 /* If an attachment was found, it must point into the packet buffer;
11907 work out how many bytes there were. */
11908 if (attachment_tmp
!= NULL
)
11910 *attachment
= attachment_tmp
;
11911 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
11917 /* See declaration.h. */
11920 readahead_cache::invalidate ()
11925 /* See declaration.h. */
11928 readahead_cache::invalidate_fd (int fd
)
11930 if (this->fd
== fd
)
11934 /* Set the filesystem remote_hostio functions that take FILENAME
11935 arguments will use. Return 0 on success, or -1 if an error
11936 occurs (and set *REMOTE_ERRNO). */
11939 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
11942 struct remote_state
*rs
= get_remote_state ();
11943 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11944 char *p
= rs
->buf
.data ();
11945 int left
= get_remote_packet_size () - 1;
11949 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11952 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11955 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11957 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11958 remote_buffer_add_string (&p
, &left
, arg
);
11960 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
11961 remote_errno
, NULL
, NULL
);
11963 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11967 rs
->fs_pid
= required_pid
;
11972 /* Implementation of to_fileio_open. */
11975 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
11976 int flags
, int mode
, int warn_if_slow
,
11979 struct remote_state
*rs
= get_remote_state ();
11980 char *p
= rs
->buf
.data ();
11981 int left
= get_remote_packet_size () - 1;
11985 static int warning_issued
= 0;
11987 printf_unfiltered (_("Reading %s from remote target...\n"),
11990 if (!warning_issued
)
11992 warning (_("File transfers from remote targets can be slow."
11993 " Use \"set sysroot\" to access files locally"
11995 warning_issued
= 1;
11999 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12002 remote_buffer_add_string (&p
, &left
, "vFile:open:");
12004 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12005 strlen (filename
));
12006 remote_buffer_add_string (&p
, &left
, ",");
12008 remote_buffer_add_int (&p
, &left
, flags
);
12009 remote_buffer_add_string (&p
, &left
, ",");
12011 remote_buffer_add_int (&p
, &left
, mode
);
12013 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
12014 remote_errno
, NULL
, NULL
);
12018 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
12019 int flags
, int mode
, int warn_if_slow
,
12022 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
12026 /* Implementation of to_fileio_pwrite. */
12029 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12030 ULONGEST offset
, int *remote_errno
)
12032 struct remote_state
*rs
= get_remote_state ();
12033 char *p
= rs
->buf
.data ();
12034 int left
= get_remote_packet_size ();
12037 rs
->readahead_cache
.invalidate_fd (fd
);
12039 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
12041 remote_buffer_add_int (&p
, &left
, fd
);
12042 remote_buffer_add_string (&p
, &left
, ",");
12044 remote_buffer_add_int (&p
, &left
, offset
);
12045 remote_buffer_add_string (&p
, &left
, ",");
12047 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
12048 (get_remote_packet_size ()
12049 - (p
- rs
->buf
.data ())));
12051 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
12052 remote_errno
, NULL
, NULL
);
12056 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12057 ULONGEST offset
, int *remote_errno
)
12059 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
12062 /* Helper for the implementation of to_fileio_pread. Read the file
12063 from the remote side with vFile:pread. */
12066 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
12067 ULONGEST offset
, int *remote_errno
)
12069 struct remote_state
*rs
= get_remote_state ();
12070 char *p
= rs
->buf
.data ();
12072 int left
= get_remote_packet_size ();
12073 int ret
, attachment_len
;
12076 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
12078 remote_buffer_add_int (&p
, &left
, fd
);
12079 remote_buffer_add_string (&p
, &left
, ",");
12081 remote_buffer_add_int (&p
, &left
, len
);
12082 remote_buffer_add_string (&p
, &left
, ",");
12084 remote_buffer_add_int (&p
, &left
, offset
);
12086 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
12087 remote_errno
, &attachment
,
12093 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12095 if (read_len
!= ret
)
12096 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
12101 /* See declaration.h. */
12104 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12108 && this->offset
<= offset
12109 && offset
< this->offset
+ this->bufsize
)
12111 ULONGEST max
= this->offset
+ this->bufsize
;
12113 if (offset
+ len
> max
)
12114 len
= max
- offset
;
12116 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12123 /* Implementation of to_fileio_pread. */
12126 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12127 ULONGEST offset
, int *remote_errno
)
12130 struct remote_state
*rs
= get_remote_state ();
12131 readahead_cache
*cache
= &rs
->readahead_cache
;
12133 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12136 cache
->hit_count
++;
12139 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12140 pulongest (cache
->hit_count
));
12144 cache
->miss_count
++;
12146 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12147 pulongest (cache
->miss_count
));
12150 cache
->offset
= offset
;
12151 cache
->bufsize
= get_remote_packet_size ();
12152 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12154 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12155 cache
->offset
, remote_errno
);
12158 cache
->invalidate_fd (fd
);
12162 cache
->bufsize
= ret
;
12163 return cache
->pread (fd
, read_buf
, len
, offset
);
12167 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12168 ULONGEST offset
, int *remote_errno
)
12170 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12173 /* Implementation of to_fileio_close. */
12176 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12178 struct remote_state
*rs
= get_remote_state ();
12179 char *p
= rs
->buf
.data ();
12180 int left
= get_remote_packet_size () - 1;
12182 rs
->readahead_cache
.invalidate_fd (fd
);
12184 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12186 remote_buffer_add_int (&p
, &left
, fd
);
12188 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12189 remote_errno
, NULL
, NULL
);
12193 remote_target::fileio_close (int fd
, int *remote_errno
)
12195 return remote_hostio_close (fd
, remote_errno
);
12198 /* Implementation of to_fileio_unlink. */
12201 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12204 struct remote_state
*rs
= get_remote_state ();
12205 char *p
= rs
->buf
.data ();
12206 int left
= get_remote_packet_size () - 1;
12208 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12211 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12213 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12214 strlen (filename
));
12216 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12217 remote_errno
, NULL
, NULL
);
12221 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12224 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12227 /* Implementation of to_fileio_readlink. */
12229 gdb::optional
<std::string
>
12230 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12233 struct remote_state
*rs
= get_remote_state ();
12234 char *p
= rs
->buf
.data ();
12236 int left
= get_remote_packet_size ();
12237 int len
, attachment_len
;
12240 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12243 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12245 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12246 strlen (filename
));
12248 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12249 remote_errno
, &attachment
,
12255 std::string
ret (len
, '\0');
12257 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12258 (gdb_byte
*) &ret
[0], len
);
12259 if (read_len
!= len
)
12260 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12265 /* Implementation of to_fileio_fstat. */
12268 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12270 struct remote_state
*rs
= get_remote_state ();
12271 char *p
= rs
->buf
.data ();
12272 int left
= get_remote_packet_size ();
12273 int attachment_len
, ret
;
12275 struct fio_stat fst
;
12278 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12280 remote_buffer_add_int (&p
, &left
, fd
);
12282 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12283 remote_errno
, &attachment
,
12287 if (*remote_errno
!= FILEIO_ENOSYS
)
12290 /* Strictly we should return -1, ENOSYS here, but when
12291 "set sysroot remote:" was implemented in August 2008
12292 BFD's need for a stat function was sidestepped with
12293 this hack. This was not remedied until March 2015
12294 so we retain the previous behavior to avoid breaking
12297 Note that the memset is a March 2015 addition; older
12298 GDBs set st_size *and nothing else* so the structure
12299 would have garbage in all other fields. This might
12300 break something but retaining the previous behavior
12301 here would be just too wrong. */
12303 memset (st
, 0, sizeof (struct stat
));
12304 st
->st_size
= INT_MAX
;
12308 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12309 (gdb_byte
*) &fst
, sizeof (fst
));
12311 if (read_len
!= ret
)
12312 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12314 if (read_len
!= sizeof (fst
))
12315 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12316 read_len
, (int) sizeof (fst
));
12318 remote_fileio_to_host_stat (&fst
, st
);
12323 /* Implementation of to_filesystem_is_local. */
12326 remote_target::filesystem_is_local ()
12328 /* Valgrind GDB presents itself as a remote target but works
12329 on the local filesystem: it does not implement remote get
12330 and users are not expected to set a sysroot. To handle
12331 this case we treat the remote filesystem as local if the
12332 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12333 does not support vFile:open. */
12334 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12336 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12338 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12340 int fd
, remote_errno
;
12342 /* Try opening a file to probe support. The supplied
12343 filename is irrelevant, we only care about whether
12344 the stub recognizes the packet or not. */
12345 fd
= remote_hostio_open (NULL
, "just probing",
12346 FILEIO_O_RDONLY
, 0700, 0,
12350 remote_hostio_close (fd
, &remote_errno
);
12352 ps
= packet_support (PACKET_vFile_open
);
12355 if (ps
== PACKET_DISABLE
)
12357 static int warning_issued
= 0;
12359 if (!warning_issued
)
12361 warning (_("remote target does not support file"
12362 " transfer, attempting to access files"
12363 " from local filesystem."));
12364 warning_issued
= 1;
12375 remote_fileio_errno_to_host (int errnum
)
12381 case FILEIO_ENOENT
:
12389 case FILEIO_EACCES
:
12391 case FILEIO_EFAULT
:
12395 case FILEIO_EEXIST
:
12397 case FILEIO_ENODEV
:
12399 case FILEIO_ENOTDIR
:
12401 case FILEIO_EISDIR
:
12403 case FILEIO_EINVAL
:
12405 case FILEIO_ENFILE
:
12407 case FILEIO_EMFILE
:
12411 case FILEIO_ENOSPC
:
12413 case FILEIO_ESPIPE
:
12417 case FILEIO_ENOSYS
:
12419 case FILEIO_ENAMETOOLONG
:
12420 return ENAMETOOLONG
;
12426 remote_hostio_error (int errnum
)
12428 int host_error
= remote_fileio_errno_to_host (errnum
);
12430 if (host_error
== -1)
12431 error (_("Unknown remote I/O error %d"), errnum
);
12433 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12436 /* A RAII wrapper around a remote file descriptor. */
12438 class scoped_remote_fd
12441 scoped_remote_fd (remote_target
*remote
, int fd
)
12442 : m_remote (remote
), m_fd (fd
)
12446 ~scoped_remote_fd ()
12453 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12457 /* Swallow exception before it escapes the dtor. If
12458 something goes wrong, likely the connection is gone,
12459 and there's nothing else that can be done. */
12464 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12466 /* Release ownership of the file descriptor, and return it. */
12467 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12474 /* Return the owned file descriptor. */
12475 int get () const noexcept
12481 /* The remote target. */
12482 remote_target
*m_remote
;
12484 /* The owned remote I/O file descriptor. */
12489 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12491 remote_target
*remote
= get_current_remote_target ();
12493 if (remote
== nullptr)
12494 error (_("command can only be used with remote target"));
12496 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12500 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12503 int retcode
, remote_errno
, bytes
, io_size
;
12504 int bytes_in_buffer
;
12508 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12510 perror_with_name (local_file
);
12512 scoped_remote_fd fd
12513 (this, remote_hostio_open (NULL
,
12514 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12516 0700, 0, &remote_errno
));
12517 if (fd
.get () == -1)
12518 remote_hostio_error (remote_errno
);
12520 /* Send up to this many bytes at once. They won't all fit in the
12521 remote packet limit, so we'll transfer slightly fewer. */
12522 io_size
= get_remote_packet_size ();
12523 gdb::byte_vector
buffer (io_size
);
12525 bytes_in_buffer
= 0;
12528 while (bytes_in_buffer
|| !saw_eof
)
12532 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12533 io_size
- bytes_in_buffer
,
12537 if (ferror (file
.get ()))
12538 error (_("Error reading %s."), local_file
);
12541 /* EOF. Unless there is something still in the
12542 buffer from the last iteration, we are done. */
12544 if (bytes_in_buffer
== 0)
12552 bytes
+= bytes_in_buffer
;
12553 bytes_in_buffer
= 0;
12555 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12556 offset
, &remote_errno
);
12559 remote_hostio_error (remote_errno
);
12560 else if (retcode
== 0)
12561 error (_("Remote write of %d bytes returned 0!"), bytes
);
12562 else if (retcode
< bytes
)
12564 /* Short write. Save the rest of the read data for the next
12566 bytes_in_buffer
= bytes
- retcode
;
12567 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12573 if (remote_hostio_close (fd
.release (), &remote_errno
))
12574 remote_hostio_error (remote_errno
);
12577 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12581 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12583 remote_target
*remote
= get_current_remote_target ();
12585 if (remote
== nullptr)
12586 error (_("command can only be used with remote target"));
12588 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12592 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12595 int remote_errno
, bytes
, io_size
;
12598 scoped_remote_fd fd
12599 (this, remote_hostio_open (NULL
,
12600 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12602 if (fd
.get () == -1)
12603 remote_hostio_error (remote_errno
);
12605 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12607 perror_with_name (local_file
);
12609 /* Send up to this many bytes at once. They won't all fit in the
12610 remote packet limit, so we'll transfer slightly fewer. */
12611 io_size
= get_remote_packet_size ();
12612 gdb::byte_vector
buffer (io_size
);
12617 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12620 /* Success, but no bytes, means end-of-file. */
12623 remote_hostio_error (remote_errno
);
12627 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12629 perror_with_name (local_file
);
12632 if (remote_hostio_close (fd
.release (), &remote_errno
))
12633 remote_hostio_error (remote_errno
);
12636 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12640 remote_file_delete (const char *remote_file
, int from_tty
)
12642 remote_target
*remote
= get_current_remote_target ();
12644 if (remote
== nullptr)
12645 error (_("command can only be used with remote target"));
12647 remote
->remote_file_delete (remote_file
, from_tty
);
12651 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12653 int retcode
, remote_errno
;
12655 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12657 remote_hostio_error (remote_errno
);
12660 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12664 remote_put_command (const char *args
, int from_tty
)
12667 error_no_arg (_("file to put"));
12669 gdb_argv
argv (args
);
12670 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12671 error (_("Invalid parameters to remote put"));
12673 remote_file_put (argv
[0], argv
[1], from_tty
);
12677 remote_get_command (const char *args
, int from_tty
)
12680 error_no_arg (_("file to get"));
12682 gdb_argv
argv (args
);
12683 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12684 error (_("Invalid parameters to remote get"));
12686 remote_file_get (argv
[0], argv
[1], from_tty
);
12690 remote_delete_command (const char *args
, int from_tty
)
12693 error_no_arg (_("file to delete"));
12695 gdb_argv
argv (args
);
12696 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12697 error (_("Invalid parameters to remote delete"));
12699 remote_file_delete (argv
[0], from_tty
);
12703 remote_command (const char *args
, int from_tty
)
12705 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12709 remote_target::can_execute_reverse ()
12711 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12712 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12719 remote_target::supports_non_stop ()
12725 remote_target::supports_disable_randomization ()
12727 /* Only supported in extended mode. */
12732 remote_target::supports_multi_process ()
12734 struct remote_state
*rs
= get_remote_state ();
12736 return remote_multi_process_p (rs
);
12740 remote_supports_cond_tracepoints ()
12742 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12746 remote_target::supports_evaluation_of_breakpoint_conditions ()
12748 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12752 remote_supports_fast_tracepoints ()
12754 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12758 remote_supports_static_tracepoints ()
12760 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12764 remote_supports_install_in_trace ()
12766 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12770 remote_target::supports_enable_disable_tracepoint ()
12772 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12777 remote_target::supports_string_tracing ()
12779 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12783 remote_target::can_run_breakpoint_commands ()
12785 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12789 remote_target::trace_init ()
12791 struct remote_state
*rs
= get_remote_state ();
12794 remote_get_noisy_reply ();
12795 if (strcmp (rs
->buf
.data (), "OK") != 0)
12796 error (_("Target does not support this command."));
12799 /* Recursive routine to walk through command list including loops, and
12800 download packets for each command. */
12803 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12804 struct command_line
*cmds
)
12806 struct remote_state
*rs
= get_remote_state ();
12807 struct command_line
*cmd
;
12809 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12811 QUIT
; /* Allow user to bail out with ^C. */
12812 strcpy (rs
->buf
.data (), "QTDPsrc:");
12813 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12814 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12815 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12817 remote_get_noisy_reply ();
12818 if (strcmp (rs
->buf
.data (), "OK"))
12819 warning (_("Target does not support source download."));
12821 if (cmd
->control_type
== while_control
12822 || cmd
->control_type
== while_stepping_control
)
12824 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12826 QUIT
; /* Allow user to bail out with ^C. */
12827 strcpy (rs
->buf
.data (), "QTDPsrc:");
12828 encode_source_string (num
, addr
, "cmd", "end",
12829 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12830 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12832 remote_get_noisy_reply ();
12833 if (strcmp (rs
->buf
.data (), "OK"))
12834 warning (_("Target does not support source download."));
12840 remote_target::download_tracepoint (struct bp_location
*loc
)
12844 std::vector
<std::string
> tdp_actions
;
12845 std::vector
<std::string
> stepping_actions
;
12847 struct breakpoint
*b
= loc
->owner
;
12848 struct tracepoint
*t
= (struct tracepoint
*) b
;
12849 struct remote_state
*rs
= get_remote_state ();
12851 const char *err_msg
= _("Tracepoint packet too large for target.");
12854 /* We use a buffer other than rs->buf because we'll build strings
12855 across multiple statements, and other statements in between could
12857 gdb::char_vector
buf (get_remote_packet_size ());
12859 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12861 tpaddr
= loc
->address
;
12862 strcpy (addrbuf
, phex (tpaddr
, sizeof (CORE_ADDR
)));
12863 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12864 b
->number
, addrbuf
, /* address */
12865 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12866 t
->step_count
, t
->pass_count
);
12868 if (ret
< 0 || ret
>= buf
.size ())
12869 error ("%s", err_msg
);
12871 /* Fast tracepoints are mostly handled by the target, but we can
12872 tell the target how big of an instruction block should be moved
12874 if (b
->type
== bp_fast_tracepoint
)
12876 /* Only test for support at download time; we may not know
12877 target capabilities at definition time. */
12878 if (remote_supports_fast_tracepoints ())
12880 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12883 size_left
= buf
.size () - strlen (buf
.data ());
12884 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12886 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12888 if (ret
< 0 || ret
>= size_left
)
12889 error ("%s", err_msg
);
12892 /* If it passed validation at definition but fails now,
12893 something is very wrong. */
12894 internal_error (__FILE__
, __LINE__
,
12895 _("Fast tracepoint not "
12896 "valid during download"));
12899 /* Fast tracepoints are functionally identical to regular
12900 tracepoints, so don't take lack of support as a reason to
12901 give up on the trace run. */
12902 warning (_("Target does not support fast tracepoints, "
12903 "downloading %d as regular tracepoint"), b
->number
);
12905 else if (b
->type
== bp_static_tracepoint
)
12907 /* Only test for support at download time; we may not know
12908 target capabilities at definition time. */
12909 if (remote_supports_static_tracepoints ())
12911 struct static_tracepoint_marker marker
;
12913 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12915 size_left
= buf
.size () - strlen (buf
.data ());
12916 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12919 if (ret
< 0 || ret
>= size_left
)
12920 error ("%s", err_msg
);
12923 error (_("Static tracepoint not valid during download"));
12926 /* Fast tracepoints are functionally identical to regular
12927 tracepoints, so don't take lack of support as a reason
12928 to give up on the trace run. */
12929 error (_("Target does not support static tracepoints"));
12931 /* If the tracepoint has a conditional, make it into an agent
12932 expression and append to the definition. */
12935 /* Only test support at download time, we may not know target
12936 capabilities at definition time. */
12937 if (remote_supports_cond_tracepoints ())
12939 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
12942 size_left
= buf
.size () - strlen (buf
.data ());
12944 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12945 size_left
, ":X%x,", aexpr
->len
);
12947 if (ret
< 0 || ret
>= size_left
)
12948 error ("%s", err_msg
);
12950 size_left
= buf
.size () - strlen (buf
.data ());
12952 /* Two bytes to encode each aexpr byte, plus the terminating
12954 if (aexpr
->len
* 2 + 1 > size_left
)
12955 error ("%s", err_msg
);
12957 pkt
= buf
.data () + strlen (buf
.data ());
12959 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12960 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12964 warning (_("Target does not support conditional tracepoints, "
12965 "ignoring tp %d cond"), b
->number
);
12968 if (b
->commands
|| *default_collect
)
12970 size_left
= buf
.size () - strlen (buf
.data ());
12972 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12975 if (ret
< 0 || ret
>= size_left
)
12976 error ("%s", err_msg
);
12979 putpkt (buf
.data ());
12980 remote_get_noisy_reply ();
12981 if (strcmp (rs
->buf
.data (), "OK"))
12982 error (_("Target does not support tracepoints."));
12984 /* do_single_steps (t); */
12985 for (auto action_it
= tdp_actions
.begin ();
12986 action_it
!= tdp_actions
.end (); action_it
++)
12988 QUIT
; /* Allow user to bail out with ^C. */
12990 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
12991 || !stepping_actions
.empty ());
12993 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
12994 b
->number
, addrbuf
, /* address */
12995 action_it
->c_str (),
12996 has_more
? '-' : 0);
12998 if (ret
< 0 || ret
>= buf
.size ())
12999 error ("%s", err_msg
);
13001 putpkt (buf
.data ());
13002 remote_get_noisy_reply ();
13003 if (strcmp (rs
->buf
.data (), "OK"))
13004 error (_("Error on target while setting tracepoints."));
13007 for (auto action_it
= stepping_actions
.begin ();
13008 action_it
!= stepping_actions
.end (); action_it
++)
13010 QUIT
; /* Allow user to bail out with ^C. */
13012 bool is_first
= action_it
== stepping_actions
.begin ();
13013 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
13015 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
13016 b
->number
, addrbuf
, /* address */
13017 is_first
? "S" : "",
13018 action_it
->c_str (),
13019 has_more
? "-" : "");
13021 if (ret
< 0 || ret
>= buf
.size ())
13022 error ("%s", err_msg
);
13024 putpkt (buf
.data ());
13025 remote_get_noisy_reply ();
13026 if (strcmp (rs
->buf
.data (), "OK"))
13027 error (_("Error on target while setting tracepoints."));
13030 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
13032 if (b
->location
!= NULL
)
13034 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13036 if (ret
< 0 || ret
>= buf
.size ())
13037 error ("%s", err_msg
);
13039 encode_source_string (b
->number
, loc
->address
, "at",
13040 event_location_to_string (b
->location
.get ()),
13041 buf
.data () + strlen (buf
.data ()),
13042 buf
.size () - strlen (buf
.data ()));
13043 putpkt (buf
.data ());
13044 remote_get_noisy_reply ();
13045 if (strcmp (rs
->buf
.data (), "OK"))
13046 warning (_("Target does not support source download."));
13048 if (b
->cond_string
)
13050 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13052 if (ret
< 0 || ret
>= buf
.size ())
13053 error ("%s", err_msg
);
13055 encode_source_string (b
->number
, loc
->address
,
13056 "cond", b
->cond_string
,
13057 buf
.data () + strlen (buf
.data ()),
13058 buf
.size () - strlen (buf
.data ()));
13059 putpkt (buf
.data ());
13060 remote_get_noisy_reply ();
13061 if (strcmp (rs
->buf
.data (), "OK"))
13062 warning (_("Target does not support source download."));
13064 remote_download_command_source (b
->number
, loc
->address
,
13065 breakpoint_commands (b
));
13070 remote_target::can_download_tracepoint ()
13072 struct remote_state
*rs
= get_remote_state ();
13073 struct trace_status
*ts
;
13076 /* Don't try to install tracepoints until we've relocated our
13077 symbols, and fetched and merged the target's tracepoint list with
13079 if (rs
->starting_up
)
13082 ts
= current_trace_status ();
13083 status
= get_trace_status (ts
);
13085 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
13088 /* If we are in a tracing experiment, but remote stub doesn't support
13089 installing tracepoint in trace, we have to return. */
13090 if (!remote_supports_install_in_trace ())
13098 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
13100 struct remote_state
*rs
= get_remote_state ();
13103 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13104 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13106 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13107 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13108 >= get_remote_packet_size ())
13109 error (_("Trace state variable name too long for tsv definition packet"));
13110 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13113 remote_get_noisy_reply ();
13114 if (rs
->buf
[0] == '\0')
13115 error (_("Target does not support this command."));
13116 if (strcmp (rs
->buf
.data (), "OK") != 0)
13117 error (_("Error on target while downloading trace state variable."));
13121 remote_target::enable_tracepoint (struct bp_location
*location
)
13123 struct remote_state
*rs
= get_remote_state ();
13125 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13126 location
->owner
->number
,
13127 phex (location
->address
, sizeof (CORE_ADDR
)));
13129 remote_get_noisy_reply ();
13130 if (rs
->buf
[0] == '\0')
13131 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13132 if (strcmp (rs
->buf
.data (), "OK") != 0)
13133 error (_("Error on target while enabling tracepoint."));
13137 remote_target::disable_tracepoint (struct bp_location
*location
)
13139 struct remote_state
*rs
= get_remote_state ();
13141 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13142 location
->owner
->number
,
13143 phex (location
->address
, sizeof (CORE_ADDR
)));
13145 remote_get_noisy_reply ();
13146 if (rs
->buf
[0] == '\0')
13147 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13148 if (strcmp (rs
->buf
.data (), "OK") != 0)
13149 error (_("Error on target while disabling tracepoint."));
13153 remote_target::trace_set_readonly_regions ()
13156 bfd_size_type size
;
13162 return; /* No information to give. */
13164 struct remote_state
*rs
= get_remote_state ();
13166 strcpy (rs
->buf
.data (), "QTro");
13167 offset
= strlen (rs
->buf
.data ());
13168 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
13170 char tmp1
[40], tmp2
[40];
13173 if ((s
->flags
& SEC_LOAD
) == 0 ||
13174 /* (s->flags & SEC_CODE) == 0 || */
13175 (s
->flags
& SEC_READONLY
) == 0)
13179 vma
= bfd_section_vma (s
);
13180 size
= bfd_section_size (s
);
13181 sprintf_vma (tmp1
, vma
);
13182 sprintf_vma (tmp2
, vma
+ size
);
13183 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13184 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13186 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13188 Too many sections for read-only sections definition packet."));
13191 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13193 offset
+= sec_length
;
13198 getpkt (&rs
->buf
, 0);
13203 remote_target::trace_start ()
13205 struct remote_state
*rs
= get_remote_state ();
13207 putpkt ("QTStart");
13208 remote_get_noisy_reply ();
13209 if (rs
->buf
[0] == '\0')
13210 error (_("Target does not support this command."));
13211 if (strcmp (rs
->buf
.data (), "OK") != 0)
13212 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13216 remote_target::get_trace_status (struct trace_status
*ts
)
13218 /* Initialize it just to avoid a GCC false warning. */
13220 enum packet_result result
;
13221 struct remote_state
*rs
= get_remote_state ();
13223 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13226 /* FIXME we need to get register block size some other way. */
13227 trace_regblock_size
13228 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13230 putpkt ("qTStatus");
13234 p
= remote_get_noisy_reply ();
13236 catch (const gdb_exception_error
&ex
)
13238 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13240 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13246 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13248 /* If the remote target doesn't do tracing, flag it. */
13249 if (result
== PACKET_UNKNOWN
)
13252 /* We're working with a live target. */
13253 ts
->filename
= NULL
;
13256 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13258 /* Function 'parse_trace_status' sets default value of each field of
13259 'ts' at first, so we don't have to do it here. */
13260 parse_trace_status (p
, ts
);
13262 return ts
->running
;
13266 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13267 struct uploaded_tp
*utp
)
13269 struct remote_state
*rs
= get_remote_state ();
13271 struct bp_location
*loc
;
13272 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13273 size_t size
= get_remote_packet_size ();
13278 tp
->traceframe_usage
= 0;
13279 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13281 /* If the tracepoint was never downloaded, don't go asking for
13283 if (tp
->number_on_target
== 0)
13285 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13286 phex_nz (loc
->address
, 0));
13288 reply
= remote_get_noisy_reply ();
13289 if (reply
&& *reply
)
13292 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13298 utp
->hit_count
= 0;
13299 utp
->traceframe_usage
= 0;
13300 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13301 phex_nz (utp
->addr
, 0));
13303 reply
= remote_get_noisy_reply ();
13304 if (reply
&& *reply
)
13307 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13313 remote_target::trace_stop ()
13315 struct remote_state
*rs
= get_remote_state ();
13318 remote_get_noisy_reply ();
13319 if (rs
->buf
[0] == '\0')
13320 error (_("Target does not support this command."));
13321 if (strcmp (rs
->buf
.data (), "OK") != 0)
13322 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13326 remote_target::trace_find (enum trace_find_type type
, int num
,
13327 CORE_ADDR addr1
, CORE_ADDR addr2
,
13330 struct remote_state
*rs
= get_remote_state ();
13331 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13333 int target_frameno
= -1, target_tracept
= -1;
13335 /* Lookups other than by absolute frame number depend on the current
13336 trace selected, so make sure it is correct on the remote end
13338 if (type
!= tfind_number
)
13339 set_remote_traceframe ();
13341 p
= rs
->buf
.data ();
13342 strcpy (p
, "QTFrame:");
13343 p
= strchr (p
, '\0');
13347 xsnprintf (p
, endbuf
- p
, "%x", num
);
13350 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13353 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13356 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13357 phex_nz (addr2
, 0));
13359 case tfind_outside
:
13360 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13361 phex_nz (addr2
, 0));
13364 error (_("Unknown trace find type %d"), type
);
13368 reply
= remote_get_noisy_reply ();
13369 if (*reply
== '\0')
13370 error (_("Target does not support this command."));
13372 while (reply
&& *reply
)
13377 target_frameno
= (int) strtol (p
, &reply
, 16);
13379 error (_("Unable to parse trace frame number"));
13380 /* Don't update our remote traceframe number cache on failure
13381 to select a remote traceframe. */
13382 if (target_frameno
== -1)
13387 target_tracept
= (int) strtol (p
, &reply
, 16);
13389 error (_("Unable to parse tracepoint number"));
13391 case 'O': /* "OK"? */
13392 if (reply
[1] == 'K' && reply
[2] == '\0')
13395 error (_("Bogus reply from target: %s"), reply
);
13398 error (_("Bogus reply from target: %s"), reply
);
13401 *tpp
= target_tracept
;
13403 rs
->remote_traceframe_number
= target_frameno
;
13404 return target_frameno
;
13408 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13410 struct remote_state
*rs
= get_remote_state ();
13414 set_remote_traceframe ();
13416 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13418 reply
= remote_get_noisy_reply ();
13419 if (reply
&& *reply
)
13423 unpack_varlen_hex (reply
+ 1, &uval
);
13424 *val
= (LONGEST
) uval
;
13432 remote_target::save_trace_data (const char *filename
)
13434 struct remote_state
*rs
= get_remote_state ();
13437 p
= rs
->buf
.data ();
13438 strcpy (p
, "QTSave:");
13440 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13441 >= get_remote_packet_size ())
13442 error (_("Remote file name too long for trace save packet"));
13443 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13446 reply
= remote_get_noisy_reply ();
13447 if (*reply
== '\0')
13448 error (_("Target does not support this command."));
13449 if (strcmp (reply
, "OK") != 0)
13450 error (_("Bogus reply from target: %s"), reply
);
13454 /* This is basically a memory transfer, but needs to be its own packet
13455 because we don't know how the target actually organizes its trace
13456 memory, plus we want to be able to ask for as much as possible, but
13457 not be unhappy if we don't get as much as we ask for. */
13460 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13462 struct remote_state
*rs
= get_remote_state ();
13467 p
= rs
->buf
.data ();
13468 strcpy (p
, "qTBuffer:");
13470 p
+= hexnumstr (p
, offset
);
13472 p
+= hexnumstr (p
, len
);
13476 reply
= remote_get_noisy_reply ();
13477 if (reply
&& *reply
)
13479 /* 'l' by itself means we're at the end of the buffer and
13480 there is nothing more to get. */
13484 /* Convert the reply into binary. Limit the number of bytes to
13485 convert according to our passed-in buffer size, rather than
13486 what was returned in the packet; if the target is
13487 unexpectedly generous and gives us a bigger reply than we
13488 asked for, we don't want to crash. */
13489 rslt
= hex2bin (reply
, buf
, len
);
13493 /* Something went wrong, flag as an error. */
13498 remote_target::set_disconnected_tracing (int val
)
13500 struct remote_state
*rs
= get_remote_state ();
13502 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13506 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13507 "QTDisconnected:%x", val
);
13509 reply
= remote_get_noisy_reply ();
13510 if (*reply
== '\0')
13511 error (_("Target does not support this command."));
13512 if (strcmp (reply
, "OK") != 0)
13513 error (_("Bogus reply from target: %s"), reply
);
13516 warning (_("Target does not support disconnected tracing."));
13520 remote_target::core_of_thread (ptid_t ptid
)
13522 thread_info
*info
= find_thread_ptid (this, ptid
);
13524 if (info
!= NULL
&& info
->priv
!= NULL
)
13525 return get_remote_thread_info (info
)->core
;
13531 remote_target::set_circular_trace_buffer (int val
)
13533 struct remote_state
*rs
= get_remote_state ();
13536 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13537 "QTBuffer:circular:%x", val
);
13539 reply
= remote_get_noisy_reply ();
13540 if (*reply
== '\0')
13541 error (_("Target does not support this command."));
13542 if (strcmp (reply
, "OK") != 0)
13543 error (_("Bogus reply from target: %s"), reply
);
13547 remote_target::traceframe_info ()
13549 gdb::optional
<gdb::char_vector
> text
13550 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13553 return parse_traceframe_info (text
->data ());
13558 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13559 instruction on which a fast tracepoint may be placed. Returns -1
13560 if the packet is not supported, and 0 if the minimum instruction
13561 length is unknown. */
13564 remote_target::get_min_fast_tracepoint_insn_len ()
13566 struct remote_state
*rs
= get_remote_state ();
13569 /* If we're not debugging a process yet, the IPA can't be
13571 if (!target_has_execution
)
13574 /* Make sure the remote is pointing at the right process. */
13575 set_general_process ();
13577 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13579 reply
= remote_get_noisy_reply ();
13580 if (*reply
== '\0')
13584 ULONGEST min_insn_len
;
13586 unpack_varlen_hex (reply
, &min_insn_len
);
13588 return (int) min_insn_len
;
13593 remote_target::set_trace_buffer_size (LONGEST val
)
13595 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13597 struct remote_state
*rs
= get_remote_state ();
13598 char *buf
= rs
->buf
.data ();
13599 char *endbuf
= buf
+ get_remote_packet_size ();
13600 enum packet_result result
;
13602 gdb_assert (val
>= 0 || val
== -1);
13603 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13604 /* Send -1 as literal "-1" to avoid host size dependency. */
13608 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13611 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13614 remote_get_noisy_reply ();
13615 result
= packet_ok (rs
->buf
,
13616 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13618 if (result
!= PACKET_OK
)
13619 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13624 remote_target::set_trace_notes (const char *user
, const char *notes
,
13625 const char *stop_notes
)
13627 struct remote_state
*rs
= get_remote_state ();
13629 char *buf
= rs
->buf
.data ();
13630 char *endbuf
= buf
+ get_remote_packet_size ();
13633 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13636 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13637 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13643 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13644 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13650 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13651 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13655 /* Ensure the buffer is terminated. */
13659 reply
= remote_get_noisy_reply ();
13660 if (*reply
== '\0')
13663 if (strcmp (reply
, "OK") != 0)
13664 error (_("Bogus reply from target: %s"), reply
);
13670 remote_target::use_agent (bool use
)
13672 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13674 struct remote_state
*rs
= get_remote_state ();
13676 /* If the stub supports QAgent. */
13677 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13679 getpkt (&rs
->buf
, 0);
13681 if (strcmp (rs
->buf
.data (), "OK") == 0)
13692 remote_target::can_use_agent ()
13694 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13697 struct btrace_target_info
13699 /* The ptid of the traced thread. */
13702 /* The obtained branch trace configuration. */
13703 struct btrace_config conf
;
13706 /* Reset our idea of our target's btrace configuration. */
13709 remote_btrace_reset (remote_state
*rs
)
13711 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13714 /* Synchronize the configuration with the target. */
13717 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13719 struct packet_config
*packet
;
13720 struct remote_state
*rs
;
13721 char *buf
, *pos
, *endbuf
;
13723 rs
= get_remote_state ();
13724 buf
= rs
->buf
.data ();
13725 endbuf
= buf
+ get_remote_packet_size ();
13727 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13728 if (packet_config_support (packet
) == PACKET_ENABLE
13729 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13732 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13736 getpkt (&rs
->buf
, 0);
13738 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13740 if (buf
[0] == 'E' && buf
[1] == '.')
13741 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13743 error (_("Failed to configure the BTS buffer size."));
13746 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13749 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13750 if (packet_config_support (packet
) == PACKET_ENABLE
13751 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13754 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13758 getpkt (&rs
->buf
, 0);
13760 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13762 if (buf
[0] == 'E' && buf
[1] == '.')
13763 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13765 error (_("Failed to configure the trace buffer size."));
13768 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13772 /* Read the current thread's btrace configuration from the target and
13773 store it into CONF. */
13776 btrace_read_config (struct btrace_config
*conf
)
13778 gdb::optional
<gdb::char_vector
> xml
13779 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13781 parse_xml_btrace_conf (conf
, xml
->data ());
13784 /* Maybe reopen target btrace. */
13787 remote_target::remote_btrace_maybe_reopen ()
13789 struct remote_state
*rs
= get_remote_state ();
13790 int btrace_target_pushed
= 0;
13791 #if !defined (HAVE_LIBIPT)
13795 /* Don't bother walking the entirety of the remote thread list when
13796 we know the feature isn't supported by the remote. */
13797 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13800 scoped_restore_current_thread restore_thread
;
13802 for (thread_info
*tp
: all_non_exited_threads (this))
13804 set_general_thread (tp
->ptid
);
13806 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13807 btrace_read_config (&rs
->btrace_config
);
13809 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13812 #if !defined (HAVE_LIBIPT)
13813 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13818 warning (_("Target is recording using Intel Processor Trace "
13819 "but support was disabled at compile time."));
13824 #endif /* !defined (HAVE_LIBIPT) */
13826 /* Push target, once, but before anything else happens. This way our
13827 changes to the threads will be cleaned up by unpushing the target
13828 in case btrace_read_config () throws. */
13829 if (!btrace_target_pushed
)
13831 btrace_target_pushed
= 1;
13832 record_btrace_push_target ();
13833 printf_filtered (_("Target is recording using %s.\n"),
13834 btrace_format_string (rs
->btrace_config
.format
));
13837 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13838 tp
->btrace
.target
->ptid
= tp
->ptid
;
13839 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13843 /* Enable branch tracing. */
13845 struct btrace_target_info
*
13846 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13848 struct btrace_target_info
*tinfo
= NULL
;
13849 struct packet_config
*packet
= NULL
;
13850 struct remote_state
*rs
= get_remote_state ();
13851 char *buf
= rs
->buf
.data ();
13852 char *endbuf
= buf
+ get_remote_packet_size ();
13854 switch (conf
->format
)
13856 case BTRACE_FORMAT_BTS
:
13857 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13860 case BTRACE_FORMAT_PT
:
13861 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13865 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13866 error (_("Target does not support branch tracing."));
13868 btrace_sync_conf (conf
);
13870 set_general_thread (ptid
);
13872 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13874 getpkt (&rs
->buf
, 0);
13876 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13878 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13879 error (_("Could not enable branch tracing for %s: %s"),
13880 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
13882 error (_("Could not enable branch tracing for %s."),
13883 target_pid_to_str (ptid
).c_str ());
13886 tinfo
= XCNEW (struct btrace_target_info
);
13887 tinfo
->ptid
= ptid
;
13889 /* If we fail to read the configuration, we lose some information, but the
13890 tracing itself is not impacted. */
13893 btrace_read_config (&tinfo
->conf
);
13895 catch (const gdb_exception_error
&err
)
13897 if (err
.message
!= NULL
)
13898 warning ("%s", err
.what ());
13904 /* Disable branch tracing. */
13907 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
13909 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13910 struct remote_state
*rs
= get_remote_state ();
13911 char *buf
= rs
->buf
.data ();
13912 char *endbuf
= buf
+ get_remote_packet_size ();
13914 if (packet_config_support (packet
) != PACKET_ENABLE
)
13915 error (_("Target does not support branch tracing."));
13917 set_general_thread (tinfo
->ptid
);
13919 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13921 getpkt (&rs
->buf
, 0);
13923 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13925 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13926 error (_("Could not disable branch tracing for %s: %s"),
13927 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
13929 error (_("Could not disable branch tracing for %s."),
13930 target_pid_to_str (tinfo
->ptid
).c_str ());
13936 /* Teardown branch tracing. */
13939 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
13941 /* We must not talk to the target during teardown. */
13945 /* Read the branch trace. */
13948 remote_target::read_btrace (struct btrace_data
*btrace
,
13949 struct btrace_target_info
*tinfo
,
13950 enum btrace_read_type type
)
13952 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13955 if (packet_config_support (packet
) != PACKET_ENABLE
)
13956 error (_("Target does not support branch tracing."));
13958 #if !defined(HAVE_LIBEXPAT)
13959 error (_("Cannot process branch tracing result. XML parsing not supported."));
13964 case BTRACE_READ_ALL
:
13967 case BTRACE_READ_NEW
:
13970 case BTRACE_READ_DELTA
:
13974 internal_error (__FILE__
, __LINE__
,
13975 _("Bad branch tracing read type: %u."),
13976 (unsigned int) type
);
13979 gdb::optional
<gdb::char_vector
> xml
13980 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
13982 return BTRACE_ERR_UNKNOWN
;
13984 parse_xml_btrace (btrace
, xml
->data ());
13986 return BTRACE_ERR_NONE
;
13989 const struct btrace_config
*
13990 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
13992 return &tinfo
->conf
;
13996 remote_target::augmented_libraries_svr4_read ()
13998 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
14002 /* Implementation of to_load. */
14005 remote_target::load (const char *name
, int from_tty
)
14007 generic_load (name
, from_tty
);
14010 /* Accepts an integer PID; returns a string representing a file that
14011 can be opened on the remote side to get the symbols for the child
14012 process. Returns NULL if the operation is not supported. */
14015 remote_target::pid_to_exec_file (int pid
)
14017 static gdb::optional
<gdb::char_vector
> filename
;
14018 char *annex
= NULL
;
14020 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
14023 inferior
*inf
= find_inferior_pid (this, pid
);
14025 internal_error (__FILE__
, __LINE__
,
14026 _("not currently attached to process %d"), pid
);
14028 if (!inf
->fake_pid_p
)
14030 const int annex_size
= 9;
14032 annex
= (char *) alloca (annex_size
);
14033 xsnprintf (annex
, annex_size
, "%x", pid
);
14036 filename
= target_read_stralloc (current_top_target (),
14037 TARGET_OBJECT_EXEC_FILE
, annex
);
14039 return filename
? filename
->data () : nullptr;
14042 /* Implement the to_can_do_single_step target_ops method. */
14045 remote_target::can_do_single_step ()
14047 /* We can only tell whether target supports single step or not by
14048 supported s and S vCont actions if the stub supports vContSupported
14049 feature. If the stub doesn't support vContSupported feature,
14050 we have conservatively to think target doesn't supports single
14052 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
14054 struct remote_state
*rs
= get_remote_state ();
14056 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14057 remote_vcont_probe ();
14059 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
14065 /* Implementation of the to_execution_direction method for the remote
14068 enum exec_direction_kind
14069 remote_target::execution_direction ()
14071 struct remote_state
*rs
= get_remote_state ();
14073 return rs
->last_resume_exec_dir
;
14076 /* Return pointer to the thread_info struct which corresponds to
14077 THREAD_HANDLE (having length HANDLE_LEN). */
14080 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
14084 for (thread_info
*tp
: all_non_exited_threads (this))
14086 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14088 if (tp
->inf
== inf
&& priv
!= NULL
)
14090 if (handle_len
!= priv
->thread_handle
.size ())
14091 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14092 handle_len
, priv
->thread_handle
.size ());
14093 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14103 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
14105 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14106 return priv
->thread_handle
;
14110 remote_target::can_async_p ()
14112 struct remote_state
*rs
= get_remote_state ();
14114 /* We don't go async if the user has explicitly prevented it with the
14115 "maint set target-async" command. */
14116 if (!target_async_permitted
)
14119 /* We're async whenever the serial device is. */
14120 return serial_can_async_p (rs
->remote_desc
);
14124 remote_target::is_async_p ()
14126 struct remote_state
*rs
= get_remote_state ();
14128 if (!target_async_permitted
)
14129 /* We only enable async when the user specifically asks for it. */
14132 /* We're async whenever the serial device is. */
14133 return serial_is_async_p (rs
->remote_desc
);
14136 /* Pass the SERIAL event on and up to the client. One day this code
14137 will be able to delay notifying the client of an event until the
14138 point where an entire packet has been received. */
14140 static serial_event_ftype remote_async_serial_handler
;
14143 remote_async_serial_handler (struct serial
*scb
, void *context
)
14145 /* Don't propogate error information up to the client. Instead let
14146 the client find out about the error by querying the target. */
14147 inferior_event_handler (INF_REG_EVENT
, NULL
);
14151 remote_async_inferior_event_handler (gdb_client_data data
)
14153 inferior_event_handler (INF_REG_EVENT
, data
);
14157 remote_target::async_wait_fd ()
14159 struct remote_state
*rs
= get_remote_state ();
14160 return rs
->remote_desc
->fd
;
14164 remote_target::async (int enable
)
14166 struct remote_state
*rs
= get_remote_state ();
14170 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14172 /* If there are pending events in the stop reply queue tell the
14173 event loop to process them. */
14174 if (!rs
->stop_reply_queue
.empty ())
14175 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14176 /* For simplicity, below we clear the pending events token
14177 without remembering whether it is marked, so here we always
14178 mark it. If there's actually no pending notification to
14179 process, this ends up being a no-op (other than a spurious
14180 event-loop wakeup). */
14181 if (target_is_non_stop_p ())
14182 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14186 serial_async (rs
->remote_desc
, NULL
, NULL
);
14187 /* If the core is disabling async, it doesn't want to be
14188 disturbed with target events. Clear all async event sources
14190 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14191 if (target_is_non_stop_p ())
14192 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14196 /* Implementation of the to_thread_events method. */
14199 remote_target::thread_events (int enable
)
14201 struct remote_state
*rs
= get_remote_state ();
14202 size_t size
= get_remote_packet_size ();
14204 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14207 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14209 getpkt (&rs
->buf
, 0);
14211 switch (packet_ok (rs
->buf
,
14212 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14215 if (strcmp (rs
->buf
.data (), "OK") != 0)
14216 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14219 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14221 case PACKET_UNKNOWN
:
14227 set_remote_cmd (const char *args
, int from_tty
)
14229 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
14233 show_remote_cmd (const char *args
, int from_tty
)
14235 /* We can't just use cmd_show_list here, because we want to skip
14236 the redundant "show remote Z-packet" and the legacy aliases. */
14237 struct cmd_list_element
*list
= remote_show_cmdlist
;
14238 struct ui_out
*uiout
= current_uiout
;
14240 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14241 for (; list
!= NULL
; list
= list
->next
)
14242 if (strcmp (list
->name
, "Z-packet") == 0)
14244 else if (list
->type
== not_set_cmd
)
14245 /* Alias commands are exactly like the original, except they
14246 don't have the normal type. */
14250 ui_out_emit_tuple
option_emitter (uiout
, "option");
14252 uiout
->field_string ("name", list
->name
);
14253 uiout
->text (": ");
14254 if (list
->type
== show_cmd
)
14255 do_show_command (NULL
, from_tty
, list
);
14257 cmd_func (list
, NULL
, from_tty
);
14262 /* Function to be called whenever a new objfile (shlib) is detected. */
14264 remote_new_objfile (struct objfile
*objfile
)
14266 remote_target
*remote
= get_current_remote_target ();
14268 if (remote
!= NULL
) /* Have a remote connection. */
14269 remote
->remote_check_symbols ();
14272 /* Pull all the tracepoints defined on the target and create local
14273 data structures representing them. We don't want to create real
14274 tracepoints yet, we don't want to mess up the user's existing
14278 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14280 struct remote_state
*rs
= get_remote_state ();
14283 /* Ask for a first packet of tracepoint definition. */
14285 getpkt (&rs
->buf
, 0);
14286 p
= rs
->buf
.data ();
14287 while (*p
&& *p
!= 'l')
14289 parse_tracepoint_definition (p
, utpp
);
14290 /* Ask for another packet of tracepoint definition. */
14292 getpkt (&rs
->buf
, 0);
14293 p
= rs
->buf
.data ();
14299 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14301 struct remote_state
*rs
= get_remote_state ();
14304 /* Ask for a first packet of variable definition. */
14306 getpkt (&rs
->buf
, 0);
14307 p
= rs
->buf
.data ();
14308 while (*p
&& *p
!= 'l')
14310 parse_tsv_definition (p
, utsvp
);
14311 /* Ask for another packet of variable definition. */
14313 getpkt (&rs
->buf
, 0);
14314 p
= rs
->buf
.data ();
14319 /* The "set/show range-stepping" show hook. */
14322 show_range_stepping (struct ui_file
*file
, int from_tty
,
14323 struct cmd_list_element
*c
,
14326 fprintf_filtered (file
,
14327 _("Debugger's willingness to use range stepping "
14328 "is %s.\n"), value
);
14331 /* Return true if the vCont;r action is supported by the remote
14335 remote_target::vcont_r_supported ()
14337 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14338 remote_vcont_probe ();
14340 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14341 && get_remote_state ()->supports_vCont
.r
);
14344 /* The "set/show range-stepping" set hook. */
14347 set_range_stepping (const char *ignore_args
, int from_tty
,
14348 struct cmd_list_element
*c
)
14350 /* When enabling, check whether range stepping is actually supported
14351 by the target, and warn if not. */
14352 if (use_range_stepping
)
14354 remote_target
*remote
= get_current_remote_target ();
14356 || !remote
->vcont_r_supported ())
14357 warning (_("Range stepping is not supported by the current target"));
14361 void _initialize_remote ();
14363 _initialize_remote ()
14365 struct cmd_list_element
*cmd
;
14366 const char *cmd_name
;
14368 /* architecture specific data */
14369 remote_g_packet_data_handle
=
14370 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14372 add_target (remote_target_info
, remote_target::open
);
14373 add_target (extended_remote_target_info
, extended_remote_target::open
);
14375 /* Hook into new objfile notification. */
14376 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14379 init_remote_threadtests ();
14382 /* set/show remote ... */
14384 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14385 Remote protocol specific variables.\n\
14386 Configure various remote-protocol specific variables such as\n\
14387 the packets being used."),
14388 &remote_set_cmdlist
, "set remote ",
14389 0 /* allow-unknown */, &setlist
);
14390 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14391 Remote protocol specific variables.\n\
14392 Configure various remote-protocol specific variables such as\n\
14393 the packets being used."),
14394 &remote_show_cmdlist
, "show remote ",
14395 0 /* allow-unknown */, &showlist
);
14397 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14398 Compare section data on target to the exec file.\n\
14399 Argument is a single section name (default: all loaded sections).\n\
14400 To compare only read-only loaded sections, specify the -r option."),
14403 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14404 Send an arbitrary packet to a remote target.\n\
14405 maintenance packet TEXT\n\
14406 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14407 this command sends the string TEXT to the inferior, and displays the\n\
14408 response packet. GDB supplies the initial `$' character, and the\n\
14409 terminating `#' character and checksum."),
14412 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14413 Set whether to send break if interrupted."), _("\
14414 Show whether to send break if interrupted."), _("\
14415 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14416 set_remotebreak
, show_remotebreak
,
14417 &setlist
, &showlist
);
14418 cmd_name
= "remotebreak";
14419 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14420 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14421 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14422 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14423 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14425 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14426 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14428 Set interrupt sequence to remote target."), _("\
14429 Show interrupt sequence to remote target."), _("\
14430 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14431 NULL
, show_interrupt_sequence
,
14432 &remote_set_cmdlist
,
14433 &remote_show_cmdlist
);
14435 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14436 &interrupt_on_connect
, _("\
14437 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14438 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14439 If set, interrupt sequence is sent to remote target."),
14441 &remote_set_cmdlist
, &remote_show_cmdlist
);
14443 /* Install commands for configuring memory read/write packets. */
14445 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14446 Set the maximum number of bytes per memory write packet (deprecated)."),
14448 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14449 Show the maximum number of bytes per memory write packet (deprecated)."),
14451 add_cmd ("memory-write-packet-size", no_class
,
14452 set_memory_write_packet_size
, _("\
14453 Set the maximum number of bytes per memory-write packet.\n\
14454 Specify the number of bytes in a packet or 0 (zero) for the\n\
14455 default packet size. The actual limit is further reduced\n\
14456 dependent on the target. Specify ``fixed'' to disable the\n\
14457 further restriction and ``limit'' to enable that restriction."),
14458 &remote_set_cmdlist
);
14459 add_cmd ("memory-read-packet-size", no_class
,
14460 set_memory_read_packet_size
, _("\
14461 Set the maximum number of bytes per memory-read packet.\n\
14462 Specify the number of bytes in a packet or 0 (zero) for the\n\
14463 default packet size. The actual limit is further reduced\n\
14464 dependent on the target. Specify ``fixed'' to disable the\n\
14465 further restriction and ``limit'' to enable that restriction."),
14466 &remote_set_cmdlist
);
14467 add_cmd ("memory-write-packet-size", no_class
,
14468 show_memory_write_packet_size
,
14469 _("Show the maximum number of bytes per memory-write packet."),
14470 &remote_show_cmdlist
);
14471 add_cmd ("memory-read-packet-size", no_class
,
14472 show_memory_read_packet_size
,
14473 _("Show the maximum number of bytes per memory-read packet."),
14474 &remote_show_cmdlist
);
14476 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14477 &remote_hw_watchpoint_limit
, _("\
14478 Set the maximum number of target hardware watchpoints."), _("\
14479 Show the maximum number of target hardware watchpoints."), _("\
14480 Specify \"unlimited\" for unlimited hardware watchpoints."),
14481 NULL
, show_hardware_watchpoint_limit
,
14482 &remote_set_cmdlist
,
14483 &remote_show_cmdlist
);
14484 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14486 &remote_hw_watchpoint_length_limit
, _("\
14487 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14488 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14489 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14490 NULL
, show_hardware_watchpoint_length_limit
,
14491 &remote_set_cmdlist
, &remote_show_cmdlist
);
14492 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14493 &remote_hw_breakpoint_limit
, _("\
14494 Set the maximum number of target hardware breakpoints."), _("\
14495 Show the maximum number of target hardware breakpoints."), _("\
14496 Specify \"unlimited\" for unlimited hardware breakpoints."),
14497 NULL
, show_hardware_breakpoint_limit
,
14498 &remote_set_cmdlist
, &remote_show_cmdlist
);
14500 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14501 &remote_address_size
, _("\
14502 Set the maximum size of the address (in bits) in a memory packet."), _("\
14503 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14505 NULL
, /* FIXME: i18n: */
14506 &setlist
, &showlist
);
14508 init_all_packet_configs ();
14510 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14511 "X", "binary-download", 1);
14513 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14514 "vCont", "verbose-resume", 0);
14516 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14517 "QPassSignals", "pass-signals", 0);
14519 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14520 "QCatchSyscalls", "catch-syscalls", 0);
14522 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14523 "QProgramSignals", "program-signals", 0);
14525 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14526 "QSetWorkingDir", "set-working-dir", 0);
14528 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14529 "QStartupWithShell", "startup-with-shell", 0);
14531 add_packet_config_cmd (&remote_protocol_packets
14532 [PACKET_QEnvironmentHexEncoded
],
14533 "QEnvironmentHexEncoded", "environment-hex-encoded",
14536 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14537 "QEnvironmentReset", "environment-reset",
14540 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14541 "QEnvironmentUnset", "environment-unset",
14544 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14545 "qSymbol", "symbol-lookup", 0);
14547 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14548 "P", "set-register", 1);
14550 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14551 "p", "fetch-register", 1);
14553 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14554 "Z0", "software-breakpoint", 0);
14556 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14557 "Z1", "hardware-breakpoint", 0);
14559 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14560 "Z2", "write-watchpoint", 0);
14562 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14563 "Z3", "read-watchpoint", 0);
14565 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14566 "Z4", "access-watchpoint", 0);
14568 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14569 "qXfer:auxv:read", "read-aux-vector", 0);
14571 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14572 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14574 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14575 "qXfer:features:read", "target-features", 0);
14577 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14578 "qXfer:libraries:read", "library-info", 0);
14580 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14581 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14583 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14584 "qXfer:memory-map:read", "memory-map", 0);
14586 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14587 "qXfer:osdata:read", "osdata", 0);
14589 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14590 "qXfer:threads:read", "threads", 0);
14592 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14593 "qXfer:siginfo:read", "read-siginfo-object", 0);
14595 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14596 "qXfer:siginfo:write", "write-siginfo-object", 0);
14598 add_packet_config_cmd
14599 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14600 "qXfer:traceframe-info:read", "traceframe-info", 0);
14602 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14603 "qXfer:uib:read", "unwind-info-block", 0);
14605 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14606 "qGetTLSAddr", "get-thread-local-storage-address",
14609 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14610 "qGetTIBAddr", "get-thread-information-block-address",
14613 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14614 "bc", "reverse-continue", 0);
14616 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14617 "bs", "reverse-step", 0);
14619 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14620 "qSupported", "supported-packets", 0);
14622 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14623 "qSearch:memory", "search-memory", 0);
14625 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14626 "qTStatus", "trace-status", 0);
14628 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14629 "vFile:setfs", "hostio-setfs", 0);
14631 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14632 "vFile:open", "hostio-open", 0);
14634 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14635 "vFile:pread", "hostio-pread", 0);
14637 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14638 "vFile:pwrite", "hostio-pwrite", 0);
14640 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14641 "vFile:close", "hostio-close", 0);
14643 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14644 "vFile:unlink", "hostio-unlink", 0);
14646 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14647 "vFile:readlink", "hostio-readlink", 0);
14649 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14650 "vFile:fstat", "hostio-fstat", 0);
14652 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14653 "vAttach", "attach", 0);
14655 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14658 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14659 "QStartNoAckMode", "noack", 0);
14661 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14662 "vKill", "kill", 0);
14664 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14665 "qAttached", "query-attached", 0);
14667 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14668 "ConditionalTracepoints",
14669 "conditional-tracepoints", 0);
14671 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14672 "ConditionalBreakpoints",
14673 "conditional-breakpoints", 0);
14675 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14676 "BreakpointCommands",
14677 "breakpoint-commands", 0);
14679 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14680 "FastTracepoints", "fast-tracepoints", 0);
14682 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14683 "TracepointSource", "TracepointSource", 0);
14685 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14686 "QAllow", "allow", 0);
14688 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14689 "StaticTracepoints", "static-tracepoints", 0);
14691 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14692 "InstallInTrace", "install-in-trace", 0);
14694 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14695 "qXfer:statictrace:read", "read-sdata-object", 0);
14697 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14698 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14700 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14701 "QDisableRandomization", "disable-randomization", 0);
14703 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14704 "QAgent", "agent", 0);
14706 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14707 "QTBuffer:size", "trace-buffer-size", 0);
14709 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14710 "Qbtrace:off", "disable-btrace", 0);
14712 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14713 "Qbtrace:bts", "enable-btrace-bts", 0);
14715 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14716 "Qbtrace:pt", "enable-btrace-pt", 0);
14718 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14719 "qXfer:btrace", "read-btrace", 0);
14721 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14722 "qXfer:btrace-conf", "read-btrace-conf", 0);
14724 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14725 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14727 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14728 "multiprocess-feature", "multiprocess-feature", 0);
14730 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14731 "swbreak-feature", "swbreak-feature", 0);
14733 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14734 "hwbreak-feature", "hwbreak-feature", 0);
14736 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14737 "fork-event-feature", "fork-event-feature", 0);
14739 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14740 "vfork-event-feature", "vfork-event-feature", 0);
14742 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14743 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14745 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14746 "vContSupported", "verbose-resume-supported", 0);
14748 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14749 "exec-event-feature", "exec-event-feature", 0);
14751 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14752 "vCtrlC", "ctrl-c", 0);
14754 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14755 "QThreadEvents", "thread-events", 0);
14757 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14758 "N stop reply", "no-resumed-stop-reply", 0);
14760 /* Assert that we've registered "set remote foo-packet" commands
14761 for all packet configs. */
14765 for (i
= 0; i
< PACKET_MAX
; i
++)
14767 /* Ideally all configs would have a command associated. Some
14768 still don't though. */
14773 case PACKET_QNonStop
:
14774 case PACKET_EnableDisableTracepoints_feature
:
14775 case PACKET_tracenz_feature
:
14776 case PACKET_DisconnectedTracing_feature
:
14777 case PACKET_augmented_libraries_svr4_read_feature
:
14779 /* Additions to this list need to be well justified:
14780 pre-existing packets are OK; new packets are not. */
14788 /* This catches both forgetting to add a config command, and
14789 forgetting to remove a packet from the exception list. */
14790 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14794 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14795 Z sub-packet has its own set and show commands, but users may
14796 have sets to this variable in their .gdbinit files (or in their
14798 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14799 &remote_Z_packet_detect
, _("\
14800 Set use of remote protocol `Z' packets."), _("\
14801 Show use of remote protocol `Z' packets."), _("\
14802 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14804 set_remote_protocol_Z_packet_cmd
,
14805 show_remote_protocol_Z_packet_cmd
,
14806 /* FIXME: i18n: Use of remote protocol
14807 `Z' packets is %s. */
14808 &remote_set_cmdlist
, &remote_show_cmdlist
);
14810 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14811 Manipulate files on the remote system.\n\
14812 Transfer files to and from the remote target system."),
14813 &remote_cmdlist
, "remote ",
14814 0 /* allow-unknown */, &cmdlist
);
14816 add_cmd ("put", class_files
, remote_put_command
,
14817 _("Copy a local file to the remote system."),
14820 add_cmd ("get", class_files
, remote_get_command
,
14821 _("Copy a remote file to the local system."),
14824 add_cmd ("delete", class_files
, remote_delete_command
,
14825 _("Delete a remote file."),
14828 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14829 &remote_exec_file_var
, _("\
14830 Set the remote pathname for \"run\"."), _("\
14831 Show the remote pathname for \"run\"."), NULL
,
14832 set_remote_exec_file
,
14833 show_remote_exec_file
,
14834 &remote_set_cmdlist
,
14835 &remote_show_cmdlist
);
14837 add_setshow_boolean_cmd ("range-stepping", class_run
,
14838 &use_range_stepping
, _("\
14839 Enable or disable range stepping."), _("\
14840 Show whether target-assisted range stepping is enabled."), _("\
14841 If on, and the target supports it, when stepping a source line, GDB\n\
14842 tells the target to step the corresponding range of addresses itself instead\n\
14843 of issuing multiple single-steps. This speeds up source level\n\
14844 stepping. If off, GDB always issues single-steps, even if range\n\
14845 stepping is supported by the target. The default is on."),
14846 set_range_stepping
,
14847 show_range_stepping
,
14851 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
14852 Set watchdog timer."), _("\
14853 Show watchdog timer."), _("\
14854 When non-zero, this timeout is used instead of waiting forever for a target\n\
14855 to finish a low-level step or continue operation. If the specified amount\n\
14856 of time passes without a response from the target, an error occurs."),
14859 &setlist
, &showlist
);
14861 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
14862 &remote_packet_max_chars
, _("\
14863 Set the maximum number of characters to display for each remote packet."), _("\
14864 Show the maximum number of characters to display for each remote packet."), _("\
14865 Specify \"unlimited\" to display all the characters."),
14866 NULL
, show_remote_packet_max_chars
,
14867 &setdebuglist
, &showdebuglist
);
14869 /* Eventually initialize fileio. See fileio.c */
14870 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);