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);
2417 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2418 static remote_thread_info
*get_remote_thread_info (remote_target
*target
,
2421 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2422 according to RUNNING. */
2425 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
)
2427 struct remote_state
*rs
= get_remote_state ();
2428 struct thread_info
*thread
;
2430 /* GDB historically didn't pull threads in the initial connection
2431 setup. If the remote target doesn't even have a concept of
2432 threads (e.g., a bare-metal target), even if internally we
2433 consider that a single-threaded target, mentioning a new thread
2434 might be confusing to the user. Be silent then, preserving the
2435 age old behavior. */
2436 if (rs
->starting_up
)
2437 thread
= add_thread_silent (this, ptid
);
2439 thread
= add_thread (this, ptid
);
2441 get_remote_thread_info (thread
)->vcont_resumed
= executing
;
2442 set_executing (this, ptid
, executing
);
2443 set_running (this, ptid
, running
);
2448 /* Come here when we learn about a thread id from the remote target.
2449 It may be the first time we hear about such thread, so take the
2450 opportunity to add it to GDB's thread list. In case this is the
2451 first time we're noticing its corresponding inferior, add it to
2452 GDB's inferior list as well. EXECUTING indicates whether the
2453 thread is (internally) executing or stopped. */
2456 remote_target::remote_notice_new_inferior (ptid_t currthread
, int executing
)
2458 /* In non-stop mode, we assume new found threads are (externally)
2459 running until proven otherwise with a stop reply. In all-stop,
2460 we can only get here if all threads are stopped. */
2461 int running
= target_is_non_stop_p () ? 1 : 0;
2463 /* If this is a new thread, add it to GDB's thread list.
2464 If we leave it up to WFI to do this, bad things will happen. */
2466 thread_info
*tp
= find_thread_ptid (this, currthread
);
2467 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2469 /* We're seeing an event on a thread id we knew had exited.
2470 This has to be a new thread reusing the old id. Add it. */
2471 remote_add_thread (currthread
, running
, executing
);
2475 if (!in_thread_list (this, currthread
))
2477 struct inferior
*inf
= NULL
;
2478 int pid
= currthread
.pid ();
2480 if (inferior_ptid
.is_pid ()
2481 && pid
== inferior_ptid
.pid ())
2483 /* inferior_ptid has no thread member yet. This can happen
2484 with the vAttach -> remote_wait,"TAAthread:" path if the
2485 stub doesn't support qC. This is the first stop reported
2486 after an attach, so this is the main thread. Update the
2487 ptid in the thread list. */
2488 if (in_thread_list (this, ptid_t (pid
)))
2489 thread_change_ptid (this, inferior_ptid
, currthread
);
2492 remote_add_thread (currthread
, running
, executing
);
2493 inferior_ptid
= currthread
;
2498 if (magic_null_ptid
== inferior_ptid
)
2500 /* inferior_ptid is not set yet. This can happen with the
2501 vRun -> remote_wait,"TAAthread:" path if the stub
2502 doesn't support qC. This is the first stop reported
2503 after an attach, so this is the main thread. Update the
2504 ptid in the thread list. */
2505 thread_change_ptid (this, inferior_ptid
, currthread
);
2509 /* When connecting to a target remote, or to a target
2510 extended-remote which already was debugging an inferior, we
2511 may not know about it yet. Add it before adding its child
2512 thread, so notifications are emitted in a sensible order. */
2513 if (find_inferior_pid (this, currthread
.pid ()) == NULL
)
2515 struct remote_state
*rs
= get_remote_state ();
2516 bool fake_pid_p
= !remote_multi_process_p (rs
);
2518 inf
= remote_add_inferior (fake_pid_p
,
2519 currthread
.pid (), -1, 1);
2522 /* This is really a new thread. Add it. */
2523 thread_info
*new_thr
2524 = remote_add_thread (currthread
, running
, executing
);
2526 /* If we found a new inferior, let the common code do whatever
2527 it needs to with it (e.g., read shared libraries, insert
2528 breakpoints), unless we're just setting up an all-stop
2532 struct remote_state
*rs
= get_remote_state ();
2534 if (!rs
->starting_up
)
2535 notice_new_inferior (new_thr
, executing
, 0);
2540 /* Return THREAD's private thread data, creating it if necessary. */
2542 static remote_thread_info
*
2543 get_remote_thread_info (thread_info
*thread
)
2545 gdb_assert (thread
!= NULL
);
2547 if (thread
->priv
== NULL
)
2548 thread
->priv
.reset (new remote_thread_info
);
2550 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2553 /* Return PTID's private thread data, creating it if necessary. */
2555 static remote_thread_info
*
2556 get_remote_thread_info (remote_target
*target
, ptid_t ptid
)
2558 thread_info
*thr
= find_thread_ptid (target
, ptid
);
2559 return get_remote_thread_info (thr
);
2562 /* Call this function as a result of
2563 1) A halt indication (T packet) containing a thread id
2564 2) A direct query of currthread
2565 3) Successful execution of set thread */
2568 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2570 rs
->general_thread
= currthread
;
2573 /* If 'QPassSignals' is supported, tell the remote stub what signals
2574 it can simply pass through to the inferior without reporting. */
2577 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2579 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2581 char *pass_packet
, *p
;
2583 struct remote_state
*rs
= get_remote_state ();
2585 gdb_assert (pass_signals
.size () < 256);
2586 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2588 if (pass_signals
[i
])
2591 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2592 strcpy (pass_packet
, "QPassSignals:");
2593 p
= pass_packet
+ strlen (pass_packet
);
2594 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2596 if (pass_signals
[i
])
2599 *p
++ = tohex (i
>> 4);
2600 *p
++ = tohex (i
& 15);
2609 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2611 putpkt (pass_packet
);
2612 getpkt (&rs
->buf
, 0);
2613 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2614 if (rs
->last_pass_packet
)
2615 xfree (rs
->last_pass_packet
);
2616 rs
->last_pass_packet
= pass_packet
;
2619 xfree (pass_packet
);
2623 /* If 'QCatchSyscalls' is supported, tell the remote stub
2624 to report syscalls to GDB. */
2627 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2628 gdb::array_view
<const int> syscall_counts
)
2630 const char *catch_packet
;
2631 enum packet_result result
;
2634 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2636 /* Not supported. */
2640 if (needed
&& any_count
== 0)
2642 /* Count how many syscalls are to be caught. */
2643 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2645 if (syscall_counts
[i
] != 0)
2652 fprintf_unfiltered (gdb_stdlog
,
2653 "remote_set_syscall_catchpoint "
2654 "pid %d needed %d any_count %d n_sysno %d\n",
2655 pid
, needed
, any_count
, n_sysno
);
2658 std::string built_packet
;
2661 /* Prepare a packet with the sysno list, assuming max 8+1
2662 characters for a sysno. If the resulting packet size is too
2663 big, fallback on the non-selective packet. */
2664 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2665 built_packet
.reserve (maxpktsz
);
2666 built_packet
= "QCatchSyscalls:1";
2669 /* Add in each syscall to be caught. */
2670 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2672 if (syscall_counts
[i
] != 0)
2673 string_appendf (built_packet
, ";%zx", i
);
2676 if (built_packet
.size () > get_remote_packet_size ())
2678 /* catch_packet too big. Fallback to less efficient
2679 non selective mode, with GDB doing the filtering. */
2680 catch_packet
= "QCatchSyscalls:1";
2683 catch_packet
= built_packet
.c_str ();
2686 catch_packet
= "QCatchSyscalls:0";
2688 struct remote_state
*rs
= get_remote_state ();
2690 putpkt (catch_packet
);
2691 getpkt (&rs
->buf
, 0);
2692 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2693 if (result
== PACKET_OK
)
2699 /* If 'QProgramSignals' is supported, tell the remote stub what
2700 signals it should pass through to the inferior when detaching. */
2703 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2705 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2709 struct remote_state
*rs
= get_remote_state ();
2711 gdb_assert (signals
.size () < 256);
2712 for (size_t i
= 0; i
< signals
.size (); i
++)
2717 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2718 strcpy (packet
, "QProgramSignals:");
2719 p
= packet
+ strlen (packet
);
2720 for (size_t i
= 0; i
< signals
.size (); i
++)
2722 if (signal_pass_state (i
))
2725 *p
++ = tohex (i
>> 4);
2726 *p
++ = tohex (i
& 15);
2735 if (!rs
->last_program_signals_packet
2736 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2739 getpkt (&rs
->buf
, 0);
2740 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2741 xfree (rs
->last_program_signals_packet
);
2742 rs
->last_program_signals_packet
= packet
;
2749 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2750 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2751 thread. If GEN is set, set the general thread, if not, then set
2752 the step/continue thread. */
2754 remote_target::set_thread (ptid_t ptid
, int gen
)
2756 struct remote_state
*rs
= get_remote_state ();
2757 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2758 char *buf
= rs
->buf
.data ();
2759 char *endbuf
= buf
+ get_remote_packet_size ();
2765 *buf
++ = gen
? 'g' : 'c';
2766 if (ptid
== magic_null_ptid
)
2767 xsnprintf (buf
, endbuf
- buf
, "0");
2768 else if (ptid
== any_thread_ptid
)
2769 xsnprintf (buf
, endbuf
- buf
, "0");
2770 else if (ptid
== minus_one_ptid
)
2771 xsnprintf (buf
, endbuf
- buf
, "-1");
2773 write_ptid (buf
, endbuf
, ptid
);
2775 getpkt (&rs
->buf
, 0);
2777 rs
->general_thread
= ptid
;
2779 rs
->continue_thread
= ptid
;
2783 remote_target::set_general_thread (ptid_t ptid
)
2785 set_thread (ptid
, 1);
2789 remote_target::set_continue_thread (ptid_t ptid
)
2791 set_thread (ptid
, 0);
2794 /* Change the remote current process. Which thread within the process
2795 ends up selected isn't important, as long as it is the same process
2796 as what INFERIOR_PTID points to.
2798 This comes from that fact that there is no explicit notion of
2799 "selected process" in the protocol. The selected process for
2800 general operations is the process the selected general thread
2804 remote_target::set_general_process ()
2806 struct remote_state
*rs
= get_remote_state ();
2808 /* If the remote can't handle multiple processes, don't bother. */
2809 if (!remote_multi_process_p (rs
))
2812 /* We only need to change the remote current thread if it's pointing
2813 at some other process. */
2814 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2815 set_general_thread (inferior_ptid
);
2819 /* Return nonzero if this is the main thread that we made up ourselves
2820 to model non-threaded targets as single-threaded. */
2823 remote_thread_always_alive (ptid_t ptid
)
2825 if (ptid
== magic_null_ptid
)
2826 /* The main thread is always alive. */
2829 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2830 /* The main thread is always alive. This can happen after a
2831 vAttach, if the remote side doesn't support
2838 /* Return nonzero if the thread PTID is still alive on the remote
2842 remote_target::thread_alive (ptid_t ptid
)
2844 struct remote_state
*rs
= get_remote_state ();
2847 /* Check if this is a thread that we made up ourselves to model
2848 non-threaded targets as single-threaded. */
2849 if (remote_thread_always_alive (ptid
))
2852 p
= rs
->buf
.data ();
2853 endp
= p
+ get_remote_packet_size ();
2856 write_ptid (p
, endp
, ptid
);
2859 getpkt (&rs
->buf
, 0);
2860 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2863 /* Return a pointer to a thread name if we know it and NULL otherwise.
2864 The thread_info object owns the memory for the name. */
2867 remote_target::thread_name (struct thread_info
*info
)
2869 if (info
->priv
!= NULL
)
2871 const std::string
&name
= get_remote_thread_info (info
)->name
;
2872 return !name
.empty () ? name
.c_str () : NULL
;
2878 /* About these extended threadlist and threadinfo packets. They are
2879 variable length packets but, the fields within them are often fixed
2880 length. They are redundant enough to send over UDP as is the
2881 remote protocol in general. There is a matching unit test module
2884 /* WARNING: This threadref data structure comes from the remote O.S.,
2885 libstub protocol encoding, and remote.c. It is not particularly
2888 /* Right now, the internal structure is int. We want it to be bigger.
2889 Plan to fix this. */
2891 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2893 /* gdb_ext_thread_info is an internal GDB data structure which is
2894 equivalent to the reply of the remote threadinfo packet. */
2896 struct gdb_ext_thread_info
2898 threadref threadid
; /* External form of thread reference. */
2899 int active
; /* Has state interesting to GDB?
2901 char display
[256]; /* Brief state display, name,
2902 blocked/suspended. */
2903 char shortname
[32]; /* To be used to name threads. */
2904 char more_display
[256]; /* Long info, statistics, queue depth,
2908 /* The volume of remote transfers can be limited by submitting
2909 a mask containing bits specifying the desired information.
2910 Use a union of these values as the 'selection' parameter to
2911 get_thread_info. FIXME: Make these TAG names more thread specific. */
2913 #define TAG_THREADID 1
2914 #define TAG_EXISTS 2
2915 #define TAG_DISPLAY 4
2916 #define TAG_THREADNAME 8
2917 #define TAG_MOREDISPLAY 16
2919 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2921 static char *unpack_nibble (char *buf
, int *val
);
2923 static char *unpack_byte (char *buf
, int *value
);
2925 static char *pack_int (char *buf
, int value
);
2927 static char *unpack_int (char *buf
, int *value
);
2929 static char *unpack_string (char *src
, char *dest
, int length
);
2931 static char *pack_threadid (char *pkt
, threadref
*id
);
2933 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2935 void int_to_threadref (threadref
*id
, int value
);
2937 static int threadref_to_int (threadref
*ref
);
2939 static void copy_threadref (threadref
*dest
, threadref
*src
);
2941 static int threadmatch (threadref
*dest
, threadref
*src
);
2943 static char *pack_threadinfo_request (char *pkt
, int mode
,
2946 static char *pack_threadlist_request (char *pkt
, int startflag
,
2948 threadref
*nextthread
);
2950 static int remote_newthread_step (threadref
*ref
, void *context
);
2953 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2954 buffer we're allowed to write to. Returns
2955 BUF+CHARACTERS_WRITTEN. */
2958 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2961 struct remote_state
*rs
= get_remote_state ();
2963 if (remote_multi_process_p (rs
))
2967 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2969 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2973 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2975 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2980 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2981 last parsed char. Returns null_ptid if no thread id is found, and
2982 throws an error if the thread id has an invalid format. */
2985 read_ptid (const char *buf
, const char **obuf
)
2987 const char *p
= buf
;
2989 ULONGEST pid
= 0, tid
= 0;
2993 /* Multi-process ptid. */
2994 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2996 error (_("invalid remote ptid: %s"), p
);
2999 pp
= unpack_varlen_hex (p
+ 1, &tid
);
3002 return ptid_t (pid
, tid
, 0);
3005 /* No multi-process. Just a tid. */
3006 pp
= unpack_varlen_hex (p
, &tid
);
3008 /* Return null_ptid when no thread id is found. */
3016 /* Since the stub is not sending a process id, then default to
3017 what's in inferior_ptid, unless it's null at this point. If so,
3018 then since there's no way to know the pid of the reported
3019 threads, use the magic number. */
3020 if (inferior_ptid
== null_ptid
)
3021 pid
= magic_null_ptid
.pid ();
3023 pid
= inferior_ptid
.pid ();
3027 return ptid_t (pid
, tid
, 0);
3033 if (ch
>= 'a' && ch
<= 'f')
3034 return ch
- 'a' + 10;
3035 if (ch
>= '0' && ch
<= '9')
3037 if (ch
>= 'A' && ch
<= 'F')
3038 return ch
- 'A' + 10;
3043 stub_unpack_int (char *buff
, int fieldlength
)
3050 nibble
= stubhex (*buff
++);
3054 retval
= retval
<< 4;
3060 unpack_nibble (char *buf
, int *val
)
3062 *val
= fromhex (*buf
++);
3067 unpack_byte (char *buf
, int *value
)
3069 *value
= stub_unpack_int (buf
, 2);
3074 pack_int (char *buf
, int value
)
3076 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3077 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3078 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3079 buf
= pack_hex_byte (buf
, (value
& 0xff));
3084 unpack_int (char *buf
, int *value
)
3086 *value
= stub_unpack_int (buf
, 8);
3090 #if 0 /* Currently unused, uncomment when needed. */
3091 static char *pack_string (char *pkt
, char *string
);
3094 pack_string (char *pkt
, char *string
)
3099 len
= strlen (string
);
3101 len
= 200; /* Bigger than most GDB packets, junk??? */
3102 pkt
= pack_hex_byte (pkt
, len
);
3106 if ((ch
== '\0') || (ch
== '#'))
3107 ch
= '*'; /* Protect encapsulation. */
3112 #endif /* 0 (unused) */
3115 unpack_string (char *src
, char *dest
, int length
)
3124 pack_threadid (char *pkt
, threadref
*id
)
3127 unsigned char *altid
;
3129 altid
= (unsigned char *) id
;
3130 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3132 pkt
= pack_hex_byte (pkt
, *altid
++);
3138 unpack_threadid (char *inbuf
, threadref
*id
)
3141 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3144 altref
= (char *) id
;
3146 while (inbuf
< limit
)
3148 x
= stubhex (*inbuf
++);
3149 y
= stubhex (*inbuf
++);
3150 *altref
++ = (x
<< 4) | y
;
3155 /* Externally, threadrefs are 64 bits but internally, they are still
3156 ints. This is due to a mismatch of specifications. We would like
3157 to use 64bit thread references internally. This is an adapter
3161 int_to_threadref (threadref
*id
, int value
)
3163 unsigned char *scan
;
3165 scan
= (unsigned char *) id
;
3171 *scan
++ = (value
>> 24) & 0xff;
3172 *scan
++ = (value
>> 16) & 0xff;
3173 *scan
++ = (value
>> 8) & 0xff;
3174 *scan
++ = (value
& 0xff);
3178 threadref_to_int (threadref
*ref
)
3181 unsigned char *scan
;
3187 value
= (value
<< 8) | ((*scan
++) & 0xff);
3192 copy_threadref (threadref
*dest
, threadref
*src
)
3195 unsigned char *csrc
, *cdest
;
3197 csrc
= (unsigned char *) src
;
3198 cdest
= (unsigned char *) dest
;
3205 threadmatch (threadref
*dest
, threadref
*src
)
3207 /* Things are broken right now, so just assume we got a match. */
3209 unsigned char *srcp
, *destp
;
3211 srcp
= (char *) src
;
3212 destp
= (char *) dest
;
3216 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3223 threadid:1, # always request threadid
3230 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3233 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3235 *pkt
++ = 'q'; /* Info Query */
3236 *pkt
++ = 'P'; /* process or thread info */
3237 pkt
= pack_int (pkt
, mode
); /* mode */
3238 pkt
= pack_threadid (pkt
, id
); /* threadid */
3239 *pkt
= '\0'; /* terminate */
3243 /* These values tag the fields in a thread info response packet. */
3244 /* Tagging the fields allows us to request specific fields and to
3245 add more fields as time goes by. */
3247 #define TAG_THREADID 1 /* Echo the thread identifier. */
3248 #define TAG_EXISTS 2 /* Is this process defined enough to
3249 fetch registers and its stack? */
3250 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3251 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3252 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3256 remote_target::remote_unpack_thread_info_response (char *pkt
,
3257 threadref
*expectedref
,
3258 gdb_ext_thread_info
*info
)
3260 struct remote_state
*rs
= get_remote_state ();
3264 char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3267 /* info->threadid = 0; FIXME: implement zero_threadref. */
3269 info
->display
[0] = '\0';
3270 info
->shortname
[0] = '\0';
3271 info
->more_display
[0] = '\0';
3273 /* Assume the characters indicating the packet type have been
3275 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3276 pkt
= unpack_threadid (pkt
, &ref
);
3279 warning (_("Incomplete response to threadinfo request."));
3280 if (!threadmatch (&ref
, expectedref
))
3281 { /* This is an answer to a different request. */
3282 warning (_("ERROR RMT Thread info mismatch."));
3285 copy_threadref (&info
->threadid
, &ref
);
3287 /* Loop on tagged fields , try to bail if something goes wrong. */
3289 /* Packets are terminated with nulls. */
3290 while ((pkt
< limit
) && mask
&& *pkt
)
3292 pkt
= unpack_int (pkt
, &tag
); /* tag */
3293 pkt
= unpack_byte (pkt
, &length
); /* length */
3294 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3296 warning (_("ERROR RMT: threadinfo tag mismatch."));
3300 if (tag
== TAG_THREADID
)
3304 warning (_("ERROR RMT: length of threadid is not 16."));
3308 pkt
= unpack_threadid (pkt
, &ref
);
3309 mask
= mask
& ~TAG_THREADID
;
3312 if (tag
== TAG_EXISTS
)
3314 info
->active
= stub_unpack_int (pkt
, length
);
3316 mask
= mask
& ~(TAG_EXISTS
);
3319 warning (_("ERROR RMT: 'exists' length too long."));
3325 if (tag
== TAG_THREADNAME
)
3327 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3328 mask
= mask
& ~TAG_THREADNAME
;
3331 if (tag
== TAG_DISPLAY
)
3333 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3334 mask
= mask
& ~TAG_DISPLAY
;
3337 if (tag
== TAG_MOREDISPLAY
)
3339 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3340 mask
= mask
& ~TAG_MOREDISPLAY
;
3343 warning (_("ERROR RMT: unknown thread info tag."));
3344 break; /* Not a tag we know about. */
3350 remote_target::remote_get_threadinfo (threadref
*threadid
,
3352 gdb_ext_thread_info
*info
)
3354 struct remote_state
*rs
= get_remote_state ();
3357 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3359 getpkt (&rs
->buf
, 0);
3361 if (rs
->buf
[0] == '\0')
3364 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3369 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3372 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3373 threadref
*nextthread
)
3375 *pkt
++ = 'q'; /* info query packet */
3376 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3377 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3378 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3379 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3384 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3387 remote_target::parse_threadlist_response (char *pkt
, int result_limit
,
3388 threadref
*original_echo
,
3389 threadref
*resultlist
,
3392 struct remote_state
*rs
= get_remote_state ();
3394 int count
, resultcount
, done
;
3397 /* Assume the 'q' and 'M chars have been stripped. */
3398 limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3399 /* done parse past here */
3400 pkt
= unpack_byte (pkt
, &count
); /* count field */
3401 pkt
= unpack_nibble (pkt
, &done
);
3402 /* The first threadid is the argument threadid. */
3403 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3404 while ((count
-- > 0) && (pkt
< limit
))
3406 pkt
= unpack_threadid (pkt
, resultlist
++);
3407 if (resultcount
++ >= result_limit
)
3415 /* Fetch the next batch of threads from the remote. Returns -1 if the
3416 qL packet is not supported, 0 on error and 1 on success. */
3419 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3420 int result_limit
, int *done
, int *result_count
,
3421 threadref
*threadlist
)
3423 struct remote_state
*rs
= get_remote_state ();
3426 /* Truncate result limit to be smaller than the packet size. */
3427 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3428 >= get_remote_packet_size ())
3429 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3431 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3434 getpkt (&rs
->buf
, 0);
3435 if (rs
->buf
[0] == '\0')
3437 /* Packet not supported. */
3442 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3443 &rs
->echo_nextthread
, threadlist
, done
);
3445 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3447 /* FIXME: This is a good reason to drop the packet. */
3448 /* Possibly, there is a duplicate response. */
3450 retransmit immediatly - race conditions
3451 retransmit after timeout - yes
3453 wait for packet, then exit
3455 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3456 return 0; /* I choose simply exiting. */
3458 if (*result_count
<= 0)
3462 warning (_("RMT ERROR : failed to get remote thread list."));
3465 return result
; /* break; */
3467 if (*result_count
> result_limit
)
3470 warning (_("RMT ERROR: threadlist response longer than requested."));
3476 /* Fetch the list of remote threads, with the qL packet, and call
3477 STEPFUNCTION for each thread found. Stops iterating and returns 1
3478 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3479 STEPFUNCTION returns false. If the packet is not supported,
3483 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3484 void *context
, int looplimit
)
3486 struct remote_state
*rs
= get_remote_state ();
3487 int done
, i
, result_count
;
3495 if (loopcount
++ > looplimit
)
3498 warning (_("Remote fetch threadlist -infinite loop-."));
3501 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3502 MAXTHREADLISTRESULTS
,
3503 &done
, &result_count
,
3504 rs
->resultthreadlist
);
3507 /* Clear for later iterations. */
3509 /* Setup to resume next batch of thread references, set nextthread. */
3510 if (result_count
>= 1)
3511 copy_threadref (&rs
->nextthread
,
3512 &rs
->resultthreadlist
[result_count
- 1]);
3514 while (result_count
--)
3516 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3526 /* A thread found on the remote target. */
3530 explicit thread_item (ptid_t ptid_
)
3534 thread_item (thread_item
&&other
) = default;
3535 thread_item
&operator= (thread_item
&&other
) = default;
3537 DISABLE_COPY_AND_ASSIGN (thread_item
);
3539 /* The thread's PTID. */
3542 /* The thread's extra info. */
3545 /* The thread's name. */
3548 /* The core the thread was running on. -1 if not known. */
3551 /* The thread handle associated with the thread. */
3552 gdb::byte_vector thread_handle
;
3555 /* Context passed around to the various methods listing remote
3556 threads. As new threads are found, they're added to the ITEMS
3559 struct threads_listing_context
3561 /* Return true if this object contains an entry for a thread with ptid
3564 bool contains_thread (ptid_t ptid
) const
3566 auto match_ptid
= [&] (const thread_item
&item
)
3568 return item
.ptid
== ptid
;
3571 auto it
= std::find_if (this->items
.begin (),
3575 return it
!= this->items
.end ();
3578 /* Remove the thread with ptid PTID. */
3580 void remove_thread (ptid_t ptid
)
3582 auto match_ptid
= [&] (const thread_item
&item
)
3584 return item
.ptid
== ptid
;
3587 auto it
= std::remove_if (this->items
.begin (),
3591 if (it
!= this->items
.end ())
3592 this->items
.erase (it
);
3595 /* The threads found on the remote target. */
3596 std::vector
<thread_item
> items
;
3600 remote_newthread_step (threadref
*ref
, void *data
)
3602 struct threads_listing_context
*context
3603 = (struct threads_listing_context
*) data
;
3604 int pid
= inferior_ptid
.pid ();
3605 int lwp
= threadref_to_int (ref
);
3606 ptid_t
ptid (pid
, lwp
);
3608 context
->items
.emplace_back (ptid
);
3610 return 1; /* continue iterator */
3613 #define CRAZY_MAX_THREADS 1000
3616 remote_target::remote_current_thread (ptid_t oldpid
)
3618 struct remote_state
*rs
= get_remote_state ();
3621 getpkt (&rs
->buf
, 0);
3622 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3627 result
= read_ptid (&rs
->buf
[2], &obuf
);
3628 if (*obuf
!= '\0' && remote_debug
)
3629 fprintf_unfiltered (gdb_stdlog
,
3630 "warning: garbage in qC reply\n");
3638 /* List remote threads using the deprecated qL packet. */
3641 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3643 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3644 CRAZY_MAX_THREADS
) >= 0)
3650 #if defined(HAVE_LIBEXPAT)
3653 start_thread (struct gdb_xml_parser
*parser
,
3654 const struct gdb_xml_element
*element
,
3656 std::vector
<gdb_xml_value
> &attributes
)
3658 struct threads_listing_context
*data
3659 = (struct threads_listing_context
*) user_data
;
3660 struct gdb_xml_value
*attr
;
3662 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3663 ptid_t ptid
= read_ptid (id
, NULL
);
3665 data
->items
.emplace_back (ptid
);
3666 thread_item
&item
= data
->items
.back ();
3668 attr
= xml_find_attribute (attributes
, "core");
3670 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3672 attr
= xml_find_attribute (attributes
, "name");
3674 item
.name
= (const char *) attr
->value
.get ();
3676 attr
= xml_find_attribute (attributes
, "handle");
3678 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3682 end_thread (struct gdb_xml_parser
*parser
,
3683 const struct gdb_xml_element
*element
,
3684 void *user_data
, const char *body_text
)
3686 struct threads_listing_context
*data
3687 = (struct threads_listing_context
*) user_data
;
3689 if (body_text
!= NULL
&& *body_text
!= '\0')
3690 data
->items
.back ().extra
= body_text
;
3693 const struct gdb_xml_attribute thread_attributes
[] = {
3694 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3695 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3696 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3697 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3698 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3701 const struct gdb_xml_element thread_children
[] = {
3702 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3705 const struct gdb_xml_element threads_children
[] = {
3706 { "thread", thread_attributes
, thread_children
,
3707 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3708 start_thread
, end_thread
},
3709 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3712 const struct gdb_xml_element threads_elements
[] = {
3713 { "threads", NULL
, threads_children
,
3714 GDB_XML_EF_NONE
, NULL
, NULL
},
3715 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3720 /* List remote threads using qXfer:threads:read. */
3723 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3725 #if defined(HAVE_LIBEXPAT)
3726 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3728 gdb::optional
<gdb::char_vector
> xml
3729 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3731 if (xml
&& (*xml
)[0] != '\0')
3733 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3734 threads_elements
, xml
->data (), context
);
3744 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3747 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3749 struct remote_state
*rs
= get_remote_state ();
3751 if (rs
->use_threadinfo_query
)
3755 putpkt ("qfThreadInfo");
3756 getpkt (&rs
->buf
, 0);
3757 bufp
= rs
->buf
.data ();
3758 if (bufp
[0] != '\0') /* q packet recognized */
3760 while (*bufp
++ == 'm') /* reply contains one or more TID */
3764 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3765 context
->items
.emplace_back (ptid
);
3767 while (*bufp
++ == ','); /* comma-separated list */
3768 putpkt ("qsThreadInfo");
3769 getpkt (&rs
->buf
, 0);
3770 bufp
= rs
->buf
.data ();
3776 /* Packet not recognized. */
3777 rs
->use_threadinfo_query
= 0;
3784 /* Implement the to_update_thread_list function for the remote
3788 remote_target::update_thread_list ()
3790 struct threads_listing_context context
;
3793 /* We have a few different mechanisms to fetch the thread list. Try
3794 them all, starting with the most preferred one first, falling
3795 back to older methods. */
3796 if (remote_get_threads_with_qxfer (&context
)
3797 || remote_get_threads_with_qthreadinfo (&context
)
3798 || remote_get_threads_with_ql (&context
))
3802 if (context
.items
.empty ()
3803 && remote_thread_always_alive (inferior_ptid
))
3805 /* Some targets don't really support threads, but still
3806 reply an (empty) thread list in response to the thread
3807 listing packets, instead of replying "packet not
3808 supported". Exit early so we don't delete the main
3813 /* CONTEXT now holds the current thread list on the remote
3814 target end. Delete GDB-side threads no longer found on the
3816 for (thread_info
*tp
: all_threads_safe ())
3818 if (tp
->inf
->process_target () != this)
3821 if (!context
.contains_thread (tp
->ptid
))
3828 /* Remove any unreported fork child threads from CONTEXT so
3829 that we don't interfere with follow fork, which is where
3830 creation of such threads is handled. */
3831 remove_new_fork_children (&context
);
3833 /* And now add threads we don't know about yet to our list. */
3834 for (thread_item
&item
: context
.items
)
3836 if (item
.ptid
!= null_ptid
)
3838 /* In non-stop mode, we assume new found threads are
3839 executing until proven otherwise with a stop reply.
3840 In all-stop, we can only get here if all threads are
3842 int executing
= target_is_non_stop_p () ? 1 : 0;
3844 remote_notice_new_inferior (item
.ptid
, executing
);
3846 thread_info
*tp
= find_thread_ptid (this, item
.ptid
);
3847 remote_thread_info
*info
= get_remote_thread_info (tp
);
3848 info
->core
= item
.core
;
3849 info
->extra
= std::move (item
.extra
);
3850 info
->name
= std::move (item
.name
);
3851 info
->thread_handle
= std::move (item
.thread_handle
);
3858 /* If no thread listing method is supported, then query whether
3859 each known thread is alive, one by one, with the T packet.
3860 If the target doesn't support threads at all, then this is a
3861 no-op. See remote_thread_alive. */
3867 * Collect a descriptive string about the given thread.
3868 * The target may say anything it wants to about the thread
3869 * (typically info about its blocked / runnable state, name, etc.).
3870 * This string will appear in the info threads display.
3872 * Optional: targets are not required to implement this function.
3876 remote_target::extra_thread_info (thread_info
*tp
)
3878 struct remote_state
*rs
= get_remote_state ();
3881 struct gdb_ext_thread_info threadinfo
;
3883 if (rs
->remote_desc
== 0) /* paranoia */
3884 internal_error (__FILE__
, __LINE__
,
3885 _("remote_threads_extra_info"));
3887 if (tp
->ptid
== magic_null_ptid
3888 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
3889 /* This is the main thread which was added by GDB. The remote
3890 server doesn't know about it. */
3893 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
3895 /* If already have cached info, use it. */
3896 if (!extra
.empty ())
3897 return extra
.c_str ();
3899 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3901 /* If we're using qXfer:threads:read, then the extra info is
3902 included in the XML. So if we didn't have anything cached,
3903 it's because there's really no extra info. */
3907 if (rs
->use_threadextra_query
)
3909 char *b
= rs
->buf
.data ();
3910 char *endb
= b
+ get_remote_packet_size ();
3912 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3914 write_ptid (b
, endb
, tp
->ptid
);
3917 getpkt (&rs
->buf
, 0);
3918 if (rs
->buf
[0] != 0)
3920 extra
.resize (strlen (rs
->buf
.data ()) / 2);
3921 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
3922 return extra
.c_str ();
3926 /* If the above query fails, fall back to the old method. */
3927 rs
->use_threadextra_query
= 0;
3928 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3929 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3930 int_to_threadref (&id
, tp
->ptid
.lwp ());
3931 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3932 if (threadinfo
.active
)
3934 if (*threadinfo
.shortname
)
3935 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
3936 if (*threadinfo
.display
)
3938 if (!extra
.empty ())
3940 string_appendf (extra
, " State: %s", threadinfo
.display
);
3942 if (*threadinfo
.more_display
)
3944 if (!extra
.empty ())
3946 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
3948 return extra
.c_str ();
3955 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
3956 struct static_tracepoint_marker
*marker
)
3958 struct remote_state
*rs
= get_remote_state ();
3959 char *p
= rs
->buf
.data ();
3961 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3963 p
+= hexnumstr (p
, addr
);
3965 getpkt (&rs
->buf
, 0);
3966 p
= rs
->buf
.data ();
3969 error (_("Remote failure reply: %s"), p
);
3973 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
3980 std::vector
<static_tracepoint_marker
>
3981 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
3983 struct remote_state
*rs
= get_remote_state ();
3984 std::vector
<static_tracepoint_marker
> markers
;
3986 static_tracepoint_marker marker
;
3988 /* Ask for a first packet of static tracepoint marker
3991 getpkt (&rs
->buf
, 0);
3992 p
= rs
->buf
.data ();
3994 error (_("Remote failure reply: %s"), p
);
4000 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
4002 if (strid
== NULL
|| marker
.str_id
== strid
)
4003 markers
.push_back (std::move (marker
));
4005 while (*p
++ == ','); /* comma-separated list */
4006 /* Ask for another packet of static tracepoint definition. */
4008 getpkt (&rs
->buf
, 0);
4009 p
= rs
->buf
.data ();
4016 /* Implement the to_get_ada_task_ptid function for the remote targets. */
4019 remote_target::get_ada_task_ptid (long lwp
, long thread
)
4021 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
4025 /* Restart the remote side; this is an extended protocol operation. */
4028 remote_target::extended_remote_restart ()
4030 struct remote_state
*rs
= get_remote_state ();
4032 /* Send the restart command; for reasons I don't understand the
4033 remote side really expects a number after the "R". */
4034 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
4037 remote_fileio_reset ();
4040 /* Clean up connection to a remote debugger. */
4043 remote_target::close ()
4045 /* Make sure we leave stdin registered in the event loop. */
4048 trace_reset_local_state ();
4053 remote_target::~remote_target ()
4055 struct remote_state
*rs
= get_remote_state ();
4057 /* Check for NULL because we may get here with a partially
4058 constructed target/connection. */
4059 if (rs
->remote_desc
== nullptr)
4062 serial_close (rs
->remote_desc
);
4064 /* We are destroying the remote target, so we should discard
4065 everything of this target. */
4066 discard_pending_stop_replies_in_queue ();
4068 if (rs
->remote_async_inferior_event_token
)
4069 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4071 delete rs
->notif_state
;
4074 /* Query the remote side for the text, data and bss offsets. */
4077 remote_target::get_offsets ()
4079 struct remote_state
*rs
= get_remote_state ();
4082 int lose
, num_segments
= 0, do_sections
, do_segments
;
4083 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4084 struct symfile_segment_data
*data
;
4086 if (symfile_objfile
== NULL
)
4089 putpkt ("qOffsets");
4090 getpkt (&rs
->buf
, 0);
4091 buf
= rs
->buf
.data ();
4093 if (buf
[0] == '\000')
4094 return; /* Return silently. Stub doesn't support
4098 warning (_("Remote failure reply: %s"), buf
);
4102 /* Pick up each field in turn. This used to be done with scanf, but
4103 scanf will make trouble if CORE_ADDR size doesn't match
4104 conversion directives correctly. The following code will work
4105 with any size of CORE_ADDR. */
4106 text_addr
= data_addr
= bss_addr
= 0;
4110 if (startswith (ptr
, "Text="))
4113 /* Don't use strtol, could lose on big values. */
4114 while (*ptr
&& *ptr
!= ';')
4115 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4117 if (startswith (ptr
, ";Data="))
4120 while (*ptr
&& *ptr
!= ';')
4121 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4126 if (!lose
&& startswith (ptr
, ";Bss="))
4129 while (*ptr
&& *ptr
!= ';')
4130 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4132 if (bss_addr
!= data_addr
)
4133 warning (_("Target reported unsupported offsets: %s"), buf
);
4138 else if (startswith (ptr
, "TextSeg="))
4141 /* Don't use strtol, could lose on big values. */
4142 while (*ptr
&& *ptr
!= ';')
4143 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4146 if (startswith (ptr
, ";DataSeg="))
4149 while (*ptr
&& *ptr
!= ';')
4150 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4158 error (_("Malformed response to offset query, %s"), buf
);
4159 else if (*ptr
!= '\0')
4160 warning (_("Target reported unsupported offsets: %s"), buf
);
4162 section_offsets offs
= symfile_objfile
->section_offsets
;
4164 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
4165 do_segments
= (data
!= NULL
);
4166 do_sections
= num_segments
== 0;
4168 if (num_segments
> 0)
4170 segments
[0] = text_addr
;
4171 segments
[1] = data_addr
;
4173 /* If we have two segments, we can still try to relocate everything
4174 by assuming that the .text and .data offsets apply to the whole
4175 text and data segments. Convert the offsets given in the packet
4176 to base addresses for symfile_map_offsets_to_segments. */
4177 else if (data
&& data
->num_segments
== 2)
4179 segments
[0] = data
->segment_bases
[0] + text_addr
;
4180 segments
[1] = data
->segment_bases
[1] + data_addr
;
4183 /* If the object file has only one segment, assume that it is text
4184 rather than data; main programs with no writable data are rare,
4185 but programs with no code are useless. Of course the code might
4186 have ended up in the data segment... to detect that we would need
4187 the permissions here. */
4188 else if (data
&& data
->num_segments
== 1)
4190 segments
[0] = data
->segment_bases
[0] + text_addr
;
4193 /* There's no way to relocate by segment. */
4199 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
4200 offs
, num_segments
, segments
);
4202 if (ret
== 0 && !do_sections
)
4203 error (_("Can not handle qOffsets TextSeg "
4204 "response with this symbol file"));
4211 free_symfile_segment_data (data
);
4215 offs
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
4217 /* This is a temporary kludge to force data and bss to use the
4218 same offsets because that's what nlmconv does now. The real
4219 solution requires changes to the stub and remote.c that I
4220 don't have time to do right now. */
4222 offs
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
4223 offs
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
4226 objfile_relocate (symfile_objfile
, offs
);
4229 /* Send interrupt_sequence to remote target. */
4232 remote_target::send_interrupt_sequence ()
4234 struct remote_state
*rs
= get_remote_state ();
4236 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4237 remote_serial_write ("\x03", 1);
4238 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4239 serial_send_break (rs
->remote_desc
);
4240 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4242 serial_send_break (rs
->remote_desc
);
4243 remote_serial_write ("g", 1);
4246 internal_error (__FILE__
, __LINE__
,
4247 _("Invalid value for interrupt_sequence_mode: %s."),
4248 interrupt_sequence_mode
);
4252 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4253 and extract the PTID. Returns NULL_PTID if not found. */
4256 stop_reply_extract_thread (char *stop_reply
)
4258 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4262 /* Txx r:val ; r:val (...) */
4265 /* Look for "register" named "thread". */
4270 p1
= strchr (p
, ':');
4274 if (strncmp (p
, "thread", p1
- p
) == 0)
4275 return read_ptid (++p1
, &p
);
4277 p1
= strchr (p
, ';');
4289 /* Determine the remote side's current thread. If we have a stop
4290 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4291 "thread" register we can extract the current thread from. If not,
4292 ask the remote which is the current thread with qC. The former
4293 method avoids a roundtrip. */
4296 remote_target::get_current_thread (char *wait_status
)
4298 ptid_t ptid
= null_ptid
;
4300 /* Note we don't use remote_parse_stop_reply as that makes use of
4301 the target architecture, which we haven't yet fully determined at
4303 if (wait_status
!= NULL
)
4304 ptid
= stop_reply_extract_thread (wait_status
);
4305 if (ptid
== null_ptid
)
4306 ptid
= remote_current_thread (inferior_ptid
);
4311 /* Query the remote target for which is the current thread/process,
4312 add it to our tables, and update INFERIOR_PTID. The caller is
4313 responsible for setting the state such that the remote end is ready
4314 to return the current thread.
4316 This function is called after handling the '?' or 'vRun' packets,
4317 whose response is a stop reply from which we can also try
4318 extracting the thread. If the target doesn't support the explicit
4319 qC query, we infer the current thread from that stop reply, passed
4320 in in WAIT_STATUS, which may be NULL. */
4323 remote_target::add_current_inferior_and_thread (char *wait_status
)
4325 struct remote_state
*rs
= get_remote_state ();
4326 bool fake_pid_p
= false;
4328 inferior_ptid
= null_ptid
;
4330 /* Now, if we have thread information, update inferior_ptid. */
4331 ptid_t curr_ptid
= get_current_thread (wait_status
);
4333 if (curr_ptid
!= null_ptid
)
4335 if (!remote_multi_process_p (rs
))
4340 /* Without this, some commands which require an active target
4341 (such as kill) won't work. This variable serves (at least)
4342 double duty as both the pid of the target process (if it has
4343 such), and as a flag indicating that a target is active. */
4344 curr_ptid
= magic_null_ptid
;
4348 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4350 /* Add the main thread and switch to it. Don't try reading
4351 registers yet, since we haven't fetched the target description
4353 thread_info
*tp
= add_thread_silent (this, curr_ptid
);
4354 switch_to_thread_no_regs (tp
);
4357 /* Print info about a thread that was found already stopped on
4361 print_one_stopped_thread (struct thread_info
*thread
)
4363 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4365 switch_to_thread (thread
);
4366 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4367 set_current_sal_from_frame (get_current_frame ());
4369 thread
->suspend
.waitstatus_pending_p
= 0;
4371 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4373 enum gdb_signal sig
= ws
->value
.sig
;
4375 if (signal_print_state (sig
))
4376 gdb::observers::signal_received
.notify (sig
);
4378 gdb::observers::normal_stop
.notify (NULL
, 1);
4381 /* Process all initial stop replies the remote side sent in response
4382 to the ? packet. These indicate threads that were already stopped
4383 on initial connection. We mark these threads as stopped and print
4384 their current frame before giving the user the prompt. */
4387 remote_target::process_initial_stop_replies (int from_tty
)
4389 int pending_stop_replies
= stop_reply_queue_length ();
4390 struct thread_info
*selected
= NULL
;
4391 struct thread_info
*lowest_stopped
= NULL
;
4392 struct thread_info
*first
= NULL
;
4394 /* Consume the initial pending events. */
4395 while (pending_stop_replies
-- > 0)
4397 ptid_t waiton_ptid
= minus_one_ptid
;
4399 struct target_waitstatus ws
;
4400 int ignore_event
= 0;
4402 memset (&ws
, 0, sizeof (ws
));
4403 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4405 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4409 case TARGET_WAITKIND_IGNORE
:
4410 case TARGET_WAITKIND_NO_RESUMED
:
4411 case TARGET_WAITKIND_SIGNALLED
:
4412 case TARGET_WAITKIND_EXITED
:
4413 /* We shouldn't see these, but if we do, just ignore. */
4415 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
4419 case TARGET_WAITKIND_EXECD
:
4420 xfree (ws
.value
.execd_pathname
);
4429 thread_info
*evthread
= find_thread_ptid (this, event_ptid
);
4431 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4433 enum gdb_signal sig
= ws
.value
.sig
;
4435 /* Stubs traditionally report SIGTRAP as initial signal,
4436 instead of signal 0. Suppress it. */
4437 if (sig
== GDB_SIGNAL_TRAP
)
4439 evthread
->suspend
.stop_signal
= sig
;
4443 evthread
->suspend
.waitstatus
= ws
;
4445 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4446 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4447 evthread
->suspend
.waitstatus_pending_p
= 1;
4449 set_executing (this, event_ptid
, 0);
4450 set_running (this, event_ptid
, 0);
4451 get_remote_thread_info (evthread
)->vcont_resumed
= 0;
4454 /* "Notice" the new inferiors before anything related to
4455 registers/memory. */
4456 for (inferior
*inf
: all_non_exited_inferiors (this))
4458 inf
->needs_setup
= 1;
4462 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4463 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4468 /* If all-stop on top of non-stop, pause all threads. Note this
4469 records the threads' stop pc, so must be done after "noticing"
4473 stop_all_threads ();
4475 /* If all threads of an inferior were already stopped, we
4476 haven't setup the inferior yet. */
4477 for (inferior
*inf
: all_non_exited_inferiors (this))
4479 if (inf
->needs_setup
)
4481 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4482 switch_to_thread_no_regs (thread
);
4488 /* Now go over all threads that are stopped, and print their current
4489 frame. If all-stop, then if there's a signalled thread, pick
4491 for (thread_info
*thread
: all_non_exited_threads (this))
4497 thread
->set_running (false);
4498 else if (thread
->state
!= THREAD_STOPPED
)
4501 if (selected
== NULL
4502 && thread
->suspend
.waitstatus_pending_p
)
4505 if (lowest_stopped
== NULL
4506 || thread
->inf
->num
< lowest_stopped
->inf
->num
4507 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4508 lowest_stopped
= thread
;
4511 print_one_stopped_thread (thread
);
4514 /* In all-stop, we only print the status of one thread, and leave
4515 others with their status pending. */
4518 thread_info
*thread
= selected
;
4520 thread
= lowest_stopped
;
4524 print_one_stopped_thread (thread
);
4527 /* For "info program". */
4528 thread_info
*thread
= inferior_thread ();
4529 if (thread
->state
== THREAD_STOPPED
)
4530 set_last_target_status (this, inferior_ptid
, thread
->suspend
.waitstatus
);
4533 /* Start the remote connection and sync state. */
4536 remote_target::start_remote (int from_tty
, int extended_p
)
4538 struct remote_state
*rs
= get_remote_state ();
4539 struct packet_config
*noack_config
;
4540 char *wait_status
= NULL
;
4542 /* Signal other parts that we're going through the initial setup,
4543 and so things may not be stable yet. E.g., we don't try to
4544 install tracepoints until we've relocated symbols. Also, a
4545 Ctrl-C before we're connected and synced up can't interrupt the
4546 target. Instead, it offers to drop the (potentially wedged)
4548 rs
->starting_up
= 1;
4552 if (interrupt_on_connect
)
4553 send_interrupt_sequence ();
4555 /* Ack any packet which the remote side has already sent. */
4556 remote_serial_write ("+", 1);
4558 /* The first packet we send to the target is the optional "supported
4559 packets" request. If the target can answer this, it will tell us
4560 which later probes to skip. */
4561 remote_query_supported ();
4563 /* If the stub wants to get a QAllow, compose one and send it. */
4564 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4567 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4568 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4569 as a reply to known packet. For packet "vFile:setfs:" it is an
4570 invalid reply and GDB would return error in
4571 remote_hostio_set_filesystem, making remote files access impossible.
4572 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4573 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4575 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4577 putpkt (v_mustreplyempty
);
4578 getpkt (&rs
->buf
, 0);
4579 if (strcmp (rs
->buf
.data (), "OK") == 0)
4580 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4581 else if (strcmp (rs
->buf
.data (), "") != 0)
4582 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4586 /* Next, we possibly activate noack mode.
4588 If the QStartNoAckMode packet configuration is set to AUTO,
4589 enable noack mode if the stub reported a wish for it with
4592 If set to TRUE, then enable noack mode even if the stub didn't
4593 report it in qSupported. If the stub doesn't reply OK, the
4594 session ends with an error.
4596 If FALSE, then don't activate noack mode, regardless of what the
4597 stub claimed should be the default with qSupported. */
4599 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4600 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4602 putpkt ("QStartNoAckMode");
4603 getpkt (&rs
->buf
, 0);
4604 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4610 /* Tell the remote that we are using the extended protocol. */
4612 getpkt (&rs
->buf
, 0);
4615 /* Let the target know which signals it is allowed to pass down to
4617 update_signals_program_target ();
4619 /* Next, if the target can specify a description, read it. We do
4620 this before anything involving memory or registers. */
4621 target_find_description ();
4623 /* Next, now that we know something about the target, update the
4624 address spaces in the program spaces. */
4625 update_address_spaces ();
4627 /* On OSs where the list of libraries is global to all
4628 processes, we fetch them early. */
4629 if (gdbarch_has_global_solist (target_gdbarch ()))
4630 solib_add (NULL
, from_tty
, auto_solib_add
);
4632 if (target_is_non_stop_p ())
4634 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4635 error (_("Non-stop mode requested, but remote "
4636 "does not support non-stop"));
4638 putpkt ("QNonStop:1");
4639 getpkt (&rs
->buf
, 0);
4641 if (strcmp (rs
->buf
.data (), "OK") != 0)
4642 error (_("Remote refused setting non-stop mode with: %s"),
4645 /* Find about threads and processes the stub is already
4646 controlling. We default to adding them in the running state.
4647 The '?' query below will then tell us about which threads are
4649 this->update_thread_list ();
4651 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4653 /* Don't assume that the stub can operate in all-stop mode.
4654 Request it explicitly. */
4655 putpkt ("QNonStop:0");
4656 getpkt (&rs
->buf
, 0);
4658 if (strcmp (rs
->buf
.data (), "OK") != 0)
4659 error (_("Remote refused setting all-stop mode with: %s"),
4663 /* Upload TSVs regardless of whether the target is running or not. The
4664 remote stub, such as GDBserver, may have some predefined or builtin
4665 TSVs, even if the target is not running. */
4666 if (get_trace_status (current_trace_status ()) != -1)
4668 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4670 upload_trace_state_variables (&uploaded_tsvs
);
4671 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4674 /* Check whether the target is running now. */
4676 getpkt (&rs
->buf
, 0);
4678 if (!target_is_non_stop_p ())
4680 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4683 error (_("The target is not running (try extended-remote?)"));
4685 /* We're connected, but not running. Drop out before we
4686 call start_remote. */
4687 rs
->starting_up
= 0;
4692 /* Save the reply for later. */
4693 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4694 strcpy (wait_status
, rs
->buf
.data ());
4697 /* Fetch thread list. */
4698 target_update_thread_list ();
4700 /* Let the stub know that we want it to return the thread. */
4701 set_continue_thread (minus_one_ptid
);
4703 if (thread_count (this) == 0)
4705 /* Target has no concept of threads at all. GDB treats
4706 non-threaded target as single-threaded; add a main
4708 add_current_inferior_and_thread (wait_status
);
4712 /* We have thread information; select the thread the target
4713 says should be current. If we're reconnecting to a
4714 multi-threaded program, this will ideally be the thread
4715 that last reported an event before GDB disconnected. */
4716 ptid_t curr_thread
= get_current_thread (wait_status
);
4717 if (curr_thread
== null_ptid
)
4719 /* Odd... The target was able to list threads, but not
4720 tell us which thread was current (no "thread"
4721 register in T stop reply?). Just pick the first
4722 thread in the thread list then. */
4725 fprintf_unfiltered (gdb_stdlog
,
4726 "warning: couldn't determine remote "
4727 "current thread; picking first in list.\n");
4729 for (thread_info
*tp
: all_non_exited_threads (this,
4732 switch_to_thread (tp
);
4737 switch_to_thread (find_thread_ptid (this, curr_thread
));
4740 /* init_wait_for_inferior should be called before get_offsets in order
4741 to manage `inserted' flag in bp loc in a correct state.
4742 breakpoint_init_inferior, called from init_wait_for_inferior, set
4743 `inserted' flag to 0, while before breakpoint_re_set, called from
4744 start_remote, set `inserted' flag to 1. In the initialization of
4745 inferior, breakpoint_init_inferior should be called first, and then
4746 breakpoint_re_set can be called. If this order is broken, state of
4747 `inserted' flag is wrong, and cause some problems on breakpoint
4749 init_wait_for_inferior ();
4751 get_offsets (); /* Get text, data & bss offsets. */
4753 /* If we could not find a description using qXfer, and we know
4754 how to do it some other way, try again. This is not
4755 supported for non-stop; it could be, but it is tricky if
4756 there are no stopped threads when we connect. */
4757 if (remote_read_description_p (this)
4758 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4760 target_clear_description ();
4761 target_find_description ();
4764 /* Use the previously fetched status. */
4765 gdb_assert (wait_status
!= NULL
);
4766 strcpy (rs
->buf
.data (), wait_status
);
4767 rs
->cached_wait_status
= 1;
4769 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4773 /* Clear WFI global state. Do this before finding about new
4774 threads and inferiors, and setting the current inferior.
4775 Otherwise we would clear the proceed status of the current
4776 inferior when we want its stop_soon state to be preserved
4777 (see notice_new_inferior). */
4778 init_wait_for_inferior ();
4780 /* In non-stop, we will either get an "OK", meaning that there
4781 are no stopped threads at this time; or, a regular stop
4782 reply. In the latter case, there may be more than one thread
4783 stopped --- we pull them all out using the vStopped
4785 if (strcmp (rs
->buf
.data (), "OK") != 0)
4787 struct notif_client
*notif
= ¬if_client_stop
;
4789 /* remote_notif_get_pending_replies acks this one, and gets
4791 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4792 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4793 remote_notif_get_pending_events (notif
);
4796 if (thread_count (this) == 0)
4799 error (_("The target is not running (try extended-remote?)"));
4801 /* We're connected, but not running. Drop out before we
4802 call start_remote. */
4803 rs
->starting_up
= 0;
4807 /* In non-stop mode, any cached wait status will be stored in
4808 the stop reply queue. */
4809 gdb_assert (wait_status
== NULL
);
4811 /* Report all signals during attach/startup. */
4814 /* If there are already stopped threads, mark them stopped and
4815 report their stops before giving the prompt to the user. */
4816 process_initial_stop_replies (from_tty
);
4818 if (target_can_async_p ())
4822 /* If we connected to a live target, do some additional setup. */
4823 if (target_has_execution
)
4825 if (symfile_objfile
) /* No use without a symbol-file. */
4826 remote_check_symbols ();
4829 /* Possibly the target has been engaged in a trace run started
4830 previously; find out where things are at. */
4831 if (get_trace_status (current_trace_status ()) != -1)
4833 struct uploaded_tp
*uploaded_tps
= NULL
;
4835 if (current_trace_status ()->running
)
4836 printf_filtered (_("Trace is already running on the target.\n"));
4838 upload_tracepoints (&uploaded_tps
);
4840 merge_uploaded_tracepoints (&uploaded_tps
);
4843 /* Possibly the target has been engaged in a btrace record started
4844 previously; find out where things are at. */
4845 remote_btrace_maybe_reopen ();
4847 /* The thread and inferior lists are now synchronized with the
4848 target, our symbols have been relocated, and we're merged the
4849 target's tracepoints with ours. We're done with basic start
4851 rs
->starting_up
= 0;
4853 /* Maybe breakpoints are global and need to be inserted now. */
4854 if (breakpoints_should_be_inserted_now ())
4855 insert_breakpoints ();
4859 remote_target::connection_string ()
4861 remote_state
*rs
= get_remote_state ();
4863 if (rs
->remote_desc
->name
!= NULL
)
4864 return rs
->remote_desc
->name
;
4869 /* Open a connection to a remote debugger.
4870 NAME is the filename used for communication. */
4873 remote_target::open (const char *name
, int from_tty
)
4875 open_1 (name
, from_tty
, 0);
4878 /* Open a connection to a remote debugger using the extended
4879 remote gdb protocol. NAME is the filename used for communication. */
4882 extended_remote_target::open (const char *name
, int from_tty
)
4884 open_1 (name
, from_tty
, 1 /*extended_p */);
4887 /* Reset all packets back to "unknown support". Called when opening a
4888 new connection to a remote target. */
4891 reset_all_packet_configs_support (void)
4895 for (i
= 0; i
< PACKET_MAX
; i
++)
4896 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4899 /* Initialize all packet configs. */
4902 init_all_packet_configs (void)
4906 for (i
= 0; i
< PACKET_MAX
; i
++)
4908 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4909 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4913 /* Symbol look-up. */
4916 remote_target::remote_check_symbols ()
4921 /* The remote side has no concept of inferiors that aren't running
4922 yet, it only knows about running processes. If we're connected
4923 but our current inferior is not running, we should not invite the
4924 remote target to request symbol lookups related to its
4925 (unrelated) current process. */
4926 if (!target_has_execution
)
4929 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4932 /* Make sure the remote is pointing at the right process. Note
4933 there's no way to select "no process". */
4934 set_general_process ();
4936 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4937 because we need both at the same time. */
4938 gdb::char_vector
msg (get_remote_packet_size ());
4939 gdb::char_vector
reply (get_remote_packet_size ());
4941 /* Invite target to request symbol lookups. */
4943 putpkt ("qSymbol::");
4945 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4947 while (startswith (reply
.data (), "qSymbol:"))
4949 struct bound_minimal_symbol sym
;
4952 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
4955 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
4956 if (sym
.minsym
== NULL
)
4957 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
4961 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4962 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4964 /* If this is a function address, return the start of code
4965 instead of any data function descriptor. */
4966 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4968 current_top_target ());
4970 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4971 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4974 putpkt (msg
.data ());
4979 static struct serial
*
4980 remote_serial_open (const char *name
)
4982 static int udp_warning
= 0;
4984 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4985 of in ser-tcp.c, because it is the remote protocol assuming that the
4986 serial connection is reliable and not the serial connection promising
4988 if (!udp_warning
&& startswith (name
, "udp:"))
4990 warning (_("The remote protocol may be unreliable over UDP.\n"
4991 "Some events may be lost, rendering further debugging "
4996 return serial_open (name
);
4999 /* Inform the target of our permission settings. The permission flags
5000 work without this, but if the target knows the settings, it can do
5001 a couple things. First, it can add its own check, to catch cases
5002 that somehow manage to get by the permissions checks in target
5003 methods. Second, if the target is wired to disallow particular
5004 settings (for instance, a system in the field that is not set up to
5005 be able to stop at a breakpoint), it can object to any unavailable
5009 remote_target::set_permissions ()
5011 struct remote_state
*rs
= get_remote_state ();
5013 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
5014 "WriteReg:%x;WriteMem:%x;"
5015 "InsertBreak:%x;InsertTrace:%x;"
5016 "InsertFastTrace:%x;Stop:%x",
5017 may_write_registers
, may_write_memory
,
5018 may_insert_breakpoints
, may_insert_tracepoints
,
5019 may_insert_fast_tracepoints
, may_stop
);
5021 getpkt (&rs
->buf
, 0);
5023 /* If the target didn't like the packet, warn the user. Do not try
5024 to undo the user's settings, that would just be maddening. */
5025 if (strcmp (rs
->buf
.data (), "OK") != 0)
5026 warning (_("Remote refused setting permissions with: %s"),
5030 /* This type describes each known response to the qSupported
5032 struct protocol_feature
5034 /* The name of this protocol feature. */
5037 /* The default for this protocol feature. */
5038 enum packet_support default_support
;
5040 /* The function to call when this feature is reported, or after
5041 qSupported processing if the feature is not supported.
5042 The first argument points to this structure. The second
5043 argument indicates whether the packet requested support be
5044 enabled, disabled, or probed (or the default, if this function
5045 is being called at the end of processing and this feature was
5046 not reported). The third argument may be NULL; if not NULL, it
5047 is a NUL-terminated string taken from the packet following
5048 this feature's name and an equals sign. */
5049 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5050 enum packet_support
, const char *);
5052 /* The corresponding packet for this feature. Only used if
5053 FUNC is remote_supported_packet. */
5058 remote_supported_packet (remote_target
*remote
,
5059 const struct protocol_feature
*feature
,
5060 enum packet_support support
,
5061 const char *argument
)
5065 warning (_("Remote qSupported response supplied an unexpected value for"
5066 " \"%s\"."), feature
->name
);
5070 remote_protocol_packets
[feature
->packet
].support
= support
;
5074 remote_target::remote_packet_size (const protocol_feature
*feature
,
5075 enum packet_support support
, const char *value
)
5077 struct remote_state
*rs
= get_remote_state ();
5082 if (support
!= PACKET_ENABLE
)
5085 if (value
== NULL
|| *value
== '\0')
5087 warning (_("Remote target reported \"%s\" without a size."),
5093 packet_size
= strtol (value
, &value_end
, 16);
5094 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5096 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5097 feature
->name
, value
);
5101 /* Record the new maximum packet size. */
5102 rs
->explicit_packet_size
= packet_size
;
5106 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5107 enum packet_support support
, const char *value
)
5109 remote
->remote_packet_size (feature
, support
, value
);
5112 static const struct protocol_feature remote_protocol_features
[] = {
5113 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5114 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5115 PACKET_qXfer_auxv
},
5116 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5117 PACKET_qXfer_exec_file
},
5118 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5119 PACKET_qXfer_features
},
5120 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5121 PACKET_qXfer_libraries
},
5122 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5123 PACKET_qXfer_libraries_svr4
},
5124 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5125 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5126 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5127 PACKET_qXfer_memory_map
},
5128 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5129 PACKET_qXfer_osdata
},
5130 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5131 PACKET_qXfer_threads
},
5132 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5133 PACKET_qXfer_traceframe_info
},
5134 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5135 PACKET_QPassSignals
},
5136 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5137 PACKET_QCatchSyscalls
},
5138 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5139 PACKET_QProgramSignals
},
5140 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5141 PACKET_QSetWorkingDir
},
5142 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5143 PACKET_QStartupWithShell
},
5144 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5145 PACKET_QEnvironmentHexEncoded
},
5146 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5147 PACKET_QEnvironmentReset
},
5148 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5149 PACKET_QEnvironmentUnset
},
5150 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5151 PACKET_QStartNoAckMode
},
5152 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5153 PACKET_multiprocess_feature
},
5154 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5155 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5156 PACKET_qXfer_siginfo_read
},
5157 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5158 PACKET_qXfer_siginfo_write
},
5159 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5160 PACKET_ConditionalTracepoints
},
5161 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5162 PACKET_ConditionalBreakpoints
},
5163 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5164 PACKET_BreakpointCommands
},
5165 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5166 PACKET_FastTracepoints
},
5167 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5168 PACKET_StaticTracepoints
},
5169 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5170 PACKET_InstallInTrace
},
5171 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5172 PACKET_DisconnectedTracing_feature
},
5173 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5175 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5177 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5178 PACKET_TracepointSource
},
5179 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5181 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5182 PACKET_EnableDisableTracepoints_feature
},
5183 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5184 PACKET_qXfer_fdpic
},
5185 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5187 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5188 PACKET_QDisableRandomization
},
5189 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5190 { "QTBuffer:size", PACKET_DISABLE
,
5191 remote_supported_packet
, PACKET_QTBuffer_size
},
5192 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5193 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5194 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5195 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5196 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5197 PACKET_qXfer_btrace
},
5198 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5199 PACKET_qXfer_btrace_conf
},
5200 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5201 PACKET_Qbtrace_conf_bts_size
},
5202 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5203 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5204 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5205 PACKET_fork_event_feature
},
5206 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5207 PACKET_vfork_event_feature
},
5208 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5209 PACKET_exec_event_feature
},
5210 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5211 PACKET_Qbtrace_conf_pt_size
},
5212 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5213 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5214 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5217 static char *remote_support_xml
;
5219 /* Register string appended to "xmlRegisters=" in qSupported query. */
5222 register_remote_support_xml (const char *xml
)
5224 #if defined(HAVE_LIBEXPAT)
5225 if (remote_support_xml
== NULL
)
5226 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5229 char *copy
= xstrdup (remote_support_xml
+ 13);
5231 char *p
= strtok_r (copy
, ",", &saveptr
);
5235 if (strcmp (p
, xml
) == 0)
5242 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5245 remote_support_xml
= reconcat (remote_support_xml
,
5246 remote_support_xml
, ",", xml
,
5253 remote_query_supported_append (std::string
*msg
, const char *append
)
5257 msg
->append (append
);
5261 remote_target::remote_query_supported ()
5263 struct remote_state
*rs
= get_remote_state ();
5266 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5268 /* The packet support flags are handled differently for this packet
5269 than for most others. We treat an error, a disabled packet, and
5270 an empty response identically: any features which must be reported
5271 to be used will be automatically disabled. An empty buffer
5272 accomplishes this, since that is also the representation for a list
5273 containing no features. */
5276 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5280 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5281 remote_query_supported_append (&q
, "multiprocess+");
5283 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5284 remote_query_supported_append (&q
, "swbreak+");
5285 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5286 remote_query_supported_append (&q
, "hwbreak+");
5288 remote_query_supported_append (&q
, "qRelocInsn+");
5290 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5291 != AUTO_BOOLEAN_FALSE
)
5292 remote_query_supported_append (&q
, "fork-events+");
5293 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5294 != AUTO_BOOLEAN_FALSE
)
5295 remote_query_supported_append (&q
, "vfork-events+");
5296 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5297 != AUTO_BOOLEAN_FALSE
)
5298 remote_query_supported_append (&q
, "exec-events+");
5300 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5301 remote_query_supported_append (&q
, "vContSupported+");
5303 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5304 remote_query_supported_append (&q
, "QThreadEvents+");
5306 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5307 remote_query_supported_append (&q
, "no-resumed+");
5309 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5310 the qSupported:xmlRegisters=i386 handling. */
5311 if (remote_support_xml
!= NULL
5312 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5313 remote_query_supported_append (&q
, remote_support_xml
);
5315 q
= "qSupported:" + q
;
5316 putpkt (q
.c_str ());
5318 getpkt (&rs
->buf
, 0);
5320 /* If an error occured, warn, but do not return - just reset the
5321 buffer to empty and go on to disable features. */
5322 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5325 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5330 memset (seen
, 0, sizeof (seen
));
5332 next
= rs
->buf
.data ();
5335 enum packet_support is_supported
;
5336 char *p
, *end
, *name_end
, *value
;
5338 /* First separate out this item from the rest of the packet. If
5339 there's another item after this, we overwrite the separator
5340 (terminated strings are much easier to work with). */
5342 end
= strchr (p
, ';');
5345 end
= p
+ strlen (p
);
5355 warning (_("empty item in \"qSupported\" response"));
5360 name_end
= strchr (p
, '=');
5363 /* This is a name=value entry. */
5364 is_supported
= PACKET_ENABLE
;
5365 value
= name_end
+ 1;
5374 is_supported
= PACKET_ENABLE
;
5378 is_supported
= PACKET_DISABLE
;
5382 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5386 warning (_("unrecognized item \"%s\" "
5387 "in \"qSupported\" response"), p
);
5393 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5394 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5396 const struct protocol_feature
*feature
;
5399 feature
= &remote_protocol_features
[i
];
5400 feature
->func (this, feature
, is_supported
, value
);
5405 /* If we increased the packet size, make sure to increase the global
5406 buffer size also. We delay this until after parsing the entire
5407 qSupported packet, because this is the same buffer we were
5409 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5410 rs
->buf
.resize (rs
->explicit_packet_size
);
5412 /* Handle the defaults for unmentioned features. */
5413 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5416 const struct protocol_feature
*feature
;
5418 feature
= &remote_protocol_features
[i
];
5419 feature
->func (this, feature
, feature
->default_support
, NULL
);
5423 /* Serial QUIT handler for the remote serial descriptor.
5425 Defers handling a Ctrl-C until we're done with the current
5426 command/response packet sequence, unless:
5428 - We're setting up the connection. Don't send a remote interrupt
5429 request, as we're not fully synced yet. Quit immediately
5432 - The target has been resumed in the foreground
5433 (target_terminal::is_ours is false) with a synchronous resume
5434 packet, and we're blocked waiting for the stop reply, thus a
5435 Ctrl-C should be immediately sent to the target.
5437 - We get a second Ctrl-C while still within the same serial read or
5438 write. In that case the serial is seemingly wedged --- offer to
5441 - We see a second Ctrl-C without target response, after having
5442 previously interrupted the target. In that case the target/stub
5443 is probably wedged --- offer to quit/disconnect.
5447 remote_target::remote_serial_quit_handler ()
5449 struct remote_state
*rs
= get_remote_state ();
5451 if (check_quit_flag ())
5453 /* If we're starting up, we're not fully synced yet. Quit
5455 if (rs
->starting_up
)
5457 else if (rs
->got_ctrlc_during_io
)
5459 if (query (_("The target is not responding to GDB commands.\n"
5460 "Stop debugging it? ")))
5461 remote_unpush_and_throw (this);
5463 /* If ^C has already been sent once, offer to disconnect. */
5464 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5466 /* All-stop protocol, and blocked waiting for stop reply. Send
5467 an interrupt request. */
5468 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5469 target_interrupt ();
5471 rs
->got_ctrlc_during_io
= 1;
5475 /* The remote_target that is current while the quit handler is
5476 overridden with remote_serial_quit_handler. */
5477 static remote_target
*curr_quit_handler_target
;
5480 remote_serial_quit_handler ()
5482 curr_quit_handler_target
->remote_serial_quit_handler ();
5485 /* Remove the remote target from the target stack of each inferior
5486 that is using it. Upper targets depend on it so remove them
5490 remote_unpush_target (remote_target
*target
)
5492 /* We have to unpush the target from all inferiors, even those that
5494 scoped_restore_current_inferior restore_current_inferior
;
5496 for (inferior
*inf
: all_inferiors (target
))
5498 switch_to_inferior_no_thread (inf
);
5499 pop_all_targets_at_and_above (process_stratum
);
5500 generic_mourn_inferior ();
5505 remote_unpush_and_throw (remote_target
*target
)
5507 remote_unpush_target (target
);
5508 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5512 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5514 remote_target
*curr_remote
= get_current_remote_target ();
5517 error (_("To open a remote debug connection, you need to specify what\n"
5518 "serial device is attached to the remote system\n"
5519 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5521 /* If we're connected to a running target, target_preopen will kill it.
5522 Ask this question first, before target_preopen has a chance to kill
5524 if (curr_remote
!= NULL
&& !target_has_execution
)
5527 && !query (_("Already connected to a remote target. Disconnect? ")))
5528 error (_("Still connected."));
5531 /* Here the possibly existing remote target gets unpushed. */
5532 target_preopen (from_tty
);
5534 remote_fileio_reset ();
5535 reopen_exec_file ();
5538 remote_target
*remote
5539 = (extended_p
? new extended_remote_target () : new remote_target ());
5540 target_ops_up
target_holder (remote
);
5542 remote_state
*rs
= remote
->get_remote_state ();
5544 /* See FIXME above. */
5545 if (!target_async_permitted
)
5546 rs
->wait_forever_enabled_p
= 1;
5548 rs
->remote_desc
= remote_serial_open (name
);
5549 if (!rs
->remote_desc
)
5550 perror_with_name (name
);
5552 if (baud_rate
!= -1)
5554 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5556 /* The requested speed could not be set. Error out to
5557 top level after closing remote_desc. Take care to
5558 set remote_desc to NULL to avoid closing remote_desc
5560 serial_close (rs
->remote_desc
);
5561 rs
->remote_desc
= NULL
;
5562 perror_with_name (name
);
5566 serial_setparity (rs
->remote_desc
, serial_parity
);
5567 serial_raw (rs
->remote_desc
);
5569 /* If there is something sitting in the buffer we might take it as a
5570 response to a command, which would be bad. */
5571 serial_flush_input (rs
->remote_desc
);
5575 puts_filtered ("Remote debugging using ");
5576 puts_filtered (name
);
5577 puts_filtered ("\n");
5580 /* Switch to using the remote target now. */
5581 push_target (std::move (target_holder
));
5583 /* Register extra event sources in the event loop. */
5584 rs
->remote_async_inferior_event_token
5585 = create_async_event_handler (remote_async_inferior_event_handler
,
5587 rs
->notif_state
= remote_notif_state_allocate (remote
);
5589 /* Reset the target state; these things will be queried either by
5590 remote_query_supported or as they are needed. */
5591 reset_all_packet_configs_support ();
5592 rs
->cached_wait_status
= 0;
5593 rs
->explicit_packet_size
= 0;
5595 rs
->extended
= extended_p
;
5596 rs
->waiting_for_stop_reply
= 0;
5597 rs
->ctrlc_pending_p
= 0;
5598 rs
->got_ctrlc_during_io
= 0;
5600 rs
->general_thread
= not_sent_ptid
;
5601 rs
->continue_thread
= not_sent_ptid
;
5602 rs
->remote_traceframe_number
= -1;
5604 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5606 /* Probe for ability to use "ThreadInfo" query, as required. */
5607 rs
->use_threadinfo_query
= 1;
5608 rs
->use_threadextra_query
= 1;
5610 rs
->readahead_cache
.invalidate ();
5612 if (target_async_permitted
)
5614 /* FIXME: cagney/1999-09-23: During the initial connection it is
5615 assumed that the target is already ready and able to respond to
5616 requests. Unfortunately remote_start_remote() eventually calls
5617 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5618 around this. Eventually a mechanism that allows
5619 wait_for_inferior() to expect/get timeouts will be
5621 rs
->wait_forever_enabled_p
= 0;
5624 /* First delete any symbols previously loaded from shared libraries. */
5625 no_shared_libraries (NULL
, 0);
5627 /* Start the remote connection. If error() or QUIT, discard this
5628 target (we'd otherwise be in an inconsistent state) and then
5629 propogate the error on up the exception chain. This ensures that
5630 the caller doesn't stumble along blindly assuming that the
5631 function succeeded. The CLI doesn't have this problem but other
5632 UI's, such as MI do.
5634 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5635 this function should return an error indication letting the
5636 caller restore the previous state. Unfortunately the command
5637 ``target remote'' is directly wired to this function making that
5638 impossible. On a positive note, the CLI side of this problem has
5639 been fixed - the function set_cmd_context() makes it possible for
5640 all the ``target ....'' commands to share a common callback
5641 function. See cli-dump.c. */
5646 remote
->start_remote (from_tty
, extended_p
);
5648 catch (const gdb_exception
&ex
)
5650 /* Pop the partially set up target - unless something else did
5651 already before throwing the exception. */
5652 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5653 remote_unpush_target (remote
);
5658 remote_btrace_reset (rs
);
5660 if (target_async_permitted
)
5661 rs
->wait_forever_enabled_p
= 1;
5664 /* Detach the specified process. */
5667 remote_target::remote_detach_pid (int pid
)
5669 struct remote_state
*rs
= get_remote_state ();
5671 /* This should not be necessary, but the handling for D;PID in
5672 GDBserver versions prior to 8.2 incorrectly assumes that the
5673 selected process points to the same process we're detaching,
5674 leading to misbehavior (and possibly GDBserver crashing) when it
5675 does not. Since it's easy and cheap, work around it by forcing
5676 GDBserver to select GDB's current process. */
5677 set_general_process ();
5679 if (remote_multi_process_p (rs
))
5680 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5682 strcpy (rs
->buf
.data (), "D");
5685 getpkt (&rs
->buf
, 0);
5687 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5689 else if (rs
->buf
[0] == '\0')
5690 error (_("Remote doesn't know how to detach"));
5692 error (_("Can't detach process."));
5695 /* This detaches a program to which we previously attached, using
5696 inferior_ptid to identify the process. After this is done, GDB
5697 can be used to debug some other program. We better not have left
5698 any breakpoints in the target program or it'll die when it hits
5702 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5704 int pid
= inferior_ptid
.pid ();
5705 struct remote_state
*rs
= get_remote_state ();
5708 if (!target_has_execution
)
5709 error (_("No process to detach from."));
5711 target_announce_detach (from_tty
);
5713 /* Tell the remote target to detach. */
5714 remote_detach_pid (pid
);
5716 /* Exit only if this is the only active inferior. */
5717 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors (this) == 1)
5718 puts_filtered (_("Ending remote debugging.\n"));
5720 thread_info
*tp
= find_thread_ptid (this, inferior_ptid
);
5722 /* Check to see if we are detaching a fork parent. Note that if we
5723 are detaching a fork child, tp == NULL. */
5724 is_fork_parent
= (tp
!= NULL
5725 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5727 /* If doing detach-on-fork, we don't mourn, because that will delete
5728 breakpoints that should be available for the followed inferior. */
5729 if (!is_fork_parent
)
5731 /* Save the pid as a string before mourning, since that will
5732 unpush the remote target, and we need the string after. */
5733 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5735 target_mourn_inferior (inferior_ptid
);
5736 if (print_inferior_events
)
5737 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5738 inf
->num
, infpid
.c_str ());
5742 inferior_ptid
= null_ptid
;
5743 detach_inferior (current_inferior ());
5748 remote_target::detach (inferior
*inf
, int from_tty
)
5750 remote_detach_1 (inf
, from_tty
);
5754 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5756 remote_detach_1 (inf
, from_tty
);
5759 /* Target follow-fork function for remote targets. On entry, and
5760 at return, the current inferior is the fork parent.
5762 Note that although this is currently only used for extended-remote,
5763 it is named remote_follow_fork in anticipation of using it for the
5764 remote target as well. */
5767 remote_target::follow_fork (int follow_child
, int detach_fork
)
5769 struct remote_state
*rs
= get_remote_state ();
5770 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5772 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5773 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5775 /* When following the parent and detaching the child, we detach
5776 the child here. For the case of following the child and
5777 detaching the parent, the detach is done in the target-
5778 independent follow fork code in infrun.c. We can't use
5779 target_detach when detaching an unfollowed child because
5780 the client side doesn't know anything about the child. */
5781 if (detach_fork
&& !follow_child
)
5783 /* Detach the fork child. */
5787 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5788 child_pid
= child_ptid
.pid ();
5790 remote_detach_pid (child_pid
);
5796 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5797 in the program space of the new inferior. On entry and at return the
5798 current inferior is the exec'ing inferior. INF is the new exec'd
5799 inferior, which may be the same as the exec'ing inferior unless
5800 follow-exec-mode is "new". */
5803 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5805 /* We know that this is a target file name, so if it has the "target:"
5806 prefix we strip it off before saving it in the program space. */
5807 if (is_target_filename (execd_pathname
))
5808 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5810 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5813 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5816 remote_target::disconnect (const char *args
, int from_tty
)
5819 error (_("Argument given to \"disconnect\" when remotely debugging."));
5821 /* Make sure we unpush even the extended remote targets. Calling
5822 target_mourn_inferior won't unpush, and
5823 remote_target::mourn_inferior won't unpush if there is more than
5824 one inferior left. */
5825 remote_unpush_target (this);
5828 puts_filtered ("Ending remote debugging.\n");
5831 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5832 be chatty about it. */
5835 extended_remote_target::attach (const char *args
, int from_tty
)
5837 struct remote_state
*rs
= get_remote_state ();
5839 char *wait_status
= NULL
;
5841 pid
= parse_pid_to_attach (args
);
5843 /* Remote PID can be freely equal to getpid, do not check it here the same
5844 way as in other targets. */
5846 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5847 error (_("This target does not support attaching to a process"));
5851 const char *exec_file
= get_exec_file (0);
5854 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5855 target_pid_to_str (ptid_t (pid
)).c_str ());
5857 printf_unfiltered (_("Attaching to %s\n"),
5858 target_pid_to_str (ptid_t (pid
)).c_str ());
5861 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5863 getpkt (&rs
->buf
, 0);
5865 switch (packet_ok (rs
->buf
,
5866 &remote_protocol_packets
[PACKET_vAttach
]))
5869 if (!target_is_non_stop_p ())
5871 /* Save the reply for later. */
5872 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5873 strcpy (wait_status
, rs
->buf
.data ());
5875 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5876 error (_("Attaching to %s failed with: %s"),
5877 target_pid_to_str (ptid_t (pid
)).c_str (),
5880 case PACKET_UNKNOWN
:
5881 error (_("This target does not support attaching to a process"));
5883 error (_("Attaching to %s failed"),
5884 target_pid_to_str (ptid_t (pid
)).c_str ());
5887 set_current_inferior (remote_add_inferior (false, pid
, 1, 0));
5889 inferior_ptid
= ptid_t (pid
);
5891 if (target_is_non_stop_p ())
5893 struct thread_info
*thread
;
5895 /* Get list of threads. */
5896 update_thread_list ();
5898 thread
= first_thread_of_inferior (current_inferior ());
5900 inferior_ptid
= thread
->ptid
;
5902 inferior_ptid
= ptid_t (pid
);
5904 /* Invalidate our notion of the remote current thread. */
5905 record_currthread (rs
, minus_one_ptid
);
5909 /* Now, if we have thread information, update inferior_ptid. */
5910 inferior_ptid
= remote_current_thread (inferior_ptid
);
5912 /* Add the main thread to the thread list. */
5913 thread_info
*thr
= add_thread_silent (this, inferior_ptid
);
5914 /* Don't consider the thread stopped until we've processed the
5915 saved stop reply. */
5916 set_executing (this, thr
->ptid
, true);
5919 /* Next, if the target can specify a description, read it. We do
5920 this before anything involving memory or registers. */
5921 target_find_description ();
5923 if (!target_is_non_stop_p ())
5925 /* Use the previously fetched status. */
5926 gdb_assert (wait_status
!= NULL
);
5928 if (target_can_async_p ())
5930 struct notif_event
*reply
5931 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
5933 push_stop_reply ((struct stop_reply
*) reply
);
5939 gdb_assert (wait_status
!= NULL
);
5940 strcpy (rs
->buf
.data (), wait_status
);
5941 rs
->cached_wait_status
= 1;
5945 gdb_assert (wait_status
== NULL
);
5948 /* Implementation of the to_post_attach method. */
5951 extended_remote_target::post_attach (int pid
)
5953 /* Get text, data & bss offsets. */
5956 /* In certain cases GDB might not have had the chance to start
5957 symbol lookup up until now. This could happen if the debugged
5958 binary is not using shared libraries, the vsyscall page is not
5959 present (on Linux) and the binary itself hadn't changed since the
5960 debugging process was started. */
5961 if (symfile_objfile
!= NULL
)
5962 remote_check_symbols();
5966 /* Check for the availability of vCont. This function should also check
5970 remote_target::remote_vcont_probe ()
5972 remote_state
*rs
= get_remote_state ();
5975 strcpy (rs
->buf
.data (), "vCont?");
5977 getpkt (&rs
->buf
, 0);
5978 buf
= rs
->buf
.data ();
5980 /* Make sure that the features we assume are supported. */
5981 if (startswith (buf
, "vCont"))
5984 int support_c
, support_C
;
5986 rs
->supports_vCont
.s
= 0;
5987 rs
->supports_vCont
.S
= 0;
5990 rs
->supports_vCont
.t
= 0;
5991 rs
->supports_vCont
.r
= 0;
5992 while (p
&& *p
== ';')
5995 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5996 rs
->supports_vCont
.s
= 1;
5997 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5998 rs
->supports_vCont
.S
= 1;
5999 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6001 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6003 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6004 rs
->supports_vCont
.t
= 1;
6005 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6006 rs
->supports_vCont
.r
= 1;
6008 p
= strchr (p
, ';');
6011 /* If c, and C are not all supported, we can't use vCont. Clearing
6012 BUF will make packet_ok disable the packet. */
6013 if (!support_c
|| !support_C
)
6017 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
6018 rs
->supports_vCont_probed
= true;
6021 /* Helper function for building "vCont" resumptions. Write a
6022 resumption to P. ENDP points to one-passed-the-end of the buffer
6023 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
6024 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
6025 resumed thread should be single-stepped and/or signalled. If PTID
6026 equals minus_one_ptid, then all threads are resumed; if PTID
6027 represents a process, then all threads of the process are resumed;
6028 the thread to be stepped and/or signalled is given in the global
6032 remote_target::append_resumption (char *p
, char *endp
,
6033 ptid_t ptid
, int step
, gdb_signal siggnal
)
6035 struct remote_state
*rs
= get_remote_state ();
6037 if (step
&& siggnal
!= GDB_SIGNAL_0
)
6038 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
6040 /* GDB is willing to range step. */
6041 && use_range_stepping
6042 /* Target supports range stepping. */
6043 && rs
->supports_vCont
.r
6044 /* We don't currently support range stepping multiple
6045 threads with a wildcard (though the protocol allows it,
6046 so stubs shouldn't make an active effort to forbid
6048 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6050 struct thread_info
*tp
;
6052 if (ptid
== minus_one_ptid
)
6054 /* If we don't know about the target thread's tid, then
6055 we're resuming magic_null_ptid (see caller). */
6056 tp
= find_thread_ptid (this, magic_null_ptid
);
6059 tp
= find_thread_ptid (this, ptid
);
6060 gdb_assert (tp
!= NULL
);
6062 if (tp
->control
.may_range_step
)
6064 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6066 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6067 phex_nz (tp
->control
.step_range_start
,
6069 phex_nz (tp
->control
.step_range_end
,
6073 p
+= xsnprintf (p
, endp
- p
, ";s");
6076 p
+= xsnprintf (p
, endp
- p
, ";s");
6077 else if (siggnal
!= GDB_SIGNAL_0
)
6078 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6080 p
+= xsnprintf (p
, endp
- p
, ";c");
6082 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6086 /* All (-1) threads of process. */
6087 nptid
= ptid_t (ptid
.pid (), -1, 0);
6089 p
+= xsnprintf (p
, endp
- p
, ":");
6090 p
= write_ptid (p
, endp
, nptid
);
6092 else if (ptid
!= minus_one_ptid
)
6094 p
+= xsnprintf (p
, endp
- p
, ":");
6095 p
= write_ptid (p
, endp
, ptid
);
6101 /* Clear the thread's private info on resume. */
6104 resume_clear_thread_private_info (struct thread_info
*thread
)
6106 if (thread
->priv
!= NULL
)
6108 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6110 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6111 priv
->watch_data_address
= 0;
6115 /* Append a vCont continue-with-signal action for threads that have a
6116 non-zero stop signal. */
6119 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6122 for (thread_info
*thread
: all_non_exited_threads (this, ptid
))
6123 if (inferior_ptid
!= thread
->ptid
6124 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6126 p
= append_resumption (p
, endp
, thread
->ptid
,
6127 0, thread
->suspend
.stop_signal
);
6128 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6129 resume_clear_thread_private_info (thread
);
6135 /* Set the target running, using the packets that use Hc
6139 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6142 struct remote_state
*rs
= get_remote_state ();
6145 rs
->last_sent_signal
= siggnal
;
6146 rs
->last_sent_step
= step
;
6148 /* The c/s/C/S resume packets use Hc, so set the continue
6150 if (ptid
== minus_one_ptid
)
6151 set_continue_thread (any_thread_ptid
);
6153 set_continue_thread (ptid
);
6155 for (thread_info
*thread
: all_non_exited_threads (this))
6156 resume_clear_thread_private_info (thread
);
6158 buf
= rs
->buf
.data ();
6159 if (::execution_direction
== EXEC_REVERSE
)
6161 /* We don't pass signals to the target in reverse exec mode. */
6162 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6163 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6166 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6167 error (_("Remote reverse-step not supported."));
6168 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6169 error (_("Remote reverse-continue not supported."));
6171 strcpy (buf
, step
? "bs" : "bc");
6173 else if (siggnal
!= GDB_SIGNAL_0
)
6175 buf
[0] = step
? 'S' : 'C';
6176 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6177 buf
[2] = tohex (((int) siggnal
) & 0xf);
6181 strcpy (buf
, step
? "s" : "c");
6186 /* Resume the remote inferior by using a "vCont" packet. The thread
6187 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6188 resumed thread should be single-stepped and/or signalled. If PTID
6189 equals minus_one_ptid, then all threads are resumed; the thread to
6190 be stepped and/or signalled is given in the global INFERIOR_PTID.
6191 This function returns non-zero iff it resumes the inferior.
6193 This function issues a strict subset of all possible vCont commands
6197 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6198 enum gdb_signal siggnal
)
6200 struct remote_state
*rs
= get_remote_state ();
6204 /* No reverse execution actions defined for vCont. */
6205 if (::execution_direction
== EXEC_REVERSE
)
6208 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6209 remote_vcont_probe ();
6211 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6214 p
= rs
->buf
.data ();
6215 endp
= p
+ get_remote_packet_size ();
6217 /* If we could generate a wider range of packets, we'd have to worry
6218 about overflowing BUF. Should there be a generic
6219 "multi-part-packet" packet? */
6221 p
+= xsnprintf (p
, endp
- p
, "vCont");
6223 if (ptid
== magic_null_ptid
)
6225 /* MAGIC_NULL_PTID means that we don't have any active threads,
6226 so we don't have any TID numbers the inferior will
6227 understand. Make sure to only send forms that do not specify
6229 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6231 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6233 /* Resume all threads (of all processes, or of a single
6234 process), with preference for INFERIOR_PTID. This assumes
6235 inferior_ptid belongs to the set of all threads we are about
6237 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6239 /* Step inferior_ptid, with or without signal. */
6240 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6243 /* Also pass down any pending signaled resumption for other
6244 threads not the current. */
6245 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6247 /* And continue others without a signal. */
6248 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6252 /* Scheduler locking; resume only PTID. */
6253 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6256 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6259 if (target_is_non_stop_p ())
6261 /* In non-stop, the stub replies to vCont with "OK". The stop
6262 reply will be reported asynchronously by means of a `%Stop'
6264 getpkt (&rs
->buf
, 0);
6265 if (strcmp (rs
->buf
.data (), "OK") != 0)
6266 error (_("Unexpected vCont reply in non-stop mode: %s"),
6273 /* Tell the remote machine to resume. */
6276 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6278 struct remote_state
*rs
= get_remote_state ();
6280 /* When connected in non-stop mode, the core resumes threads
6281 individually. Resuming remote threads directly in target_resume
6282 would thus result in sending one packet per thread. Instead, to
6283 minimize roundtrip latency, here we just store the resume
6284 request; the actual remote resumption will be done in
6285 target_commit_resume / remote_commit_resume, where we'll be able
6286 to do vCont action coalescing. */
6287 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6289 remote_thread_info
*remote_thr
;
6291 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6292 remote_thr
= get_remote_thread_info (this, inferior_ptid
);
6294 remote_thr
= get_remote_thread_info (this, ptid
);
6296 remote_thr
->last_resume_step
= step
;
6297 remote_thr
->last_resume_sig
= siggnal
;
6301 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6302 (explained in remote-notif.c:handle_notification) so
6303 remote_notif_process is not called. We need find a place where
6304 it is safe to start a 'vNotif' sequence. It is good to do it
6305 before resuming inferior, because inferior was stopped and no RSP
6306 traffic at that moment. */
6307 if (!target_is_non_stop_p ())
6308 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6310 rs
->last_resume_exec_dir
= ::execution_direction
;
6312 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6313 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6314 remote_resume_with_hc (ptid
, step
, siggnal
);
6316 /* We are about to start executing the inferior, let's register it
6317 with the event loop. NOTE: this is the one place where all the
6318 execution commands end up. We could alternatively do this in each
6319 of the execution commands in infcmd.c. */
6320 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6321 into infcmd.c in order to allow inferior function calls to work
6322 NOT asynchronously. */
6323 if (target_can_async_p ())
6326 /* We've just told the target to resume. The remote server will
6327 wait for the inferior to stop, and then send a stop reply. In
6328 the mean time, we can't start another command/query ourselves
6329 because the stub wouldn't be ready to process it. This applies
6330 only to the base all-stop protocol, however. In non-stop (which
6331 only supports vCont), the stub replies with an "OK", and is
6332 immediate able to process further serial input. */
6333 if (!target_is_non_stop_p ())
6334 rs
->waiting_for_stop_reply
= 1;
6337 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6339 /* Private per-inferior info for target remote processes. */
6341 struct remote_inferior
: public private_inferior
6343 /* Whether we can send a wildcard vCont for this process. */
6344 bool may_wildcard_vcont
= true;
6347 /* Get the remote private inferior data associated to INF. */
6349 static remote_inferior
*
6350 get_remote_inferior (inferior
*inf
)
6352 if (inf
->priv
== NULL
)
6353 inf
->priv
.reset (new remote_inferior
);
6355 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6358 /* Class used to track the construction of a vCont packet in the
6359 outgoing packet buffer. This is used to send multiple vCont
6360 packets if we have more actions than would fit a single packet. */
6365 explicit vcont_builder (remote_target
*remote
)
6372 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6377 /* The remote target. */
6378 remote_target
*m_remote
;
6380 /* Pointer to the first action. P points here if no action has been
6382 char *m_first_action
;
6384 /* Where the next action will be appended. */
6387 /* The end of the buffer. Must never write past this. */
6391 /* Prepare the outgoing buffer for a new vCont packet. */
6394 vcont_builder::restart ()
6396 struct remote_state
*rs
= m_remote
->get_remote_state ();
6398 m_p
= rs
->buf
.data ();
6399 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6400 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6401 m_first_action
= m_p
;
6404 /* If the vCont packet being built has any action, send it to the
6408 vcont_builder::flush ()
6410 struct remote_state
*rs
;
6412 if (m_p
== m_first_action
)
6415 rs
= m_remote
->get_remote_state ();
6416 m_remote
->putpkt (rs
->buf
);
6417 m_remote
->getpkt (&rs
->buf
, 0);
6418 if (strcmp (rs
->buf
.data (), "OK") != 0)
6419 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6422 /* The largest action is range-stepping, with its two addresses. This
6423 is more than sufficient. If a new, bigger action is created, it'll
6424 quickly trigger a failed assertion in append_resumption (and we'll
6426 #define MAX_ACTION_SIZE 200
6428 /* Append a new vCont action in the outgoing packet being built. If
6429 the action doesn't fit the packet along with previous actions, push
6430 what we've got so far to the remote end and start over a new vCont
6431 packet (with the new action). */
6434 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6436 char buf
[MAX_ACTION_SIZE
+ 1];
6438 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6439 ptid
, step
, siggnal
);
6441 /* Check whether this new action would fit in the vCont packet along
6442 with previous actions. If not, send what we've got so far and
6443 start a new vCont packet. */
6444 size_t rsize
= endp
- buf
;
6445 if (rsize
> m_endp
- m_p
)
6450 /* Should now fit. */
6451 gdb_assert (rsize
<= m_endp
- m_p
);
6454 memcpy (m_p
, buf
, rsize
);
6459 /* to_commit_resume implementation. */
6462 remote_target::commit_resume ()
6464 int any_process_wildcard
;
6465 int may_global_wildcard_vcont
;
6467 /* If connected in all-stop mode, we'd send the remote resume
6468 request directly from remote_resume. Likewise if
6469 reverse-debugging, as there are no defined vCont actions for
6470 reverse execution. */
6471 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6474 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6475 instead of resuming all threads of each process individually.
6476 However, if any thread of a process must remain halted, we can't
6477 send wildcard resumes and must send one action per thread.
6479 Care must be taken to not resume threads/processes the server
6480 side already told us are stopped, but the core doesn't know about
6481 yet, because the events are still in the vStopped notification
6484 #1 => vCont s:p1.1;c
6486 #3 <= %Stopped T05 p1.1
6491 #8 (infrun handles the stop for p1.1 and continues stepping)
6492 #9 => vCont s:p1.1;c
6494 The last vCont above would resume thread p1.2 by mistake, because
6495 the server has no idea that the event for p1.2 had not been
6498 The server side must similarly ignore resume actions for the
6499 thread that has a pending %Stopped notification (and any other
6500 threads with events pending), until GDB acks the notification
6501 with vStopped. Otherwise, e.g., the following case is
6504 #1 => g (or any other packet)
6506 #3 <= %Stopped T05 p1.2
6507 #4 => vCont s:p1.1;c
6510 Above, the server must not resume thread p1.2. GDB can't know
6511 that p1.2 stopped until it acks the %Stopped notification, and
6512 since from GDB's perspective all threads should be running, it
6515 Finally, special care must also be given to handling fork/vfork
6516 events. A (v)fork event actually tells us that two processes
6517 stopped -- the parent and the child. Until we follow the fork,
6518 we must not resume the child. Therefore, if we have a pending
6519 fork follow, we must not send a global wildcard resume action
6520 (vCont;c). We can still send process-wide wildcards though. */
6522 /* Start by assuming a global wildcard (vCont;c) is possible. */
6523 may_global_wildcard_vcont
= 1;
6525 /* And assume every process is individually wildcard-able too. */
6526 for (inferior
*inf
: all_non_exited_inferiors (this))
6528 remote_inferior
*priv
= get_remote_inferior (inf
);
6530 priv
->may_wildcard_vcont
= true;
6533 /* Check for any pending events (not reported or processed yet) and
6534 disable process and global wildcard resumes appropriately. */
6535 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6537 for (thread_info
*tp
: all_non_exited_threads (this))
6539 /* If a thread of a process is not meant to be resumed, then we
6540 can't wildcard that process. */
6543 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6545 /* And if we can't wildcard a process, we can't wildcard
6546 everything either. */
6547 may_global_wildcard_vcont
= 0;
6551 /* If a thread is the parent of an unfollowed fork, then we
6552 can't do a global wildcard, as that would resume the fork
6554 if (is_pending_fork_parent_thread (tp
))
6555 may_global_wildcard_vcont
= 0;
6558 /* Now let's build the vCont packet(s). Actions must be appended
6559 from narrower to wider scopes (thread -> process -> global). If
6560 we end up with too many actions for a single packet vcont_builder
6561 flushes the current vCont packet to the remote side and starts a
6563 struct vcont_builder
vcont_builder (this);
6565 /* Threads first. */
6566 for (thread_info
*tp
: all_non_exited_threads (this))
6568 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6570 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6573 gdb_assert (!thread_is_in_step_over_chain (tp
));
6575 if (!remote_thr
->last_resume_step
6576 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6577 && get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6579 /* We'll send a wildcard resume instead. */
6580 remote_thr
->vcont_resumed
= 1;
6584 vcont_builder
.push_action (tp
->ptid
,
6585 remote_thr
->last_resume_step
,
6586 remote_thr
->last_resume_sig
);
6587 remote_thr
->vcont_resumed
= 1;
6590 /* Now check whether we can send any process-wide wildcard. This is
6591 to avoid sending a global wildcard in the case nothing is
6592 supposed to be resumed. */
6593 any_process_wildcard
= 0;
6595 for (inferior
*inf
: all_non_exited_inferiors (this))
6597 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6599 any_process_wildcard
= 1;
6604 if (any_process_wildcard
)
6606 /* If all processes are wildcard-able, then send a single "c"
6607 action, otherwise, send an "all (-1) threads of process"
6608 continue action for each running process, if any. */
6609 if (may_global_wildcard_vcont
)
6611 vcont_builder
.push_action (minus_one_ptid
,
6612 false, GDB_SIGNAL_0
);
6616 for (inferior
*inf
: all_non_exited_inferiors (this))
6618 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6620 vcont_builder
.push_action (ptid_t (inf
->pid
),
6621 false, GDB_SIGNAL_0
);
6627 vcont_builder
.flush ();
6632 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6633 thread, all threads of a remote process, or all threads of all
6637 remote_target::remote_stop_ns (ptid_t ptid
)
6639 struct remote_state
*rs
= get_remote_state ();
6640 char *p
= rs
->buf
.data ();
6641 char *endp
= p
+ get_remote_packet_size ();
6643 /* FIXME: This supports_vCont_probed check is a workaround until
6644 packet_support is per-connection. */
6645 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
6646 || !rs
->supports_vCont_probed
)
6647 remote_vcont_probe ();
6649 if (!rs
->supports_vCont
.t
)
6650 error (_("Remote server does not support stopping threads"));
6652 if (ptid
== minus_one_ptid
6653 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6654 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6659 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6662 /* All (-1) threads of process. */
6663 nptid
= ptid_t (ptid
.pid (), -1, 0);
6666 /* Small optimization: if we already have a stop reply for
6667 this thread, no use in telling the stub we want this
6669 if (peek_stop_reply (ptid
))
6675 write_ptid (p
, endp
, nptid
);
6678 /* In non-stop, we get an immediate OK reply. The stop reply will
6679 come in asynchronously by notification. */
6681 getpkt (&rs
->buf
, 0);
6682 if (strcmp (rs
->buf
.data (), "OK") != 0)
6683 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6687 /* All-stop version of target_interrupt. Sends a break or a ^C to
6688 interrupt the remote target. It is undefined which thread of which
6689 process reports the interrupt. */
6692 remote_target::remote_interrupt_as ()
6694 struct remote_state
*rs
= get_remote_state ();
6696 rs
->ctrlc_pending_p
= 1;
6698 /* If the inferior is stopped already, but the core didn't know
6699 about it yet, just ignore the request. The cached wait status
6700 will be collected in remote_wait. */
6701 if (rs
->cached_wait_status
)
6704 /* Send interrupt_sequence to remote target. */
6705 send_interrupt_sequence ();
6708 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6709 the remote target. It is undefined which thread of which process
6710 reports the interrupt. Throws an error if the packet is not
6711 supported by the server. */
6714 remote_target::remote_interrupt_ns ()
6716 struct remote_state
*rs
= get_remote_state ();
6717 char *p
= rs
->buf
.data ();
6718 char *endp
= p
+ get_remote_packet_size ();
6720 xsnprintf (p
, endp
- p
, "vCtrlC");
6722 /* In non-stop, we get an immediate OK reply. The stop reply will
6723 come in asynchronously by notification. */
6725 getpkt (&rs
->buf
, 0);
6727 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6731 case PACKET_UNKNOWN
:
6732 error (_("No support for interrupting the remote target."));
6734 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6738 /* Implement the to_stop function for the remote targets. */
6741 remote_target::stop (ptid_t ptid
)
6744 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6746 if (target_is_non_stop_p ())
6747 remote_stop_ns (ptid
);
6750 /* We don't currently have a way to transparently pause the
6751 remote target in all-stop mode. Interrupt it instead. */
6752 remote_interrupt_as ();
6756 /* Implement the to_interrupt function for the remote targets. */
6759 remote_target::interrupt ()
6762 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6764 if (target_is_non_stop_p ())
6765 remote_interrupt_ns ();
6767 remote_interrupt_as ();
6770 /* Implement the to_pass_ctrlc function for the remote targets. */
6773 remote_target::pass_ctrlc ()
6775 struct remote_state
*rs
= get_remote_state ();
6778 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6780 /* If we're starting up, we're not fully synced yet. Quit
6782 if (rs
->starting_up
)
6784 /* If ^C has already been sent once, offer to disconnect. */
6785 else if (rs
->ctrlc_pending_p
)
6788 target_interrupt ();
6791 /* Ask the user what to do when an interrupt is received. */
6794 remote_target::interrupt_query ()
6796 struct remote_state
*rs
= get_remote_state ();
6798 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6800 if (query (_("The target is not responding to interrupt requests.\n"
6801 "Stop debugging it? ")))
6803 remote_unpush_target (this);
6804 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6809 if (query (_("Interrupted while waiting for the program.\n"
6810 "Give up waiting? ")))
6815 /* Enable/disable target terminal ownership. Most targets can use
6816 terminal groups to control terminal ownership. Remote targets are
6817 different in that explicit transfer of ownership to/from GDB/target
6821 remote_target::terminal_inferior ()
6823 /* NOTE: At this point we could also register our selves as the
6824 recipient of all input. Any characters typed could then be
6825 passed on down to the target. */
6829 remote_target::terminal_ours ()
6834 remote_console_output (const char *msg
)
6838 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6841 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6845 fputs_unfiltered (tb
, gdb_stdtarg
);
6847 gdb_flush (gdb_stdtarg
);
6850 struct stop_reply
: public notif_event
6854 /* The identifier of the thread about this event */
6857 /* The remote state this event is associated with. When the remote
6858 connection, represented by a remote_state object, is closed,
6859 all the associated stop_reply events should be released. */
6860 struct remote_state
*rs
;
6862 struct target_waitstatus ws
;
6864 /* The architecture associated with the expedited registers. */
6867 /* Expedited registers. This makes remote debugging a bit more
6868 efficient for those targets that provide critical registers as
6869 part of their normal status mechanism (as another roundtrip to
6870 fetch them is avoided). */
6871 std::vector
<cached_reg_t
> regcache
;
6873 enum target_stop_reason stop_reason
;
6875 CORE_ADDR watch_data_address
;
6880 /* Return the length of the stop reply queue. */
6883 remote_target::stop_reply_queue_length ()
6885 remote_state
*rs
= get_remote_state ();
6886 return rs
->stop_reply_queue
.size ();
6890 remote_notif_stop_parse (remote_target
*remote
,
6891 struct notif_client
*self
, const char *buf
,
6892 struct notif_event
*event
)
6894 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6898 remote_notif_stop_ack (remote_target
*remote
,
6899 struct notif_client
*self
, const char *buf
,
6900 struct notif_event
*event
)
6902 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6905 putpkt (remote
, self
->ack_command
);
6907 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6909 /* We got an unknown stop reply. */
6910 error (_("Unknown stop reply"));
6913 remote
->push_stop_reply (stop_reply
);
6917 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
6918 struct notif_client
*self
)
6920 /* We can't get pending events in remote_notif_process for
6921 notification stop, and we have to do this in remote_wait_ns
6922 instead. If we fetch all queued events from stub, remote stub
6923 may exit and we have no chance to process them back in
6925 remote_state
*rs
= remote
->get_remote_state ();
6926 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
6930 stop_reply::~stop_reply ()
6932 for (cached_reg_t
®
: regcache
)
6936 static notif_event_up
6937 remote_notif_stop_alloc_reply ()
6939 return notif_event_up (new struct stop_reply ());
6942 /* A client of notification Stop. */
6944 struct notif_client notif_client_stop
=
6948 remote_notif_stop_parse
,
6949 remote_notif_stop_ack
,
6950 remote_notif_stop_can_get_pending_events
,
6951 remote_notif_stop_alloc_reply
,
6955 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6956 the pid of the process that owns the threads we want to check, or
6957 -1 if we want to check all threads. */
6960 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6963 if (ws
->kind
== TARGET_WAITKIND_FORKED
6964 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6966 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
6973 /* Return the thread's pending status used to determine whether the
6974 thread is a fork parent stopped at a fork event. */
6976 static struct target_waitstatus
*
6977 thread_pending_fork_status (struct thread_info
*thread
)
6979 if (thread
->suspend
.waitstatus_pending_p
)
6980 return &thread
->suspend
.waitstatus
;
6982 return &thread
->pending_follow
;
6985 /* Determine if THREAD is a pending fork parent thread. */
6988 is_pending_fork_parent_thread (struct thread_info
*thread
)
6990 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6993 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6996 /* If CONTEXT contains any fork child threads that have not been
6997 reported yet, remove them from the CONTEXT list. If such a
6998 thread exists it is because we are stopped at a fork catchpoint
6999 and have not yet called follow_fork, which will set up the
7000 host-side data structures for the new process. */
7003 remote_target::remove_new_fork_children (threads_listing_context
*context
)
7006 struct notif_client
*notif
= ¬if_client_stop
;
7008 /* For any threads stopped at a fork event, remove the corresponding
7009 fork child threads from the CONTEXT list. */
7010 for (thread_info
*thread
: all_non_exited_threads (this))
7012 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
7014 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
7015 context
->remove_thread (ws
->value
.related_pid
);
7018 /* Check for any pending fork events (not reported or processed yet)
7019 in process PID and remove those fork child threads from the
7020 CONTEXT list as well. */
7021 remote_notif_get_pending_events (notif
);
7022 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7023 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7024 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
7025 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
7026 context
->remove_thread (event
->ws
.value
.related_pid
);
7029 /* Check whether any event pending in the vStopped queue would prevent
7030 a global or process wildcard vCont action. Clear
7031 *may_global_wildcard if we can't do a global wildcard (vCont;c),
7032 and clear the event inferior's may_wildcard_vcont flag if we can't
7033 do a process-wide wildcard resume (vCont;c:pPID.-1). */
7036 remote_target::check_pending_events_prevent_wildcard_vcont
7037 (int *may_global_wildcard
)
7039 struct notif_client
*notif
= ¬if_client_stop
;
7041 remote_notif_get_pending_events (notif
);
7042 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7044 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
7045 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
7048 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7049 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
7050 *may_global_wildcard
= 0;
7052 struct inferior
*inf
= find_inferior_ptid (this, event
->ptid
);
7054 /* This may be the first time we heard about this process.
7055 Regardless, we must not do a global wildcard resume, otherwise
7056 we'd resume this process too. */
7057 *may_global_wildcard
= 0;
7059 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7063 /* Discard all pending stop replies of inferior INF. */
7066 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7068 struct stop_reply
*reply
;
7069 struct remote_state
*rs
= get_remote_state ();
7070 struct remote_notif_state
*rns
= rs
->notif_state
;
7072 /* This function can be notified when an inferior exists. When the
7073 target is not remote, the notification state is NULL. */
7074 if (rs
->remote_desc
== NULL
)
7077 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7079 /* Discard the in-flight notification. */
7080 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7083 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7086 /* Discard the stop replies we have already pulled with
7088 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7089 rs
->stop_reply_queue
.end (),
7090 [=] (const stop_reply_up
&event
)
7092 return event
->ptid
.pid () == inf
->pid
;
7094 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7097 /* Discard the stop replies for RS in stop_reply_queue. */
7100 remote_target::discard_pending_stop_replies_in_queue ()
7102 remote_state
*rs
= get_remote_state ();
7104 /* Discard the stop replies we have already pulled with
7106 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7107 rs
->stop_reply_queue
.end (),
7108 [=] (const stop_reply_up
&event
)
7110 return event
->rs
== rs
;
7112 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7115 /* Remove the first reply in 'stop_reply_queue' which matches
7119 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7121 remote_state
*rs
= get_remote_state ();
7123 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7124 rs
->stop_reply_queue
.end (),
7125 [=] (const stop_reply_up
&event
)
7127 return event
->ptid
.matches (ptid
);
7129 struct stop_reply
*result
;
7130 if (iter
== rs
->stop_reply_queue
.end ())
7134 result
= iter
->release ();
7135 rs
->stop_reply_queue
.erase (iter
);
7139 fprintf_unfiltered (gdb_stdlog
,
7140 "notif: discard queued event: 'Stop' in %s\n",
7141 target_pid_to_str (ptid
).c_str ());
7146 /* Look for a queued stop reply belonging to PTID. If one is found,
7147 remove it from the queue, and return it. Returns NULL if none is
7148 found. If there are still queued events left to process, tell the
7149 event loop to get back to target_wait soon. */
7152 remote_target::queued_stop_reply (ptid_t ptid
)
7154 remote_state
*rs
= get_remote_state ();
7155 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7157 if (!rs
->stop_reply_queue
.empty ())
7159 /* There's still at least an event left. */
7160 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7166 /* Push a fully parsed stop reply in the stop reply queue. Since we
7167 know that we now have at least one queued event left to pass to the
7168 core side, tell the event loop to get back to target_wait soon. */
7171 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7173 remote_state
*rs
= get_remote_state ();
7174 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7177 fprintf_unfiltered (gdb_stdlog
,
7178 "notif: push 'Stop' %s to queue %d\n",
7179 target_pid_to_str (new_event
->ptid
).c_str (),
7180 int (rs
->stop_reply_queue
.size ()));
7182 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7185 /* Returns true if we have a stop reply for PTID. */
7188 remote_target::peek_stop_reply (ptid_t ptid
)
7190 remote_state
*rs
= get_remote_state ();
7191 for (auto &event
: rs
->stop_reply_queue
)
7192 if (ptid
== event
->ptid
7193 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7198 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7199 starting with P and ending with PEND matches PREFIX. */
7202 strprefix (const char *p
, const char *pend
, const char *prefix
)
7204 for ( ; p
< pend
; p
++, prefix
++)
7207 return *prefix
== '\0';
7210 /* Parse the stop reply in BUF. Either the function succeeds, and the
7211 result is stored in EVENT, or throws an error. */
7214 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7216 remote_arch_state
*rsa
= NULL
;
7221 event
->ptid
= null_ptid
;
7222 event
->rs
= get_remote_state ();
7223 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7224 event
->ws
.value
.integer
= 0;
7225 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7226 event
->regcache
.clear ();
7231 case 'T': /* Status with PC, SP, FP, ... */
7232 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7233 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7235 n... = register number
7236 r... = register contents
7239 p
= &buf
[3]; /* after Txx */
7245 p1
= strchr (p
, ':');
7247 error (_("Malformed packet(a) (missing colon): %s\n\
7251 error (_("Malformed packet(a) (missing register number): %s\n\
7255 /* Some "registers" are actually extended stop information.
7256 Note if you're adding a new entry here: GDB 7.9 and
7257 earlier assume that all register "numbers" that start
7258 with an hex digit are real register numbers. Make sure
7259 the server only sends such a packet if it knows the
7260 client understands it. */
7262 if (strprefix (p
, p1
, "thread"))
7263 event
->ptid
= read_ptid (++p1
, &p
);
7264 else if (strprefix (p
, p1
, "syscall_entry"))
7268 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7269 p
= unpack_varlen_hex (++p1
, &sysno
);
7270 event
->ws
.value
.syscall_number
= (int) sysno
;
7272 else if (strprefix (p
, p1
, "syscall_return"))
7276 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7277 p
= unpack_varlen_hex (++p1
, &sysno
);
7278 event
->ws
.value
.syscall_number
= (int) sysno
;
7280 else if (strprefix (p
, p1
, "watch")
7281 || strprefix (p
, p1
, "rwatch")
7282 || strprefix (p
, p1
, "awatch"))
7284 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7285 p
= unpack_varlen_hex (++p1
, &addr
);
7286 event
->watch_data_address
= (CORE_ADDR
) addr
;
7288 else if (strprefix (p
, p1
, "swbreak"))
7290 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7292 /* Make sure the stub doesn't forget to indicate support
7294 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7295 error (_("Unexpected swbreak stop reason"));
7297 /* The value part is documented as "must be empty",
7298 though we ignore it, in case we ever decide to make
7299 use of it in a backward compatible way. */
7300 p
= strchrnul (p1
+ 1, ';');
7302 else if (strprefix (p
, p1
, "hwbreak"))
7304 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7306 /* Make sure the stub doesn't forget to indicate support
7308 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7309 error (_("Unexpected hwbreak stop reason"));
7312 p
= strchrnul (p1
+ 1, ';');
7314 else if (strprefix (p
, p1
, "library"))
7316 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7317 p
= strchrnul (p1
+ 1, ';');
7319 else if (strprefix (p
, p1
, "replaylog"))
7321 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7322 /* p1 will indicate "begin" or "end", but it makes
7323 no difference for now, so ignore it. */
7324 p
= strchrnul (p1
+ 1, ';');
7326 else if (strprefix (p
, p1
, "core"))
7330 p
= unpack_varlen_hex (++p1
, &c
);
7333 else if (strprefix (p
, p1
, "fork"))
7335 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7336 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7338 else if (strprefix (p
, p1
, "vfork"))
7340 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7341 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7343 else if (strprefix (p
, p1
, "vforkdone"))
7345 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7346 p
= strchrnul (p1
+ 1, ';');
7348 else if (strprefix (p
, p1
, "exec"))
7353 /* Determine the length of the execd pathname. */
7354 p
= unpack_varlen_hex (++p1
, &ignored
);
7355 pathlen
= (p
- p1
) / 2;
7357 /* Save the pathname for event reporting and for
7358 the next run command. */
7359 gdb::unique_xmalloc_ptr
<char[]> pathname
7360 ((char *) xmalloc (pathlen
+ 1));
7361 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7362 pathname
[pathlen
] = '\0';
7364 /* This is freed during event handling. */
7365 event
->ws
.value
.execd_pathname
= pathname
.release ();
7366 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7368 /* Skip the registers included in this packet, since
7369 they may be for an architecture different from the
7370 one used by the original program. */
7373 else if (strprefix (p
, p1
, "create"))
7375 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7376 p
= strchrnul (p1
+ 1, ';');
7385 p
= strchrnul (p1
+ 1, ';');
7390 /* Maybe a real ``P'' register number. */
7391 p_temp
= unpack_varlen_hex (p
, &pnum
);
7392 /* If the first invalid character is the colon, we got a
7393 register number. Otherwise, it's an unknown stop
7397 /* If we haven't parsed the event's thread yet, find
7398 it now, in order to find the architecture of the
7399 reported expedited registers. */
7400 if (event
->ptid
== null_ptid
)
7402 const char *thr
= strstr (p1
+ 1, ";thread:");
7404 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7408 /* Either the current thread hasn't changed,
7409 or the inferior is not multi-threaded.
7410 The event must be for the thread we last
7411 set as (or learned as being) current. */
7412 event
->ptid
= event
->rs
->general_thread
;
7419 = (event
->ptid
== null_ptid
7421 : find_inferior_ptid (this, event
->ptid
));
7422 /* If this is the first time we learn anything
7423 about this process, skip the registers
7424 included in this packet, since we don't yet
7425 know which architecture to use to parse them.
7426 We'll determine the architecture later when
7427 we process the stop reply and retrieve the
7428 target description, via
7429 remote_notice_new_inferior ->
7430 post_create_inferior. */
7433 p
= strchrnul (p1
+ 1, ';');
7438 event
->arch
= inf
->gdbarch
;
7439 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7443 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7444 cached_reg_t cached_reg
;
7447 error (_("Remote sent bad register number %s: %s\n\
7449 hex_string (pnum
), p
, buf
);
7451 cached_reg
.num
= reg
->regnum
;
7452 cached_reg
.data
= (gdb_byte
*)
7453 xmalloc (register_size (event
->arch
, reg
->regnum
));
7456 fieldsize
= hex2bin (p
, cached_reg
.data
,
7457 register_size (event
->arch
, reg
->regnum
));
7459 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7460 warning (_("Remote reply is too short: %s"), buf
);
7462 event
->regcache
.push_back (cached_reg
);
7466 /* Not a number. Silently skip unknown optional
7468 p
= strchrnul (p1
+ 1, ';');
7473 error (_("Remote register badly formatted: %s\nhere: %s"),
7478 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7482 case 'S': /* Old style status, just signal only. */
7486 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7487 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7488 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7489 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7491 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7494 case 'w': /* Thread exited. */
7498 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7499 p
= unpack_varlen_hex (&buf
[1], &value
);
7500 event
->ws
.value
.integer
= value
;
7502 error (_("stop reply packet badly formatted: %s"), buf
);
7503 event
->ptid
= read_ptid (++p
, NULL
);
7506 case 'W': /* Target exited. */
7511 /* GDB used to accept only 2 hex chars here. Stubs should
7512 only send more if they detect GDB supports multi-process
7514 p
= unpack_varlen_hex (&buf
[1], &value
);
7518 /* The remote process exited. */
7519 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7520 event
->ws
.value
.integer
= value
;
7524 /* The remote process exited with a signal. */
7525 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7526 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7527 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7529 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7532 /* If no process is specified, return null_ptid, and let the
7533 caller figure out the right process to use. */
7543 else if (startswith (p
, "process:"))
7547 p
+= sizeof ("process:") - 1;
7548 unpack_varlen_hex (p
, &upid
);
7552 error (_("unknown stop reply packet: %s"), buf
);
7555 error (_("unknown stop reply packet: %s"), buf
);
7556 event
->ptid
= ptid_t (pid
);
7560 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7561 event
->ptid
= minus_one_ptid
;
7565 if (target_is_non_stop_p () && event
->ptid
== null_ptid
)
7566 error (_("No process or thread specified in stop reply: %s"), buf
);
7569 /* When the stub wants to tell GDB about a new notification reply, it
7570 sends a notification (%Stop, for example). Those can come it at
7571 any time, hence, we have to make sure that any pending
7572 putpkt/getpkt sequence we're making is finished, before querying
7573 the stub for more events with the corresponding ack command
7574 (vStopped, for example). E.g., if we started a vStopped sequence
7575 immediately upon receiving the notification, something like this
7583 1.6) <-- (registers reply to step #1.3)
7585 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7588 To solve this, whenever we parse a %Stop notification successfully,
7589 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7590 doing whatever we were doing:
7596 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7597 2.5) <-- (registers reply to step #2.3)
7599 Eventually after step #2.5, we return to the event loop, which
7600 notices there's an event on the
7601 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7602 associated callback --- the function below. At this point, we're
7603 always safe to start a vStopped sequence. :
7606 2.7) <-- T05 thread:2
7612 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7614 struct remote_state
*rs
= get_remote_state ();
7616 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7619 fprintf_unfiltered (gdb_stdlog
,
7620 "notif: process: '%s' ack pending event\n",
7624 nc
->ack (this, nc
, rs
->buf
.data (),
7625 rs
->notif_state
->pending_event
[nc
->id
]);
7626 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7630 getpkt (&rs
->buf
, 0);
7631 if (strcmp (rs
->buf
.data (), "OK") == 0)
7634 remote_notif_ack (this, nc
, rs
->buf
.data ());
7640 fprintf_unfiltered (gdb_stdlog
,
7641 "notif: process: '%s' no pending reply\n",
7646 /* Wrapper around remote_target::remote_notif_get_pending_events to
7647 avoid having to export the whole remote_target class. */
7650 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7652 remote
->remote_notif_get_pending_events (nc
);
7655 /* Called when it is decided that STOP_REPLY holds the info of the
7656 event that is to be returned to the core. This function always
7657 destroys STOP_REPLY. */
7660 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7661 struct target_waitstatus
*status
)
7665 *status
= stop_reply
->ws
;
7666 ptid
= stop_reply
->ptid
;
7668 /* If no thread/process was reported by the stub, assume the current
7670 if (ptid
== null_ptid
)
7671 ptid
= inferior_ptid
;
7673 if (status
->kind
!= TARGET_WAITKIND_EXITED
7674 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7675 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7677 /* Expedited registers. */
7678 if (!stop_reply
->regcache
.empty ())
7680 struct regcache
*regcache
7681 = get_thread_arch_regcache (this, ptid
, stop_reply
->arch
);
7683 for (cached_reg_t
®
: stop_reply
->regcache
)
7685 regcache
->raw_supply (reg
.num
, reg
.data
);
7689 stop_reply
->regcache
.clear ();
7692 remote_notice_new_inferior (ptid
, 0);
7693 remote_thread_info
*remote_thr
= get_remote_thread_info (this, ptid
);
7694 remote_thr
->core
= stop_reply
->core
;
7695 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7696 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7697 remote_thr
->vcont_resumed
= 0;
7704 /* The non-stop mode version of target_wait. */
7707 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7709 struct remote_state
*rs
= get_remote_state ();
7710 struct stop_reply
*stop_reply
;
7714 /* If in non-stop mode, get out of getpkt even if a
7715 notification is received. */
7717 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7720 if (ret
!= -1 && !is_notif
)
7723 case 'E': /* Error of some sort. */
7724 /* We're out of sync with the target now. Did it continue
7725 or not? We can't tell which thread it was in non-stop,
7726 so just ignore this. */
7727 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7729 case 'O': /* Console output. */
7730 remote_console_output (&rs
->buf
[1]);
7733 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7737 /* Acknowledge a pending stop reply that may have arrived in the
7739 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7740 remote_notif_get_pending_events (¬if_client_stop
);
7742 /* If indeed we noticed a stop reply, we're done. */
7743 stop_reply
= queued_stop_reply (ptid
);
7744 if (stop_reply
!= NULL
)
7745 return process_stop_reply (stop_reply
, status
);
7747 /* Still no event. If we're just polling for an event, then
7748 return to the event loop. */
7749 if (options
& TARGET_WNOHANG
)
7751 status
->kind
= TARGET_WAITKIND_IGNORE
;
7752 return minus_one_ptid
;
7755 /* Otherwise do a blocking wait. */
7756 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7760 /* Return the first resumed thread. */
7763 first_remote_resumed_thread (remote_target
*target
)
7765 for (thread_info
*tp
: all_non_exited_threads (target
, minus_one_ptid
))
7771 /* Wait until the remote machine stops, then return, storing status in
7772 STATUS just as `wait' would. */
7775 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
, int options
)
7777 struct remote_state
*rs
= get_remote_state ();
7778 ptid_t event_ptid
= null_ptid
;
7780 struct stop_reply
*stop_reply
;
7784 status
->kind
= TARGET_WAITKIND_IGNORE
;
7785 status
->value
.integer
= 0;
7787 stop_reply
= queued_stop_reply (ptid
);
7788 if (stop_reply
!= NULL
)
7789 return process_stop_reply (stop_reply
, status
);
7791 if (rs
->cached_wait_status
)
7792 /* Use the cached wait status, but only once. */
7793 rs
->cached_wait_status
= 0;
7798 int forever
= ((options
& TARGET_WNOHANG
) == 0
7799 && rs
->wait_forever_enabled_p
);
7801 if (!rs
->waiting_for_stop_reply
)
7803 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7804 return minus_one_ptid
;
7807 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7808 _never_ wait for ever -> test on target_is_async_p().
7809 However, before we do that we need to ensure that the caller
7810 knows how to take the target into/out of async mode. */
7811 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
7813 /* GDB gets a notification. Return to core as this event is
7815 if (ret
!= -1 && is_notif
)
7816 return minus_one_ptid
;
7818 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7819 return minus_one_ptid
;
7822 buf
= rs
->buf
.data ();
7824 /* Assume that the target has acknowledged Ctrl-C unless we receive
7825 an 'F' or 'O' packet. */
7826 if (buf
[0] != 'F' && buf
[0] != 'O')
7827 rs
->ctrlc_pending_p
= 0;
7831 case 'E': /* Error of some sort. */
7832 /* We're out of sync with the target now. Did it continue or
7833 not? Not is more likely, so report a stop. */
7834 rs
->waiting_for_stop_reply
= 0;
7836 warning (_("Remote failure reply: %s"), buf
);
7837 status
->kind
= TARGET_WAITKIND_STOPPED
;
7838 status
->value
.sig
= GDB_SIGNAL_0
;
7840 case 'F': /* File-I/O request. */
7841 /* GDB may access the inferior memory while handling the File-I/O
7842 request, but we don't want GDB accessing memory while waiting
7843 for a stop reply. See the comments in putpkt_binary. Set
7844 waiting_for_stop_reply to 0 temporarily. */
7845 rs
->waiting_for_stop_reply
= 0;
7846 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
7847 rs
->ctrlc_pending_p
= 0;
7848 /* GDB handled the File-I/O request, and the target is running
7849 again. Keep waiting for events. */
7850 rs
->waiting_for_stop_reply
= 1;
7852 case 'N': case 'T': case 'S': case 'X': case 'W':
7854 /* There is a stop reply to handle. */
7855 rs
->waiting_for_stop_reply
= 0;
7858 = (struct stop_reply
*) remote_notif_parse (this,
7862 event_ptid
= process_stop_reply (stop_reply
, status
);
7865 case 'O': /* Console output. */
7866 remote_console_output (buf
+ 1);
7869 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7871 /* Zero length reply means that we tried 'S' or 'C' and the
7872 remote system doesn't support it. */
7873 target_terminal::ours_for_output ();
7875 ("Can't send signals to this remote system. %s not sent.\n",
7876 gdb_signal_to_name (rs
->last_sent_signal
));
7877 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7878 target_terminal::inferior ();
7880 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7886 warning (_("Invalid remote reply: %s"), buf
);
7890 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7891 return minus_one_ptid
;
7892 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7894 /* Nothing interesting happened. If we're doing a non-blocking
7895 poll, we're done. Otherwise, go back to waiting. */
7896 if (options
& TARGET_WNOHANG
)
7897 return minus_one_ptid
;
7901 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7902 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7904 if (event_ptid
!= null_ptid
)
7905 record_currthread (rs
, event_ptid
);
7907 event_ptid
= first_remote_resumed_thread (this);
7911 /* A process exit. Invalidate our notion of current thread. */
7912 record_currthread (rs
, minus_one_ptid
);
7913 /* It's possible that the packet did not include a pid. */
7914 if (event_ptid
== null_ptid
)
7915 event_ptid
= first_remote_resumed_thread (this);
7916 /* EVENT_PTID could still be NULL_PTID. Double-check. */
7917 if (event_ptid
== null_ptid
)
7918 event_ptid
= magic_null_ptid
;
7924 /* Wait until the remote machine stops, then return, storing status in
7925 STATUS just as `wait' would. */
7928 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7932 if (target_is_non_stop_p ())
7933 event_ptid
= wait_ns (ptid
, status
, options
);
7935 event_ptid
= wait_as (ptid
, status
, options
);
7937 if (target_is_async_p ())
7939 remote_state
*rs
= get_remote_state ();
7941 /* If there are are events left in the queue tell the event loop
7943 if (!rs
->stop_reply_queue
.empty ())
7944 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7950 /* Fetch a single register using a 'p' packet. */
7953 remote_target::fetch_register_using_p (struct regcache
*regcache
,
7956 struct gdbarch
*gdbarch
= regcache
->arch ();
7957 struct remote_state
*rs
= get_remote_state ();
7959 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7962 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7965 if (reg
->pnum
== -1)
7968 p
= rs
->buf
.data ();
7970 p
+= hexnumstr (p
, reg
->pnum
);
7973 getpkt (&rs
->buf
, 0);
7975 buf
= rs
->buf
.data ();
7977 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
7981 case PACKET_UNKNOWN
:
7984 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7985 gdbarch_register_name (regcache
->arch (),
7990 /* If this register is unfetchable, tell the regcache. */
7993 regcache
->raw_supply (reg
->regnum
, NULL
);
7997 /* Otherwise, parse and supply the value. */
8003 error (_("fetch_register_using_p: early buf termination"));
8005 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8008 regcache
->raw_supply (reg
->regnum
, regp
);
8012 /* Fetch the registers included in the target's 'g' packet. */
8015 remote_target::send_g_packet ()
8017 struct remote_state
*rs
= get_remote_state ();
8020 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
8022 getpkt (&rs
->buf
, 0);
8023 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8024 error (_("Could not read registers; remote failure reply '%s'"),
8027 /* We can get out of synch in various cases. If the first character
8028 in the buffer is not a hex character, assume that has happened
8029 and try to fetch another packet to read. */
8030 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
8031 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
8032 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
8033 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
8036 fprintf_unfiltered (gdb_stdlog
,
8037 "Bad register packet; fetching a new packet\n");
8038 getpkt (&rs
->buf
, 0);
8041 buf_len
= strlen (rs
->buf
.data ());
8043 /* Sanity check the received packet. */
8044 if (buf_len
% 2 != 0)
8045 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
8051 remote_target::process_g_packet (struct regcache
*regcache
)
8053 struct gdbarch
*gdbarch
= regcache
->arch ();
8054 struct remote_state
*rs
= get_remote_state ();
8055 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8060 buf_len
= strlen (rs
->buf
.data ());
8062 /* Further sanity checks, with knowledge of the architecture. */
8063 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
8064 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8066 rsa
->sizeof_g_packet
, buf_len
/ 2,
8069 /* Save the size of the packet sent to us by the target. It is used
8070 as a heuristic when determining the max size of packets that the
8071 target can safely receive. */
8072 if (rsa
->actual_register_packet_size
== 0)
8073 rsa
->actual_register_packet_size
= buf_len
;
8075 /* If this is smaller than we guessed the 'g' packet would be,
8076 update our records. A 'g' reply that doesn't include a register's
8077 value implies either that the register is not available, or that
8078 the 'p' packet must be used. */
8079 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8081 long sizeof_g_packet
= buf_len
/ 2;
8083 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8085 long offset
= rsa
->regs
[i
].offset
;
8086 long reg_size
= register_size (gdbarch
, i
);
8088 if (rsa
->regs
[i
].pnum
== -1)
8091 if (offset
>= sizeof_g_packet
)
8092 rsa
->regs
[i
].in_g_packet
= 0;
8093 else if (offset
+ reg_size
> sizeof_g_packet
)
8094 error (_("Truncated register %d in remote 'g' packet"), i
);
8096 rsa
->regs
[i
].in_g_packet
= 1;
8099 /* Looks valid enough, we can assume this is the correct length
8100 for a 'g' packet. It's important not to adjust
8101 rsa->sizeof_g_packet if we have truncated registers otherwise
8102 this "if" won't be run the next time the method is called
8103 with a packet of the same size and one of the internal errors
8104 below will trigger instead. */
8105 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8108 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8110 /* Unimplemented registers read as all bits zero. */
8111 memset (regs
, 0, rsa
->sizeof_g_packet
);
8113 /* Reply describes registers byte by byte, each byte encoded as two
8114 hex characters. Suck them all up, then supply them to the
8115 register cacheing/storage mechanism. */
8117 p
= rs
->buf
.data ();
8118 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8120 if (p
[0] == 0 || p
[1] == 0)
8121 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8122 internal_error (__FILE__
, __LINE__
,
8123 _("unexpected end of 'g' packet reply"));
8125 if (p
[0] == 'x' && p
[1] == 'x')
8126 regs
[i
] = 0; /* 'x' */
8128 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8132 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8134 struct packet_reg
*r
= &rsa
->regs
[i
];
8135 long reg_size
= register_size (gdbarch
, i
);
8139 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8140 /* This shouldn't happen - we adjusted in_g_packet above. */
8141 internal_error (__FILE__
, __LINE__
,
8142 _("unexpected end of 'g' packet reply"));
8143 else if (rs
->buf
[r
->offset
* 2] == 'x')
8145 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8146 /* The register isn't available, mark it as such (at
8147 the same time setting the value to zero). */
8148 regcache
->raw_supply (r
->regnum
, NULL
);
8151 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8157 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8160 process_g_packet (regcache
);
8163 /* Make the remote selected traceframe match GDB's selected
8167 remote_target::set_remote_traceframe ()
8170 struct remote_state
*rs
= get_remote_state ();
8172 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8175 /* Avoid recursion, remote_trace_find calls us again. */
8176 rs
->remote_traceframe_number
= get_traceframe_number ();
8178 newnum
= target_trace_find (tfind_number
,
8179 get_traceframe_number (), 0, 0, NULL
);
8181 /* Should not happen. If it does, all bets are off. */
8182 if (newnum
!= get_traceframe_number ())
8183 warning (_("could not set remote traceframe"));
8187 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8189 struct gdbarch
*gdbarch
= regcache
->arch ();
8190 struct remote_state
*rs
= get_remote_state ();
8191 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8194 set_remote_traceframe ();
8195 set_general_thread (regcache
->ptid ());
8199 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8201 gdb_assert (reg
!= NULL
);
8203 /* If this register might be in the 'g' packet, try that first -
8204 we are likely to read more than one register. If this is the
8205 first 'g' packet, we might be overly optimistic about its
8206 contents, so fall back to 'p'. */
8207 if (reg
->in_g_packet
)
8209 fetch_registers_using_g (regcache
);
8210 if (reg
->in_g_packet
)
8214 if (fetch_register_using_p (regcache
, reg
))
8217 /* This register is not available. */
8218 regcache
->raw_supply (reg
->regnum
, NULL
);
8223 fetch_registers_using_g (regcache
);
8225 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8226 if (!rsa
->regs
[i
].in_g_packet
)
8227 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8229 /* This register is not available. */
8230 regcache
->raw_supply (i
, NULL
);
8234 /* Prepare to store registers. Since we may send them all (using a
8235 'G' request), we have to read out the ones we don't want to change
8239 remote_target::prepare_to_store (struct regcache
*regcache
)
8241 struct remote_state
*rs
= get_remote_state ();
8242 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8245 /* Make sure the entire registers array is valid. */
8246 switch (packet_support (PACKET_P
))
8248 case PACKET_DISABLE
:
8249 case PACKET_SUPPORT_UNKNOWN
:
8250 /* Make sure all the necessary registers are cached. */
8251 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8252 if (rsa
->regs
[i
].in_g_packet
)
8253 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8260 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8261 packet was not recognized. */
8264 remote_target::store_register_using_P (const struct regcache
*regcache
,
8267 struct gdbarch
*gdbarch
= regcache
->arch ();
8268 struct remote_state
*rs
= get_remote_state ();
8269 /* Try storing a single register. */
8270 char *buf
= rs
->buf
.data ();
8271 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8274 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8277 if (reg
->pnum
== -1)
8280 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8281 p
= buf
+ strlen (buf
);
8282 regcache
->raw_collect (reg
->regnum
, regp
);
8283 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8285 getpkt (&rs
->buf
, 0);
8287 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8292 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8293 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8294 case PACKET_UNKNOWN
:
8297 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8301 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8302 contents of the register cache buffer. FIXME: ignores errors. */
8305 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8307 struct remote_state
*rs
= get_remote_state ();
8308 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8312 /* Extract all the registers in the regcache copying them into a
8317 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8318 memset (regs
, 0, rsa
->sizeof_g_packet
);
8319 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8321 struct packet_reg
*r
= &rsa
->regs
[i
];
8324 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8328 /* Command describes registers byte by byte,
8329 each byte encoded as two hex characters. */
8330 p
= rs
->buf
.data ();
8332 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8334 getpkt (&rs
->buf
, 0);
8335 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8336 error (_("Could not write registers; remote failure reply '%s'"),
8340 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8341 of the register cache buffer. FIXME: ignores errors. */
8344 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8346 struct gdbarch
*gdbarch
= regcache
->arch ();
8347 struct remote_state
*rs
= get_remote_state ();
8348 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8351 set_remote_traceframe ();
8352 set_general_thread (regcache
->ptid ());
8356 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8358 gdb_assert (reg
!= NULL
);
8360 /* Always prefer to store registers using the 'P' packet if
8361 possible; we often change only a small number of registers.
8362 Sometimes we change a larger number; we'd need help from a
8363 higher layer to know to use 'G'. */
8364 if (store_register_using_P (regcache
, reg
))
8367 /* For now, don't complain if we have no way to write the
8368 register. GDB loses track of unavailable registers too
8369 easily. Some day, this may be an error. We don't have
8370 any way to read the register, either... */
8371 if (!reg
->in_g_packet
)
8374 store_registers_using_G (regcache
);
8378 store_registers_using_G (regcache
);
8380 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8381 if (!rsa
->regs
[i
].in_g_packet
)
8382 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8383 /* See above for why we do not issue an error here. */
8388 /* Return the number of hex digits in num. */
8391 hexnumlen (ULONGEST num
)
8395 for (i
= 0; num
!= 0; i
++)
8398 return std::max (i
, 1);
8401 /* Set BUF to the minimum number of hex digits representing NUM. */
8404 hexnumstr (char *buf
, ULONGEST num
)
8406 int len
= hexnumlen (num
);
8408 return hexnumnstr (buf
, num
, len
);
8412 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8415 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8421 for (i
= width
- 1; i
>= 0; i
--)
8423 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8430 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8433 remote_address_masked (CORE_ADDR addr
)
8435 unsigned int address_size
= remote_address_size
;
8437 /* If "remoteaddresssize" was not set, default to target address size. */
8439 address_size
= gdbarch_addr_bit (target_gdbarch ());
8441 if (address_size
> 0
8442 && address_size
< (sizeof (ULONGEST
) * 8))
8444 /* Only create a mask when that mask can safely be constructed
8445 in a ULONGEST variable. */
8448 mask
= (mask
<< address_size
) - 1;
8454 /* Determine whether the remote target supports binary downloading.
8455 This is accomplished by sending a no-op memory write of zero length
8456 to the target at the specified address. It does not suffice to send
8457 the whole packet, since many stubs strip the eighth bit and
8458 subsequently compute a wrong checksum, which causes real havoc with
8461 NOTE: This can still lose if the serial line is not eight-bit
8462 clean. In cases like this, the user should clear "remote
8466 remote_target::check_binary_download (CORE_ADDR addr
)
8468 struct remote_state
*rs
= get_remote_state ();
8470 switch (packet_support (PACKET_X
))
8472 case PACKET_DISABLE
:
8476 case PACKET_SUPPORT_UNKNOWN
:
8480 p
= rs
->buf
.data ();
8482 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8484 p
+= hexnumstr (p
, (ULONGEST
) 0);
8488 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8489 getpkt (&rs
->buf
, 0);
8491 if (rs
->buf
[0] == '\0')
8494 fprintf_unfiltered (gdb_stdlog
,
8495 "binary downloading NOT "
8496 "supported by target\n");
8497 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8502 fprintf_unfiltered (gdb_stdlog
,
8503 "binary downloading supported by target\n");
8504 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8511 /* Helper function to resize the payload in order to try to get a good
8512 alignment. We try to write an amount of data such that the next write will
8513 start on an address aligned on REMOTE_ALIGN_WRITES. */
8516 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8518 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8521 /* Write memory data directly to the remote machine.
8522 This does not inform the data cache; the data cache uses this.
8523 HEADER is the starting part of the packet.
8524 MEMADDR is the address in the remote memory space.
8525 MYADDR is the address of the buffer in our space.
8526 LEN_UNITS is the number of addressable units to write.
8527 UNIT_SIZE is the length in bytes of an addressable unit.
8528 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8529 should send data as binary ('X'), or hex-encoded ('M').
8531 The function creates packet of the form
8532 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8534 where encoding of <DATA> is terminated by PACKET_FORMAT.
8536 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8539 Return the transferred status, error or OK (an
8540 'enum target_xfer_status' value). Save the number of addressable units
8541 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8543 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8544 exchange between gdb and the stub could look like (?? in place of the
8550 -> $M1000,3:eeeeffffeeee#??
8554 <- eeeeffffeeeedddd */
8557 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8558 const gdb_byte
*myaddr
,
8561 ULONGEST
*xfered_len_units
,
8562 char packet_format
, int use_length
)
8564 struct remote_state
*rs
= get_remote_state ();
8570 int payload_capacity_bytes
;
8571 int payload_length_bytes
;
8573 if (packet_format
!= 'X' && packet_format
!= 'M')
8574 internal_error (__FILE__
, __LINE__
,
8575 _("remote_write_bytes_aux: bad packet format"));
8578 return TARGET_XFER_EOF
;
8580 payload_capacity_bytes
= get_memory_write_packet_size ();
8582 /* The packet buffer will be large enough for the payload;
8583 get_memory_packet_size ensures this. */
8586 /* Compute the size of the actual payload by subtracting out the
8587 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8589 payload_capacity_bytes
-= strlen ("$,:#NN");
8591 /* The comma won't be used. */
8592 payload_capacity_bytes
+= 1;
8593 payload_capacity_bytes
-= strlen (header
);
8594 payload_capacity_bytes
-= hexnumlen (memaddr
);
8596 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8598 strcat (rs
->buf
.data (), header
);
8599 p
= rs
->buf
.data () + strlen (header
);
8601 /* Compute a best guess of the number of bytes actually transfered. */
8602 if (packet_format
== 'X')
8604 /* Best guess at number of bytes that will fit. */
8605 todo_units
= std::min (len_units
,
8606 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8608 payload_capacity_bytes
-= hexnumlen (todo_units
);
8609 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8613 /* Number of bytes that will fit. */
8615 = std::min (len_units
,
8616 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8618 payload_capacity_bytes
-= hexnumlen (todo_units
);
8619 todo_units
= std::min (todo_units
,
8620 (payload_capacity_bytes
/ unit_size
) / 2);
8623 if (todo_units
<= 0)
8624 internal_error (__FILE__
, __LINE__
,
8625 _("minimum packet size too small to write data"));
8627 /* If we already need another packet, then try to align the end
8628 of this packet to a useful boundary. */
8629 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8630 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8632 /* Append "<memaddr>". */
8633 memaddr
= remote_address_masked (memaddr
);
8634 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8641 /* Append the length and retain its location and size. It may need to be
8642 adjusted once the packet body has been created. */
8644 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8652 /* Append the packet body. */
8653 if (packet_format
== 'X')
8655 /* Binary mode. Send target system values byte by byte, in
8656 increasing byte addresses. Only escape certain critical
8658 payload_length_bytes
=
8659 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8660 &units_written
, payload_capacity_bytes
);
8662 /* If not all TODO units fit, then we'll need another packet. Make
8663 a second try to keep the end of the packet aligned. Don't do
8664 this if the packet is tiny. */
8665 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8669 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8671 if (new_todo_units
!= units_written
)
8672 payload_length_bytes
=
8673 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8674 (gdb_byte
*) p
, &units_written
,
8675 payload_capacity_bytes
);
8678 p
+= payload_length_bytes
;
8679 if (use_length
&& units_written
< todo_units
)
8681 /* Escape chars have filled up the buffer prematurely,
8682 and we have actually sent fewer units than planned.
8683 Fix-up the length field of the packet. Use the same
8684 number of characters as before. */
8685 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8687 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8692 /* Normal mode: Send target system values byte by byte, in
8693 increasing byte addresses. Each byte is encoded as a two hex
8695 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8696 units_written
= todo_units
;
8699 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8700 getpkt (&rs
->buf
, 0);
8702 if (rs
->buf
[0] == 'E')
8703 return TARGET_XFER_E_IO
;
8705 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8706 send fewer units than we'd planned. */
8707 *xfered_len_units
= (ULONGEST
) units_written
;
8708 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8711 /* Write memory data directly to the remote machine.
8712 This does not inform the data cache; the data cache uses this.
8713 MEMADDR is the address in the remote memory space.
8714 MYADDR is the address of the buffer in our space.
8715 LEN is the number of bytes.
8717 Return the transferred status, error or OK (an
8718 'enum target_xfer_status' value). Save the number of bytes
8719 transferred in *XFERED_LEN. Only transfer a single packet. */
8722 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8723 ULONGEST len
, int unit_size
,
8724 ULONGEST
*xfered_len
)
8726 const char *packet_format
= NULL
;
8728 /* Check whether the target supports binary download. */
8729 check_binary_download (memaddr
);
8731 switch (packet_support (PACKET_X
))
8734 packet_format
= "X";
8736 case PACKET_DISABLE
:
8737 packet_format
= "M";
8739 case PACKET_SUPPORT_UNKNOWN
:
8740 internal_error (__FILE__
, __LINE__
,
8741 _("remote_write_bytes: bad internal state"));
8743 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8746 return remote_write_bytes_aux (packet_format
,
8747 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8748 packet_format
[0], 1);
8751 /* Read memory data directly from the remote machine.
8752 This does not use the data cache; the data cache uses this.
8753 MEMADDR is the address in the remote memory space.
8754 MYADDR is the address of the buffer in our space.
8755 LEN_UNITS is the number of addressable memory units to read..
8756 UNIT_SIZE is the length in bytes of an addressable unit.
8758 Return the transferred status, error or OK (an
8759 'enum target_xfer_status' value). Save the number of bytes
8760 transferred in *XFERED_LEN_UNITS.
8762 See the comment of remote_write_bytes_aux for an example of
8763 memory read/write exchange between gdb and the stub. */
8766 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8768 int unit_size
, ULONGEST
*xfered_len_units
)
8770 struct remote_state
*rs
= get_remote_state ();
8771 int buf_size_bytes
; /* Max size of packet output buffer. */
8776 buf_size_bytes
= get_memory_read_packet_size ();
8777 /* The packet buffer will be large enough for the payload;
8778 get_memory_packet_size ensures this. */
8780 /* Number of units that will fit. */
8781 todo_units
= std::min (len_units
,
8782 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8784 /* Construct "m"<memaddr>","<len>". */
8785 memaddr
= remote_address_masked (memaddr
);
8786 p
= rs
->buf
.data ();
8788 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8790 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8793 getpkt (&rs
->buf
, 0);
8794 if (rs
->buf
[0] == 'E'
8795 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8796 && rs
->buf
[3] == '\0')
8797 return TARGET_XFER_E_IO
;
8798 /* Reply describes memory byte by byte, each byte encoded as two hex
8800 p
= rs
->buf
.data ();
8801 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8802 /* Return what we have. Let higher layers handle partial reads. */
8803 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8804 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8807 /* Using the set of read-only target sections of remote, read live
8810 For interface/parameters/return description see target.h,
8814 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
8818 ULONGEST
*xfered_len
)
8820 struct target_section
*secp
;
8821 struct target_section_table
*table
;
8823 secp
= target_section_by_addr (this, memaddr
);
8825 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
8827 struct target_section
*p
;
8828 ULONGEST memend
= memaddr
+ len
;
8830 table
= target_get_section_table (this);
8832 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8834 if (memaddr
>= p
->addr
)
8836 if (memend
<= p
->endaddr
)
8838 /* Entire transfer is within this section. */
8839 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8842 else if (memaddr
>= p
->endaddr
)
8844 /* This section ends before the transfer starts. */
8849 /* This section overlaps the transfer. Just do half. */
8850 len
= p
->endaddr
- memaddr
;
8851 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8858 return TARGET_XFER_EOF
;
8861 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8862 first if the requested memory is unavailable in traceframe.
8863 Otherwise, fall back to remote_read_bytes_1. */
8866 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
8867 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8868 ULONGEST
*xfered_len
)
8871 return TARGET_XFER_EOF
;
8873 if (get_traceframe_number () != -1)
8875 std::vector
<mem_range
> available
;
8877 /* If we fail to get the set of available memory, then the
8878 target does not support querying traceframe info, and so we
8879 attempt reading from the traceframe anyway (assuming the
8880 target implements the old QTro packet then). */
8881 if (traceframe_available_memory (&available
, memaddr
, len
))
8883 if (available
.empty () || available
[0].start
!= memaddr
)
8885 enum target_xfer_status res
;
8887 /* Don't read into the traceframe's available
8889 if (!available
.empty ())
8891 LONGEST oldlen
= len
;
8893 len
= available
[0].start
- memaddr
;
8894 gdb_assert (len
<= oldlen
);
8897 /* This goes through the topmost target again. */
8898 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
8899 len
, unit_size
, xfered_len
);
8900 if (res
== TARGET_XFER_OK
)
8901 return TARGET_XFER_OK
;
8904 /* No use trying further, we know some memory starting
8905 at MEMADDR isn't available. */
8907 return (*xfered_len
!= 0) ?
8908 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
8912 /* Don't try to read more than how much is available, in
8913 case the target implements the deprecated QTro packet to
8914 cater for older GDBs (the target's knowledge of read-only
8915 sections may be outdated by now). */
8916 len
= available
[0].length
;
8920 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8925 /* Sends a packet with content determined by the printf format string
8926 FORMAT and the remaining arguments, then gets the reply. Returns
8927 whether the packet was a success, a failure, or unknown. */
8930 remote_target::remote_send_printf (const char *format
, ...)
8932 struct remote_state
*rs
= get_remote_state ();
8933 int max_size
= get_remote_packet_size ();
8936 va_start (ap
, format
);
8939 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
8943 if (size
>= max_size
)
8944 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8946 if (putpkt (rs
->buf
) < 0)
8947 error (_("Communication problem with target."));
8950 getpkt (&rs
->buf
, 0);
8952 return packet_check_result (rs
->buf
);
8955 /* Flash writing can take quite some time. We'll set
8956 effectively infinite timeout for flash operations.
8957 In future, we'll need to decide on a better approach. */
8958 static const int remote_flash_timeout
= 1000;
8961 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
8963 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8964 enum packet_result ret
;
8965 scoped_restore restore_timeout
8966 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8968 ret
= remote_send_printf ("vFlashErase:%s,%s",
8969 phex (address
, addr_size
),
8973 case PACKET_UNKNOWN
:
8974 error (_("Remote target does not support flash erase"));
8976 error (_("Error erasing flash with vFlashErase packet"));
8983 remote_target::remote_flash_write (ULONGEST address
,
8984 ULONGEST length
, ULONGEST
*xfered_len
,
8985 const gdb_byte
*data
)
8987 scoped_restore restore_timeout
8988 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8989 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8994 remote_target::flash_done ()
8998 scoped_restore restore_timeout
8999 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9001 ret
= remote_send_printf ("vFlashDone");
9005 case PACKET_UNKNOWN
:
9006 error (_("Remote target does not support vFlashDone"));
9008 error (_("Error finishing flash operation"));
9015 remote_target::files_info ()
9017 puts_filtered ("Debugging a target over a serial line.\n");
9020 /* Stuff for dealing with the packets which are part of this protocol.
9021 See comment at top of file for details. */
9023 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
9024 error to higher layers. Called when a serial error is detected.
9025 The exception message is STRING, followed by a colon and a blank,
9026 the system error message for errno at function entry and final dot
9027 for output compatibility with throw_perror_with_name. */
9030 unpush_and_perror (remote_target
*target
, const char *string
)
9032 int saved_errno
= errno
;
9034 remote_unpush_target (target
);
9035 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
9036 safe_strerror (saved_errno
));
9039 /* Read a single character from the remote end. The current quit
9040 handler is overridden to avoid quitting in the middle of packet
9041 sequence, as that would break communication with the remote server.
9042 See remote_serial_quit_handler for more detail. */
9045 remote_target::readchar (int timeout
)
9048 struct remote_state
*rs
= get_remote_state ();
9051 scoped_restore restore_quit_target
9052 = make_scoped_restore (&curr_quit_handler_target
, this);
9053 scoped_restore restore_quit
9054 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9056 rs
->got_ctrlc_during_io
= 0;
9058 ch
= serial_readchar (rs
->remote_desc
, timeout
);
9060 if (rs
->got_ctrlc_during_io
)
9067 switch ((enum serial_rc
) ch
)
9070 remote_unpush_target (this);
9071 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9074 unpush_and_perror (this, _("Remote communication error. "
9075 "Target disconnected."));
9077 case SERIAL_TIMEOUT
:
9083 /* Wrapper for serial_write that closes the target and throws if
9084 writing fails. The current quit handler is overridden to avoid
9085 quitting in the middle of packet sequence, as that would break
9086 communication with the remote server. See
9087 remote_serial_quit_handler for more detail. */
9090 remote_target::remote_serial_write (const char *str
, int len
)
9092 struct remote_state
*rs
= get_remote_state ();
9094 scoped_restore restore_quit_target
9095 = make_scoped_restore (&curr_quit_handler_target
, this);
9096 scoped_restore restore_quit
9097 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9099 rs
->got_ctrlc_during_io
= 0;
9101 if (serial_write (rs
->remote_desc
, str
, len
))
9103 unpush_and_perror (this, _("Remote communication error. "
9104 "Target disconnected."));
9107 if (rs
->got_ctrlc_during_io
)
9111 /* Return a string representing an escaped version of BUF, of len N.
9112 E.g. \n is converted to \\n, \t to \\t, etc. */
9115 escape_buffer (const char *buf
, int n
)
9119 stb
.putstrn (buf
, n
, '\\');
9120 return std::move (stb
.string ());
9123 /* Display a null-terminated packet on stdout, for debugging, using C
9127 print_packet (const char *buf
)
9129 puts_filtered ("\"");
9130 fputstr_filtered (buf
, '"', gdb_stdout
);
9131 puts_filtered ("\"");
9135 remote_target::putpkt (const char *buf
)
9137 return putpkt_binary (buf
, strlen (buf
));
9140 /* Wrapper around remote_target::putpkt to avoid exporting
9144 putpkt (remote_target
*remote
, const char *buf
)
9146 return remote
->putpkt (buf
);
9149 /* Send a packet to the remote machine, with error checking. The data
9150 of the packet is in BUF. The string in BUF can be at most
9151 get_remote_packet_size () - 5 to account for the $, # and checksum,
9152 and for a possible /0 if we are debugging (remote_debug) and want
9153 to print the sent packet as a string. */
9156 remote_target::putpkt_binary (const char *buf
, int cnt
)
9158 struct remote_state
*rs
= get_remote_state ();
9160 unsigned char csum
= 0;
9161 gdb::def_vector
<char> data (cnt
+ 6);
9162 char *buf2
= data
.data ();
9168 /* Catch cases like trying to read memory or listing threads while
9169 we're waiting for a stop reply. The remote server wouldn't be
9170 ready to handle this request, so we'd hang and timeout. We don't
9171 have to worry about this in synchronous mode, because in that
9172 case it's not possible to issue a command while the target is
9173 running. This is not a problem in non-stop mode, because in that
9174 case, the stub is always ready to process serial input. */
9175 if (!target_is_non_stop_p ()
9176 && target_is_async_p ()
9177 && rs
->waiting_for_stop_reply
)
9179 error (_("Cannot execute this command while the target is running.\n"
9180 "Use the \"interrupt\" command to stop the target\n"
9181 "and then try again."));
9184 /* We're sending out a new packet. Make sure we don't look at a
9185 stale cached response. */
9186 rs
->cached_wait_status
= 0;
9188 /* Copy the packet into buffer BUF2, encapsulating it
9189 and giving it a checksum. */
9194 for (i
= 0; i
< cnt
; i
++)
9200 *p
++ = tohex ((csum
>> 4) & 0xf);
9201 *p
++ = tohex (csum
& 0xf);
9203 /* Send it over and over until we get a positive ack. */
9207 int started_error_output
= 0;
9213 int len
= (int) (p
- buf2
);
9216 if (remote_packet_max_chars
< 0)
9219 max_chars
= remote_packet_max_chars
;
9222 = escape_buffer (buf2
, std::min (len
, max_chars
));
9224 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9226 if (len
> max_chars
)
9227 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9230 fprintf_unfiltered (gdb_stdlog
, "...");
9232 gdb_flush (gdb_stdlog
);
9234 remote_serial_write (buf2
, p
- buf2
);
9236 /* If this is a no acks version of the remote protocol, send the
9237 packet and move on. */
9241 /* Read until either a timeout occurs (-2) or '+' is read.
9242 Handle any notification that arrives in the mean time. */
9245 ch
= readchar (remote_timeout
);
9253 case SERIAL_TIMEOUT
:
9256 if (started_error_output
)
9258 putchar_unfiltered ('\n');
9259 started_error_output
= 0;
9268 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9272 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9274 case SERIAL_TIMEOUT
:
9278 break; /* Retransmit buffer. */
9282 fprintf_unfiltered (gdb_stdlog
,
9283 "Packet instead of Ack, ignoring it\n");
9284 /* It's probably an old response sent because an ACK
9285 was lost. Gobble up the packet and ack it so it
9286 doesn't get retransmitted when we resend this
9289 remote_serial_write ("+", 1);
9290 continue; /* Now, go look for +. */
9297 /* If we got a notification, handle it, and go back to looking
9299 /* We've found the start of a notification. Now
9300 collect the data. */
9301 val
= read_frame (&rs
->buf
);
9306 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9308 fprintf_unfiltered (gdb_stdlog
,
9309 " Notification received: %s\n",
9312 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9313 /* We're in sync now, rewait for the ack. */
9320 if (!started_error_output
)
9322 started_error_output
= 1;
9323 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9325 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9326 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9335 if (!started_error_output
)
9337 started_error_output
= 1;
9338 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9340 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9344 break; /* Here to retransmit. */
9348 /* This is wrong. If doing a long backtrace, the user should be
9349 able to get out next time we call QUIT, without anything as
9350 violent as interrupt_query. If we want to provide a way out of
9351 here without getting to the next QUIT, it should be based on
9352 hitting ^C twice as in remote_wait. */
9364 /* Come here after finding the start of a frame when we expected an
9365 ack. Do our best to discard the rest of this packet. */
9368 remote_target::skip_frame ()
9374 c
= readchar (remote_timeout
);
9377 case SERIAL_TIMEOUT
:
9378 /* Nothing we can do. */
9381 /* Discard the two bytes of checksum and stop. */
9382 c
= readchar (remote_timeout
);
9384 c
= readchar (remote_timeout
);
9387 case '*': /* Run length encoding. */
9388 /* Discard the repeat count. */
9389 c
= readchar (remote_timeout
);
9394 /* A regular character. */
9400 /* Come here after finding the start of the frame. Collect the rest
9401 into *BUF, verifying the checksum, length, and handling run-length
9402 compression. NUL terminate the buffer. If there is not enough room,
9405 Returns -1 on error, number of characters in buffer (ignoring the
9406 trailing NULL) on success. (could be extended to return one of the
9407 SERIAL status indications). */
9410 remote_target::read_frame (gdb::char_vector
*buf_p
)
9415 char *buf
= buf_p
->data ();
9416 struct remote_state
*rs
= get_remote_state ();
9423 c
= readchar (remote_timeout
);
9426 case SERIAL_TIMEOUT
:
9428 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9432 fputs_filtered ("Saw new packet start in middle of old one\n",
9434 return -1; /* Start a new packet, count retries. */
9437 unsigned char pktcsum
;
9443 check_0
= readchar (remote_timeout
);
9445 check_1
= readchar (remote_timeout
);
9447 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9450 fputs_filtered ("Timeout in checksum, retrying\n",
9454 else if (check_0
< 0 || check_1
< 0)
9457 fputs_filtered ("Communication error in checksum\n",
9462 /* Don't recompute the checksum; with no ack packets we
9463 don't have any way to indicate a packet retransmission
9468 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9469 if (csum
== pktcsum
)
9474 std::string str
= escape_buffer (buf
, bc
);
9476 fprintf_unfiltered (gdb_stdlog
,
9477 "Bad checksum, sentsum=0x%x, "
9478 "csum=0x%x, buf=%s\n",
9479 pktcsum
, csum
, str
.c_str ());
9481 /* Number of characters in buffer ignoring trailing
9485 case '*': /* Run length encoding. */
9490 c
= readchar (remote_timeout
);
9492 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9494 /* The character before ``*'' is repeated. */
9496 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9498 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9500 /* Make some more room in the buffer. */
9501 buf_p
->resize (buf_p
->size () + repeat
);
9502 buf
= buf_p
->data ();
9505 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9511 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9515 if (bc
>= buf_p
->size () - 1)
9517 /* Make some more room in the buffer. */
9518 buf_p
->resize (buf_p
->size () * 2);
9519 buf
= buf_p
->data ();
9529 /* Set this to the maximum number of seconds to wait instead of waiting forever
9530 in target_wait(). If this timer times out, then it generates an error and
9531 the command is aborted. This replaces most of the need for timeouts in the
9532 GDB test suite, and makes it possible to distinguish between a hung target
9533 and one with slow communications. */
9535 static int watchdog
= 0;
9537 show_watchdog (struct ui_file
*file
, int from_tty
,
9538 struct cmd_list_element
*c
, const char *value
)
9540 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9543 /* Read a packet from the remote machine, with error checking, and
9544 store it in *BUF. Resize *BUF if necessary to hold the result. If
9545 FOREVER, wait forever rather than timing out; this is used (in
9546 synchronous mode) to wait for a target that is is executing user
9548 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9549 don't have to change all the calls to getpkt to deal with the
9550 return value, because at the moment I don't know what the right
9551 thing to do it for those. */
9554 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9556 getpkt_sane (buf
, forever
);
9560 /* Read a packet from the remote machine, with error checking, and
9561 store it in *BUF. Resize *BUF if necessary to hold the result. If
9562 FOREVER, wait forever rather than timing out; this is used (in
9563 synchronous mode) to wait for a target that is is executing user
9564 code to stop. If FOREVER == 0, this function is allowed to time
9565 out gracefully and return an indication of this to the caller.
9566 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9567 consider receiving a notification enough reason to return to the
9568 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9569 holds a notification or not (a regular packet). */
9572 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9573 int forever
, int expecting_notif
,
9576 struct remote_state
*rs
= get_remote_state ();
9582 /* We're reading a new response. Make sure we don't look at a
9583 previously cached response. */
9584 rs
->cached_wait_status
= 0;
9586 strcpy (buf
->data (), "timeout");
9589 timeout
= watchdog
> 0 ? watchdog
: -1;
9590 else if (expecting_notif
)
9591 timeout
= 0; /* There should already be a char in the buffer. If
9594 timeout
= remote_timeout
;
9598 /* Process any number of notifications, and then return when
9602 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9604 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9606 /* This can loop forever if the remote side sends us
9607 characters continuously, but if it pauses, we'll get
9608 SERIAL_TIMEOUT from readchar because of timeout. Then
9609 we'll count that as a retry.
9611 Note that even when forever is set, we will only wait
9612 forever prior to the start of a packet. After that, we
9613 expect characters to arrive at a brisk pace. They should
9614 show up within remote_timeout intervals. */
9616 c
= readchar (timeout
);
9617 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9619 if (c
== SERIAL_TIMEOUT
)
9621 if (expecting_notif
)
9622 return -1; /* Don't complain, it's normal to not get
9623 anything in this case. */
9625 if (forever
) /* Watchdog went off? Kill the target. */
9627 remote_unpush_target (this);
9628 throw_error (TARGET_CLOSE_ERROR
,
9629 _("Watchdog timeout has expired. "
9630 "Target detached."));
9633 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9637 /* We've found the start of a packet or notification.
9638 Now collect the data. */
9639 val
= read_frame (buf
);
9644 remote_serial_write ("-", 1);
9647 if (tries
> MAX_TRIES
)
9649 /* We have tried hard enough, and just can't receive the
9650 packet/notification. Give up. */
9651 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9653 /* Skip the ack char if we're in no-ack mode. */
9654 if (!rs
->noack_mode
)
9655 remote_serial_write ("+", 1);
9659 /* If we got an ordinary packet, return that to our caller. */
9666 if (remote_packet_max_chars
< 0)
9669 max_chars
= remote_packet_max_chars
;
9672 = escape_buffer (buf
->data (),
9673 std::min (val
, max_chars
));
9675 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9678 if (val
> max_chars
)
9679 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9682 fprintf_unfiltered (gdb_stdlog
, "\n");
9685 /* Skip the ack char if we're in no-ack mode. */
9686 if (!rs
->noack_mode
)
9687 remote_serial_write ("+", 1);
9688 if (is_notif
!= NULL
)
9693 /* If we got a notification, handle it, and go back to looking
9697 gdb_assert (c
== '%');
9701 std::string str
= escape_buffer (buf
->data (), val
);
9703 fprintf_unfiltered (gdb_stdlog
,
9704 " Notification received: %s\n",
9707 if (is_notif
!= NULL
)
9710 handle_notification (rs
->notif_state
, buf
->data ());
9712 /* Notifications require no acknowledgement. */
9714 if (expecting_notif
)
9721 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9723 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9727 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9730 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9733 /* Kill any new fork children of process PID that haven't been
9734 processed by follow_fork. */
9737 remote_target::kill_new_fork_children (int pid
)
9739 remote_state
*rs
= get_remote_state ();
9740 struct notif_client
*notif
= ¬if_client_stop
;
9742 /* Kill the fork child threads of any threads in process PID
9743 that are stopped at a fork event. */
9744 for (thread_info
*thread
: all_non_exited_threads (this))
9746 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9748 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9750 int child_pid
= ws
->value
.related_pid
.pid ();
9753 res
= remote_vkill (child_pid
);
9755 error (_("Can't kill fork child process %d"), child_pid
);
9759 /* Check for any pending fork events (not reported or processed yet)
9760 in process PID and kill those fork child threads as well. */
9761 remote_notif_get_pending_events (notif
);
9762 for (auto &event
: rs
->stop_reply_queue
)
9763 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9765 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9768 res
= remote_vkill (child_pid
);
9770 error (_("Can't kill fork child process %d"), child_pid
);
9775 /* Target hook to kill the current inferior. */
9778 remote_target::kill ()
9781 int pid
= inferior_ptid
.pid ();
9782 struct remote_state
*rs
= get_remote_state ();
9784 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9786 /* If we're stopped while forking and we haven't followed yet,
9787 kill the child task. We need to do this before killing the
9788 parent task because if this is a vfork then the parent will
9790 kill_new_fork_children (pid
);
9792 res
= remote_vkill (pid
);
9795 target_mourn_inferior (inferior_ptid
);
9800 /* If we are in 'target remote' mode and we are killing the only
9801 inferior, then we will tell gdbserver to exit and unpush the
9803 if (res
== -1 && !remote_multi_process_p (rs
)
9804 && number_of_live_inferiors (this) == 1)
9808 /* We've killed the remote end, we get to mourn it. If we are
9809 not in extended mode, mourning the inferior also unpushes
9810 remote_ops from the target stack, which closes the remote
9812 target_mourn_inferior (inferior_ptid
);
9817 error (_("Can't kill process"));
9820 /* Send a kill request to the target using the 'vKill' packet. */
9823 remote_target::remote_vkill (int pid
)
9825 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9828 remote_state
*rs
= get_remote_state ();
9830 /* Tell the remote target to detach. */
9831 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
9833 getpkt (&rs
->buf
, 0);
9835 switch (packet_ok (rs
->buf
,
9836 &remote_protocol_packets
[PACKET_vKill
]))
9842 case PACKET_UNKNOWN
:
9845 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9849 /* Send a kill request to the target using the 'k' packet. */
9852 remote_target::remote_kill_k ()
9854 /* Catch errors so the user can quit from gdb even when we
9855 aren't on speaking terms with the remote system. */
9860 catch (const gdb_exception_error
&ex
)
9862 if (ex
.error
== TARGET_CLOSE_ERROR
)
9864 /* If we got an (EOF) error that caused the target
9865 to go away, then we're done, that's what we wanted.
9866 "k" is susceptible to cause a premature EOF, given
9867 that the remote server isn't actually required to
9868 reply to "k", and it can happen that it doesn't
9869 even get to reply ACK to the "k". */
9873 /* Otherwise, something went wrong. We didn't actually kill
9874 the target. Just propagate the exception, and let the
9875 user or higher layers decide what to do. */
9881 remote_target::mourn_inferior ()
9883 struct remote_state
*rs
= get_remote_state ();
9885 /* We're no longer interested in notification events of an inferior
9886 that exited or was killed/detached. */
9887 discard_pending_stop_replies (current_inferior ());
9889 /* In 'target remote' mode with one inferior, we close the connection. */
9890 if (!rs
->extended
&& number_of_live_inferiors (this) <= 1)
9892 remote_unpush_target (this);
9896 /* In case we got here due to an error, but we're going to stay
9898 rs
->waiting_for_stop_reply
= 0;
9900 /* If the current general thread belonged to the process we just
9901 detached from or has exited, the remote side current general
9902 thread becomes undefined. Considering a case like this:
9904 - We just got here due to a detach.
9905 - The process that we're detaching from happens to immediately
9906 report a global breakpoint being hit in non-stop mode, in the
9907 same thread we had selected before.
9908 - GDB attaches to this process again.
9909 - This event happens to be the next event we handle.
9911 GDB would consider that the current general thread didn't need to
9912 be set on the stub side (with Hg), since for all it knew,
9913 GENERAL_THREAD hadn't changed.
9915 Notice that although in all-stop mode, the remote server always
9916 sets the current thread to the thread reporting the stop event,
9917 that doesn't happen in non-stop mode; in non-stop, the stub *must
9918 not* change the current thread when reporting a breakpoint hit,
9919 due to the decoupling of event reporting and event handling.
9921 To keep things simple, we always invalidate our notion of the
9923 record_currthread (rs
, minus_one_ptid
);
9925 /* Call common code to mark the inferior as not running. */
9926 generic_mourn_inferior ();
9930 extended_remote_target::supports_disable_randomization ()
9932 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9936 remote_target::extended_remote_disable_randomization (int val
)
9938 struct remote_state
*rs
= get_remote_state ();
9941 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9942 "QDisableRandomization:%x", val
);
9944 reply
= remote_get_noisy_reply ();
9946 error (_("Target does not support QDisableRandomization."));
9947 if (strcmp (reply
, "OK") != 0)
9948 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9952 remote_target::extended_remote_run (const std::string
&args
)
9954 struct remote_state
*rs
= get_remote_state ();
9956 const char *remote_exec_file
= get_remote_exec_file ();
9958 /* If the user has disabled vRun support, or we have detected that
9959 support is not available, do not try it. */
9960 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9963 strcpy (rs
->buf
.data (), "vRun;");
9964 len
= strlen (rs
->buf
.data ());
9966 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9967 error (_("Remote file name too long for run packet"));
9968 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
9969 strlen (remote_exec_file
));
9975 gdb_argv
argv (args
.c_str ());
9976 for (i
= 0; argv
[i
] != NULL
; i
++)
9978 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9979 error (_("Argument list too long for run packet"));
9980 rs
->buf
[len
++] = ';';
9981 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
9986 rs
->buf
[len
++] = '\0';
9989 getpkt (&rs
->buf
, 0);
9991 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9994 /* We have a wait response. All is well. */
9996 case PACKET_UNKNOWN
:
9999 if (remote_exec_file
[0] == '\0')
10000 error (_("Running the default executable on the remote target failed; "
10001 "try \"set remote exec-file\"?"));
10003 error (_("Running \"%s\" on the remote target failed"),
10006 gdb_assert_not_reached (_("bad switch"));
10010 /* Helper function to send set/unset environment packets. ACTION is
10011 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
10012 or "QEnvironmentUnsetVariable". VALUE is the variable to be
10016 remote_target::send_environment_packet (const char *action
,
10017 const char *packet
,
10020 remote_state
*rs
= get_remote_state ();
10022 /* Convert the environment variable to an hex string, which
10023 is the best format to be transmitted over the wire. */
10024 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
10027 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10028 "%s:%s", packet
, encoded_value
.c_str ());
10031 getpkt (&rs
->buf
, 0);
10032 if (strcmp (rs
->buf
.data (), "OK") != 0)
10033 warning (_("Unable to %s environment variable '%s' on remote."),
10037 /* Helper function to handle the QEnvironment* packets. */
10040 remote_target::extended_remote_environment_support ()
10042 remote_state
*rs
= get_remote_state ();
10044 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
10046 putpkt ("QEnvironmentReset");
10047 getpkt (&rs
->buf
, 0);
10048 if (strcmp (rs
->buf
.data (), "OK") != 0)
10049 warning (_("Unable to reset environment on remote."));
10052 gdb_environ
*e
= ¤t_inferior ()->environment
;
10054 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
10055 for (const std::string
&el
: e
->user_set_env ())
10056 send_environment_packet ("set", "QEnvironmentHexEncoded",
10059 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
10060 for (const std::string
&el
: e
->user_unset_env ())
10061 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10064 /* Helper function to set the current working directory for the
10065 inferior in the remote target. */
10068 remote_target::extended_remote_set_inferior_cwd ()
10070 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10072 const char *inferior_cwd
= get_inferior_cwd ();
10073 remote_state
*rs
= get_remote_state ();
10075 if (inferior_cwd
!= NULL
)
10077 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10078 strlen (inferior_cwd
));
10080 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10081 "QSetWorkingDir:%s", hexpath
.c_str ());
10085 /* An empty inferior_cwd means that the user wants us to
10086 reset the remote server's inferior's cwd. */
10087 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10088 "QSetWorkingDir:");
10092 getpkt (&rs
->buf
, 0);
10093 if (packet_ok (rs
->buf
,
10094 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10097 Remote replied unexpectedly while setting the inferior's working\n\
10104 /* In the extended protocol we want to be able to do things like
10105 "run" and have them basically work as expected. So we need
10106 a special create_inferior function. We support changing the
10107 executable file and the command line arguments, but not the
10111 extended_remote_target::create_inferior (const char *exec_file
,
10112 const std::string
&args
,
10113 char **env
, int from_tty
)
10117 struct remote_state
*rs
= get_remote_state ();
10118 const char *remote_exec_file
= get_remote_exec_file ();
10120 /* If running asynchronously, register the target file descriptor
10121 with the event loop. */
10122 if (target_can_async_p ())
10125 /* Disable address space randomization if requested (and supported). */
10126 if (supports_disable_randomization ())
10127 extended_remote_disable_randomization (disable_randomization
);
10129 /* If startup-with-shell is on, we inform gdbserver to start the
10130 remote inferior using a shell. */
10131 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10133 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10134 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10136 getpkt (&rs
->buf
, 0);
10137 if (strcmp (rs
->buf
.data (), "OK") != 0)
10139 Remote replied unexpectedly while setting startup-with-shell: %s"),
10143 extended_remote_environment_support ();
10145 extended_remote_set_inferior_cwd ();
10147 /* Now restart the remote server. */
10148 run_worked
= extended_remote_run (args
) != -1;
10151 /* vRun was not supported. Fail if we need it to do what the
10153 if (remote_exec_file
[0])
10154 error (_("Remote target does not support \"set remote exec-file\""));
10155 if (!args
.empty ())
10156 error (_("Remote target does not support \"set args\" or run ARGS"));
10158 /* Fall back to "R". */
10159 extended_remote_restart ();
10162 /* vRun's success return is a stop reply. */
10163 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10164 add_current_inferior_and_thread (stop_reply
);
10166 /* Get updated offsets, if the stub uses qOffsets. */
10171 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10172 the list of conditions (in agent expression bytecode format), if any, the
10173 target needs to evaluate. The output is placed into the packet buffer
10174 started from BUF and ended at BUF_END. */
10177 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10178 struct bp_target_info
*bp_tgt
, char *buf
,
10181 if (bp_tgt
->conditions
.empty ())
10184 buf
+= strlen (buf
);
10185 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10188 /* Send conditions to the target. */
10189 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10191 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10192 buf
+= strlen (buf
);
10193 for (int i
= 0; i
< aexpr
->len
; ++i
)
10194 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10201 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10202 struct bp_target_info
*bp_tgt
, char *buf
)
10204 if (bp_tgt
->tcommands
.empty ())
10207 buf
+= strlen (buf
);
10209 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10210 buf
+= strlen (buf
);
10212 /* Concatenate all the agent expressions that are commands into the
10214 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10216 sprintf (buf
, "X%x,", aexpr
->len
);
10217 buf
+= strlen (buf
);
10218 for (int i
= 0; i
< aexpr
->len
; ++i
)
10219 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10224 /* Insert a breakpoint. On targets that have software breakpoint
10225 support, we ask the remote target to do the work; on targets
10226 which don't, we insert a traditional memory breakpoint. */
10229 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10230 struct bp_target_info
*bp_tgt
)
10232 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10233 If it succeeds, then set the support to PACKET_ENABLE. If it
10234 fails, and the user has explicitly requested the Z support then
10235 report an error, otherwise, mark it disabled and go on. */
10237 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10239 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10240 struct remote_state
*rs
;
10243 /* Make sure the remote is pointing at the right process, if
10245 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10246 set_general_process ();
10248 rs
= get_remote_state ();
10249 p
= rs
->buf
.data ();
10250 endbuf
= p
+ get_remote_packet_size ();
10255 addr
= (ULONGEST
) remote_address_masked (addr
);
10256 p
+= hexnumstr (p
, addr
);
10257 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10259 if (supports_evaluation_of_breakpoint_conditions ())
10260 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10262 if (can_run_breakpoint_commands ())
10263 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10266 getpkt (&rs
->buf
, 0);
10268 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10274 case PACKET_UNKNOWN
:
10279 /* If this breakpoint has target-side commands but this stub doesn't
10280 support Z0 packets, throw error. */
10281 if (!bp_tgt
->tcommands
.empty ())
10282 throw_error (NOT_SUPPORTED_ERROR
, _("\
10283 Target doesn't support breakpoints that have target side commands."));
10285 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10289 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10290 struct bp_target_info
*bp_tgt
,
10291 enum remove_bp_reason reason
)
10293 CORE_ADDR addr
= bp_tgt
->placed_address
;
10294 struct remote_state
*rs
= get_remote_state ();
10296 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10298 char *p
= rs
->buf
.data ();
10299 char *endbuf
= p
+ get_remote_packet_size ();
10301 /* Make sure the remote is pointing at the right process, if
10303 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10304 set_general_process ();
10310 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10311 p
+= hexnumstr (p
, addr
);
10312 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10315 getpkt (&rs
->buf
, 0);
10317 return (rs
->buf
[0] == 'E');
10320 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10323 static enum Z_packet_type
10324 watchpoint_to_Z_packet (int type
)
10329 return Z_PACKET_WRITE_WP
;
10332 return Z_PACKET_READ_WP
;
10335 return Z_PACKET_ACCESS_WP
;
10338 internal_error (__FILE__
, __LINE__
,
10339 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10344 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10345 enum target_hw_bp_type type
, struct expression
*cond
)
10347 struct remote_state
*rs
= get_remote_state ();
10348 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10350 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10352 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10355 /* Make sure the remote is pointing at the right process, if
10357 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10358 set_general_process ();
10360 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10361 p
= strchr (rs
->buf
.data (), '\0');
10362 addr
= remote_address_masked (addr
);
10363 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10364 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10367 getpkt (&rs
->buf
, 0);
10369 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10373 case PACKET_UNKNOWN
:
10378 internal_error (__FILE__
, __LINE__
,
10379 _("remote_insert_watchpoint: reached end of function"));
10383 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10384 CORE_ADDR start
, int length
)
10386 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10388 return diff
< length
;
10393 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10394 enum target_hw_bp_type type
, struct expression
*cond
)
10396 struct remote_state
*rs
= get_remote_state ();
10397 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10399 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10401 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10404 /* Make sure the remote is pointing at the right process, if
10406 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10407 set_general_process ();
10409 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10410 p
= strchr (rs
->buf
.data (), '\0');
10411 addr
= remote_address_masked (addr
);
10412 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10413 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10415 getpkt (&rs
->buf
, 0);
10417 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10420 case PACKET_UNKNOWN
:
10425 internal_error (__FILE__
, __LINE__
,
10426 _("remote_remove_watchpoint: reached end of function"));
10430 static int remote_hw_watchpoint_limit
= -1;
10431 static int remote_hw_watchpoint_length_limit
= -1;
10432 static int remote_hw_breakpoint_limit
= -1;
10435 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10437 if (remote_hw_watchpoint_length_limit
== 0)
10439 else if (remote_hw_watchpoint_length_limit
< 0)
10441 else if (len
<= remote_hw_watchpoint_length_limit
)
10448 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10450 if (type
== bp_hardware_breakpoint
)
10452 if (remote_hw_breakpoint_limit
== 0)
10454 else if (remote_hw_breakpoint_limit
< 0)
10456 else if (cnt
<= remote_hw_breakpoint_limit
)
10461 if (remote_hw_watchpoint_limit
== 0)
10463 else if (remote_hw_watchpoint_limit
< 0)
10467 else if (cnt
<= remote_hw_watchpoint_limit
)
10473 /* The to_stopped_by_sw_breakpoint method of target remote. */
10476 remote_target::stopped_by_sw_breakpoint ()
10478 struct thread_info
*thread
= inferior_thread ();
10480 return (thread
->priv
!= NULL
10481 && (get_remote_thread_info (thread
)->stop_reason
10482 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10485 /* The to_supports_stopped_by_sw_breakpoint method of target
10489 remote_target::supports_stopped_by_sw_breakpoint ()
10491 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10494 /* The to_stopped_by_hw_breakpoint method of target remote. */
10497 remote_target::stopped_by_hw_breakpoint ()
10499 struct thread_info
*thread
= inferior_thread ();
10501 return (thread
->priv
!= NULL
10502 && (get_remote_thread_info (thread
)->stop_reason
10503 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10506 /* The to_supports_stopped_by_hw_breakpoint method of target
10510 remote_target::supports_stopped_by_hw_breakpoint ()
10512 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10516 remote_target::stopped_by_watchpoint ()
10518 struct thread_info
*thread
= inferior_thread ();
10520 return (thread
->priv
!= NULL
10521 && (get_remote_thread_info (thread
)->stop_reason
10522 == TARGET_STOPPED_BY_WATCHPOINT
));
10526 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10528 struct thread_info
*thread
= inferior_thread ();
10530 if (thread
->priv
!= NULL
10531 && (get_remote_thread_info (thread
)->stop_reason
10532 == TARGET_STOPPED_BY_WATCHPOINT
))
10534 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10543 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10544 struct bp_target_info
*bp_tgt
)
10546 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10547 struct remote_state
*rs
;
10551 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10554 /* Make sure the remote is pointing at the right process, if
10556 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10557 set_general_process ();
10559 rs
= get_remote_state ();
10560 p
= rs
->buf
.data ();
10561 endbuf
= p
+ get_remote_packet_size ();
10567 addr
= remote_address_masked (addr
);
10568 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10569 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10571 if (supports_evaluation_of_breakpoint_conditions ())
10572 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10574 if (can_run_breakpoint_commands ())
10575 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10578 getpkt (&rs
->buf
, 0);
10580 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10583 if (rs
->buf
[1] == '.')
10585 message
= strchr (&rs
->buf
[2], '.');
10587 error (_("Remote failure reply: %s"), message
+ 1);
10590 case PACKET_UNKNOWN
:
10595 internal_error (__FILE__
, __LINE__
,
10596 _("remote_insert_hw_breakpoint: reached end of function"));
10601 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10602 struct bp_target_info
*bp_tgt
)
10605 struct remote_state
*rs
= get_remote_state ();
10606 char *p
= rs
->buf
.data ();
10607 char *endbuf
= p
+ get_remote_packet_size ();
10609 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10612 /* Make sure the remote is pointing at the right process, if
10614 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10615 set_general_process ();
10621 addr
= remote_address_masked (bp_tgt
->placed_address
);
10622 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10623 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10626 getpkt (&rs
->buf
, 0);
10628 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10631 case PACKET_UNKNOWN
:
10636 internal_error (__FILE__
, __LINE__
,
10637 _("remote_remove_hw_breakpoint: reached end of function"));
10640 /* Verify memory using the "qCRC:" request. */
10643 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10645 struct remote_state
*rs
= get_remote_state ();
10646 unsigned long host_crc
, target_crc
;
10649 /* It doesn't make sense to use qCRC if the remote target is
10650 connected but not running. */
10651 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10653 enum packet_result result
;
10655 /* Make sure the remote is pointing at the right process. */
10656 set_general_process ();
10658 /* FIXME: assumes lma can fit into long. */
10659 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10660 (long) lma
, (long) size
);
10663 /* Be clever; compute the host_crc before waiting for target
10665 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10667 getpkt (&rs
->buf
, 0);
10669 result
= packet_ok (rs
->buf
,
10670 &remote_protocol_packets
[PACKET_qCRC
]);
10671 if (result
== PACKET_ERROR
)
10673 else if (result
== PACKET_OK
)
10675 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10676 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10678 return (host_crc
== target_crc
);
10682 return simple_verify_memory (this, data
, lma
, size
);
10685 /* compare-sections command
10687 With no arguments, compares each loadable section in the exec bfd
10688 with the same memory range on the target, and reports mismatches.
10689 Useful for verifying the image on the target against the exec file. */
10692 compare_sections_command (const char *args
, int from_tty
)
10695 const char *sectname
;
10696 bfd_size_type size
;
10699 int mismatched
= 0;
10704 error (_("command cannot be used without an exec file"));
10706 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10712 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10714 if (!(s
->flags
& SEC_LOAD
))
10715 continue; /* Skip non-loadable section. */
10717 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10718 continue; /* Skip writeable sections */
10720 size
= bfd_section_size (s
);
10722 continue; /* Skip zero-length section. */
10724 sectname
= bfd_section_name (s
);
10725 if (args
&& strcmp (args
, sectname
) != 0)
10726 continue; /* Not the section selected by user. */
10728 matched
= 1; /* Do this section. */
10731 gdb::byte_vector
sectdata (size
);
10732 bfd_get_section_contents (exec_bfd
, s
, sectdata
.data (), 0, size
);
10734 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10737 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10738 paddress (target_gdbarch (), lma
),
10739 paddress (target_gdbarch (), lma
+ size
));
10741 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10742 paddress (target_gdbarch (), lma
),
10743 paddress (target_gdbarch (), lma
+ size
));
10745 printf_filtered ("matched.\n");
10748 printf_filtered ("MIS-MATCHED!\n");
10752 if (mismatched
> 0)
10753 warning (_("One or more sections of the target image does not match\n\
10754 the loaded file\n"));
10755 if (args
&& !matched
)
10756 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10759 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10760 into remote target. The number of bytes written to the remote
10761 target is returned, or -1 for error. */
10764 remote_target::remote_write_qxfer (const char *object_name
,
10765 const char *annex
, const gdb_byte
*writebuf
,
10766 ULONGEST offset
, LONGEST len
,
10767 ULONGEST
*xfered_len
,
10768 struct packet_config
*packet
)
10772 struct remote_state
*rs
= get_remote_state ();
10773 int max_size
= get_memory_write_packet_size ();
10775 if (packet_config_support (packet
) == PACKET_DISABLE
)
10776 return TARGET_XFER_E_IO
;
10778 /* Insert header. */
10779 i
= snprintf (rs
->buf
.data (), max_size
,
10780 "qXfer:%s:write:%s:%s:",
10781 object_name
, annex
? annex
: "",
10782 phex_nz (offset
, sizeof offset
));
10783 max_size
-= (i
+ 1);
10785 /* Escape as much data as fits into rs->buf. */
10786 buf_len
= remote_escape_output
10787 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10789 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10790 || getpkt_sane (&rs
->buf
, 0) < 0
10791 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10792 return TARGET_XFER_E_IO
;
10794 unpack_varlen_hex (rs
->buf
.data (), &n
);
10797 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10800 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10801 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10802 number of bytes read is returned, or 0 for EOF, or -1 for error.
10803 The number of bytes read may be less than LEN without indicating an
10804 EOF. PACKET is checked and updated to indicate whether the remote
10805 target supports this object. */
10808 remote_target::remote_read_qxfer (const char *object_name
,
10810 gdb_byte
*readbuf
, ULONGEST offset
,
10812 ULONGEST
*xfered_len
,
10813 struct packet_config
*packet
)
10815 struct remote_state
*rs
= get_remote_state ();
10816 LONGEST i
, n
, packet_len
;
10818 if (packet_config_support (packet
) == PACKET_DISABLE
)
10819 return TARGET_XFER_E_IO
;
10821 /* Check whether we've cached an end-of-object packet that matches
10823 if (rs
->finished_object
)
10825 if (strcmp (object_name
, rs
->finished_object
) == 0
10826 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10827 && offset
== rs
->finished_offset
)
10828 return TARGET_XFER_EOF
;
10831 /* Otherwise, we're now reading something different. Discard
10833 xfree (rs
->finished_object
);
10834 xfree (rs
->finished_annex
);
10835 rs
->finished_object
= NULL
;
10836 rs
->finished_annex
= NULL
;
10839 /* Request only enough to fit in a single packet. The actual data
10840 may not, since we don't know how much of it will need to be escaped;
10841 the target is free to respond with slightly less data. We subtract
10842 five to account for the response type and the protocol frame. */
10843 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10844 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
10845 "qXfer:%s:read:%s:%s,%s",
10846 object_name
, annex
? annex
: "",
10847 phex_nz (offset
, sizeof offset
),
10848 phex_nz (n
, sizeof n
));
10849 i
= putpkt (rs
->buf
);
10851 return TARGET_XFER_E_IO
;
10854 packet_len
= getpkt_sane (&rs
->buf
, 0);
10855 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10856 return TARGET_XFER_E_IO
;
10858 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10859 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
10861 /* 'm' means there is (or at least might be) more data after this
10862 batch. That does not make sense unless there's at least one byte
10863 of data in this reply. */
10864 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10865 error (_("Remote qXfer reply contained no data."));
10867 /* Got some data. */
10868 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
10869 packet_len
- 1, readbuf
, n
);
10871 /* 'l' is an EOF marker, possibly including a final block of data,
10872 or possibly empty. If we have the final block of a non-empty
10873 object, record this fact to bypass a subsequent partial read. */
10874 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10876 rs
->finished_object
= xstrdup (object_name
);
10877 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10878 rs
->finished_offset
= offset
+ i
;
10882 return TARGET_XFER_EOF
;
10886 return TARGET_XFER_OK
;
10890 enum target_xfer_status
10891 remote_target::xfer_partial (enum target_object object
,
10892 const char *annex
, gdb_byte
*readbuf
,
10893 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10894 ULONGEST
*xfered_len
)
10896 struct remote_state
*rs
;
10900 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10902 set_remote_traceframe ();
10903 set_general_thread (inferior_ptid
);
10905 rs
= get_remote_state ();
10907 /* Handle memory using the standard memory routines. */
10908 if (object
== TARGET_OBJECT_MEMORY
)
10910 /* If the remote target is connected but not running, we should
10911 pass this request down to a lower stratum (e.g. the executable
10913 if (!target_has_execution
)
10914 return TARGET_XFER_EOF
;
10916 if (writebuf
!= NULL
)
10917 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10920 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
10924 /* Handle extra signal info using qxfer packets. */
10925 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10928 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
10929 xfered_len
, &remote_protocol_packets
10930 [PACKET_qXfer_siginfo_read
]);
10932 return remote_write_qxfer ("siginfo", annex
,
10933 writebuf
, offset
, len
, xfered_len
,
10934 &remote_protocol_packets
10935 [PACKET_qXfer_siginfo_write
]);
10938 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10941 return remote_read_qxfer ("statictrace", annex
,
10942 readbuf
, offset
, len
, xfered_len
,
10943 &remote_protocol_packets
10944 [PACKET_qXfer_statictrace_read
]);
10946 return TARGET_XFER_E_IO
;
10949 /* Only handle flash writes. */
10950 if (writebuf
!= NULL
)
10954 case TARGET_OBJECT_FLASH
:
10955 return remote_flash_write (offset
, len
, xfered_len
,
10959 return TARGET_XFER_E_IO
;
10963 /* Map pre-existing objects onto letters. DO NOT do this for new
10964 objects!!! Instead specify new query packets. */
10967 case TARGET_OBJECT_AVR
:
10971 case TARGET_OBJECT_AUXV
:
10972 gdb_assert (annex
== NULL
);
10973 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
10975 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10977 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10978 return remote_read_qxfer
10979 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
10980 &remote_protocol_packets
[PACKET_qXfer_features
]);
10982 case TARGET_OBJECT_LIBRARIES
:
10983 return remote_read_qxfer
10984 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10985 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10987 case TARGET_OBJECT_LIBRARIES_SVR4
:
10988 return remote_read_qxfer
10989 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10990 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10992 case TARGET_OBJECT_MEMORY_MAP
:
10993 gdb_assert (annex
== NULL
);
10994 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
10996 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10998 case TARGET_OBJECT_OSDATA
:
10999 /* Should only get here if we're connected. */
11000 gdb_assert (rs
->remote_desc
);
11001 return remote_read_qxfer
11002 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
11003 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
11005 case TARGET_OBJECT_THREADS
:
11006 gdb_assert (annex
== NULL
);
11007 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
11009 &remote_protocol_packets
[PACKET_qXfer_threads
]);
11011 case TARGET_OBJECT_TRACEFRAME_INFO
:
11012 gdb_assert (annex
== NULL
);
11013 return remote_read_qxfer
11014 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
11015 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
11017 case TARGET_OBJECT_FDPIC
:
11018 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
11020 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
11022 case TARGET_OBJECT_OPENVMS_UIB
:
11023 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
11025 &remote_protocol_packets
[PACKET_qXfer_uib
]);
11027 case TARGET_OBJECT_BTRACE
:
11028 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
11030 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
11032 case TARGET_OBJECT_BTRACE_CONF
:
11033 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
11035 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
11037 case TARGET_OBJECT_EXEC_FILE
:
11038 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
11040 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
11043 return TARGET_XFER_E_IO
;
11046 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
11047 large enough let the caller deal with it. */
11048 if (len
< get_remote_packet_size ())
11049 return TARGET_XFER_E_IO
;
11050 len
= get_remote_packet_size ();
11052 /* Except for querying the minimum buffer size, target must be open. */
11053 if (!rs
->remote_desc
)
11054 error (_("remote query is only available after target open"));
11056 gdb_assert (annex
!= NULL
);
11057 gdb_assert (readbuf
!= NULL
);
11059 p2
= rs
->buf
.data ();
11061 *p2
++ = query_type
;
11063 /* We used one buffer char for the remote protocol q command and
11064 another for the query type. As the remote protocol encapsulation
11065 uses 4 chars plus one extra in case we are debugging
11066 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11069 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11071 /* Bad caller may have sent forbidden characters. */
11072 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11077 gdb_assert (annex
[i
] == '\0');
11079 i
= putpkt (rs
->buf
);
11081 return TARGET_XFER_E_IO
;
11083 getpkt (&rs
->buf
, 0);
11084 strcpy ((char *) readbuf
, rs
->buf
.data ());
11086 *xfered_len
= strlen ((char *) readbuf
);
11087 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11090 /* Implementation of to_get_memory_xfer_limit. */
11093 remote_target::get_memory_xfer_limit ()
11095 return get_memory_write_packet_size ();
11099 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11100 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11101 CORE_ADDR
*found_addrp
)
11103 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11104 struct remote_state
*rs
= get_remote_state ();
11105 int max_size
= get_memory_write_packet_size ();
11106 struct packet_config
*packet
=
11107 &remote_protocol_packets
[PACKET_qSearch_memory
];
11108 /* Number of packet bytes used to encode the pattern;
11109 this could be more than PATTERN_LEN due to escape characters. */
11110 int escaped_pattern_len
;
11111 /* Amount of pattern that was encodable in the packet. */
11112 int used_pattern_len
;
11115 ULONGEST found_addr
;
11117 /* Don't go to the target if we don't have to. This is done before
11118 checking packet_config_support to avoid the possibility that a
11119 success for this edge case means the facility works in
11121 if (pattern_len
> search_space_len
)
11123 if (pattern_len
== 0)
11125 *found_addrp
= start_addr
;
11129 /* If we already know the packet isn't supported, fall back to the simple
11130 way of searching memory. */
11132 if (packet_config_support (packet
) == PACKET_DISABLE
)
11134 /* Target doesn't provided special support, fall back and use the
11135 standard support (copy memory and do the search here). */
11136 return simple_search_memory (this, start_addr
, search_space_len
,
11137 pattern
, pattern_len
, found_addrp
);
11140 /* Make sure the remote is pointing at the right process. */
11141 set_general_process ();
11143 /* Insert header. */
11144 i
= snprintf (rs
->buf
.data (), max_size
,
11145 "qSearch:memory:%s;%s;",
11146 phex_nz (start_addr
, addr_size
),
11147 phex_nz (search_space_len
, sizeof (search_space_len
)));
11148 max_size
-= (i
+ 1);
11150 /* Escape as much data as fits into rs->buf. */
11151 escaped_pattern_len
=
11152 remote_escape_output (pattern
, pattern_len
, 1,
11153 (gdb_byte
*) rs
->buf
.data () + i
,
11154 &used_pattern_len
, max_size
);
11156 /* Bail if the pattern is too large. */
11157 if (used_pattern_len
!= pattern_len
)
11158 error (_("Pattern is too large to transmit to remote target."));
11160 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11161 || getpkt_sane (&rs
->buf
, 0) < 0
11162 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11164 /* The request may not have worked because the command is not
11165 supported. If so, fall back to the simple way. */
11166 if (packet_config_support (packet
) == PACKET_DISABLE
)
11168 return simple_search_memory (this, start_addr
, search_space_len
,
11169 pattern
, pattern_len
, found_addrp
);
11174 if (rs
->buf
[0] == '0')
11176 else if (rs
->buf
[0] == '1')
11179 if (rs
->buf
[1] != ',')
11180 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11181 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11182 *found_addrp
= found_addr
;
11185 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11191 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11193 struct remote_state
*rs
= get_remote_state ();
11194 char *p
= rs
->buf
.data ();
11196 if (!rs
->remote_desc
)
11197 error (_("remote rcmd is only available after target open"));
11199 /* Send a NULL command across as an empty command. */
11200 if (command
== NULL
)
11203 /* The query prefix. */
11204 strcpy (rs
->buf
.data (), "qRcmd,");
11205 p
= strchr (rs
->buf
.data (), '\0');
11207 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11208 > get_remote_packet_size ())
11209 error (_("\"monitor\" command ``%s'' is too long."), command
);
11211 /* Encode the actual command. */
11212 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11214 if (putpkt (rs
->buf
) < 0)
11215 error (_("Communication problem with target."));
11217 /* get/display the response */
11222 /* XXX - see also remote_get_noisy_reply(). */
11223 QUIT
; /* Allow user to bail out with ^C. */
11225 if (getpkt_sane (&rs
->buf
, 0) == -1)
11227 /* Timeout. Continue to (try to) read responses.
11228 This is better than stopping with an error, assuming the stub
11229 is still executing the (long) monitor command.
11230 If needed, the user can interrupt gdb using C-c, obtaining
11231 an effect similar to stop on timeout. */
11234 buf
= rs
->buf
.data ();
11235 if (buf
[0] == '\0')
11236 error (_("Target does not support this command."));
11237 if (buf
[0] == 'O' && buf
[1] != 'K')
11239 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11242 if (strcmp (buf
, "OK") == 0)
11244 if (strlen (buf
) == 3 && buf
[0] == 'E'
11245 && isdigit (buf
[1]) && isdigit (buf
[2]))
11247 error (_("Protocol error with Rcmd"));
11249 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11251 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11253 fputc_unfiltered (c
, outbuf
);
11259 std::vector
<mem_region
>
11260 remote_target::memory_map ()
11262 std::vector
<mem_region
> result
;
11263 gdb::optional
<gdb::char_vector
> text
11264 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11267 result
= parse_memory_map (text
->data ());
11273 packet_command (const char *args
, int from_tty
)
11275 remote_target
*remote
= get_current_remote_target ();
11277 if (remote
== nullptr)
11278 error (_("command can only be used with remote target"));
11280 remote
->packet_command (args
, from_tty
);
11284 remote_target::packet_command (const char *args
, int from_tty
)
11287 error (_("remote-packet command requires packet text as argument"));
11289 puts_filtered ("sending: ");
11290 print_packet (args
);
11291 puts_filtered ("\n");
11294 remote_state
*rs
= get_remote_state ();
11296 getpkt (&rs
->buf
, 0);
11297 puts_filtered ("received: ");
11298 print_packet (rs
->buf
.data ());
11299 puts_filtered ("\n");
11303 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11305 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11307 static void threadset_test_cmd (char *cmd
, int tty
);
11309 static void threadalive_test (char *cmd
, int tty
);
11311 static void threadlist_test_cmd (char *cmd
, int tty
);
11313 int get_and_display_threadinfo (threadref
*ref
);
11315 static void threadinfo_test_cmd (char *cmd
, int tty
);
11317 static int thread_display_step (threadref
*ref
, void *context
);
11319 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11321 static void init_remote_threadtests (void);
11323 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11326 threadset_test_cmd (const char *cmd
, int tty
)
11328 int sample_thread
= SAMPLE_THREAD
;
11330 printf_filtered (_("Remote threadset test\n"));
11331 set_general_thread (sample_thread
);
11336 threadalive_test (const char *cmd
, int tty
)
11338 int sample_thread
= SAMPLE_THREAD
;
11339 int pid
= inferior_ptid
.pid ();
11340 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11342 if (remote_thread_alive (ptid
))
11343 printf_filtered ("PASS: Thread alive test\n");
11345 printf_filtered ("FAIL: Thread alive test\n");
11348 void output_threadid (char *title
, threadref
*ref
);
11351 output_threadid (char *title
, threadref
*ref
)
11355 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11357 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11361 threadlist_test_cmd (const char *cmd
, int tty
)
11364 threadref nextthread
;
11365 int done
, result_count
;
11366 threadref threadlist
[3];
11368 printf_filtered ("Remote Threadlist test\n");
11369 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11370 &result_count
, &threadlist
[0]))
11371 printf_filtered ("FAIL: threadlist test\n");
11374 threadref
*scan
= threadlist
;
11375 threadref
*limit
= scan
+ result_count
;
11377 while (scan
< limit
)
11378 output_threadid (" thread ", scan
++);
11383 display_thread_info (struct gdb_ext_thread_info
*info
)
11385 output_threadid ("Threadid: ", &info
->threadid
);
11386 printf_filtered ("Name: %s\n ", info
->shortname
);
11387 printf_filtered ("State: %s\n", info
->display
);
11388 printf_filtered ("other: %s\n\n", info
->more_display
);
11392 get_and_display_threadinfo (threadref
*ref
)
11396 struct gdb_ext_thread_info threadinfo
;
11398 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11399 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11400 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11401 display_thread_info (&threadinfo
);
11406 threadinfo_test_cmd (const char *cmd
, int tty
)
11408 int athread
= SAMPLE_THREAD
;
11412 int_to_threadref (&thread
, athread
);
11413 printf_filtered ("Remote Threadinfo test\n");
11414 if (!get_and_display_threadinfo (&thread
))
11415 printf_filtered ("FAIL cannot get thread info\n");
11419 thread_display_step (threadref
*ref
, void *context
)
11421 /* output_threadid(" threadstep ",ref); *//* simple test */
11422 return get_and_display_threadinfo (ref
);
11426 threadlist_update_test_cmd (const char *cmd
, int tty
)
11428 printf_filtered ("Remote Threadlist update test\n");
11429 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11433 init_remote_threadtests (void)
11435 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11436 _("Fetch and print the remote list of "
11437 "thread identifiers, one pkt only."));
11438 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11439 _("Fetch and display info about one thread."));
11440 add_com ("tset", class_obscure
, threadset_test_cmd
,
11441 _("Test setting to a different thread."));
11442 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11443 _("Iterate through updating all remote thread info."));
11444 add_com ("talive", class_obscure
, threadalive_test
,
11445 _("Remote thread alive test."));
11450 /* Convert a thread ID to a string. */
11453 remote_target::pid_to_str (ptid_t ptid
)
11455 struct remote_state
*rs
= get_remote_state ();
11457 if (ptid
== null_ptid
)
11458 return normal_pid_to_str (ptid
);
11459 else if (ptid
.is_pid ())
11461 /* Printing an inferior target id. */
11463 /* When multi-process extensions are off, there's no way in the
11464 remote protocol to know the remote process id, if there's any
11465 at all. There's one exception --- when we're connected with
11466 target extended-remote, and we manually attached to a process
11467 with "attach PID". We don't record anywhere a flag that
11468 allows us to distinguish that case from the case of
11469 connecting with extended-remote and the stub already being
11470 attached to a process, and reporting yes to qAttached, hence
11471 no smart special casing here. */
11472 if (!remote_multi_process_p (rs
))
11473 return "Remote target";
11475 return normal_pid_to_str (ptid
);
11479 if (magic_null_ptid
== ptid
)
11480 return "Thread <main>";
11481 else if (remote_multi_process_p (rs
))
11482 if (ptid
.lwp () == 0)
11483 return normal_pid_to_str (ptid
);
11485 return string_printf ("Thread %d.%ld",
11486 ptid
.pid (), ptid
.lwp ());
11488 return string_printf ("Thread %ld", ptid
.lwp ());
11492 /* Get the address of the thread local variable in OBJFILE which is
11493 stored at OFFSET within the thread local storage for thread PTID. */
11496 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11499 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11501 struct remote_state
*rs
= get_remote_state ();
11502 char *p
= rs
->buf
.data ();
11503 char *endp
= p
+ get_remote_packet_size ();
11504 enum packet_result result
;
11506 strcpy (p
, "qGetTLSAddr:");
11508 p
= write_ptid (p
, endp
, ptid
);
11510 p
+= hexnumstr (p
, offset
);
11512 p
+= hexnumstr (p
, lm
);
11516 getpkt (&rs
->buf
, 0);
11517 result
= packet_ok (rs
->buf
,
11518 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11519 if (result
== PACKET_OK
)
11523 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11526 else if (result
== PACKET_UNKNOWN
)
11527 throw_error (TLS_GENERIC_ERROR
,
11528 _("Remote target doesn't support qGetTLSAddr packet"));
11530 throw_error (TLS_GENERIC_ERROR
,
11531 _("Remote target failed to process qGetTLSAddr request"));
11534 throw_error (TLS_GENERIC_ERROR
,
11535 _("TLS not supported or disabled on this target"));
11540 /* Provide thread local base, i.e. Thread Information Block address.
11541 Returns 1 if ptid is found and thread_local_base is non zero. */
11544 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11546 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11548 struct remote_state
*rs
= get_remote_state ();
11549 char *p
= rs
->buf
.data ();
11550 char *endp
= p
+ get_remote_packet_size ();
11551 enum packet_result result
;
11553 strcpy (p
, "qGetTIBAddr:");
11555 p
= write_ptid (p
, endp
, ptid
);
11559 getpkt (&rs
->buf
, 0);
11560 result
= packet_ok (rs
->buf
,
11561 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11562 if (result
== PACKET_OK
)
11565 unpack_varlen_hex (rs
->buf
.data (), &val
);
11567 *addr
= (CORE_ADDR
) val
;
11570 else if (result
== PACKET_UNKNOWN
)
11571 error (_("Remote target doesn't support qGetTIBAddr packet"));
11573 error (_("Remote target failed to process qGetTIBAddr request"));
11576 error (_("qGetTIBAddr not supported or disabled on this target"));
11581 /* Support for inferring a target description based on the current
11582 architecture and the size of a 'g' packet. While the 'g' packet
11583 can have any size (since optional registers can be left off the
11584 end), some sizes are easily recognizable given knowledge of the
11585 approximate architecture. */
11587 struct remote_g_packet_guess
11589 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11596 const struct target_desc
*tdesc
;
11599 struct remote_g_packet_data
: public allocate_on_obstack
11601 std::vector
<remote_g_packet_guess
> guesses
;
11604 static struct gdbarch_data
*remote_g_packet_data_handle
;
11607 remote_g_packet_data_init (struct obstack
*obstack
)
11609 return new (obstack
) remote_g_packet_data
;
11613 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11614 const struct target_desc
*tdesc
)
11616 struct remote_g_packet_data
*data
11617 = ((struct remote_g_packet_data
*)
11618 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11620 gdb_assert (tdesc
!= NULL
);
11622 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11623 if (guess
.bytes
== bytes
)
11624 internal_error (__FILE__
, __LINE__
,
11625 _("Duplicate g packet description added for size %d"),
11628 data
->guesses
.emplace_back (bytes
, tdesc
);
11631 /* Return true if remote_read_description would do anything on this target
11632 and architecture, false otherwise. */
11635 remote_read_description_p (struct target_ops
*target
)
11637 struct remote_g_packet_data
*data
11638 = ((struct remote_g_packet_data
*)
11639 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11641 return !data
->guesses
.empty ();
11644 const struct target_desc
*
11645 remote_target::read_description ()
11647 struct remote_g_packet_data
*data
11648 = ((struct remote_g_packet_data
*)
11649 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11651 /* Do not try this during initial connection, when we do not know
11652 whether there is a running but stopped thread. */
11653 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
11654 return beneath ()->read_description ();
11656 if (!data
->guesses
.empty ())
11658 int bytes
= send_g_packet ();
11660 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11661 if (guess
.bytes
== bytes
)
11662 return guess
.tdesc
;
11664 /* We discard the g packet. A minor optimization would be to
11665 hold on to it, and fill the register cache once we have selected
11666 an architecture, but it's too tricky to do safely. */
11669 return beneath ()->read_description ();
11672 /* Remote file transfer support. This is host-initiated I/O, not
11673 target-initiated; for target-initiated, see remote-fileio.c. */
11675 /* If *LEFT is at least the length of STRING, copy STRING to
11676 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11677 decrease *LEFT. Otherwise raise an error. */
11680 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11682 int len
= strlen (string
);
11685 error (_("Packet too long for target."));
11687 memcpy (*buffer
, string
, len
);
11691 /* NUL-terminate the buffer as a convenience, if there is
11697 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11698 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11699 decrease *LEFT. Otherwise raise an error. */
11702 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11705 if (2 * len
> *left
)
11706 error (_("Packet too long for target."));
11708 bin2hex (bytes
, *buffer
, len
);
11709 *buffer
+= 2 * len
;
11712 /* NUL-terminate the buffer as a convenience, if there is
11718 /* If *LEFT is large enough, convert VALUE to hex and add it to
11719 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11720 decrease *LEFT. Otherwise raise an error. */
11723 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11725 int len
= hexnumlen (value
);
11728 error (_("Packet too long for target."));
11730 hexnumstr (*buffer
, value
);
11734 /* NUL-terminate the buffer as a convenience, if there is
11740 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11741 value, *REMOTE_ERRNO to the remote error number or zero if none
11742 was included, and *ATTACHMENT to point to the start of the annex
11743 if any. The length of the packet isn't needed here; there may
11744 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11746 Return 0 if the packet could be parsed, -1 if it could not. If
11747 -1 is returned, the other variables may not be initialized. */
11750 remote_hostio_parse_result (char *buffer
, int *retcode
,
11751 int *remote_errno
, char **attachment
)
11756 *attachment
= NULL
;
11758 if (buffer
[0] != 'F')
11762 *retcode
= strtol (&buffer
[1], &p
, 16);
11763 if (errno
!= 0 || p
== &buffer
[1])
11766 /* Check for ",errno". */
11770 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11771 if (errno
!= 0 || p
+ 1 == p2
)
11776 /* Check for ";attachment". If there is no attachment, the
11777 packet should end here. */
11780 *attachment
= p
+ 1;
11783 else if (*p
== '\0')
11789 /* Send a prepared I/O packet to the target and read its response.
11790 The prepared packet is in the global RS->BUF before this function
11791 is called, and the answer is there when we return.
11793 COMMAND_BYTES is the length of the request to send, which may include
11794 binary data. WHICH_PACKET is the packet configuration to check
11795 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11796 is set to the error number and -1 is returned. Otherwise the value
11797 returned by the function is returned.
11799 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11800 attachment is expected; an error will be reported if there's a
11801 mismatch. If one is found, *ATTACHMENT will be set to point into
11802 the packet buffer and *ATTACHMENT_LEN will be set to the
11803 attachment's length. */
11806 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11807 int *remote_errno
, char **attachment
,
11808 int *attachment_len
)
11810 struct remote_state
*rs
= get_remote_state ();
11811 int ret
, bytes_read
;
11812 char *attachment_tmp
;
11814 if (packet_support (which_packet
) == PACKET_DISABLE
)
11816 *remote_errno
= FILEIO_ENOSYS
;
11820 putpkt_binary (rs
->buf
.data (), command_bytes
);
11821 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11823 /* If it timed out, something is wrong. Don't try to parse the
11825 if (bytes_read
< 0)
11827 *remote_errno
= FILEIO_EINVAL
;
11831 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11834 *remote_errno
= FILEIO_EINVAL
;
11836 case PACKET_UNKNOWN
:
11837 *remote_errno
= FILEIO_ENOSYS
;
11843 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
11846 *remote_errno
= FILEIO_EINVAL
;
11850 /* Make sure we saw an attachment if and only if we expected one. */
11851 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11852 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11854 *remote_errno
= FILEIO_EINVAL
;
11858 /* If an attachment was found, it must point into the packet buffer;
11859 work out how many bytes there were. */
11860 if (attachment_tmp
!= NULL
)
11862 *attachment
= attachment_tmp
;
11863 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
11869 /* See declaration.h. */
11872 readahead_cache::invalidate ()
11877 /* See declaration.h. */
11880 readahead_cache::invalidate_fd (int fd
)
11882 if (this->fd
== fd
)
11886 /* Set the filesystem remote_hostio functions that take FILENAME
11887 arguments will use. Return 0 on success, or -1 if an error
11888 occurs (and set *REMOTE_ERRNO). */
11891 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
11894 struct remote_state
*rs
= get_remote_state ();
11895 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11896 char *p
= rs
->buf
.data ();
11897 int left
= get_remote_packet_size () - 1;
11901 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11904 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11907 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11909 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11910 remote_buffer_add_string (&p
, &left
, arg
);
11912 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
11913 remote_errno
, NULL
, NULL
);
11915 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11919 rs
->fs_pid
= required_pid
;
11924 /* Implementation of to_fileio_open. */
11927 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
11928 int flags
, int mode
, int warn_if_slow
,
11931 struct remote_state
*rs
= get_remote_state ();
11932 char *p
= rs
->buf
.data ();
11933 int left
= get_remote_packet_size () - 1;
11937 static int warning_issued
= 0;
11939 printf_unfiltered (_("Reading %s from remote target...\n"),
11942 if (!warning_issued
)
11944 warning (_("File transfers from remote targets can be slow."
11945 " Use \"set sysroot\" to access files locally"
11947 warning_issued
= 1;
11951 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11954 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11956 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11957 strlen (filename
));
11958 remote_buffer_add_string (&p
, &left
, ",");
11960 remote_buffer_add_int (&p
, &left
, flags
);
11961 remote_buffer_add_string (&p
, &left
, ",");
11963 remote_buffer_add_int (&p
, &left
, mode
);
11965 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
11966 remote_errno
, NULL
, NULL
);
11970 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
11971 int flags
, int mode
, int warn_if_slow
,
11974 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
11978 /* Implementation of to_fileio_pwrite. */
11981 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11982 ULONGEST offset
, int *remote_errno
)
11984 struct remote_state
*rs
= get_remote_state ();
11985 char *p
= rs
->buf
.data ();
11986 int left
= get_remote_packet_size ();
11989 rs
->readahead_cache
.invalidate_fd (fd
);
11991 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11993 remote_buffer_add_int (&p
, &left
, fd
);
11994 remote_buffer_add_string (&p
, &left
, ",");
11996 remote_buffer_add_int (&p
, &left
, offset
);
11997 remote_buffer_add_string (&p
, &left
, ",");
11999 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
12000 (get_remote_packet_size ()
12001 - (p
- rs
->buf
.data ())));
12003 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
12004 remote_errno
, NULL
, NULL
);
12008 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12009 ULONGEST offset
, int *remote_errno
)
12011 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
12014 /* Helper for the implementation of to_fileio_pread. Read the file
12015 from the remote side with vFile:pread. */
12018 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
12019 ULONGEST offset
, int *remote_errno
)
12021 struct remote_state
*rs
= get_remote_state ();
12022 char *p
= rs
->buf
.data ();
12024 int left
= get_remote_packet_size ();
12025 int ret
, attachment_len
;
12028 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
12030 remote_buffer_add_int (&p
, &left
, fd
);
12031 remote_buffer_add_string (&p
, &left
, ",");
12033 remote_buffer_add_int (&p
, &left
, len
);
12034 remote_buffer_add_string (&p
, &left
, ",");
12036 remote_buffer_add_int (&p
, &left
, offset
);
12038 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
12039 remote_errno
, &attachment
,
12045 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12047 if (read_len
!= ret
)
12048 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
12053 /* See declaration.h. */
12056 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12060 && this->offset
<= offset
12061 && offset
< this->offset
+ this->bufsize
)
12063 ULONGEST max
= this->offset
+ this->bufsize
;
12065 if (offset
+ len
> max
)
12066 len
= max
- offset
;
12068 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12075 /* Implementation of to_fileio_pread. */
12078 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12079 ULONGEST offset
, int *remote_errno
)
12082 struct remote_state
*rs
= get_remote_state ();
12083 readahead_cache
*cache
= &rs
->readahead_cache
;
12085 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12088 cache
->hit_count
++;
12091 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12092 pulongest (cache
->hit_count
));
12096 cache
->miss_count
++;
12098 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12099 pulongest (cache
->miss_count
));
12102 cache
->offset
= offset
;
12103 cache
->bufsize
= get_remote_packet_size ();
12104 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12106 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12107 cache
->offset
, remote_errno
);
12110 cache
->invalidate_fd (fd
);
12114 cache
->bufsize
= ret
;
12115 return cache
->pread (fd
, read_buf
, len
, offset
);
12119 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12120 ULONGEST offset
, int *remote_errno
)
12122 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12125 /* Implementation of to_fileio_close. */
12128 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12130 struct remote_state
*rs
= get_remote_state ();
12131 char *p
= rs
->buf
.data ();
12132 int left
= get_remote_packet_size () - 1;
12134 rs
->readahead_cache
.invalidate_fd (fd
);
12136 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12138 remote_buffer_add_int (&p
, &left
, fd
);
12140 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12141 remote_errno
, NULL
, NULL
);
12145 remote_target::fileio_close (int fd
, int *remote_errno
)
12147 return remote_hostio_close (fd
, remote_errno
);
12150 /* Implementation of to_fileio_unlink. */
12153 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12156 struct remote_state
*rs
= get_remote_state ();
12157 char *p
= rs
->buf
.data ();
12158 int left
= get_remote_packet_size () - 1;
12160 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12163 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12165 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12166 strlen (filename
));
12168 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12169 remote_errno
, NULL
, NULL
);
12173 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12176 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12179 /* Implementation of to_fileio_readlink. */
12181 gdb::optional
<std::string
>
12182 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12185 struct remote_state
*rs
= get_remote_state ();
12186 char *p
= rs
->buf
.data ();
12188 int left
= get_remote_packet_size ();
12189 int len
, attachment_len
;
12192 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12195 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12197 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12198 strlen (filename
));
12200 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12201 remote_errno
, &attachment
,
12207 std::string
ret (len
, '\0');
12209 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12210 (gdb_byte
*) &ret
[0], len
);
12211 if (read_len
!= len
)
12212 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12217 /* Implementation of to_fileio_fstat. */
12220 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12222 struct remote_state
*rs
= get_remote_state ();
12223 char *p
= rs
->buf
.data ();
12224 int left
= get_remote_packet_size ();
12225 int attachment_len
, ret
;
12227 struct fio_stat fst
;
12230 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12232 remote_buffer_add_int (&p
, &left
, fd
);
12234 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12235 remote_errno
, &attachment
,
12239 if (*remote_errno
!= FILEIO_ENOSYS
)
12242 /* Strictly we should return -1, ENOSYS here, but when
12243 "set sysroot remote:" was implemented in August 2008
12244 BFD's need for a stat function was sidestepped with
12245 this hack. This was not remedied until March 2015
12246 so we retain the previous behavior to avoid breaking
12249 Note that the memset is a March 2015 addition; older
12250 GDBs set st_size *and nothing else* so the structure
12251 would have garbage in all other fields. This might
12252 break something but retaining the previous behavior
12253 here would be just too wrong. */
12255 memset (st
, 0, sizeof (struct stat
));
12256 st
->st_size
= INT_MAX
;
12260 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12261 (gdb_byte
*) &fst
, sizeof (fst
));
12263 if (read_len
!= ret
)
12264 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12266 if (read_len
!= sizeof (fst
))
12267 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12268 read_len
, (int) sizeof (fst
));
12270 remote_fileio_to_host_stat (&fst
, st
);
12275 /* Implementation of to_filesystem_is_local. */
12278 remote_target::filesystem_is_local ()
12280 /* Valgrind GDB presents itself as a remote target but works
12281 on the local filesystem: it does not implement remote get
12282 and users are not expected to set a sysroot. To handle
12283 this case we treat the remote filesystem as local if the
12284 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12285 does not support vFile:open. */
12286 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12288 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12290 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12292 int fd
, remote_errno
;
12294 /* Try opening a file to probe support. The supplied
12295 filename is irrelevant, we only care about whether
12296 the stub recognizes the packet or not. */
12297 fd
= remote_hostio_open (NULL
, "just probing",
12298 FILEIO_O_RDONLY
, 0700, 0,
12302 remote_hostio_close (fd
, &remote_errno
);
12304 ps
= packet_support (PACKET_vFile_open
);
12307 if (ps
== PACKET_DISABLE
)
12309 static int warning_issued
= 0;
12311 if (!warning_issued
)
12313 warning (_("remote target does not support file"
12314 " transfer, attempting to access files"
12315 " from local filesystem."));
12316 warning_issued
= 1;
12327 remote_fileio_errno_to_host (int errnum
)
12333 case FILEIO_ENOENT
:
12341 case FILEIO_EACCES
:
12343 case FILEIO_EFAULT
:
12347 case FILEIO_EEXIST
:
12349 case FILEIO_ENODEV
:
12351 case FILEIO_ENOTDIR
:
12353 case FILEIO_EISDIR
:
12355 case FILEIO_EINVAL
:
12357 case FILEIO_ENFILE
:
12359 case FILEIO_EMFILE
:
12363 case FILEIO_ENOSPC
:
12365 case FILEIO_ESPIPE
:
12369 case FILEIO_ENOSYS
:
12371 case FILEIO_ENAMETOOLONG
:
12372 return ENAMETOOLONG
;
12378 remote_hostio_error (int errnum
)
12380 int host_error
= remote_fileio_errno_to_host (errnum
);
12382 if (host_error
== -1)
12383 error (_("Unknown remote I/O error %d"), errnum
);
12385 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12388 /* A RAII wrapper around a remote file descriptor. */
12390 class scoped_remote_fd
12393 scoped_remote_fd (remote_target
*remote
, int fd
)
12394 : m_remote (remote
), m_fd (fd
)
12398 ~scoped_remote_fd ()
12405 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12409 /* Swallow exception before it escapes the dtor. If
12410 something goes wrong, likely the connection is gone,
12411 and there's nothing else that can be done. */
12416 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12418 /* Release ownership of the file descriptor, and return it. */
12419 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12426 /* Return the owned file descriptor. */
12427 int get () const noexcept
12433 /* The remote target. */
12434 remote_target
*m_remote
;
12436 /* The owned remote I/O file descriptor. */
12441 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12443 remote_target
*remote
= get_current_remote_target ();
12445 if (remote
== nullptr)
12446 error (_("command can only be used with remote target"));
12448 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12452 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12455 int retcode
, remote_errno
, bytes
, io_size
;
12456 int bytes_in_buffer
;
12460 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12462 perror_with_name (local_file
);
12464 scoped_remote_fd fd
12465 (this, remote_hostio_open (NULL
,
12466 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12468 0700, 0, &remote_errno
));
12469 if (fd
.get () == -1)
12470 remote_hostio_error (remote_errno
);
12472 /* Send up to this many bytes at once. They won't all fit in the
12473 remote packet limit, so we'll transfer slightly fewer. */
12474 io_size
= get_remote_packet_size ();
12475 gdb::byte_vector
buffer (io_size
);
12477 bytes_in_buffer
= 0;
12480 while (bytes_in_buffer
|| !saw_eof
)
12484 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12485 io_size
- bytes_in_buffer
,
12489 if (ferror (file
.get ()))
12490 error (_("Error reading %s."), local_file
);
12493 /* EOF. Unless there is something still in the
12494 buffer from the last iteration, we are done. */
12496 if (bytes_in_buffer
== 0)
12504 bytes
+= bytes_in_buffer
;
12505 bytes_in_buffer
= 0;
12507 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12508 offset
, &remote_errno
);
12511 remote_hostio_error (remote_errno
);
12512 else if (retcode
== 0)
12513 error (_("Remote write of %d bytes returned 0!"), bytes
);
12514 else if (retcode
< bytes
)
12516 /* Short write. Save the rest of the read data for the next
12518 bytes_in_buffer
= bytes
- retcode
;
12519 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12525 if (remote_hostio_close (fd
.release (), &remote_errno
))
12526 remote_hostio_error (remote_errno
);
12529 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12533 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12535 remote_target
*remote
= get_current_remote_target ();
12537 if (remote
== nullptr)
12538 error (_("command can only be used with remote target"));
12540 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12544 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12547 int remote_errno
, bytes
, io_size
;
12550 scoped_remote_fd fd
12551 (this, remote_hostio_open (NULL
,
12552 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12554 if (fd
.get () == -1)
12555 remote_hostio_error (remote_errno
);
12557 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12559 perror_with_name (local_file
);
12561 /* Send up to this many bytes at once. They won't all fit in the
12562 remote packet limit, so we'll transfer slightly fewer. */
12563 io_size
= get_remote_packet_size ();
12564 gdb::byte_vector
buffer (io_size
);
12569 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12572 /* Success, but no bytes, means end-of-file. */
12575 remote_hostio_error (remote_errno
);
12579 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12581 perror_with_name (local_file
);
12584 if (remote_hostio_close (fd
.release (), &remote_errno
))
12585 remote_hostio_error (remote_errno
);
12588 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12592 remote_file_delete (const char *remote_file
, int from_tty
)
12594 remote_target
*remote
= get_current_remote_target ();
12596 if (remote
== nullptr)
12597 error (_("command can only be used with remote target"));
12599 remote
->remote_file_delete (remote_file
, from_tty
);
12603 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12605 int retcode
, remote_errno
;
12607 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12609 remote_hostio_error (remote_errno
);
12612 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12616 remote_put_command (const char *args
, int from_tty
)
12619 error_no_arg (_("file to put"));
12621 gdb_argv
argv (args
);
12622 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12623 error (_("Invalid parameters to remote put"));
12625 remote_file_put (argv
[0], argv
[1], from_tty
);
12629 remote_get_command (const char *args
, int from_tty
)
12632 error_no_arg (_("file to get"));
12634 gdb_argv
argv (args
);
12635 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12636 error (_("Invalid parameters to remote get"));
12638 remote_file_get (argv
[0], argv
[1], from_tty
);
12642 remote_delete_command (const char *args
, int from_tty
)
12645 error_no_arg (_("file to delete"));
12647 gdb_argv
argv (args
);
12648 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12649 error (_("Invalid parameters to remote delete"));
12651 remote_file_delete (argv
[0], from_tty
);
12655 remote_command (const char *args
, int from_tty
)
12657 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12661 remote_target::can_execute_reverse ()
12663 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12664 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12671 remote_target::supports_non_stop ()
12677 remote_target::supports_disable_randomization ()
12679 /* Only supported in extended mode. */
12684 remote_target::supports_multi_process ()
12686 struct remote_state
*rs
= get_remote_state ();
12688 return remote_multi_process_p (rs
);
12692 remote_supports_cond_tracepoints ()
12694 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12698 remote_target::supports_evaluation_of_breakpoint_conditions ()
12700 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12704 remote_supports_fast_tracepoints ()
12706 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12710 remote_supports_static_tracepoints ()
12712 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12716 remote_supports_install_in_trace ()
12718 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12722 remote_target::supports_enable_disable_tracepoint ()
12724 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12729 remote_target::supports_string_tracing ()
12731 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12735 remote_target::can_run_breakpoint_commands ()
12737 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12741 remote_target::trace_init ()
12743 struct remote_state
*rs
= get_remote_state ();
12746 remote_get_noisy_reply ();
12747 if (strcmp (rs
->buf
.data (), "OK") != 0)
12748 error (_("Target does not support this command."));
12751 /* Recursive routine to walk through command list including loops, and
12752 download packets for each command. */
12755 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12756 struct command_line
*cmds
)
12758 struct remote_state
*rs
= get_remote_state ();
12759 struct command_line
*cmd
;
12761 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12763 QUIT
; /* Allow user to bail out with ^C. */
12764 strcpy (rs
->buf
.data (), "QTDPsrc:");
12765 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12766 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12767 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12769 remote_get_noisy_reply ();
12770 if (strcmp (rs
->buf
.data (), "OK"))
12771 warning (_("Target does not support source download."));
12773 if (cmd
->control_type
== while_control
12774 || cmd
->control_type
== while_stepping_control
)
12776 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12778 QUIT
; /* Allow user to bail out with ^C. */
12779 strcpy (rs
->buf
.data (), "QTDPsrc:");
12780 encode_source_string (num
, addr
, "cmd", "end",
12781 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12782 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12784 remote_get_noisy_reply ();
12785 if (strcmp (rs
->buf
.data (), "OK"))
12786 warning (_("Target does not support source download."));
12792 remote_target::download_tracepoint (struct bp_location
*loc
)
12796 std::vector
<std::string
> tdp_actions
;
12797 std::vector
<std::string
> stepping_actions
;
12799 struct breakpoint
*b
= loc
->owner
;
12800 struct tracepoint
*t
= (struct tracepoint
*) b
;
12801 struct remote_state
*rs
= get_remote_state ();
12803 const char *err_msg
= _("Tracepoint packet too large for target.");
12806 /* We use a buffer other than rs->buf because we'll build strings
12807 across multiple statements, and other statements in between could
12809 gdb::char_vector
buf (get_remote_packet_size ());
12811 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12813 tpaddr
= loc
->address
;
12814 sprintf_vma (addrbuf
, tpaddr
);
12815 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12816 b
->number
, addrbuf
, /* address */
12817 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12818 t
->step_count
, t
->pass_count
);
12820 if (ret
< 0 || ret
>= buf
.size ())
12821 error ("%s", err_msg
);
12823 /* Fast tracepoints are mostly handled by the target, but we can
12824 tell the target how big of an instruction block should be moved
12826 if (b
->type
== bp_fast_tracepoint
)
12828 /* Only test for support at download time; we may not know
12829 target capabilities at definition time. */
12830 if (remote_supports_fast_tracepoints ())
12832 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12835 size_left
= buf
.size () - strlen (buf
.data ());
12836 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12838 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12840 if (ret
< 0 || ret
>= size_left
)
12841 error ("%s", err_msg
);
12844 /* If it passed validation at definition but fails now,
12845 something is very wrong. */
12846 internal_error (__FILE__
, __LINE__
,
12847 _("Fast tracepoint not "
12848 "valid during download"));
12851 /* Fast tracepoints are functionally identical to regular
12852 tracepoints, so don't take lack of support as a reason to
12853 give up on the trace run. */
12854 warning (_("Target does not support fast tracepoints, "
12855 "downloading %d as regular tracepoint"), b
->number
);
12857 else if (b
->type
== bp_static_tracepoint
)
12859 /* Only test for support at download time; we may not know
12860 target capabilities at definition time. */
12861 if (remote_supports_static_tracepoints ())
12863 struct static_tracepoint_marker marker
;
12865 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12867 size_left
= buf
.size () - strlen (buf
.data ());
12868 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12871 if (ret
< 0 || ret
>= size_left
)
12872 error ("%s", err_msg
);
12875 error (_("Static tracepoint not valid during download"));
12878 /* Fast tracepoints are functionally identical to regular
12879 tracepoints, so don't take lack of support as a reason
12880 to give up on the trace run. */
12881 error (_("Target does not support static tracepoints"));
12883 /* If the tracepoint has a conditional, make it into an agent
12884 expression and append to the definition. */
12887 /* Only test support at download time, we may not know target
12888 capabilities at definition time. */
12889 if (remote_supports_cond_tracepoints ())
12891 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
12894 size_left
= buf
.size () - strlen (buf
.data ());
12896 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12897 size_left
, ":X%x,", aexpr
->len
);
12899 if (ret
< 0 || ret
>= size_left
)
12900 error ("%s", err_msg
);
12902 size_left
= buf
.size () - strlen (buf
.data ());
12904 /* Two bytes to encode each aexpr byte, plus the terminating
12906 if (aexpr
->len
* 2 + 1 > size_left
)
12907 error ("%s", err_msg
);
12909 pkt
= buf
.data () + strlen (buf
.data ());
12911 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12912 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12916 warning (_("Target does not support conditional tracepoints, "
12917 "ignoring tp %d cond"), b
->number
);
12920 if (b
->commands
|| *default_collect
)
12922 size_left
= buf
.size () - strlen (buf
.data ());
12924 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12927 if (ret
< 0 || ret
>= size_left
)
12928 error ("%s", err_msg
);
12931 putpkt (buf
.data ());
12932 remote_get_noisy_reply ();
12933 if (strcmp (rs
->buf
.data (), "OK"))
12934 error (_("Target does not support tracepoints."));
12936 /* do_single_steps (t); */
12937 for (auto action_it
= tdp_actions
.begin ();
12938 action_it
!= tdp_actions
.end (); action_it
++)
12940 QUIT
; /* Allow user to bail out with ^C. */
12942 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
12943 || !stepping_actions
.empty ());
12945 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
12946 b
->number
, addrbuf
, /* address */
12947 action_it
->c_str (),
12948 has_more
? '-' : 0);
12950 if (ret
< 0 || ret
>= buf
.size ())
12951 error ("%s", err_msg
);
12953 putpkt (buf
.data ());
12954 remote_get_noisy_reply ();
12955 if (strcmp (rs
->buf
.data (), "OK"))
12956 error (_("Error on target while setting tracepoints."));
12959 for (auto action_it
= stepping_actions
.begin ();
12960 action_it
!= stepping_actions
.end (); action_it
++)
12962 QUIT
; /* Allow user to bail out with ^C. */
12964 bool is_first
= action_it
== stepping_actions
.begin ();
12965 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
12967 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
12968 b
->number
, addrbuf
, /* address */
12969 is_first
? "S" : "",
12970 action_it
->c_str (),
12971 has_more
? "-" : "");
12973 if (ret
< 0 || ret
>= buf
.size ())
12974 error ("%s", err_msg
);
12976 putpkt (buf
.data ());
12977 remote_get_noisy_reply ();
12978 if (strcmp (rs
->buf
.data (), "OK"))
12979 error (_("Error on target while setting tracepoints."));
12982 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12984 if (b
->location
!= NULL
)
12986 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12988 if (ret
< 0 || ret
>= buf
.size ())
12989 error ("%s", err_msg
);
12991 encode_source_string (b
->number
, loc
->address
, "at",
12992 event_location_to_string (b
->location
.get ()),
12993 buf
.data () + strlen (buf
.data ()),
12994 buf
.size () - strlen (buf
.data ()));
12995 putpkt (buf
.data ());
12996 remote_get_noisy_reply ();
12997 if (strcmp (rs
->buf
.data (), "OK"))
12998 warning (_("Target does not support source download."));
13000 if (b
->cond_string
)
13002 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13004 if (ret
< 0 || ret
>= buf
.size ())
13005 error ("%s", err_msg
);
13007 encode_source_string (b
->number
, loc
->address
,
13008 "cond", b
->cond_string
,
13009 buf
.data () + strlen (buf
.data ()),
13010 buf
.size () - strlen (buf
.data ()));
13011 putpkt (buf
.data ());
13012 remote_get_noisy_reply ();
13013 if (strcmp (rs
->buf
.data (), "OK"))
13014 warning (_("Target does not support source download."));
13016 remote_download_command_source (b
->number
, loc
->address
,
13017 breakpoint_commands (b
));
13022 remote_target::can_download_tracepoint ()
13024 struct remote_state
*rs
= get_remote_state ();
13025 struct trace_status
*ts
;
13028 /* Don't try to install tracepoints until we've relocated our
13029 symbols, and fetched and merged the target's tracepoint list with
13031 if (rs
->starting_up
)
13034 ts
= current_trace_status ();
13035 status
= get_trace_status (ts
);
13037 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
13040 /* If we are in a tracing experiment, but remote stub doesn't support
13041 installing tracepoint in trace, we have to return. */
13042 if (!remote_supports_install_in_trace ())
13050 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
13052 struct remote_state
*rs
= get_remote_state ();
13055 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13056 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13058 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13059 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13060 >= get_remote_packet_size ())
13061 error (_("Trace state variable name too long for tsv definition packet"));
13062 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13065 remote_get_noisy_reply ();
13066 if (rs
->buf
[0] == '\0')
13067 error (_("Target does not support this command."));
13068 if (strcmp (rs
->buf
.data (), "OK") != 0)
13069 error (_("Error on target while downloading trace state variable."));
13073 remote_target::enable_tracepoint (struct bp_location
*location
)
13075 struct remote_state
*rs
= get_remote_state ();
13078 sprintf_vma (addr_buf
, location
->address
);
13079 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13080 location
->owner
->number
, addr_buf
);
13082 remote_get_noisy_reply ();
13083 if (rs
->buf
[0] == '\0')
13084 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13085 if (strcmp (rs
->buf
.data (), "OK") != 0)
13086 error (_("Error on target while enabling tracepoint."));
13090 remote_target::disable_tracepoint (struct bp_location
*location
)
13092 struct remote_state
*rs
= get_remote_state ();
13095 sprintf_vma (addr_buf
, location
->address
);
13096 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13097 location
->owner
->number
, addr_buf
);
13099 remote_get_noisy_reply ();
13100 if (rs
->buf
[0] == '\0')
13101 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13102 if (strcmp (rs
->buf
.data (), "OK") != 0)
13103 error (_("Error on target while disabling tracepoint."));
13107 remote_target::trace_set_readonly_regions ()
13110 bfd_size_type size
;
13116 return; /* No information to give. */
13118 struct remote_state
*rs
= get_remote_state ();
13120 strcpy (rs
->buf
.data (), "QTro");
13121 offset
= strlen (rs
->buf
.data ());
13122 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
13124 char tmp1
[40], tmp2
[40];
13127 if ((s
->flags
& SEC_LOAD
) == 0 ||
13128 /* (s->flags & SEC_CODE) == 0 || */
13129 (s
->flags
& SEC_READONLY
) == 0)
13133 vma
= bfd_section_vma (s
);
13134 size
= bfd_section_size (s
);
13135 sprintf_vma (tmp1
, vma
);
13136 sprintf_vma (tmp2
, vma
+ size
);
13137 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13138 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13140 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13142 Too many sections for read-only sections definition packet."));
13145 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13147 offset
+= sec_length
;
13152 getpkt (&rs
->buf
, 0);
13157 remote_target::trace_start ()
13159 struct remote_state
*rs
= get_remote_state ();
13161 putpkt ("QTStart");
13162 remote_get_noisy_reply ();
13163 if (rs
->buf
[0] == '\0')
13164 error (_("Target does not support this command."));
13165 if (strcmp (rs
->buf
.data (), "OK") != 0)
13166 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13170 remote_target::get_trace_status (struct trace_status
*ts
)
13172 /* Initialize it just to avoid a GCC false warning. */
13174 enum packet_result result
;
13175 struct remote_state
*rs
= get_remote_state ();
13177 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13180 /* FIXME we need to get register block size some other way. */
13181 trace_regblock_size
13182 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13184 putpkt ("qTStatus");
13188 p
= remote_get_noisy_reply ();
13190 catch (const gdb_exception_error
&ex
)
13192 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13194 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13200 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13202 /* If the remote target doesn't do tracing, flag it. */
13203 if (result
== PACKET_UNKNOWN
)
13206 /* We're working with a live target. */
13207 ts
->filename
= NULL
;
13210 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13212 /* Function 'parse_trace_status' sets default value of each field of
13213 'ts' at first, so we don't have to do it here. */
13214 parse_trace_status (p
, ts
);
13216 return ts
->running
;
13220 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13221 struct uploaded_tp
*utp
)
13223 struct remote_state
*rs
= get_remote_state ();
13225 struct bp_location
*loc
;
13226 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13227 size_t size
= get_remote_packet_size ();
13232 tp
->traceframe_usage
= 0;
13233 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13235 /* If the tracepoint was never downloaded, don't go asking for
13237 if (tp
->number_on_target
== 0)
13239 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13240 phex_nz (loc
->address
, 0));
13242 reply
= remote_get_noisy_reply ();
13243 if (reply
&& *reply
)
13246 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13252 utp
->hit_count
= 0;
13253 utp
->traceframe_usage
= 0;
13254 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13255 phex_nz (utp
->addr
, 0));
13257 reply
= remote_get_noisy_reply ();
13258 if (reply
&& *reply
)
13261 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13267 remote_target::trace_stop ()
13269 struct remote_state
*rs
= get_remote_state ();
13272 remote_get_noisy_reply ();
13273 if (rs
->buf
[0] == '\0')
13274 error (_("Target does not support this command."));
13275 if (strcmp (rs
->buf
.data (), "OK") != 0)
13276 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13280 remote_target::trace_find (enum trace_find_type type
, int num
,
13281 CORE_ADDR addr1
, CORE_ADDR addr2
,
13284 struct remote_state
*rs
= get_remote_state ();
13285 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13287 int target_frameno
= -1, target_tracept
= -1;
13289 /* Lookups other than by absolute frame number depend on the current
13290 trace selected, so make sure it is correct on the remote end
13292 if (type
!= tfind_number
)
13293 set_remote_traceframe ();
13295 p
= rs
->buf
.data ();
13296 strcpy (p
, "QTFrame:");
13297 p
= strchr (p
, '\0');
13301 xsnprintf (p
, endbuf
- p
, "%x", num
);
13304 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13307 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13310 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13311 phex_nz (addr2
, 0));
13313 case tfind_outside
:
13314 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13315 phex_nz (addr2
, 0));
13318 error (_("Unknown trace find type %d"), type
);
13322 reply
= remote_get_noisy_reply ();
13323 if (*reply
== '\0')
13324 error (_("Target does not support this command."));
13326 while (reply
&& *reply
)
13331 target_frameno
= (int) strtol (p
, &reply
, 16);
13333 error (_("Unable to parse trace frame number"));
13334 /* Don't update our remote traceframe number cache on failure
13335 to select a remote traceframe. */
13336 if (target_frameno
== -1)
13341 target_tracept
= (int) strtol (p
, &reply
, 16);
13343 error (_("Unable to parse tracepoint number"));
13345 case 'O': /* "OK"? */
13346 if (reply
[1] == 'K' && reply
[2] == '\0')
13349 error (_("Bogus reply from target: %s"), reply
);
13352 error (_("Bogus reply from target: %s"), reply
);
13355 *tpp
= target_tracept
;
13357 rs
->remote_traceframe_number
= target_frameno
;
13358 return target_frameno
;
13362 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13364 struct remote_state
*rs
= get_remote_state ();
13368 set_remote_traceframe ();
13370 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13372 reply
= remote_get_noisy_reply ();
13373 if (reply
&& *reply
)
13377 unpack_varlen_hex (reply
+ 1, &uval
);
13378 *val
= (LONGEST
) uval
;
13386 remote_target::save_trace_data (const char *filename
)
13388 struct remote_state
*rs
= get_remote_state ();
13391 p
= rs
->buf
.data ();
13392 strcpy (p
, "QTSave:");
13394 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13395 >= get_remote_packet_size ())
13396 error (_("Remote file name too long for trace save packet"));
13397 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13400 reply
= remote_get_noisy_reply ();
13401 if (*reply
== '\0')
13402 error (_("Target does not support this command."));
13403 if (strcmp (reply
, "OK") != 0)
13404 error (_("Bogus reply from target: %s"), reply
);
13408 /* This is basically a memory transfer, but needs to be its own packet
13409 because we don't know how the target actually organizes its trace
13410 memory, plus we want to be able to ask for as much as possible, but
13411 not be unhappy if we don't get as much as we ask for. */
13414 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13416 struct remote_state
*rs
= get_remote_state ();
13421 p
= rs
->buf
.data ();
13422 strcpy (p
, "qTBuffer:");
13424 p
+= hexnumstr (p
, offset
);
13426 p
+= hexnumstr (p
, len
);
13430 reply
= remote_get_noisy_reply ();
13431 if (reply
&& *reply
)
13433 /* 'l' by itself means we're at the end of the buffer and
13434 there is nothing more to get. */
13438 /* Convert the reply into binary. Limit the number of bytes to
13439 convert according to our passed-in buffer size, rather than
13440 what was returned in the packet; if the target is
13441 unexpectedly generous and gives us a bigger reply than we
13442 asked for, we don't want to crash. */
13443 rslt
= hex2bin (reply
, buf
, len
);
13447 /* Something went wrong, flag as an error. */
13452 remote_target::set_disconnected_tracing (int val
)
13454 struct remote_state
*rs
= get_remote_state ();
13456 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13460 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13461 "QTDisconnected:%x", val
);
13463 reply
= remote_get_noisy_reply ();
13464 if (*reply
== '\0')
13465 error (_("Target does not support this command."));
13466 if (strcmp (reply
, "OK") != 0)
13467 error (_("Bogus reply from target: %s"), reply
);
13470 warning (_("Target does not support disconnected tracing."));
13474 remote_target::core_of_thread (ptid_t ptid
)
13476 thread_info
*info
= find_thread_ptid (this, ptid
);
13478 if (info
!= NULL
&& info
->priv
!= NULL
)
13479 return get_remote_thread_info (info
)->core
;
13485 remote_target::set_circular_trace_buffer (int val
)
13487 struct remote_state
*rs
= get_remote_state ();
13490 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13491 "QTBuffer:circular:%x", val
);
13493 reply
= remote_get_noisy_reply ();
13494 if (*reply
== '\0')
13495 error (_("Target does not support this command."));
13496 if (strcmp (reply
, "OK") != 0)
13497 error (_("Bogus reply from target: %s"), reply
);
13501 remote_target::traceframe_info ()
13503 gdb::optional
<gdb::char_vector
> text
13504 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13507 return parse_traceframe_info (text
->data ());
13512 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13513 instruction on which a fast tracepoint may be placed. Returns -1
13514 if the packet is not supported, and 0 if the minimum instruction
13515 length is unknown. */
13518 remote_target::get_min_fast_tracepoint_insn_len ()
13520 struct remote_state
*rs
= get_remote_state ();
13523 /* If we're not debugging a process yet, the IPA can't be
13525 if (!target_has_execution
)
13528 /* Make sure the remote is pointing at the right process. */
13529 set_general_process ();
13531 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13533 reply
= remote_get_noisy_reply ();
13534 if (*reply
== '\0')
13538 ULONGEST min_insn_len
;
13540 unpack_varlen_hex (reply
, &min_insn_len
);
13542 return (int) min_insn_len
;
13547 remote_target::set_trace_buffer_size (LONGEST val
)
13549 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13551 struct remote_state
*rs
= get_remote_state ();
13552 char *buf
= rs
->buf
.data ();
13553 char *endbuf
= buf
+ get_remote_packet_size ();
13554 enum packet_result result
;
13556 gdb_assert (val
>= 0 || val
== -1);
13557 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13558 /* Send -1 as literal "-1" to avoid host size dependency. */
13562 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13565 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13568 remote_get_noisy_reply ();
13569 result
= packet_ok (rs
->buf
,
13570 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13572 if (result
!= PACKET_OK
)
13573 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13578 remote_target::set_trace_notes (const char *user
, const char *notes
,
13579 const char *stop_notes
)
13581 struct remote_state
*rs
= get_remote_state ();
13583 char *buf
= rs
->buf
.data ();
13584 char *endbuf
= buf
+ get_remote_packet_size ();
13587 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13590 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13591 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13597 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13598 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13604 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13605 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13609 /* Ensure the buffer is terminated. */
13613 reply
= remote_get_noisy_reply ();
13614 if (*reply
== '\0')
13617 if (strcmp (reply
, "OK") != 0)
13618 error (_("Bogus reply from target: %s"), reply
);
13624 remote_target::use_agent (bool use
)
13626 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13628 struct remote_state
*rs
= get_remote_state ();
13630 /* If the stub supports QAgent. */
13631 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13633 getpkt (&rs
->buf
, 0);
13635 if (strcmp (rs
->buf
.data (), "OK") == 0)
13646 remote_target::can_use_agent ()
13648 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13651 struct btrace_target_info
13653 /* The ptid of the traced thread. */
13656 /* The obtained branch trace configuration. */
13657 struct btrace_config conf
;
13660 /* Reset our idea of our target's btrace configuration. */
13663 remote_btrace_reset (remote_state
*rs
)
13665 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13668 /* Synchronize the configuration with the target. */
13671 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13673 struct packet_config
*packet
;
13674 struct remote_state
*rs
;
13675 char *buf
, *pos
, *endbuf
;
13677 rs
= get_remote_state ();
13678 buf
= rs
->buf
.data ();
13679 endbuf
= buf
+ get_remote_packet_size ();
13681 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13682 if (packet_config_support (packet
) == PACKET_ENABLE
13683 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13686 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13690 getpkt (&rs
->buf
, 0);
13692 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13694 if (buf
[0] == 'E' && buf
[1] == '.')
13695 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13697 error (_("Failed to configure the BTS buffer size."));
13700 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13703 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13704 if (packet_config_support (packet
) == PACKET_ENABLE
13705 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13708 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13712 getpkt (&rs
->buf
, 0);
13714 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13716 if (buf
[0] == 'E' && buf
[1] == '.')
13717 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13719 error (_("Failed to configure the trace buffer size."));
13722 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13726 /* Read the current thread's btrace configuration from the target and
13727 store it into CONF. */
13730 btrace_read_config (struct btrace_config
*conf
)
13732 gdb::optional
<gdb::char_vector
> xml
13733 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13735 parse_xml_btrace_conf (conf
, xml
->data ());
13738 /* Maybe reopen target btrace. */
13741 remote_target::remote_btrace_maybe_reopen ()
13743 struct remote_state
*rs
= get_remote_state ();
13744 int btrace_target_pushed
= 0;
13745 #if !defined (HAVE_LIBIPT)
13749 /* Don't bother walking the entirety of the remote thread list when
13750 we know the feature isn't supported by the remote. */
13751 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13754 scoped_restore_current_thread restore_thread
;
13756 for (thread_info
*tp
: all_non_exited_threads (this))
13758 set_general_thread (tp
->ptid
);
13760 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13761 btrace_read_config (&rs
->btrace_config
);
13763 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13766 #if !defined (HAVE_LIBIPT)
13767 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13772 warning (_("Target is recording using Intel Processor Trace "
13773 "but support was disabled at compile time."));
13778 #endif /* !defined (HAVE_LIBIPT) */
13780 /* Push target, once, but before anything else happens. This way our
13781 changes to the threads will be cleaned up by unpushing the target
13782 in case btrace_read_config () throws. */
13783 if (!btrace_target_pushed
)
13785 btrace_target_pushed
= 1;
13786 record_btrace_push_target ();
13787 printf_filtered (_("Target is recording using %s.\n"),
13788 btrace_format_string (rs
->btrace_config
.format
));
13791 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13792 tp
->btrace
.target
->ptid
= tp
->ptid
;
13793 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13797 /* Enable branch tracing. */
13799 struct btrace_target_info
*
13800 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13802 struct btrace_target_info
*tinfo
= NULL
;
13803 struct packet_config
*packet
= NULL
;
13804 struct remote_state
*rs
= get_remote_state ();
13805 char *buf
= rs
->buf
.data ();
13806 char *endbuf
= buf
+ get_remote_packet_size ();
13808 switch (conf
->format
)
13810 case BTRACE_FORMAT_BTS
:
13811 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13814 case BTRACE_FORMAT_PT
:
13815 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13819 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13820 error (_("Target does not support branch tracing."));
13822 btrace_sync_conf (conf
);
13824 set_general_thread (ptid
);
13826 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13828 getpkt (&rs
->buf
, 0);
13830 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13832 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13833 error (_("Could not enable branch tracing for %s: %s"),
13834 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
13836 error (_("Could not enable branch tracing for %s."),
13837 target_pid_to_str (ptid
).c_str ());
13840 tinfo
= XCNEW (struct btrace_target_info
);
13841 tinfo
->ptid
= ptid
;
13843 /* If we fail to read the configuration, we lose some information, but the
13844 tracing itself is not impacted. */
13847 btrace_read_config (&tinfo
->conf
);
13849 catch (const gdb_exception_error
&err
)
13851 if (err
.message
!= NULL
)
13852 warning ("%s", err
.what ());
13858 /* Disable branch tracing. */
13861 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
13863 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13864 struct remote_state
*rs
= get_remote_state ();
13865 char *buf
= rs
->buf
.data ();
13866 char *endbuf
= buf
+ get_remote_packet_size ();
13868 if (packet_config_support (packet
) != PACKET_ENABLE
)
13869 error (_("Target does not support branch tracing."));
13871 set_general_thread (tinfo
->ptid
);
13873 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13875 getpkt (&rs
->buf
, 0);
13877 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13879 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13880 error (_("Could not disable branch tracing for %s: %s"),
13881 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
13883 error (_("Could not disable branch tracing for %s."),
13884 target_pid_to_str (tinfo
->ptid
).c_str ());
13890 /* Teardown branch tracing. */
13893 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
13895 /* We must not talk to the target during teardown. */
13899 /* Read the branch trace. */
13902 remote_target::read_btrace (struct btrace_data
*btrace
,
13903 struct btrace_target_info
*tinfo
,
13904 enum btrace_read_type type
)
13906 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13909 if (packet_config_support (packet
) != PACKET_ENABLE
)
13910 error (_("Target does not support branch tracing."));
13912 #if !defined(HAVE_LIBEXPAT)
13913 error (_("Cannot process branch tracing result. XML parsing not supported."));
13918 case BTRACE_READ_ALL
:
13921 case BTRACE_READ_NEW
:
13924 case BTRACE_READ_DELTA
:
13928 internal_error (__FILE__
, __LINE__
,
13929 _("Bad branch tracing read type: %u."),
13930 (unsigned int) type
);
13933 gdb::optional
<gdb::char_vector
> xml
13934 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
13936 return BTRACE_ERR_UNKNOWN
;
13938 parse_xml_btrace (btrace
, xml
->data ());
13940 return BTRACE_ERR_NONE
;
13943 const struct btrace_config
*
13944 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
13946 return &tinfo
->conf
;
13950 remote_target::augmented_libraries_svr4_read ()
13952 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13956 /* Implementation of to_load. */
13959 remote_target::load (const char *name
, int from_tty
)
13961 generic_load (name
, from_tty
);
13964 /* Accepts an integer PID; returns a string representing a file that
13965 can be opened on the remote side to get the symbols for the child
13966 process. Returns NULL if the operation is not supported. */
13969 remote_target::pid_to_exec_file (int pid
)
13971 static gdb::optional
<gdb::char_vector
> filename
;
13972 char *annex
= NULL
;
13974 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13977 inferior
*inf
= find_inferior_pid (this, pid
);
13979 internal_error (__FILE__
, __LINE__
,
13980 _("not currently attached to process %d"), pid
);
13982 if (!inf
->fake_pid_p
)
13984 const int annex_size
= 9;
13986 annex
= (char *) alloca (annex_size
);
13987 xsnprintf (annex
, annex_size
, "%x", pid
);
13990 filename
= target_read_stralloc (current_top_target (),
13991 TARGET_OBJECT_EXEC_FILE
, annex
);
13993 return filename
? filename
->data () : nullptr;
13996 /* Implement the to_can_do_single_step target_ops method. */
13999 remote_target::can_do_single_step ()
14001 /* We can only tell whether target supports single step or not by
14002 supported s and S vCont actions if the stub supports vContSupported
14003 feature. If the stub doesn't support vContSupported feature,
14004 we have conservatively to think target doesn't supports single
14006 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
14008 struct remote_state
*rs
= get_remote_state ();
14010 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14011 remote_vcont_probe ();
14013 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
14019 /* Implementation of the to_execution_direction method for the remote
14022 enum exec_direction_kind
14023 remote_target::execution_direction ()
14025 struct remote_state
*rs
= get_remote_state ();
14027 return rs
->last_resume_exec_dir
;
14030 /* Return pointer to the thread_info struct which corresponds to
14031 THREAD_HANDLE (having length HANDLE_LEN). */
14034 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
14038 for (thread_info
*tp
: all_non_exited_threads (this))
14040 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14042 if (tp
->inf
== inf
&& priv
!= NULL
)
14044 if (handle_len
!= priv
->thread_handle
.size ())
14045 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14046 handle_len
, priv
->thread_handle
.size ());
14047 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14057 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
14059 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14060 return priv
->thread_handle
;
14064 remote_target::can_async_p ()
14066 struct remote_state
*rs
= get_remote_state ();
14068 /* We don't go async if the user has explicitly prevented it with the
14069 "maint set target-async" command. */
14070 if (!target_async_permitted
)
14073 /* We're async whenever the serial device is. */
14074 return serial_can_async_p (rs
->remote_desc
);
14078 remote_target::is_async_p ()
14080 struct remote_state
*rs
= get_remote_state ();
14082 if (!target_async_permitted
)
14083 /* We only enable async when the user specifically asks for it. */
14086 /* We're async whenever the serial device is. */
14087 return serial_is_async_p (rs
->remote_desc
);
14090 /* Pass the SERIAL event on and up to the client. One day this code
14091 will be able to delay notifying the client of an event until the
14092 point where an entire packet has been received. */
14094 static serial_event_ftype remote_async_serial_handler
;
14097 remote_async_serial_handler (struct serial
*scb
, void *context
)
14099 /* Don't propogate error information up to the client. Instead let
14100 the client find out about the error by querying the target. */
14101 inferior_event_handler (INF_REG_EVENT
, NULL
);
14105 remote_async_inferior_event_handler (gdb_client_data data
)
14107 inferior_event_handler (INF_REG_EVENT
, data
);
14111 remote_target::async_wait_fd ()
14113 struct remote_state
*rs
= get_remote_state ();
14114 return rs
->remote_desc
->fd
;
14118 remote_target::async (int enable
)
14120 struct remote_state
*rs
= get_remote_state ();
14124 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14126 /* If there are pending events in the stop reply queue tell the
14127 event loop to process them. */
14128 if (!rs
->stop_reply_queue
.empty ())
14129 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14130 /* For simplicity, below we clear the pending events token
14131 without remembering whether it is marked, so here we always
14132 mark it. If there's actually no pending notification to
14133 process, this ends up being a no-op (other than a spurious
14134 event-loop wakeup). */
14135 if (target_is_non_stop_p ())
14136 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14140 serial_async (rs
->remote_desc
, NULL
, NULL
);
14141 /* If the core is disabling async, it doesn't want to be
14142 disturbed with target events. Clear all async event sources
14144 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14145 if (target_is_non_stop_p ())
14146 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14150 /* Implementation of the to_thread_events method. */
14153 remote_target::thread_events (int enable
)
14155 struct remote_state
*rs
= get_remote_state ();
14156 size_t size
= get_remote_packet_size ();
14158 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14161 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14163 getpkt (&rs
->buf
, 0);
14165 switch (packet_ok (rs
->buf
,
14166 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14169 if (strcmp (rs
->buf
.data (), "OK") != 0)
14170 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14173 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14175 case PACKET_UNKNOWN
:
14181 set_remote_cmd (const char *args
, int from_tty
)
14183 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
14187 show_remote_cmd (const char *args
, int from_tty
)
14189 /* We can't just use cmd_show_list here, because we want to skip
14190 the redundant "show remote Z-packet" and the legacy aliases. */
14191 struct cmd_list_element
*list
= remote_show_cmdlist
;
14192 struct ui_out
*uiout
= current_uiout
;
14194 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14195 for (; list
!= NULL
; list
= list
->next
)
14196 if (strcmp (list
->name
, "Z-packet") == 0)
14198 else if (list
->type
== not_set_cmd
)
14199 /* Alias commands are exactly like the original, except they
14200 don't have the normal type. */
14204 ui_out_emit_tuple
option_emitter (uiout
, "option");
14206 uiout
->field_string ("name", list
->name
);
14207 uiout
->text (": ");
14208 if (list
->type
== show_cmd
)
14209 do_show_command (NULL
, from_tty
, list
);
14211 cmd_func (list
, NULL
, from_tty
);
14216 /* Function to be called whenever a new objfile (shlib) is detected. */
14218 remote_new_objfile (struct objfile
*objfile
)
14220 remote_target
*remote
= get_current_remote_target ();
14222 if (remote
!= NULL
) /* Have a remote connection. */
14223 remote
->remote_check_symbols ();
14226 /* Pull all the tracepoints defined on the target and create local
14227 data structures representing them. We don't want to create real
14228 tracepoints yet, we don't want to mess up the user's existing
14232 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14234 struct remote_state
*rs
= get_remote_state ();
14237 /* Ask for a first packet of tracepoint definition. */
14239 getpkt (&rs
->buf
, 0);
14240 p
= rs
->buf
.data ();
14241 while (*p
&& *p
!= 'l')
14243 parse_tracepoint_definition (p
, utpp
);
14244 /* Ask for another packet of tracepoint definition. */
14246 getpkt (&rs
->buf
, 0);
14247 p
= rs
->buf
.data ();
14253 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14255 struct remote_state
*rs
= get_remote_state ();
14258 /* Ask for a first packet of variable definition. */
14260 getpkt (&rs
->buf
, 0);
14261 p
= rs
->buf
.data ();
14262 while (*p
&& *p
!= 'l')
14264 parse_tsv_definition (p
, utsvp
);
14265 /* Ask for another packet of variable definition. */
14267 getpkt (&rs
->buf
, 0);
14268 p
= rs
->buf
.data ();
14273 /* The "set/show range-stepping" show hook. */
14276 show_range_stepping (struct ui_file
*file
, int from_tty
,
14277 struct cmd_list_element
*c
,
14280 fprintf_filtered (file
,
14281 _("Debugger's willingness to use range stepping "
14282 "is %s.\n"), value
);
14285 /* Return true if the vCont;r action is supported by the remote
14289 remote_target::vcont_r_supported ()
14291 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14292 remote_vcont_probe ();
14294 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14295 && get_remote_state ()->supports_vCont
.r
);
14298 /* The "set/show range-stepping" set hook. */
14301 set_range_stepping (const char *ignore_args
, int from_tty
,
14302 struct cmd_list_element
*c
)
14304 /* When enabling, check whether range stepping is actually supported
14305 by the target, and warn if not. */
14306 if (use_range_stepping
)
14308 remote_target
*remote
= get_current_remote_target ();
14310 || !remote
->vcont_r_supported ())
14311 warning (_("Range stepping is not supported by the current target"));
14316 _initialize_remote (void)
14318 struct cmd_list_element
*cmd
;
14319 const char *cmd_name
;
14321 /* architecture specific data */
14322 remote_g_packet_data_handle
=
14323 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14325 add_target (remote_target_info
, remote_target::open
);
14326 add_target (extended_remote_target_info
, extended_remote_target::open
);
14328 /* Hook into new objfile notification. */
14329 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14332 init_remote_threadtests ();
14335 /* set/show remote ... */
14337 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14338 Remote protocol specific variables.\n\
14339 Configure various remote-protocol specific variables such as\n\
14340 the packets being used."),
14341 &remote_set_cmdlist
, "set remote ",
14342 0 /* allow-unknown */, &setlist
);
14343 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14344 Remote protocol specific variables.\n\
14345 Configure various remote-protocol specific variables such as\n\
14346 the packets being used."),
14347 &remote_show_cmdlist
, "show remote ",
14348 0 /* allow-unknown */, &showlist
);
14350 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14351 Compare section data on target to the exec file.\n\
14352 Argument is a single section name (default: all loaded sections).\n\
14353 To compare only read-only loaded sections, specify the -r option."),
14356 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14357 Send an arbitrary packet to a remote target.\n\
14358 maintenance packet TEXT\n\
14359 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14360 this command sends the string TEXT to the inferior, and displays the\n\
14361 response packet. GDB supplies the initial `$' character, and the\n\
14362 terminating `#' character and checksum."),
14365 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14366 Set whether to send break if interrupted."), _("\
14367 Show whether to send break if interrupted."), _("\
14368 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14369 set_remotebreak
, show_remotebreak
,
14370 &setlist
, &showlist
);
14371 cmd_name
= "remotebreak";
14372 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14373 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14374 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14375 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14376 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14378 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14379 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14381 Set interrupt sequence to remote target."), _("\
14382 Show interrupt sequence to remote target."), _("\
14383 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14384 NULL
, show_interrupt_sequence
,
14385 &remote_set_cmdlist
,
14386 &remote_show_cmdlist
);
14388 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14389 &interrupt_on_connect
, _("\
14390 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14391 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14392 If set, interrupt sequence is sent to remote target."),
14394 &remote_set_cmdlist
, &remote_show_cmdlist
);
14396 /* Install commands for configuring memory read/write packets. */
14398 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14399 Set the maximum number of bytes per memory write packet (deprecated)."),
14401 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14402 Show the maximum number of bytes per memory write packet (deprecated)."),
14404 add_cmd ("memory-write-packet-size", no_class
,
14405 set_memory_write_packet_size
, _("\
14406 Set the maximum number of bytes per memory-write packet.\n\
14407 Specify the number of bytes in a packet or 0 (zero) for the\n\
14408 default packet size. The actual limit is further reduced\n\
14409 dependent on the target. Specify ``fixed'' to disable the\n\
14410 further restriction and ``limit'' to enable that restriction."),
14411 &remote_set_cmdlist
);
14412 add_cmd ("memory-read-packet-size", no_class
,
14413 set_memory_read_packet_size
, _("\
14414 Set the maximum number of bytes per memory-read packet.\n\
14415 Specify the number of bytes in a packet or 0 (zero) for the\n\
14416 default packet size. The actual limit is further reduced\n\
14417 dependent on the target. Specify ``fixed'' to disable the\n\
14418 further restriction and ``limit'' to enable that restriction."),
14419 &remote_set_cmdlist
);
14420 add_cmd ("memory-write-packet-size", no_class
,
14421 show_memory_write_packet_size
,
14422 _("Show the maximum number of bytes per memory-write packet."),
14423 &remote_show_cmdlist
);
14424 add_cmd ("memory-read-packet-size", no_class
,
14425 show_memory_read_packet_size
,
14426 _("Show the maximum number of bytes per memory-read packet."),
14427 &remote_show_cmdlist
);
14429 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14430 &remote_hw_watchpoint_limit
, _("\
14431 Set the maximum number of target hardware watchpoints."), _("\
14432 Show the maximum number of target hardware watchpoints."), _("\
14433 Specify \"unlimited\" for unlimited hardware watchpoints."),
14434 NULL
, show_hardware_watchpoint_limit
,
14435 &remote_set_cmdlist
,
14436 &remote_show_cmdlist
);
14437 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14439 &remote_hw_watchpoint_length_limit
, _("\
14440 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14441 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14442 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14443 NULL
, show_hardware_watchpoint_length_limit
,
14444 &remote_set_cmdlist
, &remote_show_cmdlist
);
14445 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14446 &remote_hw_breakpoint_limit
, _("\
14447 Set the maximum number of target hardware breakpoints."), _("\
14448 Show the maximum number of target hardware breakpoints."), _("\
14449 Specify \"unlimited\" for unlimited hardware breakpoints."),
14450 NULL
, show_hardware_breakpoint_limit
,
14451 &remote_set_cmdlist
, &remote_show_cmdlist
);
14453 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14454 &remote_address_size
, _("\
14455 Set the maximum size of the address (in bits) in a memory packet."), _("\
14456 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14458 NULL
, /* FIXME: i18n: */
14459 &setlist
, &showlist
);
14461 init_all_packet_configs ();
14463 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14464 "X", "binary-download", 1);
14466 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14467 "vCont", "verbose-resume", 0);
14469 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14470 "QPassSignals", "pass-signals", 0);
14472 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14473 "QCatchSyscalls", "catch-syscalls", 0);
14475 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14476 "QProgramSignals", "program-signals", 0);
14478 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14479 "QSetWorkingDir", "set-working-dir", 0);
14481 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14482 "QStartupWithShell", "startup-with-shell", 0);
14484 add_packet_config_cmd (&remote_protocol_packets
14485 [PACKET_QEnvironmentHexEncoded
],
14486 "QEnvironmentHexEncoded", "environment-hex-encoded",
14489 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14490 "QEnvironmentReset", "environment-reset",
14493 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14494 "QEnvironmentUnset", "environment-unset",
14497 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14498 "qSymbol", "symbol-lookup", 0);
14500 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14501 "P", "set-register", 1);
14503 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14504 "p", "fetch-register", 1);
14506 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14507 "Z0", "software-breakpoint", 0);
14509 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14510 "Z1", "hardware-breakpoint", 0);
14512 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14513 "Z2", "write-watchpoint", 0);
14515 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14516 "Z3", "read-watchpoint", 0);
14518 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14519 "Z4", "access-watchpoint", 0);
14521 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14522 "qXfer:auxv:read", "read-aux-vector", 0);
14524 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14525 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14527 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14528 "qXfer:features:read", "target-features", 0);
14530 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14531 "qXfer:libraries:read", "library-info", 0);
14533 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14534 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14536 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14537 "qXfer:memory-map:read", "memory-map", 0);
14539 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14540 "qXfer:osdata:read", "osdata", 0);
14542 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14543 "qXfer:threads:read", "threads", 0);
14545 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14546 "qXfer:siginfo:read", "read-siginfo-object", 0);
14548 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14549 "qXfer:siginfo:write", "write-siginfo-object", 0);
14551 add_packet_config_cmd
14552 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14553 "qXfer:traceframe-info:read", "traceframe-info", 0);
14555 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14556 "qXfer:uib:read", "unwind-info-block", 0);
14558 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14559 "qGetTLSAddr", "get-thread-local-storage-address",
14562 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14563 "qGetTIBAddr", "get-thread-information-block-address",
14566 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14567 "bc", "reverse-continue", 0);
14569 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14570 "bs", "reverse-step", 0);
14572 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14573 "qSupported", "supported-packets", 0);
14575 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14576 "qSearch:memory", "search-memory", 0);
14578 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14579 "qTStatus", "trace-status", 0);
14581 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14582 "vFile:setfs", "hostio-setfs", 0);
14584 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14585 "vFile:open", "hostio-open", 0);
14587 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14588 "vFile:pread", "hostio-pread", 0);
14590 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14591 "vFile:pwrite", "hostio-pwrite", 0);
14593 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14594 "vFile:close", "hostio-close", 0);
14596 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14597 "vFile:unlink", "hostio-unlink", 0);
14599 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14600 "vFile:readlink", "hostio-readlink", 0);
14602 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14603 "vFile:fstat", "hostio-fstat", 0);
14605 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14606 "vAttach", "attach", 0);
14608 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14611 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14612 "QStartNoAckMode", "noack", 0);
14614 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14615 "vKill", "kill", 0);
14617 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14618 "qAttached", "query-attached", 0);
14620 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14621 "ConditionalTracepoints",
14622 "conditional-tracepoints", 0);
14624 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14625 "ConditionalBreakpoints",
14626 "conditional-breakpoints", 0);
14628 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14629 "BreakpointCommands",
14630 "breakpoint-commands", 0);
14632 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14633 "FastTracepoints", "fast-tracepoints", 0);
14635 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14636 "TracepointSource", "TracepointSource", 0);
14638 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14639 "QAllow", "allow", 0);
14641 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14642 "StaticTracepoints", "static-tracepoints", 0);
14644 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14645 "InstallInTrace", "install-in-trace", 0);
14647 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14648 "qXfer:statictrace:read", "read-sdata-object", 0);
14650 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14651 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14653 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14654 "QDisableRandomization", "disable-randomization", 0);
14656 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14657 "QAgent", "agent", 0);
14659 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14660 "QTBuffer:size", "trace-buffer-size", 0);
14662 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14663 "Qbtrace:off", "disable-btrace", 0);
14665 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14666 "Qbtrace:bts", "enable-btrace-bts", 0);
14668 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14669 "Qbtrace:pt", "enable-btrace-pt", 0);
14671 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14672 "qXfer:btrace", "read-btrace", 0);
14674 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14675 "qXfer:btrace-conf", "read-btrace-conf", 0);
14677 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14678 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14680 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14681 "multiprocess-feature", "multiprocess-feature", 0);
14683 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14684 "swbreak-feature", "swbreak-feature", 0);
14686 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14687 "hwbreak-feature", "hwbreak-feature", 0);
14689 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14690 "fork-event-feature", "fork-event-feature", 0);
14692 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14693 "vfork-event-feature", "vfork-event-feature", 0);
14695 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14696 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14698 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14699 "vContSupported", "verbose-resume-supported", 0);
14701 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14702 "exec-event-feature", "exec-event-feature", 0);
14704 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14705 "vCtrlC", "ctrl-c", 0);
14707 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14708 "QThreadEvents", "thread-events", 0);
14710 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14711 "N stop reply", "no-resumed-stop-reply", 0);
14713 /* Assert that we've registered "set remote foo-packet" commands
14714 for all packet configs. */
14718 for (i
= 0; i
< PACKET_MAX
; i
++)
14720 /* Ideally all configs would have a command associated. Some
14721 still don't though. */
14726 case PACKET_QNonStop
:
14727 case PACKET_EnableDisableTracepoints_feature
:
14728 case PACKET_tracenz_feature
:
14729 case PACKET_DisconnectedTracing_feature
:
14730 case PACKET_augmented_libraries_svr4_read_feature
:
14732 /* Additions to this list need to be well justified:
14733 pre-existing packets are OK; new packets are not. */
14741 /* This catches both forgetting to add a config command, and
14742 forgetting to remove a packet from the exception list. */
14743 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14747 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14748 Z sub-packet has its own set and show commands, but users may
14749 have sets to this variable in their .gdbinit files (or in their
14751 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14752 &remote_Z_packet_detect
, _("\
14753 Set use of remote protocol `Z' packets."), _("\
14754 Show use of remote protocol `Z' packets."), _("\
14755 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14757 set_remote_protocol_Z_packet_cmd
,
14758 show_remote_protocol_Z_packet_cmd
,
14759 /* FIXME: i18n: Use of remote protocol
14760 `Z' packets is %s. */
14761 &remote_set_cmdlist
, &remote_show_cmdlist
);
14763 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14764 Manipulate files on the remote system.\n\
14765 Transfer files to and from the remote target system."),
14766 &remote_cmdlist
, "remote ",
14767 0 /* allow-unknown */, &cmdlist
);
14769 add_cmd ("put", class_files
, remote_put_command
,
14770 _("Copy a local file to the remote system."),
14773 add_cmd ("get", class_files
, remote_get_command
,
14774 _("Copy a remote file to the local system."),
14777 add_cmd ("delete", class_files
, remote_delete_command
,
14778 _("Delete a remote file."),
14781 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14782 &remote_exec_file_var
, _("\
14783 Set the remote pathname for \"run\"."), _("\
14784 Show the remote pathname for \"run\"."), NULL
,
14785 set_remote_exec_file
,
14786 show_remote_exec_file
,
14787 &remote_set_cmdlist
,
14788 &remote_show_cmdlist
);
14790 add_setshow_boolean_cmd ("range-stepping", class_run
,
14791 &use_range_stepping
, _("\
14792 Enable or disable range stepping."), _("\
14793 Show whether target-assisted range stepping is enabled."), _("\
14794 If on, and the target supports it, when stepping a source line, GDB\n\
14795 tells the target to step the corresponding range of addresses itself instead\n\
14796 of issuing multiple single-steps. This speeds up source level\n\
14797 stepping. If off, GDB always issues single-steps, even if range\n\
14798 stepping is supported by the target. The default is on."),
14799 set_range_stepping
,
14800 show_range_stepping
,
14804 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
14805 Set watchdog timer."), _("\
14806 Show watchdog timer."), _("\
14807 When non-zero, this timeout is used instead of waiting forever for a target\n\
14808 to finish a low-level step or continue operation. If the specified amount\n\
14809 of time passes without a response from the target, an error occurs."),
14812 &setlist
, &showlist
);
14814 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
14815 &remote_packet_max_chars
, _("\
14816 Set the maximum number of characters to display for each remote packet."), _("\
14817 Show the maximum number of characters to display for each remote packet."), _("\
14818 Specify \"unlimited\" to display all the characters."),
14819 NULL
, show_remote_packet_max_chars
,
14820 &setdebuglist
, &showdebuglist
);
14822 /* Eventually initialize fileio. See fileio.c */
14823 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);