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 int follow_fork (int, int) 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 (int follow_child
, int 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
);
5799 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5800 in the program space of the new inferior. On entry and at return the
5801 current inferior is the exec'ing inferior. INF is the new exec'd
5802 inferior, which may be the same as the exec'ing inferior unless
5803 follow-exec-mode is "new". */
5806 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5808 /* We know that this is a target file name, so if it has the "target:"
5809 prefix we strip it off before saving it in the program space. */
5810 if (is_target_filename (execd_pathname
))
5811 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5813 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5816 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5819 remote_target::disconnect (const char *args
, int from_tty
)
5822 error (_("Argument given to \"disconnect\" when remotely debugging."));
5824 /* Make sure we unpush even the extended remote targets. Calling
5825 target_mourn_inferior won't unpush, and
5826 remote_target::mourn_inferior won't unpush if there is more than
5827 one inferior left. */
5828 remote_unpush_target (this);
5831 puts_filtered ("Ending remote debugging.\n");
5834 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5835 be chatty about it. */
5838 extended_remote_target::attach (const char *args
, int from_tty
)
5840 struct remote_state
*rs
= get_remote_state ();
5842 char *wait_status
= NULL
;
5844 pid
= parse_pid_to_attach (args
);
5846 /* Remote PID can be freely equal to getpid, do not check it here the same
5847 way as in other targets. */
5849 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5850 error (_("This target does not support attaching to a process"));
5854 const char *exec_file
= get_exec_file (0);
5857 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5858 target_pid_to_str (ptid_t (pid
)).c_str ());
5860 printf_unfiltered (_("Attaching to %s\n"),
5861 target_pid_to_str (ptid_t (pid
)).c_str ());
5864 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5866 getpkt (&rs
->buf
, 0);
5868 switch (packet_ok (rs
->buf
,
5869 &remote_protocol_packets
[PACKET_vAttach
]))
5872 if (!target_is_non_stop_p ())
5874 /* Save the reply for later. */
5875 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5876 strcpy (wait_status
, rs
->buf
.data ());
5878 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5879 error (_("Attaching to %s failed with: %s"),
5880 target_pid_to_str (ptid_t (pid
)).c_str (),
5883 case PACKET_UNKNOWN
:
5884 error (_("This target does not support attaching to a process"));
5886 error (_("Attaching to %s failed"),
5887 target_pid_to_str (ptid_t (pid
)).c_str ());
5890 set_current_inferior (remote_add_inferior (false, pid
, 1, 0));
5892 inferior_ptid
= ptid_t (pid
);
5894 if (target_is_non_stop_p ())
5896 struct thread_info
*thread
;
5898 /* Get list of threads. */
5899 update_thread_list ();
5901 thread
= first_thread_of_inferior (current_inferior ());
5903 inferior_ptid
= thread
->ptid
;
5905 inferior_ptid
= ptid_t (pid
);
5907 /* Invalidate our notion of the remote current thread. */
5908 record_currthread (rs
, minus_one_ptid
);
5912 /* Now, if we have thread information, update inferior_ptid. */
5913 inferior_ptid
= remote_current_thread (inferior_ptid
);
5915 /* Add the main thread to the thread list. */
5916 thread_info
*thr
= add_thread_silent (this, inferior_ptid
);
5917 /* Don't consider the thread stopped until we've processed the
5918 saved stop reply. */
5919 set_executing (this, thr
->ptid
, true);
5922 /* Next, if the target can specify a description, read it. We do
5923 this before anything involving memory or registers. */
5924 target_find_description ();
5926 if (!target_is_non_stop_p ())
5928 /* Use the previously fetched status. */
5929 gdb_assert (wait_status
!= NULL
);
5931 if (target_can_async_p ())
5933 struct notif_event
*reply
5934 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
5936 push_stop_reply ((struct stop_reply
*) reply
);
5942 gdb_assert (wait_status
!= NULL
);
5943 strcpy (rs
->buf
.data (), wait_status
);
5944 rs
->cached_wait_status
= 1;
5948 gdb_assert (wait_status
== NULL
);
5951 /* Implementation of the to_post_attach method. */
5954 extended_remote_target::post_attach (int pid
)
5956 /* Get text, data & bss offsets. */
5959 /* In certain cases GDB might not have had the chance to start
5960 symbol lookup up until now. This could happen if the debugged
5961 binary is not using shared libraries, the vsyscall page is not
5962 present (on Linux) and the binary itself hadn't changed since the
5963 debugging process was started. */
5964 if (symfile_objfile
!= NULL
)
5965 remote_check_symbols();
5969 /* Check for the availability of vCont. This function should also check
5973 remote_target::remote_vcont_probe ()
5975 remote_state
*rs
= get_remote_state ();
5978 strcpy (rs
->buf
.data (), "vCont?");
5980 getpkt (&rs
->buf
, 0);
5981 buf
= rs
->buf
.data ();
5983 /* Make sure that the features we assume are supported. */
5984 if (startswith (buf
, "vCont"))
5987 int support_c
, support_C
;
5989 rs
->supports_vCont
.s
= 0;
5990 rs
->supports_vCont
.S
= 0;
5993 rs
->supports_vCont
.t
= 0;
5994 rs
->supports_vCont
.r
= 0;
5995 while (p
&& *p
== ';')
5998 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5999 rs
->supports_vCont
.s
= 1;
6000 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6001 rs
->supports_vCont
.S
= 1;
6002 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6004 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6006 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6007 rs
->supports_vCont
.t
= 1;
6008 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6009 rs
->supports_vCont
.r
= 1;
6011 p
= strchr (p
, ';');
6014 /* If c, and C are not all supported, we can't use vCont. Clearing
6015 BUF will make packet_ok disable the packet. */
6016 if (!support_c
|| !support_C
)
6020 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
6021 rs
->supports_vCont_probed
= true;
6024 /* Helper function for building "vCont" resumptions. Write a
6025 resumption to P. ENDP points to one-passed-the-end of the buffer
6026 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
6027 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
6028 resumed thread should be single-stepped and/or signalled. If PTID
6029 equals minus_one_ptid, then all threads are resumed; if PTID
6030 represents a process, then all threads of the process are resumed;
6031 the thread to be stepped and/or signalled is given in the global
6035 remote_target::append_resumption (char *p
, char *endp
,
6036 ptid_t ptid
, int step
, gdb_signal siggnal
)
6038 struct remote_state
*rs
= get_remote_state ();
6040 if (step
&& siggnal
!= GDB_SIGNAL_0
)
6041 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
6043 /* GDB is willing to range step. */
6044 && use_range_stepping
6045 /* Target supports range stepping. */
6046 && rs
->supports_vCont
.r
6047 /* We don't currently support range stepping multiple
6048 threads with a wildcard (though the protocol allows it,
6049 so stubs shouldn't make an active effort to forbid
6051 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6053 struct thread_info
*tp
;
6055 if (ptid
== minus_one_ptid
)
6057 /* If we don't know about the target thread's tid, then
6058 we're resuming magic_null_ptid (see caller). */
6059 tp
= find_thread_ptid (this, magic_null_ptid
);
6062 tp
= find_thread_ptid (this, ptid
);
6063 gdb_assert (tp
!= NULL
);
6065 if (tp
->control
.may_range_step
)
6067 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6069 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6070 phex_nz (tp
->control
.step_range_start
,
6072 phex_nz (tp
->control
.step_range_end
,
6076 p
+= xsnprintf (p
, endp
- p
, ";s");
6079 p
+= xsnprintf (p
, endp
- p
, ";s");
6080 else if (siggnal
!= GDB_SIGNAL_0
)
6081 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6083 p
+= xsnprintf (p
, endp
- p
, ";c");
6085 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6089 /* All (-1) threads of process. */
6090 nptid
= ptid_t (ptid
.pid (), -1, 0);
6092 p
+= xsnprintf (p
, endp
- p
, ":");
6093 p
= write_ptid (p
, endp
, nptid
);
6095 else if (ptid
!= minus_one_ptid
)
6097 p
+= xsnprintf (p
, endp
- p
, ":");
6098 p
= write_ptid (p
, endp
, ptid
);
6104 /* Clear the thread's private info on resume. */
6107 resume_clear_thread_private_info (struct thread_info
*thread
)
6109 if (thread
->priv
!= NULL
)
6111 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6113 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6114 priv
->watch_data_address
= 0;
6118 /* Append a vCont continue-with-signal action for threads that have a
6119 non-zero stop signal. */
6122 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6125 for (thread_info
*thread
: all_non_exited_threads (this, ptid
))
6126 if (inferior_ptid
!= thread
->ptid
6127 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6129 p
= append_resumption (p
, endp
, thread
->ptid
,
6130 0, thread
->suspend
.stop_signal
);
6131 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6132 resume_clear_thread_private_info (thread
);
6138 /* Set the target running, using the packets that use Hc
6142 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6145 struct remote_state
*rs
= get_remote_state ();
6148 rs
->last_sent_signal
= siggnal
;
6149 rs
->last_sent_step
= step
;
6151 /* The c/s/C/S resume packets use Hc, so set the continue
6153 if (ptid
== minus_one_ptid
)
6154 set_continue_thread (any_thread_ptid
);
6156 set_continue_thread (ptid
);
6158 for (thread_info
*thread
: all_non_exited_threads (this))
6159 resume_clear_thread_private_info (thread
);
6161 buf
= rs
->buf
.data ();
6162 if (::execution_direction
== EXEC_REVERSE
)
6164 /* We don't pass signals to the target in reverse exec mode. */
6165 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6166 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6169 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6170 error (_("Remote reverse-step not supported."));
6171 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6172 error (_("Remote reverse-continue not supported."));
6174 strcpy (buf
, step
? "bs" : "bc");
6176 else if (siggnal
!= GDB_SIGNAL_0
)
6178 buf
[0] = step
? 'S' : 'C';
6179 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6180 buf
[2] = tohex (((int) siggnal
) & 0xf);
6184 strcpy (buf
, step
? "s" : "c");
6189 /* Resume the remote inferior by using a "vCont" packet. The thread
6190 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6191 resumed thread should be single-stepped and/or signalled. If PTID
6192 equals minus_one_ptid, then all threads are resumed; the thread to
6193 be stepped and/or signalled is given in the global INFERIOR_PTID.
6194 This function returns non-zero iff it resumes the inferior.
6196 This function issues a strict subset of all possible vCont commands
6200 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6201 enum gdb_signal siggnal
)
6203 struct remote_state
*rs
= get_remote_state ();
6207 /* No reverse execution actions defined for vCont. */
6208 if (::execution_direction
== EXEC_REVERSE
)
6211 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6212 remote_vcont_probe ();
6214 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6217 p
= rs
->buf
.data ();
6218 endp
= p
+ get_remote_packet_size ();
6220 /* If we could generate a wider range of packets, we'd have to worry
6221 about overflowing BUF. Should there be a generic
6222 "multi-part-packet" packet? */
6224 p
+= xsnprintf (p
, endp
- p
, "vCont");
6226 if (ptid
== magic_null_ptid
)
6228 /* MAGIC_NULL_PTID means that we don't have any active threads,
6229 so we don't have any TID numbers the inferior will
6230 understand. Make sure to only send forms that do not specify
6232 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6234 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6236 /* Resume all threads (of all processes, or of a single
6237 process), with preference for INFERIOR_PTID. This assumes
6238 inferior_ptid belongs to the set of all threads we are about
6240 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6242 /* Step inferior_ptid, with or without signal. */
6243 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6246 /* Also pass down any pending signaled resumption for other
6247 threads not the current. */
6248 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6250 /* And continue others without a signal. */
6251 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6255 /* Scheduler locking; resume only PTID. */
6256 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6259 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6262 if (target_is_non_stop_p ())
6264 /* In non-stop, the stub replies to vCont with "OK". The stop
6265 reply will be reported asynchronously by means of a `%Stop'
6267 getpkt (&rs
->buf
, 0);
6268 if (strcmp (rs
->buf
.data (), "OK") != 0)
6269 error (_("Unexpected vCont reply in non-stop mode: %s"),
6276 /* Tell the remote machine to resume. */
6279 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6281 struct remote_state
*rs
= get_remote_state ();
6283 /* When connected in non-stop mode, the core resumes threads
6284 individually. Resuming remote threads directly in target_resume
6285 would thus result in sending one packet per thread. Instead, to
6286 minimize roundtrip latency, here we just store the resume
6287 request; the actual remote resumption will be done in
6288 target_commit_resume / remote_commit_resume, where we'll be able
6289 to do vCont action coalescing. */
6290 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6292 remote_thread_info
*remote_thr
;
6294 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6295 remote_thr
= get_remote_thread_info (this, inferior_ptid
);
6297 remote_thr
= get_remote_thread_info (this, ptid
);
6299 remote_thr
->last_resume_step
= step
;
6300 remote_thr
->last_resume_sig
= siggnal
;
6304 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6305 (explained in remote-notif.c:handle_notification) so
6306 remote_notif_process is not called. We need find a place where
6307 it is safe to start a 'vNotif' sequence. It is good to do it
6308 before resuming inferior, because inferior was stopped and no RSP
6309 traffic at that moment. */
6310 if (!target_is_non_stop_p ())
6311 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6313 rs
->last_resume_exec_dir
= ::execution_direction
;
6315 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6316 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6317 remote_resume_with_hc (ptid
, step
, siggnal
);
6319 /* We are about to start executing the inferior, let's register it
6320 with the event loop. NOTE: this is the one place where all the
6321 execution commands end up. We could alternatively do this in each
6322 of the execution commands in infcmd.c. */
6323 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6324 into infcmd.c in order to allow inferior function calls to work
6325 NOT asynchronously. */
6326 if (target_can_async_p ())
6329 /* We've just told the target to resume. The remote server will
6330 wait for the inferior to stop, and then send a stop reply. In
6331 the mean time, we can't start another command/query ourselves
6332 because the stub wouldn't be ready to process it. This applies
6333 only to the base all-stop protocol, however. In non-stop (which
6334 only supports vCont), the stub replies with an "OK", and is
6335 immediate able to process further serial input. */
6336 if (!target_is_non_stop_p ())
6337 rs
->waiting_for_stop_reply
= 1;
6340 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6342 /* Private per-inferior info for target remote processes. */
6344 struct remote_inferior
: public private_inferior
6346 /* Whether we can send a wildcard vCont for this process. */
6347 bool may_wildcard_vcont
= true;
6350 /* Get the remote private inferior data associated to INF. */
6352 static remote_inferior
*
6353 get_remote_inferior (inferior
*inf
)
6355 if (inf
->priv
== NULL
)
6356 inf
->priv
.reset (new remote_inferior
);
6358 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6361 /* Class used to track the construction of a vCont packet in the
6362 outgoing packet buffer. This is used to send multiple vCont
6363 packets if we have more actions than would fit a single packet. */
6368 explicit vcont_builder (remote_target
*remote
)
6375 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6380 /* The remote target. */
6381 remote_target
*m_remote
;
6383 /* Pointer to the first action. P points here if no action has been
6385 char *m_first_action
;
6387 /* Where the next action will be appended. */
6390 /* The end of the buffer. Must never write past this. */
6394 /* Prepare the outgoing buffer for a new vCont packet. */
6397 vcont_builder::restart ()
6399 struct remote_state
*rs
= m_remote
->get_remote_state ();
6401 m_p
= rs
->buf
.data ();
6402 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6403 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6404 m_first_action
= m_p
;
6407 /* If the vCont packet being built has any action, send it to the
6411 vcont_builder::flush ()
6413 struct remote_state
*rs
;
6415 if (m_p
== m_first_action
)
6418 rs
= m_remote
->get_remote_state ();
6419 m_remote
->putpkt (rs
->buf
);
6420 m_remote
->getpkt (&rs
->buf
, 0);
6421 if (strcmp (rs
->buf
.data (), "OK") != 0)
6422 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6425 /* The largest action is range-stepping, with its two addresses. This
6426 is more than sufficient. If a new, bigger action is created, it'll
6427 quickly trigger a failed assertion in append_resumption (and we'll
6429 #define MAX_ACTION_SIZE 200
6431 /* Append a new vCont action in the outgoing packet being built. If
6432 the action doesn't fit the packet along with previous actions, push
6433 what we've got so far to the remote end and start over a new vCont
6434 packet (with the new action). */
6437 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6439 char buf
[MAX_ACTION_SIZE
+ 1];
6441 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6442 ptid
, step
, siggnal
);
6444 /* Check whether this new action would fit in the vCont packet along
6445 with previous actions. If not, send what we've got so far and
6446 start a new vCont packet. */
6447 size_t rsize
= endp
- buf
;
6448 if (rsize
> m_endp
- m_p
)
6453 /* Should now fit. */
6454 gdb_assert (rsize
<= m_endp
- m_p
);
6457 memcpy (m_p
, buf
, rsize
);
6462 /* to_commit_resume implementation. */
6465 remote_target::commit_resume ()
6467 int any_process_wildcard
;
6468 int may_global_wildcard_vcont
;
6470 /* If connected in all-stop mode, we'd send the remote resume
6471 request directly from remote_resume. Likewise if
6472 reverse-debugging, as there are no defined vCont actions for
6473 reverse execution. */
6474 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6477 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6478 instead of resuming all threads of each process individually.
6479 However, if any thread of a process must remain halted, we can't
6480 send wildcard resumes and must send one action per thread.
6482 Care must be taken to not resume threads/processes the server
6483 side already told us are stopped, but the core doesn't know about
6484 yet, because the events are still in the vStopped notification
6487 #1 => vCont s:p1.1;c
6489 #3 <= %Stopped T05 p1.1
6494 #8 (infrun handles the stop for p1.1 and continues stepping)
6495 #9 => vCont s:p1.1;c
6497 The last vCont above would resume thread p1.2 by mistake, because
6498 the server has no idea that the event for p1.2 had not been
6501 The server side must similarly ignore resume actions for the
6502 thread that has a pending %Stopped notification (and any other
6503 threads with events pending), until GDB acks the notification
6504 with vStopped. Otherwise, e.g., the following case is
6507 #1 => g (or any other packet)
6509 #3 <= %Stopped T05 p1.2
6510 #4 => vCont s:p1.1;c
6513 Above, the server must not resume thread p1.2. GDB can't know
6514 that p1.2 stopped until it acks the %Stopped notification, and
6515 since from GDB's perspective all threads should be running, it
6518 Finally, special care must also be given to handling fork/vfork
6519 events. A (v)fork event actually tells us that two processes
6520 stopped -- the parent and the child. Until we follow the fork,
6521 we must not resume the child. Therefore, if we have a pending
6522 fork follow, we must not send a global wildcard resume action
6523 (vCont;c). We can still send process-wide wildcards though. */
6525 /* Start by assuming a global wildcard (vCont;c) is possible. */
6526 may_global_wildcard_vcont
= 1;
6528 /* And assume every process is individually wildcard-able too. */
6529 for (inferior
*inf
: all_non_exited_inferiors (this))
6531 remote_inferior
*priv
= get_remote_inferior (inf
);
6533 priv
->may_wildcard_vcont
= true;
6536 /* Check for any pending events (not reported or processed yet) and
6537 disable process and global wildcard resumes appropriately. */
6538 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6540 for (thread_info
*tp
: all_non_exited_threads (this))
6542 /* If a thread of a process is not meant to be resumed, then we
6543 can't wildcard that process. */
6546 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6548 /* And if we can't wildcard a process, we can't wildcard
6549 everything either. */
6550 may_global_wildcard_vcont
= 0;
6554 /* If a thread is the parent of an unfollowed fork, then we
6555 can't do a global wildcard, as that would resume the fork
6557 if (is_pending_fork_parent_thread (tp
))
6558 may_global_wildcard_vcont
= 0;
6561 /* Now let's build the vCont packet(s). Actions must be appended
6562 from narrower to wider scopes (thread -> process -> global). If
6563 we end up with too many actions for a single packet vcont_builder
6564 flushes the current vCont packet to the remote side and starts a
6566 struct vcont_builder
vcont_builder (this);
6568 /* Threads first. */
6569 for (thread_info
*tp
: all_non_exited_threads (this))
6571 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6573 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6576 gdb_assert (!thread_is_in_step_over_chain (tp
));
6578 if (!remote_thr
->last_resume_step
6579 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6580 && get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6582 /* We'll send a wildcard resume instead. */
6583 remote_thr
->vcont_resumed
= 1;
6587 vcont_builder
.push_action (tp
->ptid
,
6588 remote_thr
->last_resume_step
,
6589 remote_thr
->last_resume_sig
);
6590 remote_thr
->vcont_resumed
= 1;
6593 /* Now check whether we can send any process-wide wildcard. This is
6594 to avoid sending a global wildcard in the case nothing is
6595 supposed to be resumed. */
6596 any_process_wildcard
= 0;
6598 for (inferior
*inf
: all_non_exited_inferiors (this))
6600 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6602 any_process_wildcard
= 1;
6607 if (any_process_wildcard
)
6609 /* If all processes are wildcard-able, then send a single "c"
6610 action, otherwise, send an "all (-1) threads of process"
6611 continue action for each running process, if any. */
6612 if (may_global_wildcard_vcont
)
6614 vcont_builder
.push_action (minus_one_ptid
,
6615 false, GDB_SIGNAL_0
);
6619 for (inferior
*inf
: all_non_exited_inferiors (this))
6621 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6623 vcont_builder
.push_action (ptid_t (inf
->pid
),
6624 false, GDB_SIGNAL_0
);
6630 vcont_builder
.flush ();
6635 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6636 thread, all threads of a remote process, or all threads of all
6640 remote_target::remote_stop_ns (ptid_t ptid
)
6642 struct remote_state
*rs
= get_remote_state ();
6643 char *p
= rs
->buf
.data ();
6644 char *endp
= p
+ get_remote_packet_size ();
6646 /* FIXME: This supports_vCont_probed check is a workaround until
6647 packet_support is per-connection. */
6648 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
6649 || !rs
->supports_vCont_probed
)
6650 remote_vcont_probe ();
6652 if (!rs
->supports_vCont
.t
)
6653 error (_("Remote server does not support stopping threads"));
6655 if (ptid
== minus_one_ptid
6656 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6657 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6662 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6665 /* All (-1) threads of process. */
6666 nptid
= ptid_t (ptid
.pid (), -1, 0);
6669 /* Small optimization: if we already have a stop reply for
6670 this thread, no use in telling the stub we want this
6672 if (peek_stop_reply (ptid
))
6678 write_ptid (p
, endp
, nptid
);
6681 /* In non-stop, we get an immediate OK reply. The stop reply will
6682 come in asynchronously by notification. */
6684 getpkt (&rs
->buf
, 0);
6685 if (strcmp (rs
->buf
.data (), "OK") != 0)
6686 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6690 /* All-stop version of target_interrupt. Sends a break or a ^C to
6691 interrupt the remote target. It is undefined which thread of which
6692 process reports the interrupt. */
6695 remote_target::remote_interrupt_as ()
6697 struct remote_state
*rs
= get_remote_state ();
6699 rs
->ctrlc_pending_p
= 1;
6701 /* If the inferior is stopped already, but the core didn't know
6702 about it yet, just ignore the request. The cached wait status
6703 will be collected in remote_wait. */
6704 if (rs
->cached_wait_status
)
6707 /* Send interrupt_sequence to remote target. */
6708 send_interrupt_sequence ();
6711 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6712 the remote target. It is undefined which thread of which process
6713 reports the interrupt. Throws an error if the packet is not
6714 supported by the server. */
6717 remote_target::remote_interrupt_ns ()
6719 struct remote_state
*rs
= get_remote_state ();
6720 char *p
= rs
->buf
.data ();
6721 char *endp
= p
+ get_remote_packet_size ();
6723 xsnprintf (p
, endp
- p
, "vCtrlC");
6725 /* In non-stop, we get an immediate OK reply. The stop reply will
6726 come in asynchronously by notification. */
6728 getpkt (&rs
->buf
, 0);
6730 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6734 case PACKET_UNKNOWN
:
6735 error (_("No support for interrupting the remote target."));
6737 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6741 /* Implement the to_stop function for the remote targets. */
6744 remote_target::stop (ptid_t ptid
)
6747 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6749 if (target_is_non_stop_p ())
6750 remote_stop_ns (ptid
);
6753 /* We don't currently have a way to transparently pause the
6754 remote target in all-stop mode. Interrupt it instead. */
6755 remote_interrupt_as ();
6759 /* Implement the to_interrupt function for the remote targets. */
6762 remote_target::interrupt ()
6765 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6767 if (target_is_non_stop_p ())
6768 remote_interrupt_ns ();
6770 remote_interrupt_as ();
6773 /* Implement the to_pass_ctrlc function for the remote targets. */
6776 remote_target::pass_ctrlc ()
6778 struct remote_state
*rs
= get_remote_state ();
6781 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6783 /* If we're starting up, we're not fully synced yet. Quit
6785 if (rs
->starting_up
)
6787 /* If ^C has already been sent once, offer to disconnect. */
6788 else if (rs
->ctrlc_pending_p
)
6791 target_interrupt ();
6794 /* Ask the user what to do when an interrupt is received. */
6797 remote_target::interrupt_query ()
6799 struct remote_state
*rs
= get_remote_state ();
6801 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6803 if (query (_("The target is not responding to interrupt requests.\n"
6804 "Stop debugging it? ")))
6806 remote_unpush_target (this);
6807 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6812 if (query (_("Interrupted while waiting for the program.\n"
6813 "Give up waiting? ")))
6818 /* Enable/disable target terminal ownership. Most targets can use
6819 terminal groups to control terminal ownership. Remote targets are
6820 different in that explicit transfer of ownership to/from GDB/target
6824 remote_target::terminal_inferior ()
6826 /* NOTE: At this point we could also register our selves as the
6827 recipient of all input. Any characters typed could then be
6828 passed on down to the target. */
6832 remote_target::terminal_ours ()
6837 remote_console_output (const char *msg
)
6841 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6844 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6848 gdb_stdtarg
->puts (tb
);
6850 gdb_stdtarg
->flush ();
6853 struct stop_reply
: public notif_event
6857 /* The identifier of the thread about this event */
6860 /* The remote state this event is associated with. When the remote
6861 connection, represented by a remote_state object, is closed,
6862 all the associated stop_reply events should be released. */
6863 struct remote_state
*rs
;
6865 struct target_waitstatus ws
;
6867 /* The architecture associated with the expedited registers. */
6870 /* Expedited registers. This makes remote debugging a bit more
6871 efficient for those targets that provide critical registers as
6872 part of their normal status mechanism (as another roundtrip to
6873 fetch them is avoided). */
6874 std::vector
<cached_reg_t
> regcache
;
6876 enum target_stop_reason stop_reason
;
6878 CORE_ADDR watch_data_address
;
6883 /* Return the length of the stop reply queue. */
6886 remote_target::stop_reply_queue_length ()
6888 remote_state
*rs
= get_remote_state ();
6889 return rs
->stop_reply_queue
.size ();
6893 remote_notif_stop_parse (remote_target
*remote
,
6894 struct notif_client
*self
, const char *buf
,
6895 struct notif_event
*event
)
6897 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6901 remote_notif_stop_ack (remote_target
*remote
,
6902 struct notif_client
*self
, const char *buf
,
6903 struct notif_event
*event
)
6905 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6908 putpkt (remote
, self
->ack_command
);
6910 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6912 /* We got an unknown stop reply. */
6913 error (_("Unknown stop reply"));
6916 remote
->push_stop_reply (stop_reply
);
6920 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
6921 struct notif_client
*self
)
6923 /* We can't get pending events in remote_notif_process for
6924 notification stop, and we have to do this in remote_wait_ns
6925 instead. If we fetch all queued events from stub, remote stub
6926 may exit and we have no chance to process them back in
6928 remote_state
*rs
= remote
->get_remote_state ();
6929 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
6933 stop_reply::~stop_reply ()
6935 for (cached_reg_t
®
: regcache
)
6939 static notif_event_up
6940 remote_notif_stop_alloc_reply ()
6942 return notif_event_up (new struct stop_reply ());
6945 /* A client of notification Stop. */
6947 struct notif_client notif_client_stop
=
6951 remote_notif_stop_parse
,
6952 remote_notif_stop_ack
,
6953 remote_notif_stop_can_get_pending_events
,
6954 remote_notif_stop_alloc_reply
,
6958 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6959 the pid of the process that owns the threads we want to check, or
6960 -1 if we want to check all threads. */
6963 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6966 if (ws
->kind
== TARGET_WAITKIND_FORKED
6967 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6969 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
6976 /* Return the thread's pending status used to determine whether the
6977 thread is a fork parent stopped at a fork event. */
6979 static struct target_waitstatus
*
6980 thread_pending_fork_status (struct thread_info
*thread
)
6982 if (thread
->suspend
.waitstatus_pending_p
)
6983 return &thread
->suspend
.waitstatus
;
6985 return &thread
->pending_follow
;
6988 /* Determine if THREAD is a pending fork parent thread. */
6991 is_pending_fork_parent_thread (struct thread_info
*thread
)
6993 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6996 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6999 /* If CONTEXT contains any fork child threads that have not been
7000 reported yet, remove them from the CONTEXT list. If such a
7001 thread exists it is because we are stopped at a fork catchpoint
7002 and have not yet called follow_fork, which will set up the
7003 host-side data structures for the new process. */
7006 remote_target::remove_new_fork_children (threads_listing_context
*context
)
7009 struct notif_client
*notif
= ¬if_client_stop
;
7011 /* For any threads stopped at a fork event, remove the corresponding
7012 fork child threads from the CONTEXT list. */
7013 for (thread_info
*thread
: all_non_exited_threads (this))
7015 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
7017 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
7018 context
->remove_thread (ws
->value
.related_pid
);
7021 /* Check for any pending fork events (not reported or processed yet)
7022 in process PID and remove those fork child threads from the
7023 CONTEXT list as well. */
7024 remote_notif_get_pending_events (notif
);
7025 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7026 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7027 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
7028 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
7029 context
->remove_thread (event
->ws
.value
.related_pid
);
7032 /* Check whether any event pending in the vStopped queue would prevent
7033 a global or process wildcard vCont action. Clear
7034 *may_global_wildcard if we can't do a global wildcard (vCont;c),
7035 and clear the event inferior's may_wildcard_vcont flag if we can't
7036 do a process-wide wildcard resume (vCont;c:pPID.-1). */
7039 remote_target::check_pending_events_prevent_wildcard_vcont
7040 (int *may_global_wildcard
)
7042 struct notif_client
*notif
= ¬if_client_stop
;
7044 remote_notif_get_pending_events (notif
);
7045 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7047 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
7048 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
7051 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7052 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
7053 *may_global_wildcard
= 0;
7055 struct inferior
*inf
= find_inferior_ptid (this, event
->ptid
);
7057 /* This may be the first time we heard about this process.
7058 Regardless, we must not do a global wildcard resume, otherwise
7059 we'd resume this process too. */
7060 *may_global_wildcard
= 0;
7062 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7066 /* Discard all pending stop replies of inferior INF. */
7069 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7071 struct stop_reply
*reply
;
7072 struct remote_state
*rs
= get_remote_state ();
7073 struct remote_notif_state
*rns
= rs
->notif_state
;
7075 /* This function can be notified when an inferior exists. When the
7076 target is not remote, the notification state is NULL. */
7077 if (rs
->remote_desc
== NULL
)
7080 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7082 /* Discard the in-flight notification. */
7083 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7086 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7089 /* Discard the stop replies we have already pulled with
7091 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7092 rs
->stop_reply_queue
.end (),
7093 [=] (const stop_reply_up
&event
)
7095 return event
->ptid
.pid () == inf
->pid
;
7097 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7100 /* Discard the stop replies for RS in stop_reply_queue. */
7103 remote_target::discard_pending_stop_replies_in_queue ()
7105 remote_state
*rs
= get_remote_state ();
7107 /* Discard the stop replies we have already pulled with
7109 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7110 rs
->stop_reply_queue
.end (),
7111 [=] (const stop_reply_up
&event
)
7113 return event
->rs
== rs
;
7115 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7118 /* Remove the first reply in 'stop_reply_queue' which matches
7122 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7124 remote_state
*rs
= get_remote_state ();
7126 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7127 rs
->stop_reply_queue
.end (),
7128 [=] (const stop_reply_up
&event
)
7130 return event
->ptid
.matches (ptid
);
7132 struct stop_reply
*result
;
7133 if (iter
== rs
->stop_reply_queue
.end ())
7137 result
= iter
->release ();
7138 rs
->stop_reply_queue
.erase (iter
);
7142 fprintf_unfiltered (gdb_stdlog
,
7143 "notif: discard queued event: 'Stop' in %s\n",
7144 target_pid_to_str (ptid
).c_str ());
7149 /* Look for a queued stop reply belonging to PTID. If one is found,
7150 remove it from the queue, and return it. Returns NULL if none is
7151 found. If there are still queued events left to process, tell the
7152 event loop to get back to target_wait soon. */
7155 remote_target::queued_stop_reply (ptid_t ptid
)
7157 remote_state
*rs
= get_remote_state ();
7158 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7160 if (!rs
->stop_reply_queue
.empty ())
7162 /* There's still at least an event left. */
7163 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7169 /* Push a fully parsed stop reply in the stop reply queue. Since we
7170 know that we now have at least one queued event left to pass to the
7171 core side, tell the event loop to get back to target_wait soon. */
7174 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7176 remote_state
*rs
= get_remote_state ();
7177 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7180 fprintf_unfiltered (gdb_stdlog
,
7181 "notif: push 'Stop' %s to queue %d\n",
7182 target_pid_to_str (new_event
->ptid
).c_str (),
7183 int (rs
->stop_reply_queue
.size ()));
7185 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7188 /* Returns true if we have a stop reply for PTID. */
7191 remote_target::peek_stop_reply (ptid_t ptid
)
7193 remote_state
*rs
= get_remote_state ();
7194 for (auto &event
: rs
->stop_reply_queue
)
7195 if (ptid
== event
->ptid
7196 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7201 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7202 starting with P and ending with PEND matches PREFIX. */
7205 strprefix (const char *p
, const char *pend
, const char *prefix
)
7207 for ( ; p
< pend
; p
++, prefix
++)
7210 return *prefix
== '\0';
7213 /* Parse the stop reply in BUF. Either the function succeeds, and the
7214 result is stored in EVENT, or throws an error. */
7217 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7219 remote_arch_state
*rsa
= NULL
;
7224 event
->ptid
= null_ptid
;
7225 event
->rs
= get_remote_state ();
7226 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7227 event
->ws
.value
.integer
= 0;
7228 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7229 event
->regcache
.clear ();
7234 case 'T': /* Status with PC, SP, FP, ... */
7235 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7236 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7238 n... = register number
7239 r... = register contents
7242 p
= &buf
[3]; /* after Txx */
7248 p1
= strchr (p
, ':');
7250 error (_("Malformed packet(a) (missing colon): %s\n\
7254 error (_("Malformed packet(a) (missing register number): %s\n\
7258 /* Some "registers" are actually extended stop information.
7259 Note if you're adding a new entry here: GDB 7.9 and
7260 earlier assume that all register "numbers" that start
7261 with an hex digit are real register numbers. Make sure
7262 the server only sends such a packet if it knows the
7263 client understands it. */
7265 if (strprefix (p
, p1
, "thread"))
7266 event
->ptid
= read_ptid (++p1
, &p
);
7267 else if (strprefix (p
, p1
, "syscall_entry"))
7271 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7272 p
= unpack_varlen_hex (++p1
, &sysno
);
7273 event
->ws
.value
.syscall_number
= (int) sysno
;
7275 else if (strprefix (p
, p1
, "syscall_return"))
7279 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7280 p
= unpack_varlen_hex (++p1
, &sysno
);
7281 event
->ws
.value
.syscall_number
= (int) sysno
;
7283 else if (strprefix (p
, p1
, "watch")
7284 || strprefix (p
, p1
, "rwatch")
7285 || strprefix (p
, p1
, "awatch"))
7287 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7288 p
= unpack_varlen_hex (++p1
, &addr
);
7289 event
->watch_data_address
= (CORE_ADDR
) addr
;
7291 else if (strprefix (p
, p1
, "swbreak"))
7293 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7295 /* Make sure the stub doesn't forget to indicate support
7297 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7298 error (_("Unexpected swbreak stop reason"));
7300 /* The value part is documented as "must be empty",
7301 though we ignore it, in case we ever decide to make
7302 use of it in a backward compatible way. */
7303 p
= strchrnul (p1
+ 1, ';');
7305 else if (strprefix (p
, p1
, "hwbreak"))
7307 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7309 /* Make sure the stub doesn't forget to indicate support
7311 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7312 error (_("Unexpected hwbreak stop reason"));
7315 p
= strchrnul (p1
+ 1, ';');
7317 else if (strprefix (p
, p1
, "library"))
7319 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7320 p
= strchrnul (p1
+ 1, ';');
7322 else if (strprefix (p
, p1
, "replaylog"))
7324 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7325 /* p1 will indicate "begin" or "end", but it makes
7326 no difference for now, so ignore it. */
7327 p
= strchrnul (p1
+ 1, ';');
7329 else if (strprefix (p
, p1
, "core"))
7333 p
= unpack_varlen_hex (++p1
, &c
);
7336 else if (strprefix (p
, p1
, "fork"))
7338 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7339 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7341 else if (strprefix (p
, p1
, "vfork"))
7343 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7344 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7346 else if (strprefix (p
, p1
, "vforkdone"))
7348 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7349 p
= strchrnul (p1
+ 1, ';');
7351 else if (strprefix (p
, p1
, "exec"))
7356 /* Determine the length of the execd pathname. */
7357 p
= unpack_varlen_hex (++p1
, &ignored
);
7358 pathlen
= (p
- p1
) / 2;
7360 /* Save the pathname for event reporting and for
7361 the next run command. */
7362 gdb::unique_xmalloc_ptr
<char[]> pathname
7363 ((char *) xmalloc (pathlen
+ 1));
7364 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7365 pathname
[pathlen
] = '\0';
7367 /* This is freed during event handling. */
7368 event
->ws
.value
.execd_pathname
= pathname
.release ();
7369 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7371 /* Skip the registers included in this packet, since
7372 they may be for an architecture different from the
7373 one used by the original program. */
7376 else if (strprefix (p
, p1
, "create"))
7378 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7379 p
= strchrnul (p1
+ 1, ';');
7388 p
= strchrnul (p1
+ 1, ';');
7393 /* Maybe a real ``P'' register number. */
7394 p_temp
= unpack_varlen_hex (p
, &pnum
);
7395 /* If the first invalid character is the colon, we got a
7396 register number. Otherwise, it's an unknown stop
7400 /* If we haven't parsed the event's thread yet, find
7401 it now, in order to find the architecture of the
7402 reported expedited registers. */
7403 if (event
->ptid
== null_ptid
)
7405 /* If there is no thread-id information then leave
7406 the event->ptid as null_ptid. Later in
7407 process_stop_reply we will pick a suitable
7409 const char *thr
= strstr (p1
+ 1, ";thread:");
7411 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7418 = (event
->ptid
== null_ptid
7420 : find_inferior_ptid (this, event
->ptid
));
7421 /* If this is the first time we learn anything
7422 about this process, skip the registers
7423 included in this packet, since we don't yet
7424 know which architecture to use to parse them.
7425 We'll determine the architecture later when
7426 we process the stop reply and retrieve the
7427 target description, via
7428 remote_notice_new_inferior ->
7429 post_create_inferior. */
7432 p
= strchrnul (p1
+ 1, ';');
7437 event
->arch
= inf
->gdbarch
;
7438 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7442 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7443 cached_reg_t cached_reg
;
7446 error (_("Remote sent bad register number %s: %s\n\
7448 hex_string (pnum
), p
, buf
);
7450 cached_reg
.num
= reg
->regnum
;
7451 cached_reg
.data
= (gdb_byte
*)
7452 xmalloc (register_size (event
->arch
, reg
->regnum
));
7455 fieldsize
= hex2bin (p
, cached_reg
.data
,
7456 register_size (event
->arch
, reg
->regnum
));
7458 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7459 warning (_("Remote reply is too short: %s"), buf
);
7461 event
->regcache
.push_back (cached_reg
);
7465 /* Not a number. Silently skip unknown optional
7467 p
= strchrnul (p1
+ 1, ';');
7472 error (_("Remote register badly formatted: %s\nhere: %s"),
7477 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7481 case 'S': /* Old style status, just signal only. */
7485 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7486 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7487 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7488 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7490 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7493 case 'w': /* Thread exited. */
7497 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7498 p
= unpack_varlen_hex (&buf
[1], &value
);
7499 event
->ws
.value
.integer
= value
;
7501 error (_("stop reply packet badly formatted: %s"), buf
);
7502 event
->ptid
= read_ptid (++p
, NULL
);
7505 case 'W': /* Target exited. */
7510 /* GDB used to accept only 2 hex chars here. Stubs should
7511 only send more if they detect GDB supports multi-process
7513 p
= unpack_varlen_hex (&buf
[1], &value
);
7517 /* The remote process exited. */
7518 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7519 event
->ws
.value
.integer
= value
;
7523 /* The remote process exited with a signal. */
7524 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7525 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7526 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7528 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7531 /* If no process is specified, return null_ptid, and let the
7532 caller figure out the right process to use. */
7542 else if (startswith (p
, "process:"))
7546 p
+= sizeof ("process:") - 1;
7547 unpack_varlen_hex (p
, &upid
);
7551 error (_("unknown stop reply packet: %s"), buf
);
7554 error (_("unknown stop reply packet: %s"), buf
);
7555 event
->ptid
= ptid_t (pid
);
7559 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7560 event
->ptid
= minus_one_ptid
;
7564 if (target_is_non_stop_p () && event
->ptid
== null_ptid
)
7565 error (_("No process or thread specified in stop reply: %s"), buf
);
7568 /* When the stub wants to tell GDB about a new notification reply, it
7569 sends a notification (%Stop, for example). Those can come it at
7570 any time, hence, we have to make sure that any pending
7571 putpkt/getpkt sequence we're making is finished, before querying
7572 the stub for more events with the corresponding ack command
7573 (vStopped, for example). E.g., if we started a vStopped sequence
7574 immediately upon receiving the notification, something like this
7582 1.6) <-- (registers reply to step #1.3)
7584 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7587 To solve this, whenever we parse a %Stop notification successfully,
7588 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7589 doing whatever we were doing:
7595 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7596 2.5) <-- (registers reply to step #2.3)
7598 Eventually after step #2.5, we return to the event loop, which
7599 notices there's an event on the
7600 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7601 associated callback --- the function below. At this point, we're
7602 always safe to start a vStopped sequence. :
7605 2.7) <-- T05 thread:2
7611 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7613 struct remote_state
*rs
= get_remote_state ();
7615 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7618 fprintf_unfiltered (gdb_stdlog
,
7619 "notif: process: '%s' ack pending event\n",
7623 nc
->ack (this, nc
, rs
->buf
.data (),
7624 rs
->notif_state
->pending_event
[nc
->id
]);
7625 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7629 getpkt (&rs
->buf
, 0);
7630 if (strcmp (rs
->buf
.data (), "OK") == 0)
7633 remote_notif_ack (this, nc
, rs
->buf
.data ());
7639 fprintf_unfiltered (gdb_stdlog
,
7640 "notif: process: '%s' no pending reply\n",
7645 /* Wrapper around remote_target::remote_notif_get_pending_events to
7646 avoid having to export the whole remote_target class. */
7649 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7651 remote
->remote_notif_get_pending_events (nc
);
7654 /* Called when it is decided that STOP_REPLY holds the info of the
7655 event that is to be returned to the core. This function always
7656 destroys STOP_REPLY. */
7659 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7660 struct target_waitstatus
*status
)
7664 *status
= stop_reply
->ws
;
7665 ptid
= stop_reply
->ptid
;
7667 /* If no thread/process was reported by the stub then use the first
7668 non-exited thread in the current target. */
7669 if (ptid
== null_ptid
)
7671 for (thread_info
*thr
: all_non_exited_threads (this))
7673 if (ptid
!= null_ptid
)
7675 static bool warned
= false;
7679 /* If you are seeing this warning then the remote target
7680 has multiple threads and either sent an 'S' stop
7681 packet, or a 'T' stop packet without a thread-id. In
7682 both of these cases GDB is unable to know which thread
7683 just stopped and is now having to guess. The correct
7684 action is to fix the remote target to send the correct
7685 packet (a 'T' packet and include a thread-id). */
7686 warning (_("multi-threaded target stopped without sending "
7687 "a thread-id, using first non-exited thread"));
7694 gdb_assert (ptid
!= null_ptid
);
7697 if (status
->kind
!= TARGET_WAITKIND_EXITED
7698 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7699 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7701 /* Expedited registers. */
7702 if (!stop_reply
->regcache
.empty ())
7704 struct regcache
*regcache
7705 = get_thread_arch_regcache (this, ptid
, stop_reply
->arch
);
7707 for (cached_reg_t
®
: stop_reply
->regcache
)
7709 regcache
->raw_supply (reg
.num
, reg
.data
);
7713 stop_reply
->regcache
.clear ();
7716 remote_notice_new_inferior (ptid
, 0);
7717 remote_thread_info
*remote_thr
= get_remote_thread_info (this, ptid
);
7718 remote_thr
->core
= stop_reply
->core
;
7719 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7720 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7721 remote_thr
->vcont_resumed
= 0;
7728 /* The non-stop mode version of target_wait. */
7731 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7733 struct remote_state
*rs
= get_remote_state ();
7734 struct stop_reply
*stop_reply
;
7738 /* If in non-stop mode, get out of getpkt even if a
7739 notification is received. */
7741 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7744 if (ret
!= -1 && !is_notif
)
7747 case 'E': /* Error of some sort. */
7748 /* We're out of sync with the target now. Did it continue
7749 or not? We can't tell which thread it was in non-stop,
7750 so just ignore this. */
7751 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7753 case 'O': /* Console output. */
7754 remote_console_output (&rs
->buf
[1]);
7757 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7761 /* Acknowledge a pending stop reply that may have arrived in the
7763 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7764 remote_notif_get_pending_events (¬if_client_stop
);
7766 /* If indeed we noticed a stop reply, we're done. */
7767 stop_reply
= queued_stop_reply (ptid
);
7768 if (stop_reply
!= NULL
)
7769 return process_stop_reply (stop_reply
, status
);
7771 /* Still no event. If we're just polling for an event, then
7772 return to the event loop. */
7773 if (options
& TARGET_WNOHANG
)
7775 status
->kind
= TARGET_WAITKIND_IGNORE
;
7776 return minus_one_ptid
;
7779 /* Otherwise do a blocking wait. */
7780 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7784 /* Return the first resumed thread. */
7787 first_remote_resumed_thread (remote_target
*target
)
7789 for (thread_info
*tp
: all_non_exited_threads (target
, minus_one_ptid
))
7795 /* Wait until the remote machine stops, then return, storing status in
7796 STATUS just as `wait' would. */
7799 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
, int options
)
7801 struct remote_state
*rs
= get_remote_state ();
7802 ptid_t event_ptid
= null_ptid
;
7804 struct stop_reply
*stop_reply
;
7808 status
->kind
= TARGET_WAITKIND_IGNORE
;
7809 status
->value
.integer
= 0;
7811 stop_reply
= queued_stop_reply (ptid
);
7812 if (stop_reply
!= NULL
)
7813 return process_stop_reply (stop_reply
, status
);
7815 if (rs
->cached_wait_status
)
7816 /* Use the cached wait status, but only once. */
7817 rs
->cached_wait_status
= 0;
7822 int forever
= ((options
& TARGET_WNOHANG
) == 0
7823 && rs
->wait_forever_enabled_p
);
7825 if (!rs
->waiting_for_stop_reply
)
7827 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7828 return minus_one_ptid
;
7831 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7832 _never_ wait for ever -> test on target_is_async_p().
7833 However, before we do that we need to ensure that the caller
7834 knows how to take the target into/out of async mode. */
7835 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
7837 /* GDB gets a notification. Return to core as this event is
7839 if (ret
!= -1 && is_notif
)
7840 return minus_one_ptid
;
7842 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7843 return minus_one_ptid
;
7846 buf
= rs
->buf
.data ();
7848 /* Assume that the target has acknowledged Ctrl-C unless we receive
7849 an 'F' or 'O' packet. */
7850 if (buf
[0] != 'F' && buf
[0] != 'O')
7851 rs
->ctrlc_pending_p
= 0;
7855 case 'E': /* Error of some sort. */
7856 /* We're out of sync with the target now. Did it continue or
7857 not? Not is more likely, so report a stop. */
7858 rs
->waiting_for_stop_reply
= 0;
7860 warning (_("Remote failure reply: %s"), buf
);
7861 status
->kind
= TARGET_WAITKIND_STOPPED
;
7862 status
->value
.sig
= GDB_SIGNAL_0
;
7864 case 'F': /* File-I/O request. */
7865 /* GDB may access the inferior memory while handling the File-I/O
7866 request, but we don't want GDB accessing memory while waiting
7867 for a stop reply. See the comments in putpkt_binary. Set
7868 waiting_for_stop_reply to 0 temporarily. */
7869 rs
->waiting_for_stop_reply
= 0;
7870 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
7871 rs
->ctrlc_pending_p
= 0;
7872 /* GDB handled the File-I/O request, and the target is running
7873 again. Keep waiting for events. */
7874 rs
->waiting_for_stop_reply
= 1;
7876 case 'N': case 'T': case 'S': case 'X': case 'W':
7878 /* There is a stop reply to handle. */
7879 rs
->waiting_for_stop_reply
= 0;
7882 = (struct stop_reply
*) remote_notif_parse (this,
7886 event_ptid
= process_stop_reply (stop_reply
, status
);
7889 case 'O': /* Console output. */
7890 remote_console_output (buf
+ 1);
7893 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7895 /* Zero length reply means that we tried 'S' or 'C' and the
7896 remote system doesn't support it. */
7897 target_terminal::ours_for_output ();
7899 ("Can't send signals to this remote system. %s not sent.\n",
7900 gdb_signal_to_name (rs
->last_sent_signal
));
7901 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7902 target_terminal::inferior ();
7904 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7910 warning (_("Invalid remote reply: %s"), buf
);
7914 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7915 return minus_one_ptid
;
7916 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7918 /* Nothing interesting happened. If we're doing a non-blocking
7919 poll, we're done. Otherwise, go back to waiting. */
7920 if (options
& TARGET_WNOHANG
)
7921 return minus_one_ptid
;
7925 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7926 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7928 if (event_ptid
!= null_ptid
)
7929 record_currthread (rs
, event_ptid
);
7931 event_ptid
= first_remote_resumed_thread (this);
7935 /* A process exit. Invalidate our notion of current thread. */
7936 record_currthread (rs
, minus_one_ptid
);
7937 /* It's possible that the packet did not include a pid. */
7938 if (event_ptid
== null_ptid
)
7939 event_ptid
= first_remote_resumed_thread (this);
7940 /* EVENT_PTID could still be NULL_PTID. Double-check. */
7941 if (event_ptid
== null_ptid
)
7942 event_ptid
= magic_null_ptid
;
7948 /* Wait until the remote machine stops, then return, storing status in
7949 STATUS just as `wait' would. */
7952 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7956 if (target_is_non_stop_p ())
7957 event_ptid
= wait_ns (ptid
, status
, options
);
7959 event_ptid
= wait_as (ptid
, status
, options
);
7961 if (target_is_async_p ())
7963 remote_state
*rs
= get_remote_state ();
7965 /* If there are are events left in the queue tell the event loop
7967 if (!rs
->stop_reply_queue
.empty ())
7968 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7974 /* Fetch a single register using a 'p' packet. */
7977 remote_target::fetch_register_using_p (struct regcache
*regcache
,
7980 struct gdbarch
*gdbarch
= regcache
->arch ();
7981 struct remote_state
*rs
= get_remote_state ();
7983 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7986 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7989 if (reg
->pnum
== -1)
7992 p
= rs
->buf
.data ();
7994 p
+= hexnumstr (p
, reg
->pnum
);
7997 getpkt (&rs
->buf
, 0);
7999 buf
= rs
->buf
.data ();
8001 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
8005 case PACKET_UNKNOWN
:
8008 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
8009 gdbarch_register_name (regcache
->arch (),
8014 /* If this register is unfetchable, tell the regcache. */
8017 regcache
->raw_supply (reg
->regnum
, NULL
);
8021 /* Otherwise, parse and supply the value. */
8027 error (_("fetch_register_using_p: early buf termination"));
8029 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8032 regcache
->raw_supply (reg
->regnum
, regp
);
8036 /* Fetch the registers included in the target's 'g' packet. */
8039 remote_target::send_g_packet ()
8041 struct remote_state
*rs
= get_remote_state ();
8044 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
8046 getpkt (&rs
->buf
, 0);
8047 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8048 error (_("Could not read registers; remote failure reply '%s'"),
8051 /* We can get out of synch in various cases. If the first character
8052 in the buffer is not a hex character, assume that has happened
8053 and try to fetch another packet to read. */
8054 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
8055 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
8056 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
8057 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
8060 fprintf_unfiltered (gdb_stdlog
,
8061 "Bad register packet; fetching a new packet\n");
8062 getpkt (&rs
->buf
, 0);
8065 buf_len
= strlen (rs
->buf
.data ());
8067 /* Sanity check the received packet. */
8068 if (buf_len
% 2 != 0)
8069 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
8075 remote_target::process_g_packet (struct regcache
*regcache
)
8077 struct gdbarch
*gdbarch
= regcache
->arch ();
8078 struct remote_state
*rs
= get_remote_state ();
8079 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8084 buf_len
= strlen (rs
->buf
.data ());
8086 /* Further sanity checks, with knowledge of the architecture. */
8087 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
8088 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8090 rsa
->sizeof_g_packet
, buf_len
/ 2,
8093 /* Save the size of the packet sent to us by the target. It is used
8094 as a heuristic when determining the max size of packets that the
8095 target can safely receive. */
8096 if (rsa
->actual_register_packet_size
== 0)
8097 rsa
->actual_register_packet_size
= buf_len
;
8099 /* If this is smaller than we guessed the 'g' packet would be,
8100 update our records. A 'g' reply that doesn't include a register's
8101 value implies either that the register is not available, or that
8102 the 'p' packet must be used. */
8103 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8105 long sizeof_g_packet
= buf_len
/ 2;
8107 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8109 long offset
= rsa
->regs
[i
].offset
;
8110 long reg_size
= register_size (gdbarch
, i
);
8112 if (rsa
->regs
[i
].pnum
== -1)
8115 if (offset
>= sizeof_g_packet
)
8116 rsa
->regs
[i
].in_g_packet
= 0;
8117 else if (offset
+ reg_size
> sizeof_g_packet
)
8118 error (_("Truncated register %d in remote 'g' packet"), i
);
8120 rsa
->regs
[i
].in_g_packet
= 1;
8123 /* Looks valid enough, we can assume this is the correct length
8124 for a 'g' packet. It's important not to adjust
8125 rsa->sizeof_g_packet if we have truncated registers otherwise
8126 this "if" won't be run the next time the method is called
8127 with a packet of the same size and one of the internal errors
8128 below will trigger instead. */
8129 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8132 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8134 /* Unimplemented registers read as all bits zero. */
8135 memset (regs
, 0, rsa
->sizeof_g_packet
);
8137 /* Reply describes registers byte by byte, each byte encoded as two
8138 hex characters. Suck them all up, then supply them to the
8139 register cacheing/storage mechanism. */
8141 p
= rs
->buf
.data ();
8142 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8144 if (p
[0] == 0 || p
[1] == 0)
8145 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8146 internal_error (__FILE__
, __LINE__
,
8147 _("unexpected end of 'g' packet reply"));
8149 if (p
[0] == 'x' && p
[1] == 'x')
8150 regs
[i
] = 0; /* 'x' */
8152 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8156 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8158 struct packet_reg
*r
= &rsa
->regs
[i
];
8159 long reg_size
= register_size (gdbarch
, i
);
8163 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8164 /* This shouldn't happen - we adjusted in_g_packet above. */
8165 internal_error (__FILE__
, __LINE__
,
8166 _("unexpected end of 'g' packet reply"));
8167 else if (rs
->buf
[r
->offset
* 2] == 'x')
8169 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8170 /* The register isn't available, mark it as such (at
8171 the same time setting the value to zero). */
8172 regcache
->raw_supply (r
->regnum
, NULL
);
8175 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8181 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8184 process_g_packet (regcache
);
8187 /* Make the remote selected traceframe match GDB's selected
8191 remote_target::set_remote_traceframe ()
8194 struct remote_state
*rs
= get_remote_state ();
8196 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8199 /* Avoid recursion, remote_trace_find calls us again. */
8200 rs
->remote_traceframe_number
= get_traceframe_number ();
8202 newnum
= target_trace_find (tfind_number
,
8203 get_traceframe_number (), 0, 0, NULL
);
8205 /* Should not happen. If it does, all bets are off. */
8206 if (newnum
!= get_traceframe_number ())
8207 warning (_("could not set remote traceframe"));
8211 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8213 struct gdbarch
*gdbarch
= regcache
->arch ();
8214 struct remote_state
*rs
= get_remote_state ();
8215 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8218 set_remote_traceframe ();
8219 set_general_thread (regcache
->ptid ());
8223 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8225 gdb_assert (reg
!= NULL
);
8227 /* If this register might be in the 'g' packet, try that first -
8228 we are likely to read more than one register. If this is the
8229 first 'g' packet, we might be overly optimistic about its
8230 contents, so fall back to 'p'. */
8231 if (reg
->in_g_packet
)
8233 fetch_registers_using_g (regcache
);
8234 if (reg
->in_g_packet
)
8238 if (fetch_register_using_p (regcache
, reg
))
8241 /* This register is not available. */
8242 regcache
->raw_supply (reg
->regnum
, NULL
);
8247 fetch_registers_using_g (regcache
);
8249 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8250 if (!rsa
->regs
[i
].in_g_packet
)
8251 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8253 /* This register is not available. */
8254 regcache
->raw_supply (i
, NULL
);
8258 /* Prepare to store registers. Since we may send them all (using a
8259 'G' request), we have to read out the ones we don't want to change
8263 remote_target::prepare_to_store (struct regcache
*regcache
)
8265 struct remote_state
*rs
= get_remote_state ();
8266 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8269 /* Make sure the entire registers array is valid. */
8270 switch (packet_support (PACKET_P
))
8272 case PACKET_DISABLE
:
8273 case PACKET_SUPPORT_UNKNOWN
:
8274 /* Make sure all the necessary registers are cached. */
8275 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8276 if (rsa
->regs
[i
].in_g_packet
)
8277 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8284 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8285 packet was not recognized. */
8288 remote_target::store_register_using_P (const struct regcache
*regcache
,
8291 struct gdbarch
*gdbarch
= regcache
->arch ();
8292 struct remote_state
*rs
= get_remote_state ();
8293 /* Try storing a single register. */
8294 char *buf
= rs
->buf
.data ();
8295 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8298 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8301 if (reg
->pnum
== -1)
8304 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8305 p
= buf
+ strlen (buf
);
8306 regcache
->raw_collect (reg
->regnum
, regp
);
8307 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8309 getpkt (&rs
->buf
, 0);
8311 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8316 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8317 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8318 case PACKET_UNKNOWN
:
8321 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8325 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8326 contents of the register cache buffer. FIXME: ignores errors. */
8329 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8331 struct remote_state
*rs
= get_remote_state ();
8332 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8336 /* Extract all the registers in the regcache copying them into a
8341 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8342 memset (regs
, 0, rsa
->sizeof_g_packet
);
8343 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8345 struct packet_reg
*r
= &rsa
->regs
[i
];
8348 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8352 /* Command describes registers byte by byte,
8353 each byte encoded as two hex characters. */
8354 p
= rs
->buf
.data ();
8356 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8358 getpkt (&rs
->buf
, 0);
8359 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8360 error (_("Could not write registers; remote failure reply '%s'"),
8364 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8365 of the register cache buffer. FIXME: ignores errors. */
8368 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8370 struct gdbarch
*gdbarch
= regcache
->arch ();
8371 struct remote_state
*rs
= get_remote_state ();
8372 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8375 set_remote_traceframe ();
8376 set_general_thread (regcache
->ptid ());
8380 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8382 gdb_assert (reg
!= NULL
);
8384 /* Always prefer to store registers using the 'P' packet if
8385 possible; we often change only a small number of registers.
8386 Sometimes we change a larger number; we'd need help from a
8387 higher layer to know to use 'G'. */
8388 if (store_register_using_P (regcache
, reg
))
8391 /* For now, don't complain if we have no way to write the
8392 register. GDB loses track of unavailable registers too
8393 easily. Some day, this may be an error. We don't have
8394 any way to read the register, either... */
8395 if (!reg
->in_g_packet
)
8398 store_registers_using_G (regcache
);
8402 store_registers_using_G (regcache
);
8404 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8405 if (!rsa
->regs
[i
].in_g_packet
)
8406 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8407 /* See above for why we do not issue an error here. */
8412 /* Return the number of hex digits in num. */
8415 hexnumlen (ULONGEST num
)
8419 for (i
= 0; num
!= 0; i
++)
8422 return std::max (i
, 1);
8425 /* Set BUF to the minimum number of hex digits representing NUM. */
8428 hexnumstr (char *buf
, ULONGEST num
)
8430 int len
= hexnumlen (num
);
8432 return hexnumnstr (buf
, num
, len
);
8436 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8439 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8445 for (i
= width
- 1; i
>= 0; i
--)
8447 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8454 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8457 remote_address_masked (CORE_ADDR addr
)
8459 unsigned int address_size
= remote_address_size
;
8461 /* If "remoteaddresssize" was not set, default to target address size. */
8463 address_size
= gdbarch_addr_bit (target_gdbarch ());
8465 if (address_size
> 0
8466 && address_size
< (sizeof (ULONGEST
) * 8))
8468 /* Only create a mask when that mask can safely be constructed
8469 in a ULONGEST variable. */
8472 mask
= (mask
<< address_size
) - 1;
8478 /* Determine whether the remote target supports binary downloading.
8479 This is accomplished by sending a no-op memory write of zero length
8480 to the target at the specified address. It does not suffice to send
8481 the whole packet, since many stubs strip the eighth bit and
8482 subsequently compute a wrong checksum, which causes real havoc with
8485 NOTE: This can still lose if the serial line is not eight-bit
8486 clean. In cases like this, the user should clear "remote
8490 remote_target::check_binary_download (CORE_ADDR addr
)
8492 struct remote_state
*rs
= get_remote_state ();
8494 switch (packet_support (PACKET_X
))
8496 case PACKET_DISABLE
:
8500 case PACKET_SUPPORT_UNKNOWN
:
8504 p
= rs
->buf
.data ();
8506 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8508 p
+= hexnumstr (p
, (ULONGEST
) 0);
8512 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8513 getpkt (&rs
->buf
, 0);
8515 if (rs
->buf
[0] == '\0')
8518 fprintf_unfiltered (gdb_stdlog
,
8519 "binary downloading NOT "
8520 "supported by target\n");
8521 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8526 fprintf_unfiltered (gdb_stdlog
,
8527 "binary downloading supported by target\n");
8528 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8535 /* Helper function to resize the payload in order to try to get a good
8536 alignment. We try to write an amount of data such that the next write will
8537 start on an address aligned on REMOTE_ALIGN_WRITES. */
8540 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8542 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8545 /* Write memory data directly to the remote machine.
8546 This does not inform the data cache; the data cache uses this.
8547 HEADER is the starting part of the packet.
8548 MEMADDR is the address in the remote memory space.
8549 MYADDR is the address of the buffer in our space.
8550 LEN_UNITS is the number of addressable units to write.
8551 UNIT_SIZE is the length in bytes of an addressable unit.
8552 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8553 should send data as binary ('X'), or hex-encoded ('M').
8555 The function creates packet of the form
8556 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8558 where encoding of <DATA> is terminated by PACKET_FORMAT.
8560 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8563 Return the transferred status, error or OK (an
8564 'enum target_xfer_status' value). Save the number of addressable units
8565 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8567 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8568 exchange between gdb and the stub could look like (?? in place of the
8574 -> $M1000,3:eeeeffffeeee#??
8578 <- eeeeffffeeeedddd */
8581 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8582 const gdb_byte
*myaddr
,
8585 ULONGEST
*xfered_len_units
,
8586 char packet_format
, int use_length
)
8588 struct remote_state
*rs
= get_remote_state ();
8594 int payload_capacity_bytes
;
8595 int payload_length_bytes
;
8597 if (packet_format
!= 'X' && packet_format
!= 'M')
8598 internal_error (__FILE__
, __LINE__
,
8599 _("remote_write_bytes_aux: bad packet format"));
8602 return TARGET_XFER_EOF
;
8604 payload_capacity_bytes
= get_memory_write_packet_size ();
8606 /* The packet buffer will be large enough for the payload;
8607 get_memory_packet_size ensures this. */
8610 /* Compute the size of the actual payload by subtracting out the
8611 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8613 payload_capacity_bytes
-= strlen ("$,:#NN");
8615 /* The comma won't be used. */
8616 payload_capacity_bytes
+= 1;
8617 payload_capacity_bytes
-= strlen (header
);
8618 payload_capacity_bytes
-= hexnumlen (memaddr
);
8620 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8622 strcat (rs
->buf
.data (), header
);
8623 p
= rs
->buf
.data () + strlen (header
);
8625 /* Compute a best guess of the number of bytes actually transfered. */
8626 if (packet_format
== 'X')
8628 /* Best guess at number of bytes that will fit. */
8629 todo_units
= std::min (len_units
,
8630 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8632 payload_capacity_bytes
-= hexnumlen (todo_units
);
8633 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8637 /* Number of bytes that will fit. */
8639 = std::min (len_units
,
8640 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8642 payload_capacity_bytes
-= hexnumlen (todo_units
);
8643 todo_units
= std::min (todo_units
,
8644 (payload_capacity_bytes
/ unit_size
) / 2);
8647 if (todo_units
<= 0)
8648 internal_error (__FILE__
, __LINE__
,
8649 _("minimum packet size too small to write data"));
8651 /* If we already need another packet, then try to align the end
8652 of this packet to a useful boundary. */
8653 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8654 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8656 /* Append "<memaddr>". */
8657 memaddr
= remote_address_masked (memaddr
);
8658 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8665 /* Append the length and retain its location and size. It may need to be
8666 adjusted once the packet body has been created. */
8668 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8676 /* Append the packet body. */
8677 if (packet_format
== 'X')
8679 /* Binary mode. Send target system values byte by byte, in
8680 increasing byte addresses. Only escape certain critical
8682 payload_length_bytes
=
8683 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8684 &units_written
, payload_capacity_bytes
);
8686 /* If not all TODO units fit, then we'll need another packet. Make
8687 a second try to keep the end of the packet aligned. Don't do
8688 this if the packet is tiny. */
8689 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8693 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8695 if (new_todo_units
!= units_written
)
8696 payload_length_bytes
=
8697 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8698 (gdb_byte
*) p
, &units_written
,
8699 payload_capacity_bytes
);
8702 p
+= payload_length_bytes
;
8703 if (use_length
&& units_written
< todo_units
)
8705 /* Escape chars have filled up the buffer prematurely,
8706 and we have actually sent fewer units than planned.
8707 Fix-up the length field of the packet. Use the same
8708 number of characters as before. */
8709 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8711 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8716 /* Normal mode: Send target system values byte by byte, in
8717 increasing byte addresses. Each byte is encoded as a two hex
8719 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8720 units_written
= todo_units
;
8723 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8724 getpkt (&rs
->buf
, 0);
8726 if (rs
->buf
[0] == 'E')
8727 return TARGET_XFER_E_IO
;
8729 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8730 send fewer units than we'd planned. */
8731 *xfered_len_units
= (ULONGEST
) units_written
;
8732 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8735 /* Write memory data directly to the remote machine.
8736 This does not inform the data cache; the data cache uses this.
8737 MEMADDR is the address in the remote memory space.
8738 MYADDR is the address of the buffer in our space.
8739 LEN is the number of bytes.
8741 Return the transferred status, error or OK (an
8742 'enum target_xfer_status' value). Save the number of bytes
8743 transferred in *XFERED_LEN. Only transfer a single packet. */
8746 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8747 ULONGEST len
, int unit_size
,
8748 ULONGEST
*xfered_len
)
8750 const char *packet_format
= NULL
;
8752 /* Check whether the target supports binary download. */
8753 check_binary_download (memaddr
);
8755 switch (packet_support (PACKET_X
))
8758 packet_format
= "X";
8760 case PACKET_DISABLE
:
8761 packet_format
= "M";
8763 case PACKET_SUPPORT_UNKNOWN
:
8764 internal_error (__FILE__
, __LINE__
,
8765 _("remote_write_bytes: bad internal state"));
8767 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8770 return remote_write_bytes_aux (packet_format
,
8771 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8772 packet_format
[0], 1);
8775 /* Read memory data directly from the remote machine.
8776 This does not use the data cache; the data cache uses this.
8777 MEMADDR is the address in the remote memory space.
8778 MYADDR is the address of the buffer in our space.
8779 LEN_UNITS is the number of addressable memory units to read..
8780 UNIT_SIZE is the length in bytes of an addressable unit.
8782 Return the transferred status, error or OK (an
8783 'enum target_xfer_status' value). Save the number of bytes
8784 transferred in *XFERED_LEN_UNITS.
8786 See the comment of remote_write_bytes_aux for an example of
8787 memory read/write exchange between gdb and the stub. */
8790 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8792 int unit_size
, ULONGEST
*xfered_len_units
)
8794 struct remote_state
*rs
= get_remote_state ();
8795 int buf_size_bytes
; /* Max size of packet output buffer. */
8800 buf_size_bytes
= get_memory_read_packet_size ();
8801 /* The packet buffer will be large enough for the payload;
8802 get_memory_packet_size ensures this. */
8804 /* Number of units that will fit. */
8805 todo_units
= std::min (len_units
,
8806 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8808 /* Construct "m"<memaddr>","<len>". */
8809 memaddr
= remote_address_masked (memaddr
);
8810 p
= rs
->buf
.data ();
8812 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8814 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8817 getpkt (&rs
->buf
, 0);
8818 if (rs
->buf
[0] == 'E'
8819 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8820 && rs
->buf
[3] == '\0')
8821 return TARGET_XFER_E_IO
;
8822 /* Reply describes memory byte by byte, each byte encoded as two hex
8824 p
= rs
->buf
.data ();
8825 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8826 /* Return what we have. Let higher layers handle partial reads. */
8827 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8828 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8831 /* Using the set of read-only target sections of remote, read live
8834 For interface/parameters/return description see target.h,
8838 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
8842 ULONGEST
*xfered_len
)
8844 struct target_section
*secp
;
8845 struct target_section_table
*table
;
8847 secp
= target_section_by_addr (this, memaddr
);
8849 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
8851 struct target_section
*p
;
8852 ULONGEST memend
= memaddr
+ len
;
8854 table
= target_get_section_table (this);
8856 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8858 if (memaddr
>= p
->addr
)
8860 if (memend
<= p
->endaddr
)
8862 /* Entire transfer is within this section. */
8863 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8866 else if (memaddr
>= p
->endaddr
)
8868 /* This section ends before the transfer starts. */
8873 /* This section overlaps the transfer. Just do half. */
8874 len
= p
->endaddr
- memaddr
;
8875 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8882 return TARGET_XFER_EOF
;
8885 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8886 first if the requested memory is unavailable in traceframe.
8887 Otherwise, fall back to remote_read_bytes_1. */
8890 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
8891 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8892 ULONGEST
*xfered_len
)
8895 return TARGET_XFER_EOF
;
8897 if (get_traceframe_number () != -1)
8899 std::vector
<mem_range
> available
;
8901 /* If we fail to get the set of available memory, then the
8902 target does not support querying traceframe info, and so we
8903 attempt reading from the traceframe anyway (assuming the
8904 target implements the old QTro packet then). */
8905 if (traceframe_available_memory (&available
, memaddr
, len
))
8907 if (available
.empty () || available
[0].start
!= memaddr
)
8909 enum target_xfer_status res
;
8911 /* Don't read into the traceframe's available
8913 if (!available
.empty ())
8915 LONGEST oldlen
= len
;
8917 len
= available
[0].start
- memaddr
;
8918 gdb_assert (len
<= oldlen
);
8921 /* This goes through the topmost target again. */
8922 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
8923 len
, unit_size
, xfered_len
);
8924 if (res
== TARGET_XFER_OK
)
8925 return TARGET_XFER_OK
;
8928 /* No use trying further, we know some memory starting
8929 at MEMADDR isn't available. */
8931 return (*xfered_len
!= 0) ?
8932 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
8936 /* Don't try to read more than how much is available, in
8937 case the target implements the deprecated QTro packet to
8938 cater for older GDBs (the target's knowledge of read-only
8939 sections may be outdated by now). */
8940 len
= available
[0].length
;
8944 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8949 /* Sends a packet with content determined by the printf format string
8950 FORMAT and the remaining arguments, then gets the reply. Returns
8951 whether the packet was a success, a failure, or unknown. */
8954 remote_target::remote_send_printf (const char *format
, ...)
8956 struct remote_state
*rs
= get_remote_state ();
8957 int max_size
= get_remote_packet_size ();
8960 va_start (ap
, format
);
8963 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
8967 if (size
>= max_size
)
8968 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8970 if (putpkt (rs
->buf
) < 0)
8971 error (_("Communication problem with target."));
8974 getpkt (&rs
->buf
, 0);
8976 return packet_check_result (rs
->buf
);
8979 /* Flash writing can take quite some time. We'll set
8980 effectively infinite timeout for flash operations.
8981 In future, we'll need to decide on a better approach. */
8982 static const int remote_flash_timeout
= 1000;
8985 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
8987 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8988 enum packet_result ret
;
8989 scoped_restore restore_timeout
8990 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8992 ret
= remote_send_printf ("vFlashErase:%s,%s",
8993 phex (address
, addr_size
),
8997 case PACKET_UNKNOWN
:
8998 error (_("Remote target does not support flash erase"));
9000 error (_("Error erasing flash with vFlashErase packet"));
9007 remote_target::remote_flash_write (ULONGEST address
,
9008 ULONGEST length
, ULONGEST
*xfered_len
,
9009 const gdb_byte
*data
)
9011 scoped_restore restore_timeout
9012 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9013 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
9018 remote_target::flash_done ()
9022 scoped_restore restore_timeout
9023 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9025 ret
= remote_send_printf ("vFlashDone");
9029 case PACKET_UNKNOWN
:
9030 error (_("Remote target does not support vFlashDone"));
9032 error (_("Error finishing flash operation"));
9039 remote_target::files_info ()
9041 puts_filtered ("Debugging a target over a serial line.\n");
9044 /* Stuff for dealing with the packets which are part of this protocol.
9045 See comment at top of file for details. */
9047 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
9048 error to higher layers. Called when a serial error is detected.
9049 The exception message is STRING, followed by a colon and a blank,
9050 the system error message for errno at function entry and final dot
9051 for output compatibility with throw_perror_with_name. */
9054 unpush_and_perror (remote_target
*target
, const char *string
)
9056 int saved_errno
= errno
;
9058 remote_unpush_target (target
);
9059 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
9060 safe_strerror (saved_errno
));
9063 /* Read a single character from the remote end. The current quit
9064 handler is overridden to avoid quitting in the middle of packet
9065 sequence, as that would break communication with the remote server.
9066 See remote_serial_quit_handler for more detail. */
9069 remote_target::readchar (int timeout
)
9072 struct remote_state
*rs
= get_remote_state ();
9075 scoped_restore restore_quit_target
9076 = make_scoped_restore (&curr_quit_handler_target
, this);
9077 scoped_restore restore_quit
9078 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9080 rs
->got_ctrlc_during_io
= 0;
9082 ch
= serial_readchar (rs
->remote_desc
, timeout
);
9084 if (rs
->got_ctrlc_during_io
)
9091 switch ((enum serial_rc
) ch
)
9094 remote_unpush_target (this);
9095 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9098 unpush_and_perror (this, _("Remote communication error. "
9099 "Target disconnected."));
9101 case SERIAL_TIMEOUT
:
9107 /* Wrapper for serial_write that closes the target and throws if
9108 writing fails. The current quit handler is overridden to avoid
9109 quitting in the middle of packet sequence, as that would break
9110 communication with the remote server. See
9111 remote_serial_quit_handler for more detail. */
9114 remote_target::remote_serial_write (const char *str
, int len
)
9116 struct remote_state
*rs
= get_remote_state ();
9118 scoped_restore restore_quit_target
9119 = make_scoped_restore (&curr_quit_handler_target
, this);
9120 scoped_restore restore_quit
9121 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9123 rs
->got_ctrlc_during_io
= 0;
9125 if (serial_write (rs
->remote_desc
, str
, len
))
9127 unpush_and_perror (this, _("Remote communication error. "
9128 "Target disconnected."));
9131 if (rs
->got_ctrlc_during_io
)
9135 /* Return a string representing an escaped version of BUF, of len N.
9136 E.g. \n is converted to \\n, \t to \\t, etc. */
9139 escape_buffer (const char *buf
, int n
)
9143 stb
.putstrn (buf
, n
, '\\');
9144 return std::move (stb
.string ());
9147 /* Display a null-terminated packet on stdout, for debugging, using C
9151 print_packet (const char *buf
)
9153 puts_filtered ("\"");
9154 fputstr_filtered (buf
, '"', gdb_stdout
);
9155 puts_filtered ("\"");
9159 remote_target::putpkt (const char *buf
)
9161 return putpkt_binary (buf
, strlen (buf
));
9164 /* Wrapper around remote_target::putpkt to avoid exporting
9168 putpkt (remote_target
*remote
, const char *buf
)
9170 return remote
->putpkt (buf
);
9173 /* Send a packet to the remote machine, with error checking. The data
9174 of the packet is in BUF. The string in BUF can be at most
9175 get_remote_packet_size () - 5 to account for the $, # and checksum,
9176 and for a possible /0 if we are debugging (remote_debug) and want
9177 to print the sent packet as a string. */
9180 remote_target::putpkt_binary (const char *buf
, int cnt
)
9182 struct remote_state
*rs
= get_remote_state ();
9184 unsigned char csum
= 0;
9185 gdb::def_vector
<char> data (cnt
+ 6);
9186 char *buf2
= data
.data ();
9192 /* Catch cases like trying to read memory or listing threads while
9193 we're waiting for a stop reply. The remote server wouldn't be
9194 ready to handle this request, so we'd hang and timeout. We don't
9195 have to worry about this in synchronous mode, because in that
9196 case it's not possible to issue a command while the target is
9197 running. This is not a problem in non-stop mode, because in that
9198 case, the stub is always ready to process serial input. */
9199 if (!target_is_non_stop_p ()
9200 && target_is_async_p ()
9201 && rs
->waiting_for_stop_reply
)
9203 error (_("Cannot execute this command while the target is running.\n"
9204 "Use the \"interrupt\" command to stop the target\n"
9205 "and then try again."));
9208 /* We're sending out a new packet. Make sure we don't look at a
9209 stale cached response. */
9210 rs
->cached_wait_status
= 0;
9212 /* Copy the packet into buffer BUF2, encapsulating it
9213 and giving it a checksum. */
9218 for (i
= 0; i
< cnt
; i
++)
9224 *p
++ = tohex ((csum
>> 4) & 0xf);
9225 *p
++ = tohex (csum
& 0xf);
9227 /* Send it over and over until we get a positive ack. */
9231 int started_error_output
= 0;
9237 int len
= (int) (p
- buf2
);
9240 if (remote_packet_max_chars
< 0)
9243 max_chars
= remote_packet_max_chars
;
9246 = escape_buffer (buf2
, std::min (len
, max_chars
));
9248 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9250 if (len
> max_chars
)
9251 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9254 fprintf_unfiltered (gdb_stdlog
, "...");
9256 gdb_flush (gdb_stdlog
);
9258 remote_serial_write (buf2
, p
- buf2
);
9260 /* If this is a no acks version of the remote protocol, send the
9261 packet and move on. */
9265 /* Read until either a timeout occurs (-2) or '+' is read.
9266 Handle any notification that arrives in the mean time. */
9269 ch
= readchar (remote_timeout
);
9277 case SERIAL_TIMEOUT
:
9280 if (started_error_output
)
9282 putchar_unfiltered ('\n');
9283 started_error_output
= 0;
9292 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9296 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9298 case SERIAL_TIMEOUT
:
9302 break; /* Retransmit buffer. */
9306 fprintf_unfiltered (gdb_stdlog
,
9307 "Packet instead of Ack, ignoring it\n");
9308 /* It's probably an old response sent because an ACK
9309 was lost. Gobble up the packet and ack it so it
9310 doesn't get retransmitted when we resend this
9313 remote_serial_write ("+", 1);
9314 continue; /* Now, go look for +. */
9321 /* If we got a notification, handle it, and go back to looking
9323 /* We've found the start of a notification. Now
9324 collect the data. */
9325 val
= read_frame (&rs
->buf
);
9330 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9332 fprintf_unfiltered (gdb_stdlog
,
9333 " Notification received: %s\n",
9336 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9337 /* We're in sync now, rewait for the ack. */
9344 if (!started_error_output
)
9346 started_error_output
= 1;
9347 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9349 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9350 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9359 if (!started_error_output
)
9361 started_error_output
= 1;
9362 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9364 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9368 break; /* Here to retransmit. */
9372 /* This is wrong. If doing a long backtrace, the user should be
9373 able to get out next time we call QUIT, without anything as
9374 violent as interrupt_query. If we want to provide a way out of
9375 here without getting to the next QUIT, it should be based on
9376 hitting ^C twice as in remote_wait. */
9388 /* Come here after finding the start of a frame when we expected an
9389 ack. Do our best to discard the rest of this packet. */
9392 remote_target::skip_frame ()
9398 c
= readchar (remote_timeout
);
9401 case SERIAL_TIMEOUT
:
9402 /* Nothing we can do. */
9405 /* Discard the two bytes of checksum and stop. */
9406 c
= readchar (remote_timeout
);
9408 c
= readchar (remote_timeout
);
9411 case '*': /* Run length encoding. */
9412 /* Discard the repeat count. */
9413 c
= readchar (remote_timeout
);
9418 /* A regular character. */
9424 /* Come here after finding the start of the frame. Collect the rest
9425 into *BUF, verifying the checksum, length, and handling run-length
9426 compression. NUL terminate the buffer. If there is not enough room,
9429 Returns -1 on error, number of characters in buffer (ignoring the
9430 trailing NULL) on success. (could be extended to return one of the
9431 SERIAL status indications). */
9434 remote_target::read_frame (gdb::char_vector
*buf_p
)
9439 char *buf
= buf_p
->data ();
9440 struct remote_state
*rs
= get_remote_state ();
9447 c
= readchar (remote_timeout
);
9450 case SERIAL_TIMEOUT
:
9452 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9456 fputs_filtered ("Saw new packet start in middle of old one\n",
9458 return -1; /* Start a new packet, count retries. */
9461 unsigned char pktcsum
;
9467 check_0
= readchar (remote_timeout
);
9469 check_1
= readchar (remote_timeout
);
9471 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9474 fputs_filtered ("Timeout in checksum, retrying\n",
9478 else if (check_0
< 0 || check_1
< 0)
9481 fputs_filtered ("Communication error in checksum\n",
9486 /* Don't recompute the checksum; with no ack packets we
9487 don't have any way to indicate a packet retransmission
9492 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9493 if (csum
== pktcsum
)
9498 std::string str
= escape_buffer (buf
, bc
);
9500 fprintf_unfiltered (gdb_stdlog
,
9501 "Bad checksum, sentsum=0x%x, "
9502 "csum=0x%x, buf=%s\n",
9503 pktcsum
, csum
, str
.c_str ());
9505 /* Number of characters in buffer ignoring trailing
9509 case '*': /* Run length encoding. */
9514 c
= readchar (remote_timeout
);
9516 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9518 /* The character before ``*'' is repeated. */
9520 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9522 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9524 /* Make some more room in the buffer. */
9525 buf_p
->resize (buf_p
->size () + repeat
);
9526 buf
= buf_p
->data ();
9529 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9535 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9539 if (bc
>= buf_p
->size () - 1)
9541 /* Make some more room in the buffer. */
9542 buf_p
->resize (buf_p
->size () * 2);
9543 buf
= buf_p
->data ();
9553 /* Set this to the maximum number of seconds to wait instead of waiting forever
9554 in target_wait(). If this timer times out, then it generates an error and
9555 the command is aborted. This replaces most of the need for timeouts in the
9556 GDB test suite, and makes it possible to distinguish between a hung target
9557 and one with slow communications. */
9559 static int watchdog
= 0;
9561 show_watchdog (struct ui_file
*file
, int from_tty
,
9562 struct cmd_list_element
*c
, const char *value
)
9564 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9567 /* Read a packet from the remote machine, with error checking, and
9568 store it in *BUF. Resize *BUF if necessary to hold the result. If
9569 FOREVER, wait forever rather than timing out; this is used (in
9570 synchronous mode) to wait for a target that is is executing user
9572 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9573 don't have to change all the calls to getpkt to deal with the
9574 return value, because at the moment I don't know what the right
9575 thing to do it for those. */
9578 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9580 getpkt_sane (buf
, forever
);
9584 /* Read a packet from the remote machine, with error checking, and
9585 store it in *BUF. Resize *BUF if necessary to hold the result. If
9586 FOREVER, wait forever rather than timing out; this is used (in
9587 synchronous mode) to wait for a target that is is executing user
9588 code to stop. If FOREVER == 0, this function is allowed to time
9589 out gracefully and return an indication of this to the caller.
9590 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9591 consider receiving a notification enough reason to return to the
9592 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9593 holds a notification or not (a regular packet). */
9596 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9597 int forever
, int expecting_notif
,
9600 struct remote_state
*rs
= get_remote_state ();
9606 /* We're reading a new response. Make sure we don't look at a
9607 previously cached response. */
9608 rs
->cached_wait_status
= 0;
9610 strcpy (buf
->data (), "timeout");
9613 timeout
= watchdog
> 0 ? watchdog
: -1;
9614 else if (expecting_notif
)
9615 timeout
= 0; /* There should already be a char in the buffer. If
9618 timeout
= remote_timeout
;
9622 /* Process any number of notifications, and then return when
9626 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9628 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9630 /* This can loop forever if the remote side sends us
9631 characters continuously, but if it pauses, we'll get
9632 SERIAL_TIMEOUT from readchar because of timeout. Then
9633 we'll count that as a retry.
9635 Note that even when forever is set, we will only wait
9636 forever prior to the start of a packet. After that, we
9637 expect characters to arrive at a brisk pace. They should
9638 show up within remote_timeout intervals. */
9640 c
= readchar (timeout
);
9641 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9643 if (c
== SERIAL_TIMEOUT
)
9645 if (expecting_notif
)
9646 return -1; /* Don't complain, it's normal to not get
9647 anything in this case. */
9649 if (forever
) /* Watchdog went off? Kill the target. */
9651 remote_unpush_target (this);
9652 throw_error (TARGET_CLOSE_ERROR
,
9653 _("Watchdog timeout has expired. "
9654 "Target detached."));
9657 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9661 /* We've found the start of a packet or notification.
9662 Now collect the data. */
9663 val
= read_frame (buf
);
9668 remote_serial_write ("-", 1);
9671 if (tries
> MAX_TRIES
)
9673 /* We have tried hard enough, and just can't receive the
9674 packet/notification. Give up. */
9675 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9677 /* Skip the ack char if we're in no-ack mode. */
9678 if (!rs
->noack_mode
)
9679 remote_serial_write ("+", 1);
9683 /* If we got an ordinary packet, return that to our caller. */
9690 if (remote_packet_max_chars
< 0)
9693 max_chars
= remote_packet_max_chars
;
9696 = escape_buffer (buf
->data (),
9697 std::min (val
, max_chars
));
9699 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9702 if (val
> max_chars
)
9703 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9706 fprintf_unfiltered (gdb_stdlog
, "\n");
9709 /* Skip the ack char if we're in no-ack mode. */
9710 if (!rs
->noack_mode
)
9711 remote_serial_write ("+", 1);
9712 if (is_notif
!= NULL
)
9717 /* If we got a notification, handle it, and go back to looking
9721 gdb_assert (c
== '%');
9725 std::string str
= escape_buffer (buf
->data (), val
);
9727 fprintf_unfiltered (gdb_stdlog
,
9728 " Notification received: %s\n",
9731 if (is_notif
!= NULL
)
9734 handle_notification (rs
->notif_state
, buf
->data ());
9736 /* Notifications require no acknowledgement. */
9738 if (expecting_notif
)
9745 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9747 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9751 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9754 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9757 /* Kill any new fork children of process PID that haven't been
9758 processed by follow_fork. */
9761 remote_target::kill_new_fork_children (int pid
)
9763 remote_state
*rs
= get_remote_state ();
9764 struct notif_client
*notif
= ¬if_client_stop
;
9766 /* Kill the fork child threads of any threads in process PID
9767 that are stopped at a fork event. */
9768 for (thread_info
*thread
: all_non_exited_threads (this))
9770 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9772 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9774 int child_pid
= ws
->value
.related_pid
.pid ();
9777 res
= remote_vkill (child_pid
);
9779 error (_("Can't kill fork child process %d"), child_pid
);
9783 /* Check for any pending fork events (not reported or processed yet)
9784 in process PID and kill those fork child threads as well. */
9785 remote_notif_get_pending_events (notif
);
9786 for (auto &event
: rs
->stop_reply_queue
)
9787 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9789 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9792 res
= remote_vkill (child_pid
);
9794 error (_("Can't kill fork child process %d"), child_pid
);
9799 /* Target hook to kill the current inferior. */
9802 remote_target::kill ()
9805 int pid
= inferior_ptid
.pid ();
9806 struct remote_state
*rs
= get_remote_state ();
9808 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9810 /* If we're stopped while forking and we haven't followed yet,
9811 kill the child task. We need to do this before killing the
9812 parent task because if this is a vfork then the parent will
9814 kill_new_fork_children (pid
);
9816 res
= remote_vkill (pid
);
9819 target_mourn_inferior (inferior_ptid
);
9824 /* If we are in 'target remote' mode and we are killing the only
9825 inferior, then we will tell gdbserver to exit and unpush the
9827 if (res
== -1 && !remote_multi_process_p (rs
)
9828 && number_of_live_inferiors (this) == 1)
9832 /* We've killed the remote end, we get to mourn it. If we are
9833 not in extended mode, mourning the inferior also unpushes
9834 remote_ops from the target stack, which closes the remote
9836 target_mourn_inferior (inferior_ptid
);
9841 error (_("Can't kill process"));
9844 /* Send a kill request to the target using the 'vKill' packet. */
9847 remote_target::remote_vkill (int pid
)
9849 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9852 remote_state
*rs
= get_remote_state ();
9854 /* Tell the remote target to detach. */
9855 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
9857 getpkt (&rs
->buf
, 0);
9859 switch (packet_ok (rs
->buf
,
9860 &remote_protocol_packets
[PACKET_vKill
]))
9866 case PACKET_UNKNOWN
:
9869 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9873 /* Send a kill request to the target using the 'k' packet. */
9876 remote_target::remote_kill_k ()
9878 /* Catch errors so the user can quit from gdb even when we
9879 aren't on speaking terms with the remote system. */
9884 catch (const gdb_exception_error
&ex
)
9886 if (ex
.error
== TARGET_CLOSE_ERROR
)
9888 /* If we got an (EOF) error that caused the target
9889 to go away, then we're done, that's what we wanted.
9890 "k" is susceptible to cause a premature EOF, given
9891 that the remote server isn't actually required to
9892 reply to "k", and it can happen that it doesn't
9893 even get to reply ACK to the "k". */
9897 /* Otherwise, something went wrong. We didn't actually kill
9898 the target. Just propagate the exception, and let the
9899 user or higher layers decide what to do. */
9905 remote_target::mourn_inferior ()
9907 struct remote_state
*rs
= get_remote_state ();
9909 /* We're no longer interested in notification events of an inferior
9910 that exited or was killed/detached. */
9911 discard_pending_stop_replies (current_inferior ());
9913 /* In 'target remote' mode with one inferior, we close the connection. */
9914 if (!rs
->extended
&& number_of_live_inferiors (this) <= 1)
9916 remote_unpush_target (this);
9920 /* In case we got here due to an error, but we're going to stay
9922 rs
->waiting_for_stop_reply
= 0;
9924 /* If the current general thread belonged to the process we just
9925 detached from or has exited, the remote side current general
9926 thread becomes undefined. Considering a case like this:
9928 - We just got here due to a detach.
9929 - The process that we're detaching from happens to immediately
9930 report a global breakpoint being hit in non-stop mode, in the
9931 same thread we had selected before.
9932 - GDB attaches to this process again.
9933 - This event happens to be the next event we handle.
9935 GDB would consider that the current general thread didn't need to
9936 be set on the stub side (with Hg), since for all it knew,
9937 GENERAL_THREAD hadn't changed.
9939 Notice that although in all-stop mode, the remote server always
9940 sets the current thread to the thread reporting the stop event,
9941 that doesn't happen in non-stop mode; in non-stop, the stub *must
9942 not* change the current thread when reporting a breakpoint hit,
9943 due to the decoupling of event reporting and event handling.
9945 To keep things simple, we always invalidate our notion of the
9947 record_currthread (rs
, minus_one_ptid
);
9949 /* Call common code to mark the inferior as not running. */
9950 generic_mourn_inferior ();
9954 extended_remote_target::supports_disable_randomization ()
9956 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9960 remote_target::extended_remote_disable_randomization (int val
)
9962 struct remote_state
*rs
= get_remote_state ();
9965 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9966 "QDisableRandomization:%x", val
);
9968 reply
= remote_get_noisy_reply ();
9970 error (_("Target does not support QDisableRandomization."));
9971 if (strcmp (reply
, "OK") != 0)
9972 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9976 remote_target::extended_remote_run (const std::string
&args
)
9978 struct remote_state
*rs
= get_remote_state ();
9980 const char *remote_exec_file
= get_remote_exec_file ();
9982 /* If the user has disabled vRun support, or we have detected that
9983 support is not available, do not try it. */
9984 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9987 strcpy (rs
->buf
.data (), "vRun;");
9988 len
= strlen (rs
->buf
.data ());
9990 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9991 error (_("Remote file name too long for run packet"));
9992 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
9993 strlen (remote_exec_file
));
9999 gdb_argv
argv (args
.c_str ());
10000 for (i
= 0; argv
[i
] != NULL
; i
++)
10002 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
10003 error (_("Argument list too long for run packet"));
10004 rs
->buf
[len
++] = ';';
10005 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
10010 rs
->buf
[len
++] = '\0';
10013 getpkt (&rs
->buf
, 0);
10015 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
10018 /* We have a wait response. All is well. */
10020 case PACKET_UNKNOWN
:
10023 if (remote_exec_file
[0] == '\0')
10024 error (_("Running the default executable on the remote target failed; "
10025 "try \"set remote exec-file\"?"));
10027 error (_("Running \"%s\" on the remote target failed"),
10030 gdb_assert_not_reached (_("bad switch"));
10034 /* Helper function to send set/unset environment packets. ACTION is
10035 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
10036 or "QEnvironmentUnsetVariable". VALUE is the variable to be
10040 remote_target::send_environment_packet (const char *action
,
10041 const char *packet
,
10044 remote_state
*rs
= get_remote_state ();
10046 /* Convert the environment variable to an hex string, which
10047 is the best format to be transmitted over the wire. */
10048 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
10051 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10052 "%s:%s", packet
, encoded_value
.c_str ());
10055 getpkt (&rs
->buf
, 0);
10056 if (strcmp (rs
->buf
.data (), "OK") != 0)
10057 warning (_("Unable to %s environment variable '%s' on remote."),
10061 /* Helper function to handle the QEnvironment* packets. */
10064 remote_target::extended_remote_environment_support ()
10066 remote_state
*rs
= get_remote_state ();
10068 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
10070 putpkt ("QEnvironmentReset");
10071 getpkt (&rs
->buf
, 0);
10072 if (strcmp (rs
->buf
.data (), "OK") != 0)
10073 warning (_("Unable to reset environment on remote."));
10076 gdb_environ
*e
= ¤t_inferior ()->environment
;
10078 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
10079 for (const std::string
&el
: e
->user_set_env ())
10080 send_environment_packet ("set", "QEnvironmentHexEncoded",
10083 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
10084 for (const std::string
&el
: e
->user_unset_env ())
10085 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10088 /* Helper function to set the current working directory for the
10089 inferior in the remote target. */
10092 remote_target::extended_remote_set_inferior_cwd ()
10094 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10096 const char *inferior_cwd
= get_inferior_cwd ();
10097 remote_state
*rs
= get_remote_state ();
10099 if (inferior_cwd
!= NULL
)
10101 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10102 strlen (inferior_cwd
));
10104 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10105 "QSetWorkingDir:%s", hexpath
.c_str ());
10109 /* An empty inferior_cwd means that the user wants us to
10110 reset the remote server's inferior's cwd. */
10111 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10112 "QSetWorkingDir:");
10116 getpkt (&rs
->buf
, 0);
10117 if (packet_ok (rs
->buf
,
10118 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10121 Remote replied unexpectedly while setting the inferior's working\n\
10128 /* In the extended protocol we want to be able to do things like
10129 "run" and have them basically work as expected. So we need
10130 a special create_inferior function. We support changing the
10131 executable file and the command line arguments, but not the
10135 extended_remote_target::create_inferior (const char *exec_file
,
10136 const std::string
&args
,
10137 char **env
, int from_tty
)
10141 struct remote_state
*rs
= get_remote_state ();
10142 const char *remote_exec_file
= get_remote_exec_file ();
10144 /* If running asynchronously, register the target file descriptor
10145 with the event loop. */
10146 if (target_can_async_p ())
10149 /* Disable address space randomization if requested (and supported). */
10150 if (supports_disable_randomization ())
10151 extended_remote_disable_randomization (disable_randomization
);
10153 /* If startup-with-shell is on, we inform gdbserver to start the
10154 remote inferior using a shell. */
10155 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10157 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10158 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10160 getpkt (&rs
->buf
, 0);
10161 if (strcmp (rs
->buf
.data (), "OK") != 0)
10163 Remote replied unexpectedly while setting startup-with-shell: %s"),
10167 extended_remote_environment_support ();
10169 extended_remote_set_inferior_cwd ();
10171 /* Now restart the remote server. */
10172 run_worked
= extended_remote_run (args
) != -1;
10175 /* vRun was not supported. Fail if we need it to do what the
10177 if (remote_exec_file
[0])
10178 error (_("Remote target does not support \"set remote exec-file\""));
10179 if (!args
.empty ())
10180 error (_("Remote target does not support \"set args\" or run ARGS"));
10182 /* Fall back to "R". */
10183 extended_remote_restart ();
10186 /* vRun's success return is a stop reply. */
10187 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10188 add_current_inferior_and_thread (stop_reply
);
10190 /* Get updated offsets, if the stub uses qOffsets. */
10195 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10196 the list of conditions (in agent expression bytecode format), if any, the
10197 target needs to evaluate. The output is placed into the packet buffer
10198 started from BUF and ended at BUF_END. */
10201 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10202 struct bp_target_info
*bp_tgt
, char *buf
,
10205 if (bp_tgt
->conditions
.empty ())
10208 buf
+= strlen (buf
);
10209 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10212 /* Send conditions to the target. */
10213 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10215 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10216 buf
+= strlen (buf
);
10217 for (int i
= 0; i
< aexpr
->len
; ++i
)
10218 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10225 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10226 struct bp_target_info
*bp_tgt
, char *buf
)
10228 if (bp_tgt
->tcommands
.empty ())
10231 buf
+= strlen (buf
);
10233 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10234 buf
+= strlen (buf
);
10236 /* Concatenate all the agent expressions that are commands into the
10238 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10240 sprintf (buf
, "X%x,", aexpr
->len
);
10241 buf
+= strlen (buf
);
10242 for (int i
= 0; i
< aexpr
->len
; ++i
)
10243 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10248 /* Insert a breakpoint. On targets that have software breakpoint
10249 support, we ask the remote target to do the work; on targets
10250 which don't, we insert a traditional memory breakpoint. */
10253 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10254 struct bp_target_info
*bp_tgt
)
10256 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10257 If it succeeds, then set the support to PACKET_ENABLE. If it
10258 fails, and the user has explicitly requested the Z support then
10259 report an error, otherwise, mark it disabled and go on. */
10261 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10263 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10264 struct remote_state
*rs
;
10267 /* Make sure the remote is pointing at the right process, if
10269 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10270 set_general_process ();
10272 rs
= get_remote_state ();
10273 p
= rs
->buf
.data ();
10274 endbuf
= p
+ get_remote_packet_size ();
10279 addr
= (ULONGEST
) remote_address_masked (addr
);
10280 p
+= hexnumstr (p
, addr
);
10281 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10283 if (supports_evaluation_of_breakpoint_conditions ())
10284 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10286 if (can_run_breakpoint_commands ())
10287 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10290 getpkt (&rs
->buf
, 0);
10292 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10298 case PACKET_UNKNOWN
:
10303 /* If this breakpoint has target-side commands but this stub doesn't
10304 support Z0 packets, throw error. */
10305 if (!bp_tgt
->tcommands
.empty ())
10306 throw_error (NOT_SUPPORTED_ERROR
, _("\
10307 Target doesn't support breakpoints that have target side commands."));
10309 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10313 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10314 struct bp_target_info
*bp_tgt
,
10315 enum remove_bp_reason reason
)
10317 CORE_ADDR addr
= bp_tgt
->placed_address
;
10318 struct remote_state
*rs
= get_remote_state ();
10320 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10322 char *p
= rs
->buf
.data ();
10323 char *endbuf
= p
+ get_remote_packet_size ();
10325 /* Make sure the remote is pointing at the right process, if
10327 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10328 set_general_process ();
10334 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10335 p
+= hexnumstr (p
, addr
);
10336 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10339 getpkt (&rs
->buf
, 0);
10341 return (rs
->buf
[0] == 'E');
10344 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10347 static enum Z_packet_type
10348 watchpoint_to_Z_packet (int type
)
10353 return Z_PACKET_WRITE_WP
;
10356 return Z_PACKET_READ_WP
;
10359 return Z_PACKET_ACCESS_WP
;
10362 internal_error (__FILE__
, __LINE__
,
10363 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10368 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10369 enum target_hw_bp_type type
, struct expression
*cond
)
10371 struct remote_state
*rs
= get_remote_state ();
10372 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10374 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10376 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10379 /* Make sure the remote is pointing at the right process, if
10381 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10382 set_general_process ();
10384 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10385 p
= strchr (rs
->buf
.data (), '\0');
10386 addr
= remote_address_masked (addr
);
10387 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10388 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10391 getpkt (&rs
->buf
, 0);
10393 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10397 case PACKET_UNKNOWN
:
10402 internal_error (__FILE__
, __LINE__
,
10403 _("remote_insert_watchpoint: reached end of function"));
10407 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10408 CORE_ADDR start
, int length
)
10410 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10412 return diff
< length
;
10417 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10418 enum target_hw_bp_type type
, struct expression
*cond
)
10420 struct remote_state
*rs
= get_remote_state ();
10421 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10423 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10425 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10428 /* Make sure the remote is pointing at the right process, if
10430 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10431 set_general_process ();
10433 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10434 p
= strchr (rs
->buf
.data (), '\0');
10435 addr
= remote_address_masked (addr
);
10436 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10437 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10439 getpkt (&rs
->buf
, 0);
10441 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10444 case PACKET_UNKNOWN
:
10449 internal_error (__FILE__
, __LINE__
,
10450 _("remote_remove_watchpoint: reached end of function"));
10454 static int remote_hw_watchpoint_limit
= -1;
10455 static int remote_hw_watchpoint_length_limit
= -1;
10456 static int remote_hw_breakpoint_limit
= -1;
10459 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10461 if (remote_hw_watchpoint_length_limit
== 0)
10463 else if (remote_hw_watchpoint_length_limit
< 0)
10465 else if (len
<= remote_hw_watchpoint_length_limit
)
10472 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10474 if (type
== bp_hardware_breakpoint
)
10476 if (remote_hw_breakpoint_limit
== 0)
10478 else if (remote_hw_breakpoint_limit
< 0)
10480 else if (cnt
<= remote_hw_breakpoint_limit
)
10485 if (remote_hw_watchpoint_limit
== 0)
10487 else if (remote_hw_watchpoint_limit
< 0)
10491 else if (cnt
<= remote_hw_watchpoint_limit
)
10497 /* The to_stopped_by_sw_breakpoint method of target remote. */
10500 remote_target::stopped_by_sw_breakpoint ()
10502 struct thread_info
*thread
= inferior_thread ();
10504 return (thread
->priv
!= NULL
10505 && (get_remote_thread_info (thread
)->stop_reason
10506 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10509 /* The to_supports_stopped_by_sw_breakpoint method of target
10513 remote_target::supports_stopped_by_sw_breakpoint ()
10515 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10518 /* The to_stopped_by_hw_breakpoint method of target remote. */
10521 remote_target::stopped_by_hw_breakpoint ()
10523 struct thread_info
*thread
= inferior_thread ();
10525 return (thread
->priv
!= NULL
10526 && (get_remote_thread_info (thread
)->stop_reason
10527 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10530 /* The to_supports_stopped_by_hw_breakpoint method of target
10534 remote_target::supports_stopped_by_hw_breakpoint ()
10536 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10540 remote_target::stopped_by_watchpoint ()
10542 struct thread_info
*thread
= inferior_thread ();
10544 return (thread
->priv
!= NULL
10545 && (get_remote_thread_info (thread
)->stop_reason
10546 == TARGET_STOPPED_BY_WATCHPOINT
));
10550 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10552 struct thread_info
*thread
= inferior_thread ();
10554 if (thread
->priv
!= NULL
10555 && (get_remote_thread_info (thread
)->stop_reason
10556 == TARGET_STOPPED_BY_WATCHPOINT
))
10558 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10567 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10568 struct bp_target_info
*bp_tgt
)
10570 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10571 struct remote_state
*rs
;
10575 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10578 /* Make sure the remote is pointing at the right process, if
10580 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10581 set_general_process ();
10583 rs
= get_remote_state ();
10584 p
= rs
->buf
.data ();
10585 endbuf
= p
+ get_remote_packet_size ();
10591 addr
= remote_address_masked (addr
);
10592 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10593 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10595 if (supports_evaluation_of_breakpoint_conditions ())
10596 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10598 if (can_run_breakpoint_commands ())
10599 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10602 getpkt (&rs
->buf
, 0);
10604 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10607 if (rs
->buf
[1] == '.')
10609 message
= strchr (&rs
->buf
[2], '.');
10611 error (_("Remote failure reply: %s"), message
+ 1);
10614 case PACKET_UNKNOWN
:
10619 internal_error (__FILE__
, __LINE__
,
10620 _("remote_insert_hw_breakpoint: reached end of function"));
10625 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10626 struct bp_target_info
*bp_tgt
)
10629 struct remote_state
*rs
= get_remote_state ();
10630 char *p
= rs
->buf
.data ();
10631 char *endbuf
= p
+ get_remote_packet_size ();
10633 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10636 /* Make sure the remote is pointing at the right process, if
10638 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10639 set_general_process ();
10645 addr
= remote_address_masked (bp_tgt
->placed_address
);
10646 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10647 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10650 getpkt (&rs
->buf
, 0);
10652 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10655 case PACKET_UNKNOWN
:
10660 internal_error (__FILE__
, __LINE__
,
10661 _("remote_remove_hw_breakpoint: reached end of function"));
10664 /* Verify memory using the "qCRC:" request. */
10667 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10669 struct remote_state
*rs
= get_remote_state ();
10670 unsigned long host_crc
, target_crc
;
10673 /* It doesn't make sense to use qCRC if the remote target is
10674 connected but not running. */
10675 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10677 enum packet_result result
;
10679 /* Make sure the remote is pointing at the right process. */
10680 set_general_process ();
10682 /* FIXME: assumes lma can fit into long. */
10683 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10684 (long) lma
, (long) size
);
10687 /* Be clever; compute the host_crc before waiting for target
10689 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10691 getpkt (&rs
->buf
, 0);
10693 result
= packet_ok (rs
->buf
,
10694 &remote_protocol_packets
[PACKET_qCRC
]);
10695 if (result
== PACKET_ERROR
)
10697 else if (result
== PACKET_OK
)
10699 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10700 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10702 return (host_crc
== target_crc
);
10706 return simple_verify_memory (this, data
, lma
, size
);
10709 /* compare-sections command
10711 With no arguments, compares each loadable section in the exec bfd
10712 with the same memory range on the target, and reports mismatches.
10713 Useful for verifying the image on the target against the exec file. */
10716 compare_sections_command (const char *args
, int from_tty
)
10719 const char *sectname
;
10720 bfd_size_type size
;
10723 int mismatched
= 0;
10728 error (_("command cannot be used without an exec file"));
10730 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10736 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10738 if (!(s
->flags
& SEC_LOAD
))
10739 continue; /* Skip non-loadable section. */
10741 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10742 continue; /* Skip writeable sections */
10744 size
= bfd_section_size (s
);
10746 continue; /* Skip zero-length section. */
10748 sectname
= bfd_section_name (s
);
10749 if (args
&& strcmp (args
, sectname
) != 0)
10750 continue; /* Not the section selected by user. */
10752 matched
= 1; /* Do this section. */
10755 gdb::byte_vector
sectdata (size
);
10756 bfd_get_section_contents (exec_bfd
, s
, sectdata
.data (), 0, size
);
10758 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10761 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10762 paddress (target_gdbarch (), lma
),
10763 paddress (target_gdbarch (), lma
+ size
));
10765 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10766 paddress (target_gdbarch (), lma
),
10767 paddress (target_gdbarch (), lma
+ size
));
10769 printf_filtered ("matched.\n");
10772 printf_filtered ("MIS-MATCHED!\n");
10776 if (mismatched
> 0)
10777 warning (_("One or more sections of the target image does not match\n\
10778 the loaded file\n"));
10779 if (args
&& !matched
)
10780 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10783 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10784 into remote target. The number of bytes written to the remote
10785 target is returned, or -1 for error. */
10788 remote_target::remote_write_qxfer (const char *object_name
,
10789 const char *annex
, const gdb_byte
*writebuf
,
10790 ULONGEST offset
, LONGEST len
,
10791 ULONGEST
*xfered_len
,
10792 struct packet_config
*packet
)
10796 struct remote_state
*rs
= get_remote_state ();
10797 int max_size
= get_memory_write_packet_size ();
10799 if (packet_config_support (packet
) == PACKET_DISABLE
)
10800 return TARGET_XFER_E_IO
;
10802 /* Insert header. */
10803 i
= snprintf (rs
->buf
.data (), max_size
,
10804 "qXfer:%s:write:%s:%s:",
10805 object_name
, annex
? annex
: "",
10806 phex_nz (offset
, sizeof offset
));
10807 max_size
-= (i
+ 1);
10809 /* Escape as much data as fits into rs->buf. */
10810 buf_len
= remote_escape_output
10811 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10813 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10814 || getpkt_sane (&rs
->buf
, 0) < 0
10815 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10816 return TARGET_XFER_E_IO
;
10818 unpack_varlen_hex (rs
->buf
.data (), &n
);
10821 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10824 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10825 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10826 number of bytes read is returned, or 0 for EOF, or -1 for error.
10827 The number of bytes read may be less than LEN without indicating an
10828 EOF. PACKET is checked and updated to indicate whether the remote
10829 target supports this object. */
10832 remote_target::remote_read_qxfer (const char *object_name
,
10834 gdb_byte
*readbuf
, ULONGEST offset
,
10836 ULONGEST
*xfered_len
,
10837 struct packet_config
*packet
)
10839 struct remote_state
*rs
= get_remote_state ();
10840 LONGEST i
, n
, packet_len
;
10842 if (packet_config_support (packet
) == PACKET_DISABLE
)
10843 return TARGET_XFER_E_IO
;
10845 /* Check whether we've cached an end-of-object packet that matches
10847 if (rs
->finished_object
)
10849 if (strcmp (object_name
, rs
->finished_object
) == 0
10850 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10851 && offset
== rs
->finished_offset
)
10852 return TARGET_XFER_EOF
;
10855 /* Otherwise, we're now reading something different. Discard
10857 xfree (rs
->finished_object
);
10858 xfree (rs
->finished_annex
);
10859 rs
->finished_object
= NULL
;
10860 rs
->finished_annex
= NULL
;
10863 /* Request only enough to fit in a single packet. The actual data
10864 may not, since we don't know how much of it will need to be escaped;
10865 the target is free to respond with slightly less data. We subtract
10866 five to account for the response type and the protocol frame. */
10867 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10868 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
10869 "qXfer:%s:read:%s:%s,%s",
10870 object_name
, annex
? annex
: "",
10871 phex_nz (offset
, sizeof offset
),
10872 phex_nz (n
, sizeof n
));
10873 i
= putpkt (rs
->buf
);
10875 return TARGET_XFER_E_IO
;
10878 packet_len
= getpkt_sane (&rs
->buf
, 0);
10879 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10880 return TARGET_XFER_E_IO
;
10882 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10883 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
10885 /* 'm' means there is (or at least might be) more data after this
10886 batch. That does not make sense unless there's at least one byte
10887 of data in this reply. */
10888 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10889 error (_("Remote qXfer reply contained no data."));
10891 /* Got some data. */
10892 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
10893 packet_len
- 1, readbuf
, n
);
10895 /* 'l' is an EOF marker, possibly including a final block of data,
10896 or possibly empty. If we have the final block of a non-empty
10897 object, record this fact to bypass a subsequent partial read. */
10898 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10900 rs
->finished_object
= xstrdup (object_name
);
10901 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10902 rs
->finished_offset
= offset
+ i
;
10906 return TARGET_XFER_EOF
;
10910 return TARGET_XFER_OK
;
10914 enum target_xfer_status
10915 remote_target::xfer_partial (enum target_object object
,
10916 const char *annex
, gdb_byte
*readbuf
,
10917 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10918 ULONGEST
*xfered_len
)
10920 struct remote_state
*rs
;
10924 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10926 set_remote_traceframe ();
10927 set_general_thread (inferior_ptid
);
10929 rs
= get_remote_state ();
10931 /* Handle memory using the standard memory routines. */
10932 if (object
== TARGET_OBJECT_MEMORY
)
10934 /* If the remote target is connected but not running, we should
10935 pass this request down to a lower stratum (e.g. the executable
10937 if (!target_has_execution
)
10938 return TARGET_XFER_EOF
;
10940 if (writebuf
!= NULL
)
10941 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10944 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
10948 /* Handle extra signal info using qxfer packets. */
10949 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10952 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
10953 xfered_len
, &remote_protocol_packets
10954 [PACKET_qXfer_siginfo_read
]);
10956 return remote_write_qxfer ("siginfo", annex
,
10957 writebuf
, offset
, len
, xfered_len
,
10958 &remote_protocol_packets
10959 [PACKET_qXfer_siginfo_write
]);
10962 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10965 return remote_read_qxfer ("statictrace", annex
,
10966 readbuf
, offset
, len
, xfered_len
,
10967 &remote_protocol_packets
10968 [PACKET_qXfer_statictrace_read
]);
10970 return TARGET_XFER_E_IO
;
10973 /* Only handle flash writes. */
10974 if (writebuf
!= NULL
)
10978 case TARGET_OBJECT_FLASH
:
10979 return remote_flash_write (offset
, len
, xfered_len
,
10983 return TARGET_XFER_E_IO
;
10987 /* Map pre-existing objects onto letters. DO NOT do this for new
10988 objects!!! Instead specify new query packets. */
10991 case TARGET_OBJECT_AVR
:
10995 case TARGET_OBJECT_AUXV
:
10996 gdb_assert (annex
== NULL
);
10997 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
10999 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
11001 case TARGET_OBJECT_AVAILABLE_FEATURES
:
11002 return remote_read_qxfer
11003 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
11004 &remote_protocol_packets
[PACKET_qXfer_features
]);
11006 case TARGET_OBJECT_LIBRARIES
:
11007 return remote_read_qxfer
11008 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
11009 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
11011 case TARGET_OBJECT_LIBRARIES_SVR4
:
11012 return remote_read_qxfer
11013 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
11014 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
11016 case TARGET_OBJECT_MEMORY_MAP
:
11017 gdb_assert (annex
== NULL
);
11018 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
11020 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
11022 case TARGET_OBJECT_OSDATA
:
11023 /* Should only get here if we're connected. */
11024 gdb_assert (rs
->remote_desc
);
11025 return remote_read_qxfer
11026 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
11027 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
11029 case TARGET_OBJECT_THREADS
:
11030 gdb_assert (annex
== NULL
);
11031 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
11033 &remote_protocol_packets
[PACKET_qXfer_threads
]);
11035 case TARGET_OBJECT_TRACEFRAME_INFO
:
11036 gdb_assert (annex
== NULL
);
11037 return remote_read_qxfer
11038 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
11039 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
11041 case TARGET_OBJECT_FDPIC
:
11042 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
11044 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
11046 case TARGET_OBJECT_OPENVMS_UIB
:
11047 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
11049 &remote_protocol_packets
[PACKET_qXfer_uib
]);
11051 case TARGET_OBJECT_BTRACE
:
11052 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
11054 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
11056 case TARGET_OBJECT_BTRACE_CONF
:
11057 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
11059 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
11061 case TARGET_OBJECT_EXEC_FILE
:
11062 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
11064 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
11067 return TARGET_XFER_E_IO
;
11070 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
11071 large enough let the caller deal with it. */
11072 if (len
< get_remote_packet_size ())
11073 return TARGET_XFER_E_IO
;
11074 len
= get_remote_packet_size ();
11076 /* Except for querying the minimum buffer size, target must be open. */
11077 if (!rs
->remote_desc
)
11078 error (_("remote query is only available after target open"));
11080 gdb_assert (annex
!= NULL
);
11081 gdb_assert (readbuf
!= NULL
);
11083 p2
= rs
->buf
.data ();
11085 *p2
++ = query_type
;
11087 /* We used one buffer char for the remote protocol q command and
11088 another for the query type. As the remote protocol encapsulation
11089 uses 4 chars plus one extra in case we are debugging
11090 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11093 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11095 /* Bad caller may have sent forbidden characters. */
11096 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11101 gdb_assert (annex
[i
] == '\0');
11103 i
= putpkt (rs
->buf
);
11105 return TARGET_XFER_E_IO
;
11107 getpkt (&rs
->buf
, 0);
11108 strcpy ((char *) readbuf
, rs
->buf
.data ());
11110 *xfered_len
= strlen ((char *) readbuf
);
11111 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11114 /* Implementation of to_get_memory_xfer_limit. */
11117 remote_target::get_memory_xfer_limit ()
11119 return get_memory_write_packet_size ();
11123 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11124 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11125 CORE_ADDR
*found_addrp
)
11127 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11128 struct remote_state
*rs
= get_remote_state ();
11129 int max_size
= get_memory_write_packet_size ();
11130 struct packet_config
*packet
=
11131 &remote_protocol_packets
[PACKET_qSearch_memory
];
11132 /* Number of packet bytes used to encode the pattern;
11133 this could be more than PATTERN_LEN due to escape characters. */
11134 int escaped_pattern_len
;
11135 /* Amount of pattern that was encodable in the packet. */
11136 int used_pattern_len
;
11139 ULONGEST found_addr
;
11141 /* Don't go to the target if we don't have to. This is done before
11142 checking packet_config_support to avoid the possibility that a
11143 success for this edge case means the facility works in
11145 if (pattern_len
> search_space_len
)
11147 if (pattern_len
== 0)
11149 *found_addrp
= start_addr
;
11153 /* If we already know the packet isn't supported, fall back to the simple
11154 way of searching memory. */
11156 if (packet_config_support (packet
) == PACKET_DISABLE
)
11158 /* Target doesn't provided special support, fall back and use the
11159 standard support (copy memory and do the search here). */
11160 return simple_search_memory (this, start_addr
, search_space_len
,
11161 pattern
, pattern_len
, found_addrp
);
11164 /* Make sure the remote is pointing at the right process. */
11165 set_general_process ();
11167 /* Insert header. */
11168 i
= snprintf (rs
->buf
.data (), max_size
,
11169 "qSearch:memory:%s;%s;",
11170 phex_nz (start_addr
, addr_size
),
11171 phex_nz (search_space_len
, sizeof (search_space_len
)));
11172 max_size
-= (i
+ 1);
11174 /* Escape as much data as fits into rs->buf. */
11175 escaped_pattern_len
=
11176 remote_escape_output (pattern
, pattern_len
, 1,
11177 (gdb_byte
*) rs
->buf
.data () + i
,
11178 &used_pattern_len
, max_size
);
11180 /* Bail if the pattern is too large. */
11181 if (used_pattern_len
!= pattern_len
)
11182 error (_("Pattern is too large to transmit to remote target."));
11184 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11185 || getpkt_sane (&rs
->buf
, 0) < 0
11186 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11188 /* The request may not have worked because the command is not
11189 supported. If so, fall back to the simple way. */
11190 if (packet_config_support (packet
) == PACKET_DISABLE
)
11192 return simple_search_memory (this, start_addr
, search_space_len
,
11193 pattern
, pattern_len
, found_addrp
);
11198 if (rs
->buf
[0] == '0')
11200 else if (rs
->buf
[0] == '1')
11203 if (rs
->buf
[1] != ',')
11204 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11205 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11206 *found_addrp
= found_addr
;
11209 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11215 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11217 struct remote_state
*rs
= get_remote_state ();
11218 char *p
= rs
->buf
.data ();
11220 if (!rs
->remote_desc
)
11221 error (_("remote rcmd is only available after target open"));
11223 /* Send a NULL command across as an empty command. */
11224 if (command
== NULL
)
11227 /* The query prefix. */
11228 strcpy (rs
->buf
.data (), "qRcmd,");
11229 p
= strchr (rs
->buf
.data (), '\0');
11231 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11232 > get_remote_packet_size ())
11233 error (_("\"monitor\" command ``%s'' is too long."), command
);
11235 /* Encode the actual command. */
11236 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11238 if (putpkt (rs
->buf
) < 0)
11239 error (_("Communication problem with target."));
11241 /* get/display the response */
11246 /* XXX - see also remote_get_noisy_reply(). */
11247 QUIT
; /* Allow user to bail out with ^C. */
11249 if (getpkt_sane (&rs
->buf
, 0) == -1)
11251 /* Timeout. Continue to (try to) read responses.
11252 This is better than stopping with an error, assuming the stub
11253 is still executing the (long) monitor command.
11254 If needed, the user can interrupt gdb using C-c, obtaining
11255 an effect similar to stop on timeout. */
11258 buf
= rs
->buf
.data ();
11259 if (buf
[0] == '\0')
11260 error (_("Target does not support this command."));
11261 if (buf
[0] == 'O' && buf
[1] != 'K')
11263 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11266 if (strcmp (buf
, "OK") == 0)
11268 if (strlen (buf
) == 3 && buf
[0] == 'E'
11269 && isdigit (buf
[1]) && isdigit (buf
[2]))
11271 error (_("Protocol error with Rcmd"));
11273 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11275 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11277 fputc_unfiltered (c
, outbuf
);
11283 std::vector
<mem_region
>
11284 remote_target::memory_map ()
11286 std::vector
<mem_region
> result
;
11287 gdb::optional
<gdb::char_vector
> text
11288 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11291 result
= parse_memory_map (text
->data ());
11297 packet_command (const char *args
, int from_tty
)
11299 remote_target
*remote
= get_current_remote_target ();
11301 if (remote
== nullptr)
11302 error (_("command can only be used with remote target"));
11304 remote
->packet_command (args
, from_tty
);
11308 remote_target::packet_command (const char *args
, int from_tty
)
11311 error (_("remote-packet command requires packet text as argument"));
11313 puts_filtered ("sending: ");
11314 print_packet (args
);
11315 puts_filtered ("\n");
11318 remote_state
*rs
= get_remote_state ();
11320 getpkt (&rs
->buf
, 0);
11321 puts_filtered ("received: ");
11322 print_packet (rs
->buf
.data ());
11323 puts_filtered ("\n");
11327 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11329 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11331 static void threadset_test_cmd (char *cmd
, int tty
);
11333 static void threadalive_test (char *cmd
, int tty
);
11335 static void threadlist_test_cmd (char *cmd
, int tty
);
11337 int get_and_display_threadinfo (threadref
*ref
);
11339 static void threadinfo_test_cmd (char *cmd
, int tty
);
11341 static int thread_display_step (threadref
*ref
, void *context
);
11343 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11345 static void init_remote_threadtests (void);
11347 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11350 threadset_test_cmd (const char *cmd
, int tty
)
11352 int sample_thread
= SAMPLE_THREAD
;
11354 printf_filtered (_("Remote threadset test\n"));
11355 set_general_thread (sample_thread
);
11360 threadalive_test (const char *cmd
, int tty
)
11362 int sample_thread
= SAMPLE_THREAD
;
11363 int pid
= inferior_ptid
.pid ();
11364 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11366 if (remote_thread_alive (ptid
))
11367 printf_filtered ("PASS: Thread alive test\n");
11369 printf_filtered ("FAIL: Thread alive test\n");
11372 void output_threadid (char *title
, threadref
*ref
);
11375 output_threadid (char *title
, threadref
*ref
)
11379 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11381 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11385 threadlist_test_cmd (const char *cmd
, int tty
)
11388 threadref nextthread
;
11389 int done
, result_count
;
11390 threadref threadlist
[3];
11392 printf_filtered ("Remote Threadlist test\n");
11393 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11394 &result_count
, &threadlist
[0]))
11395 printf_filtered ("FAIL: threadlist test\n");
11398 threadref
*scan
= threadlist
;
11399 threadref
*limit
= scan
+ result_count
;
11401 while (scan
< limit
)
11402 output_threadid (" thread ", scan
++);
11407 display_thread_info (struct gdb_ext_thread_info
*info
)
11409 output_threadid ("Threadid: ", &info
->threadid
);
11410 printf_filtered ("Name: %s\n ", info
->shortname
);
11411 printf_filtered ("State: %s\n", info
->display
);
11412 printf_filtered ("other: %s\n\n", info
->more_display
);
11416 get_and_display_threadinfo (threadref
*ref
)
11420 struct gdb_ext_thread_info threadinfo
;
11422 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11423 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11424 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11425 display_thread_info (&threadinfo
);
11430 threadinfo_test_cmd (const char *cmd
, int tty
)
11432 int athread
= SAMPLE_THREAD
;
11436 int_to_threadref (&thread
, athread
);
11437 printf_filtered ("Remote Threadinfo test\n");
11438 if (!get_and_display_threadinfo (&thread
))
11439 printf_filtered ("FAIL cannot get thread info\n");
11443 thread_display_step (threadref
*ref
, void *context
)
11445 /* output_threadid(" threadstep ",ref); *//* simple test */
11446 return get_and_display_threadinfo (ref
);
11450 threadlist_update_test_cmd (const char *cmd
, int tty
)
11452 printf_filtered ("Remote Threadlist update test\n");
11453 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11457 init_remote_threadtests (void)
11459 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11460 _("Fetch and print the remote list of "
11461 "thread identifiers, one pkt only."));
11462 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11463 _("Fetch and display info about one thread."));
11464 add_com ("tset", class_obscure
, threadset_test_cmd
,
11465 _("Test setting to a different thread."));
11466 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11467 _("Iterate through updating all remote thread info."));
11468 add_com ("talive", class_obscure
, threadalive_test
,
11469 _("Remote thread alive test."));
11474 /* Convert a thread ID to a string. */
11477 remote_target::pid_to_str (ptid_t ptid
)
11479 struct remote_state
*rs
= get_remote_state ();
11481 if (ptid
== null_ptid
)
11482 return normal_pid_to_str (ptid
);
11483 else if (ptid
.is_pid ())
11485 /* Printing an inferior target id. */
11487 /* When multi-process extensions are off, there's no way in the
11488 remote protocol to know the remote process id, if there's any
11489 at all. There's one exception --- when we're connected with
11490 target extended-remote, and we manually attached to a process
11491 with "attach PID". We don't record anywhere a flag that
11492 allows us to distinguish that case from the case of
11493 connecting with extended-remote and the stub already being
11494 attached to a process, and reporting yes to qAttached, hence
11495 no smart special casing here. */
11496 if (!remote_multi_process_p (rs
))
11497 return "Remote target";
11499 return normal_pid_to_str (ptid
);
11503 if (magic_null_ptid
== ptid
)
11504 return "Thread <main>";
11505 else if (remote_multi_process_p (rs
))
11506 if (ptid
.lwp () == 0)
11507 return normal_pid_to_str (ptid
);
11509 return string_printf ("Thread %d.%ld",
11510 ptid
.pid (), ptid
.lwp ());
11512 return string_printf ("Thread %ld", ptid
.lwp ());
11516 /* Get the address of the thread local variable in OBJFILE which is
11517 stored at OFFSET within the thread local storage for thread PTID. */
11520 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11523 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11525 struct remote_state
*rs
= get_remote_state ();
11526 char *p
= rs
->buf
.data ();
11527 char *endp
= p
+ get_remote_packet_size ();
11528 enum packet_result result
;
11530 strcpy (p
, "qGetTLSAddr:");
11532 p
= write_ptid (p
, endp
, ptid
);
11534 p
+= hexnumstr (p
, offset
);
11536 p
+= hexnumstr (p
, lm
);
11540 getpkt (&rs
->buf
, 0);
11541 result
= packet_ok (rs
->buf
,
11542 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11543 if (result
== PACKET_OK
)
11547 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11550 else if (result
== PACKET_UNKNOWN
)
11551 throw_error (TLS_GENERIC_ERROR
,
11552 _("Remote target doesn't support qGetTLSAddr packet"));
11554 throw_error (TLS_GENERIC_ERROR
,
11555 _("Remote target failed to process qGetTLSAddr request"));
11558 throw_error (TLS_GENERIC_ERROR
,
11559 _("TLS not supported or disabled on this target"));
11564 /* Provide thread local base, i.e. Thread Information Block address.
11565 Returns 1 if ptid is found and thread_local_base is non zero. */
11568 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11570 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11572 struct remote_state
*rs
= get_remote_state ();
11573 char *p
= rs
->buf
.data ();
11574 char *endp
= p
+ get_remote_packet_size ();
11575 enum packet_result result
;
11577 strcpy (p
, "qGetTIBAddr:");
11579 p
= write_ptid (p
, endp
, ptid
);
11583 getpkt (&rs
->buf
, 0);
11584 result
= packet_ok (rs
->buf
,
11585 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11586 if (result
== PACKET_OK
)
11589 unpack_varlen_hex (rs
->buf
.data (), &val
);
11591 *addr
= (CORE_ADDR
) val
;
11594 else if (result
== PACKET_UNKNOWN
)
11595 error (_("Remote target doesn't support qGetTIBAddr packet"));
11597 error (_("Remote target failed to process qGetTIBAddr request"));
11600 error (_("qGetTIBAddr not supported or disabled on this target"));
11605 /* Support for inferring a target description based on the current
11606 architecture and the size of a 'g' packet. While the 'g' packet
11607 can have any size (since optional registers can be left off the
11608 end), some sizes are easily recognizable given knowledge of the
11609 approximate architecture. */
11611 struct remote_g_packet_guess
11613 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11620 const struct target_desc
*tdesc
;
11623 struct remote_g_packet_data
: public allocate_on_obstack
11625 std::vector
<remote_g_packet_guess
> guesses
;
11628 static struct gdbarch_data
*remote_g_packet_data_handle
;
11631 remote_g_packet_data_init (struct obstack
*obstack
)
11633 return new (obstack
) remote_g_packet_data
;
11637 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11638 const struct target_desc
*tdesc
)
11640 struct remote_g_packet_data
*data
11641 = ((struct remote_g_packet_data
*)
11642 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11644 gdb_assert (tdesc
!= NULL
);
11646 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11647 if (guess
.bytes
== bytes
)
11648 internal_error (__FILE__
, __LINE__
,
11649 _("Duplicate g packet description added for size %d"),
11652 data
->guesses
.emplace_back (bytes
, tdesc
);
11655 /* Return true if remote_read_description would do anything on this target
11656 and architecture, false otherwise. */
11659 remote_read_description_p (struct target_ops
*target
)
11661 struct remote_g_packet_data
*data
11662 = ((struct remote_g_packet_data
*)
11663 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11665 return !data
->guesses
.empty ();
11668 const struct target_desc
*
11669 remote_target::read_description ()
11671 struct remote_g_packet_data
*data
11672 = ((struct remote_g_packet_data
*)
11673 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11675 /* Do not try this during initial connection, when we do not know
11676 whether there is a running but stopped thread. */
11677 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
11678 return beneath ()->read_description ();
11680 if (!data
->guesses
.empty ())
11682 int bytes
= send_g_packet ();
11684 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11685 if (guess
.bytes
== bytes
)
11686 return guess
.tdesc
;
11688 /* We discard the g packet. A minor optimization would be to
11689 hold on to it, and fill the register cache once we have selected
11690 an architecture, but it's too tricky to do safely. */
11693 return beneath ()->read_description ();
11696 /* Remote file transfer support. This is host-initiated I/O, not
11697 target-initiated; for target-initiated, see remote-fileio.c. */
11699 /* If *LEFT is at least the length of STRING, copy STRING to
11700 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11701 decrease *LEFT. Otherwise raise an error. */
11704 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11706 int len
= strlen (string
);
11709 error (_("Packet too long for target."));
11711 memcpy (*buffer
, string
, len
);
11715 /* NUL-terminate the buffer as a convenience, if there is
11721 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11722 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11723 decrease *LEFT. Otherwise raise an error. */
11726 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11729 if (2 * len
> *left
)
11730 error (_("Packet too long for target."));
11732 bin2hex (bytes
, *buffer
, len
);
11733 *buffer
+= 2 * len
;
11736 /* NUL-terminate the buffer as a convenience, if there is
11742 /* If *LEFT is large enough, convert VALUE to hex and add it to
11743 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11744 decrease *LEFT. Otherwise raise an error. */
11747 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11749 int len
= hexnumlen (value
);
11752 error (_("Packet too long for target."));
11754 hexnumstr (*buffer
, value
);
11758 /* NUL-terminate the buffer as a convenience, if there is
11764 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11765 value, *REMOTE_ERRNO to the remote error number or zero if none
11766 was included, and *ATTACHMENT to point to the start of the annex
11767 if any. The length of the packet isn't needed here; there may
11768 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11770 Return 0 if the packet could be parsed, -1 if it could not. If
11771 -1 is returned, the other variables may not be initialized. */
11774 remote_hostio_parse_result (char *buffer
, int *retcode
,
11775 int *remote_errno
, char **attachment
)
11780 *attachment
= NULL
;
11782 if (buffer
[0] != 'F')
11786 *retcode
= strtol (&buffer
[1], &p
, 16);
11787 if (errno
!= 0 || p
== &buffer
[1])
11790 /* Check for ",errno". */
11794 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11795 if (errno
!= 0 || p
+ 1 == p2
)
11800 /* Check for ";attachment". If there is no attachment, the
11801 packet should end here. */
11804 *attachment
= p
+ 1;
11807 else if (*p
== '\0')
11813 /* Send a prepared I/O packet to the target and read its response.
11814 The prepared packet is in the global RS->BUF before this function
11815 is called, and the answer is there when we return.
11817 COMMAND_BYTES is the length of the request to send, which may include
11818 binary data. WHICH_PACKET is the packet configuration to check
11819 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11820 is set to the error number and -1 is returned. Otherwise the value
11821 returned by the function is returned.
11823 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11824 attachment is expected; an error will be reported if there's a
11825 mismatch. If one is found, *ATTACHMENT will be set to point into
11826 the packet buffer and *ATTACHMENT_LEN will be set to the
11827 attachment's length. */
11830 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11831 int *remote_errno
, char **attachment
,
11832 int *attachment_len
)
11834 struct remote_state
*rs
= get_remote_state ();
11835 int ret
, bytes_read
;
11836 char *attachment_tmp
;
11838 if (packet_support (which_packet
) == PACKET_DISABLE
)
11840 *remote_errno
= FILEIO_ENOSYS
;
11844 putpkt_binary (rs
->buf
.data (), command_bytes
);
11845 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11847 /* If it timed out, something is wrong. Don't try to parse the
11849 if (bytes_read
< 0)
11851 *remote_errno
= FILEIO_EINVAL
;
11855 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11858 *remote_errno
= FILEIO_EINVAL
;
11860 case PACKET_UNKNOWN
:
11861 *remote_errno
= FILEIO_ENOSYS
;
11867 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
11870 *remote_errno
= FILEIO_EINVAL
;
11874 /* Make sure we saw an attachment if and only if we expected one. */
11875 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11876 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11878 *remote_errno
= FILEIO_EINVAL
;
11882 /* If an attachment was found, it must point into the packet buffer;
11883 work out how many bytes there were. */
11884 if (attachment_tmp
!= NULL
)
11886 *attachment
= attachment_tmp
;
11887 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
11893 /* See declaration.h. */
11896 readahead_cache::invalidate ()
11901 /* See declaration.h. */
11904 readahead_cache::invalidate_fd (int fd
)
11906 if (this->fd
== fd
)
11910 /* Set the filesystem remote_hostio functions that take FILENAME
11911 arguments will use. Return 0 on success, or -1 if an error
11912 occurs (and set *REMOTE_ERRNO). */
11915 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
11918 struct remote_state
*rs
= get_remote_state ();
11919 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11920 char *p
= rs
->buf
.data ();
11921 int left
= get_remote_packet_size () - 1;
11925 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11928 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11931 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11933 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11934 remote_buffer_add_string (&p
, &left
, arg
);
11936 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
11937 remote_errno
, NULL
, NULL
);
11939 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11943 rs
->fs_pid
= required_pid
;
11948 /* Implementation of to_fileio_open. */
11951 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
11952 int flags
, int mode
, int warn_if_slow
,
11955 struct remote_state
*rs
= get_remote_state ();
11956 char *p
= rs
->buf
.data ();
11957 int left
= get_remote_packet_size () - 1;
11961 static int warning_issued
= 0;
11963 printf_unfiltered (_("Reading %s from remote target...\n"),
11966 if (!warning_issued
)
11968 warning (_("File transfers from remote targets can be slow."
11969 " Use \"set sysroot\" to access files locally"
11971 warning_issued
= 1;
11975 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11978 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11980 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11981 strlen (filename
));
11982 remote_buffer_add_string (&p
, &left
, ",");
11984 remote_buffer_add_int (&p
, &left
, flags
);
11985 remote_buffer_add_string (&p
, &left
, ",");
11987 remote_buffer_add_int (&p
, &left
, mode
);
11989 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
11990 remote_errno
, NULL
, NULL
);
11994 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
11995 int flags
, int mode
, int warn_if_slow
,
11998 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
12002 /* Implementation of to_fileio_pwrite. */
12005 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12006 ULONGEST offset
, int *remote_errno
)
12008 struct remote_state
*rs
= get_remote_state ();
12009 char *p
= rs
->buf
.data ();
12010 int left
= get_remote_packet_size ();
12013 rs
->readahead_cache
.invalidate_fd (fd
);
12015 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
12017 remote_buffer_add_int (&p
, &left
, fd
);
12018 remote_buffer_add_string (&p
, &left
, ",");
12020 remote_buffer_add_int (&p
, &left
, offset
);
12021 remote_buffer_add_string (&p
, &left
, ",");
12023 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
12024 (get_remote_packet_size ()
12025 - (p
- rs
->buf
.data ())));
12027 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
12028 remote_errno
, NULL
, NULL
);
12032 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12033 ULONGEST offset
, int *remote_errno
)
12035 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
12038 /* Helper for the implementation of to_fileio_pread. Read the file
12039 from the remote side with vFile:pread. */
12042 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
12043 ULONGEST offset
, int *remote_errno
)
12045 struct remote_state
*rs
= get_remote_state ();
12046 char *p
= rs
->buf
.data ();
12048 int left
= get_remote_packet_size ();
12049 int ret
, attachment_len
;
12052 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
12054 remote_buffer_add_int (&p
, &left
, fd
);
12055 remote_buffer_add_string (&p
, &left
, ",");
12057 remote_buffer_add_int (&p
, &left
, len
);
12058 remote_buffer_add_string (&p
, &left
, ",");
12060 remote_buffer_add_int (&p
, &left
, offset
);
12062 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
12063 remote_errno
, &attachment
,
12069 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12071 if (read_len
!= ret
)
12072 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
12077 /* See declaration.h. */
12080 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12084 && this->offset
<= offset
12085 && offset
< this->offset
+ this->bufsize
)
12087 ULONGEST max
= this->offset
+ this->bufsize
;
12089 if (offset
+ len
> max
)
12090 len
= max
- offset
;
12092 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12099 /* Implementation of to_fileio_pread. */
12102 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12103 ULONGEST offset
, int *remote_errno
)
12106 struct remote_state
*rs
= get_remote_state ();
12107 readahead_cache
*cache
= &rs
->readahead_cache
;
12109 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12112 cache
->hit_count
++;
12115 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12116 pulongest (cache
->hit_count
));
12120 cache
->miss_count
++;
12122 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12123 pulongest (cache
->miss_count
));
12126 cache
->offset
= offset
;
12127 cache
->bufsize
= get_remote_packet_size ();
12128 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12130 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12131 cache
->offset
, remote_errno
);
12134 cache
->invalidate_fd (fd
);
12138 cache
->bufsize
= ret
;
12139 return cache
->pread (fd
, read_buf
, len
, offset
);
12143 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12144 ULONGEST offset
, int *remote_errno
)
12146 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12149 /* Implementation of to_fileio_close. */
12152 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12154 struct remote_state
*rs
= get_remote_state ();
12155 char *p
= rs
->buf
.data ();
12156 int left
= get_remote_packet_size () - 1;
12158 rs
->readahead_cache
.invalidate_fd (fd
);
12160 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12162 remote_buffer_add_int (&p
, &left
, fd
);
12164 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12165 remote_errno
, NULL
, NULL
);
12169 remote_target::fileio_close (int fd
, int *remote_errno
)
12171 return remote_hostio_close (fd
, remote_errno
);
12174 /* Implementation of to_fileio_unlink. */
12177 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12180 struct remote_state
*rs
= get_remote_state ();
12181 char *p
= rs
->buf
.data ();
12182 int left
= get_remote_packet_size () - 1;
12184 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12187 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12189 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12190 strlen (filename
));
12192 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12193 remote_errno
, NULL
, NULL
);
12197 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12200 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12203 /* Implementation of to_fileio_readlink. */
12205 gdb::optional
<std::string
>
12206 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12209 struct remote_state
*rs
= get_remote_state ();
12210 char *p
= rs
->buf
.data ();
12212 int left
= get_remote_packet_size ();
12213 int len
, attachment_len
;
12216 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12219 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12221 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12222 strlen (filename
));
12224 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12225 remote_errno
, &attachment
,
12231 std::string
ret (len
, '\0');
12233 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12234 (gdb_byte
*) &ret
[0], len
);
12235 if (read_len
!= len
)
12236 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12241 /* Implementation of to_fileio_fstat. */
12244 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12246 struct remote_state
*rs
= get_remote_state ();
12247 char *p
= rs
->buf
.data ();
12248 int left
= get_remote_packet_size ();
12249 int attachment_len
, ret
;
12251 struct fio_stat fst
;
12254 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12256 remote_buffer_add_int (&p
, &left
, fd
);
12258 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12259 remote_errno
, &attachment
,
12263 if (*remote_errno
!= FILEIO_ENOSYS
)
12266 /* Strictly we should return -1, ENOSYS here, but when
12267 "set sysroot remote:" was implemented in August 2008
12268 BFD's need for a stat function was sidestepped with
12269 this hack. This was not remedied until March 2015
12270 so we retain the previous behavior to avoid breaking
12273 Note that the memset is a March 2015 addition; older
12274 GDBs set st_size *and nothing else* so the structure
12275 would have garbage in all other fields. This might
12276 break something but retaining the previous behavior
12277 here would be just too wrong. */
12279 memset (st
, 0, sizeof (struct stat
));
12280 st
->st_size
= INT_MAX
;
12284 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12285 (gdb_byte
*) &fst
, sizeof (fst
));
12287 if (read_len
!= ret
)
12288 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12290 if (read_len
!= sizeof (fst
))
12291 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12292 read_len
, (int) sizeof (fst
));
12294 remote_fileio_to_host_stat (&fst
, st
);
12299 /* Implementation of to_filesystem_is_local. */
12302 remote_target::filesystem_is_local ()
12304 /* Valgrind GDB presents itself as a remote target but works
12305 on the local filesystem: it does not implement remote get
12306 and users are not expected to set a sysroot. To handle
12307 this case we treat the remote filesystem as local if the
12308 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12309 does not support vFile:open. */
12310 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12312 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12314 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12316 int fd
, remote_errno
;
12318 /* Try opening a file to probe support. The supplied
12319 filename is irrelevant, we only care about whether
12320 the stub recognizes the packet or not. */
12321 fd
= remote_hostio_open (NULL
, "just probing",
12322 FILEIO_O_RDONLY
, 0700, 0,
12326 remote_hostio_close (fd
, &remote_errno
);
12328 ps
= packet_support (PACKET_vFile_open
);
12331 if (ps
== PACKET_DISABLE
)
12333 static int warning_issued
= 0;
12335 if (!warning_issued
)
12337 warning (_("remote target does not support file"
12338 " transfer, attempting to access files"
12339 " from local filesystem."));
12340 warning_issued
= 1;
12351 remote_fileio_errno_to_host (int errnum
)
12357 case FILEIO_ENOENT
:
12365 case FILEIO_EACCES
:
12367 case FILEIO_EFAULT
:
12371 case FILEIO_EEXIST
:
12373 case FILEIO_ENODEV
:
12375 case FILEIO_ENOTDIR
:
12377 case FILEIO_EISDIR
:
12379 case FILEIO_EINVAL
:
12381 case FILEIO_ENFILE
:
12383 case FILEIO_EMFILE
:
12387 case FILEIO_ENOSPC
:
12389 case FILEIO_ESPIPE
:
12393 case FILEIO_ENOSYS
:
12395 case FILEIO_ENAMETOOLONG
:
12396 return ENAMETOOLONG
;
12402 remote_hostio_error (int errnum
)
12404 int host_error
= remote_fileio_errno_to_host (errnum
);
12406 if (host_error
== -1)
12407 error (_("Unknown remote I/O error %d"), errnum
);
12409 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12412 /* A RAII wrapper around a remote file descriptor. */
12414 class scoped_remote_fd
12417 scoped_remote_fd (remote_target
*remote
, int fd
)
12418 : m_remote (remote
), m_fd (fd
)
12422 ~scoped_remote_fd ()
12429 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12433 /* Swallow exception before it escapes the dtor. If
12434 something goes wrong, likely the connection is gone,
12435 and there's nothing else that can be done. */
12440 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12442 /* Release ownership of the file descriptor, and return it. */
12443 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12450 /* Return the owned file descriptor. */
12451 int get () const noexcept
12457 /* The remote target. */
12458 remote_target
*m_remote
;
12460 /* The owned remote I/O file descriptor. */
12465 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12467 remote_target
*remote
= get_current_remote_target ();
12469 if (remote
== nullptr)
12470 error (_("command can only be used with remote target"));
12472 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12476 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12479 int retcode
, remote_errno
, bytes
, io_size
;
12480 int bytes_in_buffer
;
12484 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12486 perror_with_name (local_file
);
12488 scoped_remote_fd fd
12489 (this, remote_hostio_open (NULL
,
12490 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12492 0700, 0, &remote_errno
));
12493 if (fd
.get () == -1)
12494 remote_hostio_error (remote_errno
);
12496 /* Send up to this many bytes at once. They won't all fit in the
12497 remote packet limit, so we'll transfer slightly fewer. */
12498 io_size
= get_remote_packet_size ();
12499 gdb::byte_vector
buffer (io_size
);
12501 bytes_in_buffer
= 0;
12504 while (bytes_in_buffer
|| !saw_eof
)
12508 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12509 io_size
- bytes_in_buffer
,
12513 if (ferror (file
.get ()))
12514 error (_("Error reading %s."), local_file
);
12517 /* EOF. Unless there is something still in the
12518 buffer from the last iteration, we are done. */
12520 if (bytes_in_buffer
== 0)
12528 bytes
+= bytes_in_buffer
;
12529 bytes_in_buffer
= 0;
12531 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12532 offset
, &remote_errno
);
12535 remote_hostio_error (remote_errno
);
12536 else if (retcode
== 0)
12537 error (_("Remote write of %d bytes returned 0!"), bytes
);
12538 else if (retcode
< bytes
)
12540 /* Short write. Save the rest of the read data for the next
12542 bytes_in_buffer
= bytes
- retcode
;
12543 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12549 if (remote_hostio_close (fd
.release (), &remote_errno
))
12550 remote_hostio_error (remote_errno
);
12553 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12557 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12559 remote_target
*remote
= get_current_remote_target ();
12561 if (remote
== nullptr)
12562 error (_("command can only be used with remote target"));
12564 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12568 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12571 int remote_errno
, bytes
, io_size
;
12574 scoped_remote_fd fd
12575 (this, remote_hostio_open (NULL
,
12576 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12578 if (fd
.get () == -1)
12579 remote_hostio_error (remote_errno
);
12581 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12583 perror_with_name (local_file
);
12585 /* Send up to this many bytes at once. They won't all fit in the
12586 remote packet limit, so we'll transfer slightly fewer. */
12587 io_size
= get_remote_packet_size ();
12588 gdb::byte_vector
buffer (io_size
);
12593 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12596 /* Success, but no bytes, means end-of-file. */
12599 remote_hostio_error (remote_errno
);
12603 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12605 perror_with_name (local_file
);
12608 if (remote_hostio_close (fd
.release (), &remote_errno
))
12609 remote_hostio_error (remote_errno
);
12612 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12616 remote_file_delete (const char *remote_file
, int from_tty
)
12618 remote_target
*remote
= get_current_remote_target ();
12620 if (remote
== nullptr)
12621 error (_("command can only be used with remote target"));
12623 remote
->remote_file_delete (remote_file
, from_tty
);
12627 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12629 int retcode
, remote_errno
;
12631 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12633 remote_hostio_error (remote_errno
);
12636 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12640 remote_put_command (const char *args
, int from_tty
)
12643 error_no_arg (_("file to put"));
12645 gdb_argv
argv (args
);
12646 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12647 error (_("Invalid parameters to remote put"));
12649 remote_file_put (argv
[0], argv
[1], from_tty
);
12653 remote_get_command (const char *args
, int from_tty
)
12656 error_no_arg (_("file to get"));
12658 gdb_argv
argv (args
);
12659 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12660 error (_("Invalid parameters to remote get"));
12662 remote_file_get (argv
[0], argv
[1], from_tty
);
12666 remote_delete_command (const char *args
, int from_tty
)
12669 error_no_arg (_("file to delete"));
12671 gdb_argv
argv (args
);
12672 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12673 error (_("Invalid parameters to remote delete"));
12675 remote_file_delete (argv
[0], from_tty
);
12679 remote_command (const char *args
, int from_tty
)
12681 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12685 remote_target::can_execute_reverse ()
12687 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12688 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12695 remote_target::supports_non_stop ()
12701 remote_target::supports_disable_randomization ()
12703 /* Only supported in extended mode. */
12708 remote_target::supports_multi_process ()
12710 struct remote_state
*rs
= get_remote_state ();
12712 return remote_multi_process_p (rs
);
12716 remote_supports_cond_tracepoints ()
12718 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12722 remote_target::supports_evaluation_of_breakpoint_conditions ()
12724 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12728 remote_supports_fast_tracepoints ()
12730 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12734 remote_supports_static_tracepoints ()
12736 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12740 remote_supports_install_in_trace ()
12742 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12746 remote_target::supports_enable_disable_tracepoint ()
12748 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12753 remote_target::supports_string_tracing ()
12755 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12759 remote_target::can_run_breakpoint_commands ()
12761 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12765 remote_target::trace_init ()
12767 struct remote_state
*rs
= get_remote_state ();
12770 remote_get_noisy_reply ();
12771 if (strcmp (rs
->buf
.data (), "OK") != 0)
12772 error (_("Target does not support this command."));
12775 /* Recursive routine to walk through command list including loops, and
12776 download packets for each command. */
12779 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12780 struct command_line
*cmds
)
12782 struct remote_state
*rs
= get_remote_state ();
12783 struct command_line
*cmd
;
12785 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12787 QUIT
; /* Allow user to bail out with ^C. */
12788 strcpy (rs
->buf
.data (), "QTDPsrc:");
12789 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12790 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12791 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12793 remote_get_noisy_reply ();
12794 if (strcmp (rs
->buf
.data (), "OK"))
12795 warning (_("Target does not support source download."));
12797 if (cmd
->control_type
== while_control
12798 || cmd
->control_type
== while_stepping_control
)
12800 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12802 QUIT
; /* Allow user to bail out with ^C. */
12803 strcpy (rs
->buf
.data (), "QTDPsrc:");
12804 encode_source_string (num
, addr
, "cmd", "end",
12805 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12806 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12808 remote_get_noisy_reply ();
12809 if (strcmp (rs
->buf
.data (), "OK"))
12810 warning (_("Target does not support source download."));
12816 remote_target::download_tracepoint (struct bp_location
*loc
)
12820 std::vector
<std::string
> tdp_actions
;
12821 std::vector
<std::string
> stepping_actions
;
12823 struct breakpoint
*b
= loc
->owner
;
12824 struct tracepoint
*t
= (struct tracepoint
*) b
;
12825 struct remote_state
*rs
= get_remote_state ();
12827 const char *err_msg
= _("Tracepoint packet too large for target.");
12830 /* We use a buffer other than rs->buf because we'll build strings
12831 across multiple statements, and other statements in between could
12833 gdb::char_vector
buf (get_remote_packet_size ());
12835 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12837 tpaddr
= loc
->address
;
12838 sprintf_vma (addrbuf
, tpaddr
);
12839 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12840 b
->number
, addrbuf
, /* address */
12841 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12842 t
->step_count
, t
->pass_count
);
12844 if (ret
< 0 || ret
>= buf
.size ())
12845 error ("%s", err_msg
);
12847 /* Fast tracepoints are mostly handled by the target, but we can
12848 tell the target how big of an instruction block should be moved
12850 if (b
->type
== bp_fast_tracepoint
)
12852 /* Only test for support at download time; we may not know
12853 target capabilities at definition time. */
12854 if (remote_supports_fast_tracepoints ())
12856 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12859 size_left
= buf
.size () - strlen (buf
.data ());
12860 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12862 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12864 if (ret
< 0 || ret
>= size_left
)
12865 error ("%s", err_msg
);
12868 /* If it passed validation at definition but fails now,
12869 something is very wrong. */
12870 internal_error (__FILE__
, __LINE__
,
12871 _("Fast tracepoint not "
12872 "valid during download"));
12875 /* Fast tracepoints are functionally identical to regular
12876 tracepoints, so don't take lack of support as a reason to
12877 give up on the trace run. */
12878 warning (_("Target does not support fast tracepoints, "
12879 "downloading %d as regular tracepoint"), b
->number
);
12881 else if (b
->type
== bp_static_tracepoint
)
12883 /* Only test for support at download time; we may not know
12884 target capabilities at definition time. */
12885 if (remote_supports_static_tracepoints ())
12887 struct static_tracepoint_marker marker
;
12889 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12891 size_left
= buf
.size () - strlen (buf
.data ());
12892 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12895 if (ret
< 0 || ret
>= size_left
)
12896 error ("%s", err_msg
);
12899 error (_("Static tracepoint not valid during download"));
12902 /* Fast tracepoints are functionally identical to regular
12903 tracepoints, so don't take lack of support as a reason
12904 to give up on the trace run. */
12905 error (_("Target does not support static tracepoints"));
12907 /* If the tracepoint has a conditional, make it into an agent
12908 expression and append to the definition. */
12911 /* Only test support at download time, we may not know target
12912 capabilities at definition time. */
12913 if (remote_supports_cond_tracepoints ())
12915 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
12918 size_left
= buf
.size () - strlen (buf
.data ());
12920 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12921 size_left
, ":X%x,", aexpr
->len
);
12923 if (ret
< 0 || ret
>= size_left
)
12924 error ("%s", err_msg
);
12926 size_left
= buf
.size () - strlen (buf
.data ());
12928 /* Two bytes to encode each aexpr byte, plus the terminating
12930 if (aexpr
->len
* 2 + 1 > size_left
)
12931 error ("%s", err_msg
);
12933 pkt
= buf
.data () + strlen (buf
.data ());
12935 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12936 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12940 warning (_("Target does not support conditional tracepoints, "
12941 "ignoring tp %d cond"), b
->number
);
12944 if (b
->commands
|| *default_collect
)
12946 size_left
= buf
.size () - strlen (buf
.data ());
12948 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12951 if (ret
< 0 || ret
>= size_left
)
12952 error ("%s", err_msg
);
12955 putpkt (buf
.data ());
12956 remote_get_noisy_reply ();
12957 if (strcmp (rs
->buf
.data (), "OK"))
12958 error (_("Target does not support tracepoints."));
12960 /* do_single_steps (t); */
12961 for (auto action_it
= tdp_actions
.begin ();
12962 action_it
!= tdp_actions
.end (); action_it
++)
12964 QUIT
; /* Allow user to bail out with ^C. */
12966 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
12967 || !stepping_actions
.empty ());
12969 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
12970 b
->number
, addrbuf
, /* address */
12971 action_it
->c_str (),
12972 has_more
? '-' : 0);
12974 if (ret
< 0 || ret
>= buf
.size ())
12975 error ("%s", err_msg
);
12977 putpkt (buf
.data ());
12978 remote_get_noisy_reply ();
12979 if (strcmp (rs
->buf
.data (), "OK"))
12980 error (_("Error on target while setting tracepoints."));
12983 for (auto action_it
= stepping_actions
.begin ();
12984 action_it
!= stepping_actions
.end (); action_it
++)
12986 QUIT
; /* Allow user to bail out with ^C. */
12988 bool is_first
= action_it
== stepping_actions
.begin ();
12989 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
12991 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
12992 b
->number
, addrbuf
, /* address */
12993 is_first
? "S" : "",
12994 action_it
->c_str (),
12995 has_more
? "-" : "");
12997 if (ret
< 0 || ret
>= buf
.size ())
12998 error ("%s", err_msg
);
13000 putpkt (buf
.data ());
13001 remote_get_noisy_reply ();
13002 if (strcmp (rs
->buf
.data (), "OK"))
13003 error (_("Error on target while setting tracepoints."));
13006 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
13008 if (b
->location
!= NULL
)
13010 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13012 if (ret
< 0 || ret
>= buf
.size ())
13013 error ("%s", err_msg
);
13015 encode_source_string (b
->number
, loc
->address
, "at",
13016 event_location_to_string (b
->location
.get ()),
13017 buf
.data () + strlen (buf
.data ()),
13018 buf
.size () - strlen (buf
.data ()));
13019 putpkt (buf
.data ());
13020 remote_get_noisy_reply ();
13021 if (strcmp (rs
->buf
.data (), "OK"))
13022 warning (_("Target does not support source download."));
13024 if (b
->cond_string
)
13026 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13028 if (ret
< 0 || ret
>= buf
.size ())
13029 error ("%s", err_msg
);
13031 encode_source_string (b
->number
, loc
->address
,
13032 "cond", b
->cond_string
,
13033 buf
.data () + strlen (buf
.data ()),
13034 buf
.size () - strlen (buf
.data ()));
13035 putpkt (buf
.data ());
13036 remote_get_noisy_reply ();
13037 if (strcmp (rs
->buf
.data (), "OK"))
13038 warning (_("Target does not support source download."));
13040 remote_download_command_source (b
->number
, loc
->address
,
13041 breakpoint_commands (b
));
13046 remote_target::can_download_tracepoint ()
13048 struct remote_state
*rs
= get_remote_state ();
13049 struct trace_status
*ts
;
13052 /* Don't try to install tracepoints until we've relocated our
13053 symbols, and fetched and merged the target's tracepoint list with
13055 if (rs
->starting_up
)
13058 ts
= current_trace_status ();
13059 status
= get_trace_status (ts
);
13061 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
13064 /* If we are in a tracing experiment, but remote stub doesn't support
13065 installing tracepoint in trace, we have to return. */
13066 if (!remote_supports_install_in_trace ())
13074 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
13076 struct remote_state
*rs
= get_remote_state ();
13079 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13080 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13082 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13083 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13084 >= get_remote_packet_size ())
13085 error (_("Trace state variable name too long for tsv definition packet"));
13086 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13089 remote_get_noisy_reply ();
13090 if (rs
->buf
[0] == '\0')
13091 error (_("Target does not support this command."));
13092 if (strcmp (rs
->buf
.data (), "OK") != 0)
13093 error (_("Error on target while downloading trace state variable."));
13097 remote_target::enable_tracepoint (struct bp_location
*location
)
13099 struct remote_state
*rs
= get_remote_state ();
13102 sprintf_vma (addr_buf
, location
->address
);
13103 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13104 location
->owner
->number
, addr_buf
);
13106 remote_get_noisy_reply ();
13107 if (rs
->buf
[0] == '\0')
13108 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13109 if (strcmp (rs
->buf
.data (), "OK") != 0)
13110 error (_("Error on target while enabling tracepoint."));
13114 remote_target::disable_tracepoint (struct bp_location
*location
)
13116 struct remote_state
*rs
= get_remote_state ();
13119 sprintf_vma (addr_buf
, location
->address
);
13120 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13121 location
->owner
->number
, addr_buf
);
13123 remote_get_noisy_reply ();
13124 if (rs
->buf
[0] == '\0')
13125 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13126 if (strcmp (rs
->buf
.data (), "OK") != 0)
13127 error (_("Error on target while disabling tracepoint."));
13131 remote_target::trace_set_readonly_regions ()
13134 bfd_size_type size
;
13140 return; /* No information to give. */
13142 struct remote_state
*rs
= get_remote_state ();
13144 strcpy (rs
->buf
.data (), "QTro");
13145 offset
= strlen (rs
->buf
.data ());
13146 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
13148 char tmp1
[40], tmp2
[40];
13151 if ((s
->flags
& SEC_LOAD
) == 0 ||
13152 /* (s->flags & SEC_CODE) == 0 || */
13153 (s
->flags
& SEC_READONLY
) == 0)
13157 vma
= bfd_section_vma (s
);
13158 size
= bfd_section_size (s
);
13159 sprintf_vma (tmp1
, vma
);
13160 sprintf_vma (tmp2
, vma
+ size
);
13161 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13162 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13164 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13166 Too many sections for read-only sections definition packet."));
13169 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13171 offset
+= sec_length
;
13176 getpkt (&rs
->buf
, 0);
13181 remote_target::trace_start ()
13183 struct remote_state
*rs
= get_remote_state ();
13185 putpkt ("QTStart");
13186 remote_get_noisy_reply ();
13187 if (rs
->buf
[0] == '\0')
13188 error (_("Target does not support this command."));
13189 if (strcmp (rs
->buf
.data (), "OK") != 0)
13190 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13194 remote_target::get_trace_status (struct trace_status
*ts
)
13196 /* Initialize it just to avoid a GCC false warning. */
13198 enum packet_result result
;
13199 struct remote_state
*rs
= get_remote_state ();
13201 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13204 /* FIXME we need to get register block size some other way. */
13205 trace_regblock_size
13206 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13208 putpkt ("qTStatus");
13212 p
= remote_get_noisy_reply ();
13214 catch (const gdb_exception_error
&ex
)
13216 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13218 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13224 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13226 /* If the remote target doesn't do tracing, flag it. */
13227 if (result
== PACKET_UNKNOWN
)
13230 /* We're working with a live target. */
13231 ts
->filename
= NULL
;
13234 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13236 /* Function 'parse_trace_status' sets default value of each field of
13237 'ts' at first, so we don't have to do it here. */
13238 parse_trace_status (p
, ts
);
13240 return ts
->running
;
13244 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13245 struct uploaded_tp
*utp
)
13247 struct remote_state
*rs
= get_remote_state ();
13249 struct bp_location
*loc
;
13250 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13251 size_t size
= get_remote_packet_size ();
13256 tp
->traceframe_usage
= 0;
13257 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13259 /* If the tracepoint was never downloaded, don't go asking for
13261 if (tp
->number_on_target
== 0)
13263 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13264 phex_nz (loc
->address
, 0));
13266 reply
= remote_get_noisy_reply ();
13267 if (reply
&& *reply
)
13270 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13276 utp
->hit_count
= 0;
13277 utp
->traceframe_usage
= 0;
13278 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13279 phex_nz (utp
->addr
, 0));
13281 reply
= remote_get_noisy_reply ();
13282 if (reply
&& *reply
)
13285 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13291 remote_target::trace_stop ()
13293 struct remote_state
*rs
= get_remote_state ();
13296 remote_get_noisy_reply ();
13297 if (rs
->buf
[0] == '\0')
13298 error (_("Target does not support this command."));
13299 if (strcmp (rs
->buf
.data (), "OK") != 0)
13300 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13304 remote_target::trace_find (enum trace_find_type type
, int num
,
13305 CORE_ADDR addr1
, CORE_ADDR addr2
,
13308 struct remote_state
*rs
= get_remote_state ();
13309 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13311 int target_frameno
= -1, target_tracept
= -1;
13313 /* Lookups other than by absolute frame number depend on the current
13314 trace selected, so make sure it is correct on the remote end
13316 if (type
!= tfind_number
)
13317 set_remote_traceframe ();
13319 p
= rs
->buf
.data ();
13320 strcpy (p
, "QTFrame:");
13321 p
= strchr (p
, '\0');
13325 xsnprintf (p
, endbuf
- p
, "%x", num
);
13328 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13331 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13334 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13335 phex_nz (addr2
, 0));
13337 case tfind_outside
:
13338 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13339 phex_nz (addr2
, 0));
13342 error (_("Unknown trace find type %d"), type
);
13346 reply
= remote_get_noisy_reply ();
13347 if (*reply
== '\0')
13348 error (_("Target does not support this command."));
13350 while (reply
&& *reply
)
13355 target_frameno
= (int) strtol (p
, &reply
, 16);
13357 error (_("Unable to parse trace frame number"));
13358 /* Don't update our remote traceframe number cache on failure
13359 to select a remote traceframe. */
13360 if (target_frameno
== -1)
13365 target_tracept
= (int) strtol (p
, &reply
, 16);
13367 error (_("Unable to parse tracepoint number"));
13369 case 'O': /* "OK"? */
13370 if (reply
[1] == 'K' && reply
[2] == '\0')
13373 error (_("Bogus reply from target: %s"), reply
);
13376 error (_("Bogus reply from target: %s"), reply
);
13379 *tpp
= target_tracept
;
13381 rs
->remote_traceframe_number
= target_frameno
;
13382 return target_frameno
;
13386 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13388 struct remote_state
*rs
= get_remote_state ();
13392 set_remote_traceframe ();
13394 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13396 reply
= remote_get_noisy_reply ();
13397 if (reply
&& *reply
)
13401 unpack_varlen_hex (reply
+ 1, &uval
);
13402 *val
= (LONGEST
) uval
;
13410 remote_target::save_trace_data (const char *filename
)
13412 struct remote_state
*rs
= get_remote_state ();
13415 p
= rs
->buf
.data ();
13416 strcpy (p
, "QTSave:");
13418 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13419 >= get_remote_packet_size ())
13420 error (_("Remote file name too long for trace save packet"));
13421 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13424 reply
= remote_get_noisy_reply ();
13425 if (*reply
== '\0')
13426 error (_("Target does not support this command."));
13427 if (strcmp (reply
, "OK") != 0)
13428 error (_("Bogus reply from target: %s"), reply
);
13432 /* This is basically a memory transfer, but needs to be its own packet
13433 because we don't know how the target actually organizes its trace
13434 memory, plus we want to be able to ask for as much as possible, but
13435 not be unhappy if we don't get as much as we ask for. */
13438 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13440 struct remote_state
*rs
= get_remote_state ();
13445 p
= rs
->buf
.data ();
13446 strcpy (p
, "qTBuffer:");
13448 p
+= hexnumstr (p
, offset
);
13450 p
+= hexnumstr (p
, len
);
13454 reply
= remote_get_noisy_reply ();
13455 if (reply
&& *reply
)
13457 /* 'l' by itself means we're at the end of the buffer and
13458 there is nothing more to get. */
13462 /* Convert the reply into binary. Limit the number of bytes to
13463 convert according to our passed-in buffer size, rather than
13464 what was returned in the packet; if the target is
13465 unexpectedly generous and gives us a bigger reply than we
13466 asked for, we don't want to crash. */
13467 rslt
= hex2bin (reply
, buf
, len
);
13471 /* Something went wrong, flag as an error. */
13476 remote_target::set_disconnected_tracing (int val
)
13478 struct remote_state
*rs
= get_remote_state ();
13480 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13484 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13485 "QTDisconnected:%x", val
);
13487 reply
= remote_get_noisy_reply ();
13488 if (*reply
== '\0')
13489 error (_("Target does not support this command."));
13490 if (strcmp (reply
, "OK") != 0)
13491 error (_("Bogus reply from target: %s"), reply
);
13494 warning (_("Target does not support disconnected tracing."));
13498 remote_target::core_of_thread (ptid_t ptid
)
13500 thread_info
*info
= find_thread_ptid (this, ptid
);
13502 if (info
!= NULL
&& info
->priv
!= NULL
)
13503 return get_remote_thread_info (info
)->core
;
13509 remote_target::set_circular_trace_buffer (int val
)
13511 struct remote_state
*rs
= get_remote_state ();
13514 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13515 "QTBuffer:circular:%x", val
);
13517 reply
= remote_get_noisy_reply ();
13518 if (*reply
== '\0')
13519 error (_("Target does not support this command."));
13520 if (strcmp (reply
, "OK") != 0)
13521 error (_("Bogus reply from target: %s"), reply
);
13525 remote_target::traceframe_info ()
13527 gdb::optional
<gdb::char_vector
> text
13528 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13531 return parse_traceframe_info (text
->data ());
13536 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13537 instruction on which a fast tracepoint may be placed. Returns -1
13538 if the packet is not supported, and 0 if the minimum instruction
13539 length is unknown. */
13542 remote_target::get_min_fast_tracepoint_insn_len ()
13544 struct remote_state
*rs
= get_remote_state ();
13547 /* If we're not debugging a process yet, the IPA can't be
13549 if (!target_has_execution
)
13552 /* Make sure the remote is pointing at the right process. */
13553 set_general_process ();
13555 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13557 reply
= remote_get_noisy_reply ();
13558 if (*reply
== '\0')
13562 ULONGEST min_insn_len
;
13564 unpack_varlen_hex (reply
, &min_insn_len
);
13566 return (int) min_insn_len
;
13571 remote_target::set_trace_buffer_size (LONGEST val
)
13573 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13575 struct remote_state
*rs
= get_remote_state ();
13576 char *buf
= rs
->buf
.data ();
13577 char *endbuf
= buf
+ get_remote_packet_size ();
13578 enum packet_result result
;
13580 gdb_assert (val
>= 0 || val
== -1);
13581 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13582 /* Send -1 as literal "-1" to avoid host size dependency. */
13586 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13589 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13592 remote_get_noisy_reply ();
13593 result
= packet_ok (rs
->buf
,
13594 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13596 if (result
!= PACKET_OK
)
13597 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13602 remote_target::set_trace_notes (const char *user
, const char *notes
,
13603 const char *stop_notes
)
13605 struct remote_state
*rs
= get_remote_state ();
13607 char *buf
= rs
->buf
.data ();
13608 char *endbuf
= buf
+ get_remote_packet_size ();
13611 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13614 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13615 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13621 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13622 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13628 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13629 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13633 /* Ensure the buffer is terminated. */
13637 reply
= remote_get_noisy_reply ();
13638 if (*reply
== '\0')
13641 if (strcmp (reply
, "OK") != 0)
13642 error (_("Bogus reply from target: %s"), reply
);
13648 remote_target::use_agent (bool use
)
13650 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13652 struct remote_state
*rs
= get_remote_state ();
13654 /* If the stub supports QAgent. */
13655 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13657 getpkt (&rs
->buf
, 0);
13659 if (strcmp (rs
->buf
.data (), "OK") == 0)
13670 remote_target::can_use_agent ()
13672 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13675 struct btrace_target_info
13677 /* The ptid of the traced thread. */
13680 /* The obtained branch trace configuration. */
13681 struct btrace_config conf
;
13684 /* Reset our idea of our target's btrace configuration. */
13687 remote_btrace_reset (remote_state
*rs
)
13689 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13692 /* Synchronize the configuration with the target. */
13695 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13697 struct packet_config
*packet
;
13698 struct remote_state
*rs
;
13699 char *buf
, *pos
, *endbuf
;
13701 rs
= get_remote_state ();
13702 buf
= rs
->buf
.data ();
13703 endbuf
= buf
+ get_remote_packet_size ();
13705 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13706 if (packet_config_support (packet
) == PACKET_ENABLE
13707 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13710 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13714 getpkt (&rs
->buf
, 0);
13716 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13718 if (buf
[0] == 'E' && buf
[1] == '.')
13719 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13721 error (_("Failed to configure the BTS buffer size."));
13724 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13727 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13728 if (packet_config_support (packet
) == PACKET_ENABLE
13729 && conf
->pt
.size
!= rs
->btrace_config
.pt
.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 trace buffer size: %s"), buf
+ 2);
13743 error (_("Failed to configure the trace buffer size."));
13746 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13750 /* Read the current thread's btrace configuration from the target and
13751 store it into CONF. */
13754 btrace_read_config (struct btrace_config
*conf
)
13756 gdb::optional
<gdb::char_vector
> xml
13757 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13759 parse_xml_btrace_conf (conf
, xml
->data ());
13762 /* Maybe reopen target btrace. */
13765 remote_target::remote_btrace_maybe_reopen ()
13767 struct remote_state
*rs
= get_remote_state ();
13768 int btrace_target_pushed
= 0;
13769 #if !defined (HAVE_LIBIPT)
13773 /* Don't bother walking the entirety of the remote thread list when
13774 we know the feature isn't supported by the remote. */
13775 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13778 scoped_restore_current_thread restore_thread
;
13780 for (thread_info
*tp
: all_non_exited_threads (this))
13782 set_general_thread (tp
->ptid
);
13784 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13785 btrace_read_config (&rs
->btrace_config
);
13787 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13790 #if !defined (HAVE_LIBIPT)
13791 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13796 warning (_("Target is recording using Intel Processor Trace "
13797 "but support was disabled at compile time."));
13802 #endif /* !defined (HAVE_LIBIPT) */
13804 /* Push target, once, but before anything else happens. This way our
13805 changes to the threads will be cleaned up by unpushing the target
13806 in case btrace_read_config () throws. */
13807 if (!btrace_target_pushed
)
13809 btrace_target_pushed
= 1;
13810 record_btrace_push_target ();
13811 printf_filtered (_("Target is recording using %s.\n"),
13812 btrace_format_string (rs
->btrace_config
.format
));
13815 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13816 tp
->btrace
.target
->ptid
= tp
->ptid
;
13817 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13821 /* Enable branch tracing. */
13823 struct btrace_target_info
*
13824 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13826 struct btrace_target_info
*tinfo
= NULL
;
13827 struct packet_config
*packet
= NULL
;
13828 struct remote_state
*rs
= get_remote_state ();
13829 char *buf
= rs
->buf
.data ();
13830 char *endbuf
= buf
+ get_remote_packet_size ();
13832 switch (conf
->format
)
13834 case BTRACE_FORMAT_BTS
:
13835 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13838 case BTRACE_FORMAT_PT
:
13839 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13843 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13844 error (_("Target does not support branch tracing."));
13846 btrace_sync_conf (conf
);
13848 set_general_thread (ptid
);
13850 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13852 getpkt (&rs
->buf
, 0);
13854 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13856 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13857 error (_("Could not enable branch tracing for %s: %s"),
13858 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
13860 error (_("Could not enable branch tracing for %s."),
13861 target_pid_to_str (ptid
).c_str ());
13864 tinfo
= XCNEW (struct btrace_target_info
);
13865 tinfo
->ptid
= ptid
;
13867 /* If we fail to read the configuration, we lose some information, but the
13868 tracing itself is not impacted. */
13871 btrace_read_config (&tinfo
->conf
);
13873 catch (const gdb_exception_error
&err
)
13875 if (err
.message
!= NULL
)
13876 warning ("%s", err
.what ());
13882 /* Disable branch tracing. */
13885 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
13887 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13888 struct remote_state
*rs
= get_remote_state ();
13889 char *buf
= rs
->buf
.data ();
13890 char *endbuf
= buf
+ get_remote_packet_size ();
13892 if (packet_config_support (packet
) != PACKET_ENABLE
)
13893 error (_("Target does not support branch tracing."));
13895 set_general_thread (tinfo
->ptid
);
13897 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13899 getpkt (&rs
->buf
, 0);
13901 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13903 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13904 error (_("Could not disable branch tracing for %s: %s"),
13905 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
13907 error (_("Could not disable branch tracing for %s."),
13908 target_pid_to_str (tinfo
->ptid
).c_str ());
13914 /* Teardown branch tracing. */
13917 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
13919 /* We must not talk to the target during teardown. */
13923 /* Read the branch trace. */
13926 remote_target::read_btrace (struct btrace_data
*btrace
,
13927 struct btrace_target_info
*tinfo
,
13928 enum btrace_read_type type
)
13930 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13933 if (packet_config_support (packet
) != PACKET_ENABLE
)
13934 error (_("Target does not support branch tracing."));
13936 #if !defined(HAVE_LIBEXPAT)
13937 error (_("Cannot process branch tracing result. XML parsing not supported."));
13942 case BTRACE_READ_ALL
:
13945 case BTRACE_READ_NEW
:
13948 case BTRACE_READ_DELTA
:
13952 internal_error (__FILE__
, __LINE__
,
13953 _("Bad branch tracing read type: %u."),
13954 (unsigned int) type
);
13957 gdb::optional
<gdb::char_vector
> xml
13958 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
13960 return BTRACE_ERR_UNKNOWN
;
13962 parse_xml_btrace (btrace
, xml
->data ());
13964 return BTRACE_ERR_NONE
;
13967 const struct btrace_config
*
13968 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
13970 return &tinfo
->conf
;
13974 remote_target::augmented_libraries_svr4_read ()
13976 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13980 /* Implementation of to_load. */
13983 remote_target::load (const char *name
, int from_tty
)
13985 generic_load (name
, from_tty
);
13988 /* Accepts an integer PID; returns a string representing a file that
13989 can be opened on the remote side to get the symbols for the child
13990 process. Returns NULL if the operation is not supported. */
13993 remote_target::pid_to_exec_file (int pid
)
13995 static gdb::optional
<gdb::char_vector
> filename
;
13996 char *annex
= NULL
;
13998 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
14001 inferior
*inf
= find_inferior_pid (this, pid
);
14003 internal_error (__FILE__
, __LINE__
,
14004 _("not currently attached to process %d"), pid
);
14006 if (!inf
->fake_pid_p
)
14008 const int annex_size
= 9;
14010 annex
= (char *) alloca (annex_size
);
14011 xsnprintf (annex
, annex_size
, "%x", pid
);
14014 filename
= target_read_stralloc (current_top_target (),
14015 TARGET_OBJECT_EXEC_FILE
, annex
);
14017 return filename
? filename
->data () : nullptr;
14020 /* Implement the to_can_do_single_step target_ops method. */
14023 remote_target::can_do_single_step ()
14025 /* We can only tell whether target supports single step or not by
14026 supported s and S vCont actions if the stub supports vContSupported
14027 feature. If the stub doesn't support vContSupported feature,
14028 we have conservatively to think target doesn't supports single
14030 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
14032 struct remote_state
*rs
= get_remote_state ();
14034 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14035 remote_vcont_probe ();
14037 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
14043 /* Implementation of the to_execution_direction method for the remote
14046 enum exec_direction_kind
14047 remote_target::execution_direction ()
14049 struct remote_state
*rs
= get_remote_state ();
14051 return rs
->last_resume_exec_dir
;
14054 /* Return pointer to the thread_info struct which corresponds to
14055 THREAD_HANDLE (having length HANDLE_LEN). */
14058 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
14062 for (thread_info
*tp
: all_non_exited_threads (this))
14064 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14066 if (tp
->inf
== inf
&& priv
!= NULL
)
14068 if (handle_len
!= priv
->thread_handle
.size ())
14069 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14070 handle_len
, priv
->thread_handle
.size ());
14071 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14081 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
14083 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14084 return priv
->thread_handle
;
14088 remote_target::can_async_p ()
14090 struct remote_state
*rs
= get_remote_state ();
14092 /* We don't go async if the user has explicitly prevented it with the
14093 "maint set target-async" command. */
14094 if (!target_async_permitted
)
14097 /* We're async whenever the serial device is. */
14098 return serial_can_async_p (rs
->remote_desc
);
14102 remote_target::is_async_p ()
14104 struct remote_state
*rs
= get_remote_state ();
14106 if (!target_async_permitted
)
14107 /* We only enable async when the user specifically asks for it. */
14110 /* We're async whenever the serial device is. */
14111 return serial_is_async_p (rs
->remote_desc
);
14114 /* Pass the SERIAL event on and up to the client. One day this code
14115 will be able to delay notifying the client of an event until the
14116 point where an entire packet has been received. */
14118 static serial_event_ftype remote_async_serial_handler
;
14121 remote_async_serial_handler (struct serial
*scb
, void *context
)
14123 /* Don't propogate error information up to the client. Instead let
14124 the client find out about the error by querying the target. */
14125 inferior_event_handler (INF_REG_EVENT
, NULL
);
14129 remote_async_inferior_event_handler (gdb_client_data data
)
14131 inferior_event_handler (INF_REG_EVENT
, data
);
14135 remote_target::async_wait_fd ()
14137 struct remote_state
*rs
= get_remote_state ();
14138 return rs
->remote_desc
->fd
;
14142 remote_target::async (int enable
)
14144 struct remote_state
*rs
= get_remote_state ();
14148 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14150 /* If there are pending events in the stop reply queue tell the
14151 event loop to process them. */
14152 if (!rs
->stop_reply_queue
.empty ())
14153 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14154 /* For simplicity, below we clear the pending events token
14155 without remembering whether it is marked, so here we always
14156 mark it. If there's actually no pending notification to
14157 process, this ends up being a no-op (other than a spurious
14158 event-loop wakeup). */
14159 if (target_is_non_stop_p ())
14160 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14164 serial_async (rs
->remote_desc
, NULL
, NULL
);
14165 /* If the core is disabling async, it doesn't want to be
14166 disturbed with target events. Clear all async event sources
14168 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14169 if (target_is_non_stop_p ())
14170 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14174 /* Implementation of the to_thread_events method. */
14177 remote_target::thread_events (int enable
)
14179 struct remote_state
*rs
= get_remote_state ();
14180 size_t size
= get_remote_packet_size ();
14182 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14185 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14187 getpkt (&rs
->buf
, 0);
14189 switch (packet_ok (rs
->buf
,
14190 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14193 if (strcmp (rs
->buf
.data (), "OK") != 0)
14194 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14197 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14199 case PACKET_UNKNOWN
:
14205 set_remote_cmd (const char *args
, int from_tty
)
14207 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
14211 show_remote_cmd (const char *args
, int from_tty
)
14213 /* We can't just use cmd_show_list here, because we want to skip
14214 the redundant "show remote Z-packet" and the legacy aliases. */
14215 struct cmd_list_element
*list
= remote_show_cmdlist
;
14216 struct ui_out
*uiout
= current_uiout
;
14218 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14219 for (; list
!= NULL
; list
= list
->next
)
14220 if (strcmp (list
->name
, "Z-packet") == 0)
14222 else if (list
->type
== not_set_cmd
)
14223 /* Alias commands are exactly like the original, except they
14224 don't have the normal type. */
14228 ui_out_emit_tuple
option_emitter (uiout
, "option");
14230 uiout
->field_string ("name", list
->name
);
14231 uiout
->text (": ");
14232 if (list
->type
== show_cmd
)
14233 do_show_command (NULL
, from_tty
, list
);
14235 cmd_func (list
, NULL
, from_tty
);
14240 /* Function to be called whenever a new objfile (shlib) is detected. */
14242 remote_new_objfile (struct objfile
*objfile
)
14244 remote_target
*remote
= get_current_remote_target ();
14246 if (remote
!= NULL
) /* Have a remote connection. */
14247 remote
->remote_check_symbols ();
14250 /* Pull all the tracepoints defined on the target and create local
14251 data structures representing them. We don't want to create real
14252 tracepoints yet, we don't want to mess up the user's existing
14256 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14258 struct remote_state
*rs
= get_remote_state ();
14261 /* Ask for a first packet of tracepoint definition. */
14263 getpkt (&rs
->buf
, 0);
14264 p
= rs
->buf
.data ();
14265 while (*p
&& *p
!= 'l')
14267 parse_tracepoint_definition (p
, utpp
);
14268 /* Ask for another packet of tracepoint definition. */
14270 getpkt (&rs
->buf
, 0);
14271 p
= rs
->buf
.data ();
14277 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14279 struct remote_state
*rs
= get_remote_state ();
14282 /* Ask for a first packet of variable definition. */
14284 getpkt (&rs
->buf
, 0);
14285 p
= rs
->buf
.data ();
14286 while (*p
&& *p
!= 'l')
14288 parse_tsv_definition (p
, utsvp
);
14289 /* Ask for another packet of variable definition. */
14291 getpkt (&rs
->buf
, 0);
14292 p
= rs
->buf
.data ();
14297 /* The "set/show range-stepping" show hook. */
14300 show_range_stepping (struct ui_file
*file
, int from_tty
,
14301 struct cmd_list_element
*c
,
14304 fprintf_filtered (file
,
14305 _("Debugger's willingness to use range stepping "
14306 "is %s.\n"), value
);
14309 /* Return true if the vCont;r action is supported by the remote
14313 remote_target::vcont_r_supported ()
14315 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14316 remote_vcont_probe ();
14318 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14319 && get_remote_state ()->supports_vCont
.r
);
14322 /* The "set/show range-stepping" set hook. */
14325 set_range_stepping (const char *ignore_args
, int from_tty
,
14326 struct cmd_list_element
*c
)
14328 /* When enabling, check whether range stepping is actually supported
14329 by the target, and warn if not. */
14330 if (use_range_stepping
)
14332 remote_target
*remote
= get_current_remote_target ();
14334 || !remote
->vcont_r_supported ())
14335 warning (_("Range stepping is not supported by the current target"));
14339 void _initialize_remote ();
14341 _initialize_remote ()
14343 struct cmd_list_element
*cmd
;
14344 const char *cmd_name
;
14346 /* architecture specific data */
14347 remote_g_packet_data_handle
=
14348 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14350 add_target (remote_target_info
, remote_target::open
);
14351 add_target (extended_remote_target_info
, extended_remote_target::open
);
14353 /* Hook into new objfile notification. */
14354 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14357 init_remote_threadtests ();
14360 /* set/show remote ... */
14362 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14363 Remote protocol specific variables.\n\
14364 Configure various remote-protocol specific variables such as\n\
14365 the packets being used."),
14366 &remote_set_cmdlist
, "set remote ",
14367 0 /* allow-unknown */, &setlist
);
14368 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14369 Remote protocol specific variables.\n\
14370 Configure various remote-protocol specific variables such as\n\
14371 the packets being used."),
14372 &remote_show_cmdlist
, "show remote ",
14373 0 /* allow-unknown */, &showlist
);
14375 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14376 Compare section data on target to the exec file.\n\
14377 Argument is a single section name (default: all loaded sections).\n\
14378 To compare only read-only loaded sections, specify the -r option."),
14381 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14382 Send an arbitrary packet to a remote target.\n\
14383 maintenance packet TEXT\n\
14384 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14385 this command sends the string TEXT to the inferior, and displays the\n\
14386 response packet. GDB supplies the initial `$' character, and the\n\
14387 terminating `#' character and checksum."),
14390 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14391 Set whether to send break if interrupted."), _("\
14392 Show whether to send break if interrupted."), _("\
14393 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14394 set_remotebreak
, show_remotebreak
,
14395 &setlist
, &showlist
);
14396 cmd_name
= "remotebreak";
14397 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14398 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14399 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14400 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14401 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14403 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14404 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14406 Set interrupt sequence to remote target."), _("\
14407 Show interrupt sequence to remote target."), _("\
14408 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14409 NULL
, show_interrupt_sequence
,
14410 &remote_set_cmdlist
,
14411 &remote_show_cmdlist
);
14413 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14414 &interrupt_on_connect
, _("\
14415 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14416 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14417 If set, interrupt sequence is sent to remote target."),
14419 &remote_set_cmdlist
, &remote_show_cmdlist
);
14421 /* Install commands for configuring memory read/write packets. */
14423 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14424 Set the maximum number of bytes per memory write packet (deprecated)."),
14426 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14427 Show the maximum number of bytes per memory write packet (deprecated)."),
14429 add_cmd ("memory-write-packet-size", no_class
,
14430 set_memory_write_packet_size
, _("\
14431 Set the maximum number of bytes per memory-write packet.\n\
14432 Specify the number of bytes in a packet or 0 (zero) for the\n\
14433 default packet size. The actual limit is further reduced\n\
14434 dependent on the target. Specify ``fixed'' to disable the\n\
14435 further restriction and ``limit'' to enable that restriction."),
14436 &remote_set_cmdlist
);
14437 add_cmd ("memory-read-packet-size", no_class
,
14438 set_memory_read_packet_size
, _("\
14439 Set the maximum number of bytes per memory-read packet.\n\
14440 Specify the number of bytes in a packet or 0 (zero) for the\n\
14441 default packet size. The actual limit is further reduced\n\
14442 dependent on the target. Specify ``fixed'' to disable the\n\
14443 further restriction and ``limit'' to enable that restriction."),
14444 &remote_set_cmdlist
);
14445 add_cmd ("memory-write-packet-size", no_class
,
14446 show_memory_write_packet_size
,
14447 _("Show the maximum number of bytes per memory-write packet."),
14448 &remote_show_cmdlist
);
14449 add_cmd ("memory-read-packet-size", no_class
,
14450 show_memory_read_packet_size
,
14451 _("Show the maximum number of bytes per memory-read packet."),
14452 &remote_show_cmdlist
);
14454 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14455 &remote_hw_watchpoint_limit
, _("\
14456 Set the maximum number of target hardware watchpoints."), _("\
14457 Show the maximum number of target hardware watchpoints."), _("\
14458 Specify \"unlimited\" for unlimited hardware watchpoints."),
14459 NULL
, show_hardware_watchpoint_limit
,
14460 &remote_set_cmdlist
,
14461 &remote_show_cmdlist
);
14462 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14464 &remote_hw_watchpoint_length_limit
, _("\
14465 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14466 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14467 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14468 NULL
, show_hardware_watchpoint_length_limit
,
14469 &remote_set_cmdlist
, &remote_show_cmdlist
);
14470 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14471 &remote_hw_breakpoint_limit
, _("\
14472 Set the maximum number of target hardware breakpoints."), _("\
14473 Show the maximum number of target hardware breakpoints."), _("\
14474 Specify \"unlimited\" for unlimited hardware breakpoints."),
14475 NULL
, show_hardware_breakpoint_limit
,
14476 &remote_set_cmdlist
, &remote_show_cmdlist
);
14478 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14479 &remote_address_size
, _("\
14480 Set the maximum size of the address (in bits) in a memory packet."), _("\
14481 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14483 NULL
, /* FIXME: i18n: */
14484 &setlist
, &showlist
);
14486 init_all_packet_configs ();
14488 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14489 "X", "binary-download", 1);
14491 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14492 "vCont", "verbose-resume", 0);
14494 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14495 "QPassSignals", "pass-signals", 0);
14497 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14498 "QCatchSyscalls", "catch-syscalls", 0);
14500 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14501 "QProgramSignals", "program-signals", 0);
14503 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14504 "QSetWorkingDir", "set-working-dir", 0);
14506 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14507 "QStartupWithShell", "startup-with-shell", 0);
14509 add_packet_config_cmd (&remote_protocol_packets
14510 [PACKET_QEnvironmentHexEncoded
],
14511 "QEnvironmentHexEncoded", "environment-hex-encoded",
14514 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14515 "QEnvironmentReset", "environment-reset",
14518 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14519 "QEnvironmentUnset", "environment-unset",
14522 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14523 "qSymbol", "symbol-lookup", 0);
14525 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14526 "P", "set-register", 1);
14528 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14529 "p", "fetch-register", 1);
14531 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14532 "Z0", "software-breakpoint", 0);
14534 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14535 "Z1", "hardware-breakpoint", 0);
14537 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14538 "Z2", "write-watchpoint", 0);
14540 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14541 "Z3", "read-watchpoint", 0);
14543 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14544 "Z4", "access-watchpoint", 0);
14546 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14547 "qXfer:auxv:read", "read-aux-vector", 0);
14549 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14550 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14552 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14553 "qXfer:features:read", "target-features", 0);
14555 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14556 "qXfer:libraries:read", "library-info", 0);
14558 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14559 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14561 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14562 "qXfer:memory-map:read", "memory-map", 0);
14564 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14565 "qXfer:osdata:read", "osdata", 0);
14567 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14568 "qXfer:threads:read", "threads", 0);
14570 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14571 "qXfer:siginfo:read", "read-siginfo-object", 0);
14573 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14574 "qXfer:siginfo:write", "write-siginfo-object", 0);
14576 add_packet_config_cmd
14577 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14578 "qXfer:traceframe-info:read", "traceframe-info", 0);
14580 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14581 "qXfer:uib:read", "unwind-info-block", 0);
14583 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14584 "qGetTLSAddr", "get-thread-local-storage-address",
14587 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14588 "qGetTIBAddr", "get-thread-information-block-address",
14591 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14592 "bc", "reverse-continue", 0);
14594 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14595 "bs", "reverse-step", 0);
14597 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14598 "qSupported", "supported-packets", 0);
14600 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14601 "qSearch:memory", "search-memory", 0);
14603 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14604 "qTStatus", "trace-status", 0);
14606 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14607 "vFile:setfs", "hostio-setfs", 0);
14609 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14610 "vFile:open", "hostio-open", 0);
14612 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14613 "vFile:pread", "hostio-pread", 0);
14615 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14616 "vFile:pwrite", "hostio-pwrite", 0);
14618 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14619 "vFile:close", "hostio-close", 0);
14621 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14622 "vFile:unlink", "hostio-unlink", 0);
14624 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14625 "vFile:readlink", "hostio-readlink", 0);
14627 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14628 "vFile:fstat", "hostio-fstat", 0);
14630 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14631 "vAttach", "attach", 0);
14633 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14636 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14637 "QStartNoAckMode", "noack", 0);
14639 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14640 "vKill", "kill", 0);
14642 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14643 "qAttached", "query-attached", 0);
14645 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14646 "ConditionalTracepoints",
14647 "conditional-tracepoints", 0);
14649 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14650 "ConditionalBreakpoints",
14651 "conditional-breakpoints", 0);
14653 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14654 "BreakpointCommands",
14655 "breakpoint-commands", 0);
14657 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14658 "FastTracepoints", "fast-tracepoints", 0);
14660 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14661 "TracepointSource", "TracepointSource", 0);
14663 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14664 "QAllow", "allow", 0);
14666 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14667 "StaticTracepoints", "static-tracepoints", 0);
14669 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14670 "InstallInTrace", "install-in-trace", 0);
14672 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14673 "qXfer:statictrace:read", "read-sdata-object", 0);
14675 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14676 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14678 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14679 "QDisableRandomization", "disable-randomization", 0);
14681 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14682 "QAgent", "agent", 0);
14684 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14685 "QTBuffer:size", "trace-buffer-size", 0);
14687 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14688 "Qbtrace:off", "disable-btrace", 0);
14690 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14691 "Qbtrace:bts", "enable-btrace-bts", 0);
14693 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14694 "Qbtrace:pt", "enable-btrace-pt", 0);
14696 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14697 "qXfer:btrace", "read-btrace", 0);
14699 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14700 "qXfer:btrace-conf", "read-btrace-conf", 0);
14702 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14703 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14705 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14706 "multiprocess-feature", "multiprocess-feature", 0);
14708 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14709 "swbreak-feature", "swbreak-feature", 0);
14711 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14712 "hwbreak-feature", "hwbreak-feature", 0);
14714 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14715 "fork-event-feature", "fork-event-feature", 0);
14717 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14718 "vfork-event-feature", "vfork-event-feature", 0);
14720 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14721 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14723 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14724 "vContSupported", "verbose-resume-supported", 0);
14726 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14727 "exec-event-feature", "exec-event-feature", 0);
14729 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14730 "vCtrlC", "ctrl-c", 0);
14732 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14733 "QThreadEvents", "thread-events", 0);
14735 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14736 "N stop reply", "no-resumed-stop-reply", 0);
14738 /* Assert that we've registered "set remote foo-packet" commands
14739 for all packet configs. */
14743 for (i
= 0; i
< PACKET_MAX
; i
++)
14745 /* Ideally all configs would have a command associated. Some
14746 still don't though. */
14751 case PACKET_QNonStop
:
14752 case PACKET_EnableDisableTracepoints_feature
:
14753 case PACKET_tracenz_feature
:
14754 case PACKET_DisconnectedTracing_feature
:
14755 case PACKET_augmented_libraries_svr4_read_feature
:
14757 /* Additions to this list need to be well justified:
14758 pre-existing packets are OK; new packets are not. */
14766 /* This catches both forgetting to add a config command, and
14767 forgetting to remove a packet from the exception list. */
14768 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14772 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14773 Z sub-packet has its own set and show commands, but users may
14774 have sets to this variable in their .gdbinit files (or in their
14776 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14777 &remote_Z_packet_detect
, _("\
14778 Set use of remote protocol `Z' packets."), _("\
14779 Show use of remote protocol `Z' packets."), _("\
14780 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14782 set_remote_protocol_Z_packet_cmd
,
14783 show_remote_protocol_Z_packet_cmd
,
14784 /* FIXME: i18n: Use of remote protocol
14785 `Z' packets is %s. */
14786 &remote_set_cmdlist
, &remote_show_cmdlist
);
14788 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14789 Manipulate files on the remote system.\n\
14790 Transfer files to and from the remote target system."),
14791 &remote_cmdlist
, "remote ",
14792 0 /* allow-unknown */, &cmdlist
);
14794 add_cmd ("put", class_files
, remote_put_command
,
14795 _("Copy a local file to the remote system."),
14798 add_cmd ("get", class_files
, remote_get_command
,
14799 _("Copy a remote file to the local system."),
14802 add_cmd ("delete", class_files
, remote_delete_command
,
14803 _("Delete a remote file."),
14806 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14807 &remote_exec_file_var
, _("\
14808 Set the remote pathname for \"run\"."), _("\
14809 Show the remote pathname for \"run\"."), NULL
,
14810 set_remote_exec_file
,
14811 show_remote_exec_file
,
14812 &remote_set_cmdlist
,
14813 &remote_show_cmdlist
);
14815 add_setshow_boolean_cmd ("range-stepping", class_run
,
14816 &use_range_stepping
, _("\
14817 Enable or disable range stepping."), _("\
14818 Show whether target-assisted range stepping is enabled."), _("\
14819 If on, and the target supports it, when stepping a source line, GDB\n\
14820 tells the target to step the corresponding range of addresses itself instead\n\
14821 of issuing multiple single-steps. This speeds up source level\n\
14822 stepping. If off, GDB always issues single-steps, even if range\n\
14823 stepping is supported by the target. The default is on."),
14824 set_range_stepping
,
14825 show_range_stepping
,
14829 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
14830 Set watchdog timer."), _("\
14831 Show watchdog timer."), _("\
14832 When non-zero, this timeout is used instead of waiting forever for a target\n\
14833 to finish a low-level step or continue operation. If the specified amount\n\
14834 of time passes without a response from the target, an error occurs."),
14837 &setlist
, &showlist
);
14839 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
14840 &remote_packet_max_chars
, _("\
14841 Set the maximum number of characters to display for each remote packet."), _("\
14842 Show the maximum number of characters to display for each remote packet."), _("\
14843 Specify \"unlimited\" to display all the characters."),
14844 NULL
, show_remote_packet_max_chars
,
14845 &setdebuglist
, &showdebuglist
);
14847 /* Eventually initialize fileio. See fileio.c */
14848 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);