1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* See the GDB User Guide for details of the GDB remote protocol. */
30 #include "process-stratum-target.h"
33 #include "gdb-stabs.h"
34 #include "gdbthread.h"
36 #include "remote-notif.h"
39 #include "observable.h"
41 #include "cli/cli-decode.h"
42 #include "cli/cli-setshow.h"
43 #include "target-descriptions.h"
45 #include "gdbsupport/filestuff.h"
46 #include "gdbsupport/rsp-low.h"
50 #include "gdbsupport/gdb_sys_time.h"
52 #include "event-loop.h"
53 #include "event-top.h"
59 #include "gdbcore.h" /* for exec_bfd */
61 #include "remote-fileio.h"
62 #include "gdb/fileio.h"
64 #include "xml-support.h"
66 #include "memory-map.h"
68 #include "tracepoint.h"
71 #include "gdbsupport/agent.h"
73 #include "record-btrace.h"
75 #include "gdbsupport/scoped_restore.h"
76 #include "gdbsupport/environ.h"
77 #include "gdbsupport/byte-vector.h"
79 #include <unordered_map>
81 /* The remote target. */
83 static const char remote_doc
[] = N_("\
84 Use a remote computer via a serial line, using a gdb-specific protocol.\n\
85 Specify the serial device it is connected to\n\
86 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
88 #define OPAQUETHREADBYTES 8
90 /* a 64 bit opaque identifier */
91 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
93 struct gdb_ext_thread_info
;
94 struct threads_listing_context
;
95 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
96 struct protocol_feature
;
100 typedef std::unique_ptr
<stop_reply
> stop_reply_up
;
102 /* Generic configuration support for packets the stub optionally
103 supports. Allows the user to specify the use of the packet as well
104 as allowing GDB to auto-detect support in the remote stub. */
108 PACKET_SUPPORT_UNKNOWN
= 0,
113 /* Analyze a packet's return value and update the packet config
123 struct threads_listing_context
;
125 /* Stub vCont actions support.
127 Each field is a boolean flag indicating whether the stub reports
128 support for the corresponding action. */
130 struct vCont_action_support
145 /* About this many threadids fit in a packet. */
147 #define MAXTHREADLISTRESULTS 32
149 /* Data for the vFile:pread readahead cache. */
151 struct readahead_cache
153 /* Invalidate the readahead cache. */
156 /* Invalidate the readahead cache if it is holding data for FD. */
157 void invalidate_fd (int fd
);
159 /* Serve pread from the readahead cache. Returns number of bytes
160 read, or 0 if the request can't be served from the cache. */
161 int pread (int fd
, gdb_byte
*read_buf
, size_t len
, ULONGEST offset
);
163 /* The file descriptor for the file that is being cached. -1 if the
167 /* The offset into the file that the cache buffer corresponds
171 /* The buffer holding the cache contents. */
172 gdb_byte
*buf
= nullptr;
173 /* The buffer's size. We try to read as much as fits into a packet
177 /* Cache hit and miss counters. */
178 ULONGEST hit_count
= 0;
179 ULONGEST miss_count
= 0;
182 /* Description of the remote protocol for a given architecture. */
186 long offset
; /* Offset into G packet. */
187 long regnum
; /* GDB's internal register number. */
188 LONGEST pnum
; /* Remote protocol register number. */
189 int in_g_packet
; /* Always part of G packet. */
190 /* long size in bytes; == register_size (target_gdbarch (), regnum);
192 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
196 struct remote_arch_state
198 explicit remote_arch_state (struct gdbarch
*gdbarch
);
200 /* Description of the remote protocol registers. */
201 long sizeof_g_packet
;
203 /* Description of the remote protocol registers indexed by REGNUM
204 (making an array gdbarch_num_regs in size). */
205 std::unique_ptr
<packet_reg
[]> regs
;
207 /* This is the size (in chars) of the first response to the ``g''
208 packet. It is used as a heuristic when determining the maximum
209 size of memory-read and memory-write packets. A target will
210 typically only reserve a buffer large enough to hold the ``g''
211 packet. The size does not include packet overhead (headers and
213 long actual_register_packet_size
;
215 /* This is the maximum size (in chars) of a non read/write packet.
216 It is also used as a cap on the size of read/write packets. */
217 long remote_packet_size
;
220 /* Description of the remote protocol state for the currently
221 connected target. This is per-target state, and independent of the
222 selected architecture. */
231 /* Get the remote arch state for GDBARCH. */
232 struct remote_arch_state
*get_remote_arch_state (struct gdbarch
*gdbarch
);
236 /* A buffer to use for incoming packets, and its current size. The
237 buffer is grown dynamically for larger incoming packets.
238 Outgoing packets may also be constructed in this buffer.
239 The size of the buffer is always at least REMOTE_PACKET_SIZE;
240 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
242 gdb::char_vector buf
;
244 /* True if we're going through initial connection setup (finding out
245 about the remote side's threads, relocating symbols, etc.). */
246 bool starting_up
= false;
248 /* If we negotiated packet size explicitly (and thus can bypass
249 heuristics for the largest packet size that will not overflow
250 a buffer in the stub), this will be set to that packet size.
251 Otherwise zero, meaning to use the guessed size. */
252 long explicit_packet_size
= 0;
254 /* remote_wait is normally called when the target is running and
255 waits for a stop reply packet. But sometimes we need to call it
256 when the target is already stopped. We can send a "?" packet
257 and have remote_wait read the response. Or, if we already have
258 the response, we can stash it in BUF and tell remote_wait to
259 skip calling getpkt. This flag is set when BUF contains a
260 stop reply packet and the target is not waiting. */
261 int cached_wait_status
= 0;
263 /* True, if in no ack mode. That is, neither GDB nor the stub will
264 expect acks from each other. The connection is assumed to be
266 bool noack_mode
= false;
268 /* True if we're connected in extended remote mode. */
269 bool extended
= false;
271 /* True if we resumed the target and we're waiting for the target to
272 stop. In the mean time, we can't start another command/query.
273 The remote server wouldn't be ready to process it, so we'd
274 timeout waiting for a reply that would never come and eventually
275 we'd close the connection. This can happen in asynchronous mode
276 because we allow GDB commands while the target is running. */
277 bool waiting_for_stop_reply
= false;
279 /* The status of the stub support for the various vCont actions. */
280 vCont_action_support supports_vCont
;
281 /* Whether vCont support was probed already. This is a workaround
282 until packet_support is per-connection. */
283 bool supports_vCont_probed
;
285 /* True if the user has pressed Ctrl-C, but the target hasn't
286 responded to that. */
287 bool ctrlc_pending_p
= false;
289 /* True if we saw a Ctrl-C while reading or writing from/to the
290 remote descriptor. At that point it is not safe to send a remote
291 interrupt packet, so we instead remember we saw the Ctrl-C and
292 process it once we're done with sending/receiving the current
293 packet, which should be shortly. If however that takes too long,
294 and the user presses Ctrl-C again, we offer to disconnect. */
295 bool got_ctrlc_during_io
= false;
297 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
298 remote_open knows that we don't have a file open when the program
300 struct serial
*remote_desc
= nullptr;
302 /* These are the threads which we last sent to the remote system. The
303 TID member will be -1 for all or -2 for not sent yet. */
304 ptid_t general_thread
= null_ptid
;
305 ptid_t continue_thread
= null_ptid
;
307 /* This is the traceframe which we last selected on the remote system.
308 It will be -1 if no traceframe is selected. */
309 int remote_traceframe_number
= -1;
311 char *last_pass_packet
= nullptr;
313 /* The last QProgramSignals packet sent to the target. We bypass
314 sending a new program signals list down to the target if the new
315 packet is exactly the same as the last we sent. IOW, we only let
316 the target know about program signals list changes. */
317 char *last_program_signals_packet
= nullptr;
319 gdb_signal last_sent_signal
= GDB_SIGNAL_0
;
321 bool last_sent_step
= false;
323 /* The execution direction of the last resume we got. */
324 exec_direction_kind last_resume_exec_dir
= EXEC_FORWARD
;
326 char *finished_object
= nullptr;
327 char *finished_annex
= nullptr;
328 ULONGEST finished_offset
= 0;
330 /* Should we try the 'ThreadInfo' query packet?
332 This variable (NOT available to the user: auto-detect only!)
333 determines whether GDB will use the new, simpler "ThreadInfo"
334 query or the older, more complex syntax for thread queries.
335 This is an auto-detect variable (set to true at each connect,
336 and set to false when the target fails to recognize it). */
337 bool use_threadinfo_query
= false;
338 bool use_threadextra_query
= false;
340 threadref echo_nextthread
{};
341 threadref nextthread
{};
342 threadref resultthreadlist
[MAXTHREADLISTRESULTS
] {};
344 /* The state of remote notification. */
345 struct remote_notif_state
*notif_state
= nullptr;
347 /* The branch trace configuration. */
348 struct btrace_config btrace_config
{};
350 /* The argument to the last "vFile:setfs:" packet we sent, used
351 to avoid sending repeated unnecessary "vFile:setfs:" packets.
352 Initialized to -1 to indicate that no "vFile:setfs:" packet
353 has yet been sent. */
356 /* A readahead cache for vFile:pread. Often, reading a binary
357 involves a sequence of small reads. E.g., when parsing an ELF
358 file. A readahead cache helps mostly the case of remote
359 debugging on a connection with higher latency, due to the
360 request/reply nature of the RSP. We only cache data for a single
361 file descriptor at a time. */
362 struct readahead_cache readahead_cache
;
364 /* The list of already fetched and acknowledged stop events. This
365 queue is used for notification Stop, and other notifications
366 don't need queue for their events, because the notification
367 events of Stop can't be consumed immediately, so that events
368 should be queued first, and be consumed by remote_wait_{ns,as}
369 one per time. Other notifications can consume their events
370 immediately, so queue is not needed for them. */
371 std::vector
<stop_reply_up
> stop_reply_queue
;
373 /* Asynchronous signal handle registered as event loop source for
374 when we have pending events ready to be passed to the core. */
375 struct async_event_handler
*remote_async_inferior_event_token
= nullptr;
377 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
378 ``forever'' still use the normal timeout mechanism. This is
379 currently used by the ASYNC code to guarentee that target reads
380 during the initial connect always time-out. Once getpkt has been
381 modified to return a timeout indication and, in turn
382 remote_wait()/wait_for_inferior() have gained a timeout parameter
384 int wait_forever_enabled_p
= 1;
387 /* Mapping of remote protocol data for each gdbarch. Usually there
388 is only one entry here, though we may see more with stubs that
389 support multi-process. */
390 std::unordered_map
<struct gdbarch
*, remote_arch_state
>
394 static const target_info remote_target_info
= {
396 N_("Remote serial target in gdb-specific protocol"),
400 class remote_target
: public process_stratum_target
403 remote_target () = default;
404 ~remote_target () override
;
406 const target_info
&info () const override
407 { return remote_target_info
; }
409 const char *connection_string () override
;
411 thread_control_capabilities
get_thread_control_capabilities () override
412 { return tc_schedlock
; }
414 /* Open a remote connection. */
415 static void open (const char *, int);
417 void close () override
;
419 void detach (inferior
*, int) override
;
420 void disconnect (const char *, int) override
;
422 void commit_resume () override
;
423 void resume (ptid_t
, int, enum gdb_signal
) override
;
424 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
426 void fetch_registers (struct regcache
*, int) override
;
427 void store_registers (struct regcache
*, int) override
;
428 void prepare_to_store (struct regcache
*) override
;
430 void files_info () override
;
432 int insert_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
434 int remove_breakpoint (struct gdbarch
*, struct bp_target_info
*,
435 enum remove_bp_reason
) override
;
438 bool stopped_by_sw_breakpoint () override
;
439 bool supports_stopped_by_sw_breakpoint () override
;
441 bool stopped_by_hw_breakpoint () override
;
443 bool supports_stopped_by_hw_breakpoint () override
;
445 bool stopped_by_watchpoint () override
;
447 bool stopped_data_address (CORE_ADDR
*) override
;
449 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
451 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
453 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
455 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
457 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
459 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
460 struct expression
*) override
;
462 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
463 struct expression
*) override
;
465 void kill () override
;
467 void load (const char *, int) override
;
469 void mourn_inferior () override
;
471 void pass_signals (gdb::array_view
<const unsigned char>) override
;
473 int set_syscall_catchpoint (int, bool, int,
474 gdb::array_view
<const int>) override
;
476 void program_signals (gdb::array_view
<const unsigned char>) override
;
478 bool thread_alive (ptid_t ptid
) override
;
480 const char *thread_name (struct thread_info
*) override
;
482 void update_thread_list () override
;
484 std::string
pid_to_str (ptid_t
) override
;
486 const char *extra_thread_info (struct thread_info
*) override
;
488 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
490 thread_info
*thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
492 inferior
*inf
) override
;
494 gdb::byte_vector
thread_info_to_thread_handle (struct thread_info
*tp
)
497 void stop (ptid_t
) override
;
499 void interrupt () override
;
501 void pass_ctrlc () override
;
503 enum target_xfer_status
xfer_partial (enum target_object object
,
506 const gdb_byte
*writebuf
,
507 ULONGEST offset
, ULONGEST len
,
508 ULONGEST
*xfered_len
) override
;
510 ULONGEST
get_memory_xfer_limit () override
;
512 void rcmd (const char *command
, struct ui_file
*output
) override
;
514 char *pid_to_exec_file (int pid
) override
;
516 void log_command (const char *cmd
) override
518 serial_log_command (this, cmd
);
521 CORE_ADDR
get_thread_local_address (ptid_t ptid
,
522 CORE_ADDR load_module_addr
,
523 CORE_ADDR offset
) override
;
525 bool can_execute_reverse () override
;
527 std::vector
<mem_region
> memory_map () override
;
529 void flash_erase (ULONGEST address
, LONGEST length
) override
;
531 void flash_done () override
;
533 const struct target_desc
*read_description () override
;
535 int search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
536 const gdb_byte
*pattern
, ULONGEST pattern_len
,
537 CORE_ADDR
*found_addrp
) override
;
539 bool can_async_p () override
;
541 bool is_async_p () override
;
543 void async (int) override
;
545 int async_wait_fd () override
;
547 void thread_events (int) override
;
549 int can_do_single_step () override
;
551 void terminal_inferior () override
;
553 void terminal_ours () override
;
555 bool supports_non_stop () override
;
557 bool supports_multi_process () override
;
559 bool supports_disable_randomization () override
;
561 bool filesystem_is_local () override
;
564 int fileio_open (struct inferior
*inf
, const char *filename
,
565 int flags
, int mode
, int warn_if_slow
,
566 int *target_errno
) override
;
568 int fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
569 ULONGEST offset
, int *target_errno
) override
;
571 int fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
572 ULONGEST offset
, int *target_errno
) override
;
574 int fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
) override
;
576 int fileio_close (int fd
, int *target_errno
) override
;
578 int fileio_unlink (struct inferior
*inf
,
579 const char *filename
,
580 int *target_errno
) override
;
582 gdb::optional
<std::string
>
583 fileio_readlink (struct inferior
*inf
,
584 const char *filename
,
585 int *target_errno
) override
;
587 bool supports_enable_disable_tracepoint () override
;
589 bool supports_string_tracing () override
;
591 bool supports_evaluation_of_breakpoint_conditions () override
;
593 bool can_run_breakpoint_commands () override
;
595 void trace_init () override
;
597 void download_tracepoint (struct bp_location
*location
) override
;
599 bool can_download_tracepoint () override
;
601 void download_trace_state_variable (const trace_state_variable
&tsv
) override
;
603 void enable_tracepoint (struct bp_location
*location
) override
;
605 void disable_tracepoint (struct bp_location
*location
) override
;
607 void trace_set_readonly_regions () override
;
609 void trace_start () override
;
611 int get_trace_status (struct trace_status
*ts
) override
;
613 void get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
616 void trace_stop () override
;
618 int trace_find (enum trace_find_type type
, int num
,
619 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
) override
;
621 bool get_trace_state_variable_value (int tsv
, LONGEST
*val
) override
;
623 int save_trace_data (const char *filename
) override
;
625 int upload_tracepoints (struct uploaded_tp
**utpp
) override
;
627 int upload_trace_state_variables (struct uploaded_tsv
**utsvp
) override
;
629 LONGEST
get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
) override
;
631 int get_min_fast_tracepoint_insn_len () override
;
633 void set_disconnected_tracing (int val
) override
;
635 void set_circular_trace_buffer (int val
) override
;
637 void set_trace_buffer_size (LONGEST val
) override
;
639 bool set_trace_notes (const char *user
, const char *notes
,
640 const char *stopnotes
) override
;
642 int core_of_thread (ptid_t ptid
) override
;
644 int verify_memory (const gdb_byte
*data
,
645 CORE_ADDR memaddr
, ULONGEST size
) override
;
648 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
650 void set_permissions () override
;
652 bool static_tracepoint_marker_at (CORE_ADDR
,
653 struct static_tracepoint_marker
*marker
)
656 std::vector
<static_tracepoint_marker
>
657 static_tracepoint_markers_by_strid (const char *id
) override
;
659 traceframe_info_up
traceframe_info () override
;
661 bool use_agent (bool use
) override
;
662 bool can_use_agent () override
;
664 struct btrace_target_info
*enable_btrace (ptid_t ptid
,
665 const struct btrace_config
*conf
) override
;
667 void disable_btrace (struct btrace_target_info
*tinfo
) override
;
669 void teardown_btrace (struct btrace_target_info
*tinfo
) override
;
671 enum btrace_error
read_btrace (struct btrace_data
*data
,
672 struct btrace_target_info
*btinfo
,
673 enum btrace_read_type type
) override
;
675 const struct btrace_config
*btrace_conf (const struct btrace_target_info
*) override
;
676 bool augmented_libraries_svr4_read () override
;
677 bool follow_fork (bool, bool) override
;
678 void follow_exec (struct inferior
*, const char *) override
;
679 int insert_fork_catchpoint (int) override
;
680 int remove_fork_catchpoint (int) override
;
681 int insert_vfork_catchpoint (int) override
;
682 int remove_vfork_catchpoint (int) override
;
683 int insert_exec_catchpoint (int) override
;
684 int remove_exec_catchpoint (int) override
;
685 enum exec_direction_kind
execution_direction () override
;
687 public: /* Remote specific methods. */
689 void remote_download_command_source (int num
, ULONGEST addr
,
690 struct command_line
*cmds
);
692 void remote_file_put (const char *local_file
, const char *remote_file
,
694 void remote_file_get (const char *remote_file
, const char *local_file
,
696 void remote_file_delete (const char *remote_file
, int from_tty
);
698 int remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
699 ULONGEST offset
, int *remote_errno
);
700 int remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
701 ULONGEST offset
, int *remote_errno
);
702 int remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
703 ULONGEST offset
, int *remote_errno
);
705 int remote_hostio_send_command (int command_bytes
, int which_packet
,
706 int *remote_errno
, char **attachment
,
707 int *attachment_len
);
708 int remote_hostio_set_filesystem (struct inferior
*inf
,
710 /* We should get rid of this and use fileio_open directly. */
711 int remote_hostio_open (struct inferior
*inf
, const char *filename
,
712 int flags
, int mode
, int warn_if_slow
,
714 int remote_hostio_close (int fd
, int *remote_errno
);
716 int remote_hostio_unlink (inferior
*inf
, const char *filename
,
719 struct remote_state
*get_remote_state ();
721 long get_remote_packet_size (void);
722 long get_memory_packet_size (struct memory_packet_config
*config
);
724 long get_memory_write_packet_size ();
725 long get_memory_read_packet_size ();
727 char *append_pending_thread_resumptions (char *p
, char *endp
,
729 static void open_1 (const char *name
, int from_tty
, int extended_p
);
730 void start_remote (int from_tty
, int extended_p
);
731 void remote_detach_1 (struct inferior
*inf
, int from_tty
);
733 char *append_resumption (char *p
, char *endp
,
734 ptid_t ptid
, int step
, gdb_signal siggnal
);
735 int remote_resume_with_vcont (ptid_t ptid
, int step
,
738 void add_current_inferior_and_thread (char *wait_status
);
740 ptid_t
wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
742 ptid_t
wait_as (ptid_t ptid
, target_waitstatus
*status
,
745 ptid_t
process_stop_reply (struct stop_reply
*stop_reply
,
746 target_waitstatus
*status
);
748 void remote_notice_new_inferior (ptid_t currthread
, int executing
);
750 void process_initial_stop_replies (int from_tty
);
752 thread_info
*remote_add_thread (ptid_t ptid
, bool running
, bool executing
);
754 void btrace_sync_conf (const btrace_config
*conf
);
756 void remote_btrace_maybe_reopen ();
758 void remove_new_fork_children (threads_listing_context
*context
);
759 void kill_new_fork_children (int pid
);
760 void discard_pending_stop_replies (struct inferior
*inf
);
761 int stop_reply_queue_length ();
763 void check_pending_events_prevent_wildcard_vcont
764 (int *may_global_wildcard_vcont
);
766 void discard_pending_stop_replies_in_queue ();
767 struct stop_reply
*remote_notif_remove_queued_reply (ptid_t ptid
);
768 struct stop_reply
*queued_stop_reply (ptid_t ptid
);
769 int peek_stop_reply (ptid_t ptid
);
770 void remote_parse_stop_reply (const char *buf
, stop_reply
*event
);
772 void remote_stop_ns (ptid_t ptid
);
773 void remote_interrupt_as ();
774 void remote_interrupt_ns ();
776 char *remote_get_noisy_reply ();
777 int remote_query_attached (int pid
);
778 inferior
*remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
781 ptid_t
remote_current_thread (ptid_t oldpid
);
782 ptid_t
get_current_thread (char *wait_status
);
784 void set_thread (ptid_t ptid
, int gen
);
785 void set_general_thread (ptid_t ptid
);
786 void set_continue_thread (ptid_t ptid
);
787 void set_general_process ();
789 char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
791 int remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
792 gdb_ext_thread_info
*info
);
793 int remote_get_threadinfo (threadref
*threadid
, int fieldset
,
794 gdb_ext_thread_info
*info
);
796 int parse_threadlist_response (char *pkt
, int result_limit
,
797 threadref
*original_echo
,
798 threadref
*resultlist
,
800 int remote_get_threadlist (int startflag
, threadref
*nextthread
,
801 int result_limit
, int *done
, int *result_count
,
802 threadref
*threadlist
);
804 int remote_threadlist_iterator (rmt_thread_action stepfunction
,
805 void *context
, int looplimit
);
807 int remote_get_threads_with_ql (threads_listing_context
*context
);
808 int remote_get_threads_with_qxfer (threads_listing_context
*context
);
809 int remote_get_threads_with_qthreadinfo (threads_listing_context
*context
);
811 void extended_remote_restart ();
815 void remote_check_symbols ();
817 void remote_supported_packet (const struct protocol_feature
*feature
,
818 enum packet_support support
,
819 const char *argument
);
821 void remote_query_supported ();
823 void remote_packet_size (const protocol_feature
*feature
,
824 packet_support support
, const char *value
);
826 void remote_serial_quit_handler ();
828 void remote_detach_pid (int pid
);
830 void remote_vcont_probe ();
832 void remote_resume_with_hc (ptid_t ptid
, int step
,
835 void send_interrupt_sequence ();
836 void interrupt_query ();
838 void remote_notif_get_pending_events (notif_client
*nc
);
840 int fetch_register_using_p (struct regcache
*regcache
,
842 int send_g_packet ();
843 void process_g_packet (struct regcache
*regcache
);
844 void fetch_registers_using_g (struct regcache
*regcache
);
845 int store_register_using_P (const struct regcache
*regcache
,
847 void store_registers_using_G (const struct regcache
*regcache
);
849 void set_remote_traceframe ();
851 void check_binary_download (CORE_ADDR addr
);
853 target_xfer_status
remote_write_bytes_aux (const char *header
,
855 const gdb_byte
*myaddr
,
858 ULONGEST
*xfered_len_units
,
862 target_xfer_status
remote_write_bytes (CORE_ADDR memaddr
,
863 const gdb_byte
*myaddr
, ULONGEST len
,
864 int unit_size
, ULONGEST
*xfered_len
);
866 target_xfer_status
remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
868 int unit_size
, ULONGEST
*xfered_len_units
);
870 target_xfer_status
remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
874 ULONGEST
*xfered_len
);
876 target_xfer_status
remote_read_bytes (CORE_ADDR memaddr
,
877 gdb_byte
*myaddr
, ULONGEST len
,
879 ULONGEST
*xfered_len
);
881 packet_result
remote_send_printf (const char *format
, ...)
882 ATTRIBUTE_PRINTF (2, 3);
884 target_xfer_status
remote_flash_write (ULONGEST address
,
885 ULONGEST length
, ULONGEST
*xfered_len
,
886 const gdb_byte
*data
);
888 int readchar (int timeout
);
890 void remote_serial_write (const char *str
, int len
);
892 int putpkt (const char *buf
);
893 int putpkt_binary (const char *buf
, int cnt
);
895 int putpkt (const gdb::char_vector
&buf
)
897 return putpkt (buf
.data ());
901 long read_frame (gdb::char_vector
*buf_p
);
902 void getpkt (gdb::char_vector
*buf
, int forever
);
903 int getpkt_or_notif_sane_1 (gdb::char_vector
*buf
, int forever
,
904 int expecting_notif
, int *is_notif
);
905 int getpkt_sane (gdb::char_vector
*buf
, int forever
);
906 int getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
908 int remote_vkill (int pid
);
909 void remote_kill_k ();
911 void extended_remote_disable_randomization (int val
);
912 int extended_remote_run (const std::string
&args
);
914 void send_environment_packet (const char *action
,
918 void extended_remote_environment_support ();
919 void extended_remote_set_inferior_cwd ();
921 target_xfer_status
remote_write_qxfer (const char *object_name
,
923 const gdb_byte
*writebuf
,
924 ULONGEST offset
, LONGEST len
,
925 ULONGEST
*xfered_len
,
926 struct packet_config
*packet
);
928 target_xfer_status
remote_read_qxfer (const char *object_name
,
930 gdb_byte
*readbuf
, ULONGEST offset
,
932 ULONGEST
*xfered_len
,
933 struct packet_config
*packet
);
935 void push_stop_reply (struct stop_reply
*new_event
);
937 bool vcont_r_supported ();
939 void packet_command (const char *args
, int from_tty
);
941 private: /* data fields */
943 /* The remote state. Don't reference this directly. Use the
944 get_remote_state method instead. */
945 remote_state m_remote_state
;
948 static const target_info extended_remote_target_info
= {
950 N_("Extended remote serial target in gdb-specific protocol"),
954 /* Set up the extended remote target by extending the standard remote
955 target and adding to it. */
957 class extended_remote_target final
: public remote_target
960 const target_info
&info () const override
961 { return extended_remote_target_info
; }
963 /* Open an extended-remote connection. */
964 static void open (const char *, int);
966 bool can_create_inferior () override
{ return true; }
967 void create_inferior (const char *, const std::string
&,
968 char **, int) override
;
970 void detach (inferior
*, int) override
;
972 bool can_attach () override
{ return true; }
973 void attach (const char *, int) override
;
975 void post_attach (int) override
;
976 bool supports_disable_randomization () override
;
979 /* Per-program-space data key. */
980 static const struct program_space_key
<char, gdb::xfree_deleter
<char>>
983 /* The variable registered as the control variable used by the
984 remote exec-file commands. While the remote exec-file setting is
985 per-program-space, the set/show machinery uses this as the
986 location of the remote exec-file value. */
987 static char *remote_exec_file_var
;
989 /* The size to align memory write packets, when practical. The protocol
990 does not guarantee any alignment, and gdb will generate short
991 writes and unaligned writes, but even as a best-effort attempt this
992 can improve bulk transfers. For instance, if a write is misaligned
993 relative to the target's data bus, the stub may need to make an extra
994 round trip fetching data from the target. This doesn't make a
995 huge difference, but it's easy to do, so we try to be helpful.
997 The alignment chosen is arbitrary; usually data bus width is
998 important here, not the possibly larger cache line size. */
999 enum { REMOTE_ALIGN_WRITES
= 16 };
1001 /* Prototypes for local functions. */
1003 static int hexnumlen (ULONGEST num
);
1005 static int stubhex (int ch
);
1007 static int hexnumstr (char *, ULONGEST
);
1009 static int hexnumnstr (char *, ULONGEST
, int);
1011 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
1013 static void print_packet (const char *);
1015 static int stub_unpack_int (char *buff
, int fieldlength
);
1017 struct packet_config
;
1019 static void show_packet_config_cmd (struct packet_config
*config
);
1021 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
1023 struct cmd_list_element
*c
,
1026 static ptid_t
read_ptid (const char *buf
, const char **obuf
);
1028 static void remote_async_inferior_event_handler (gdb_client_data
);
1030 static bool remote_read_description_p (struct target_ops
*target
);
1032 static void remote_console_output (const char *msg
);
1034 static void remote_btrace_reset (remote_state
*rs
);
1036 static void remote_unpush_and_throw (remote_target
*target
);
1040 static struct cmd_list_element
*remote_cmdlist
;
1042 /* For "set remote" and "show remote". */
1044 static struct cmd_list_element
*remote_set_cmdlist
;
1045 static struct cmd_list_element
*remote_show_cmdlist
;
1047 /* Controls whether GDB is willing to use range stepping. */
1049 static bool use_range_stepping
= true;
1051 /* Private data that we'll store in (struct thread_info)->priv. */
1052 struct remote_thread_info
: public private_thread_info
1058 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1059 sequence of bytes. */
1060 gdb::byte_vector thread_handle
;
1062 /* Whether the target stopped for a breakpoint/watchpoint. */
1063 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1065 /* This is set to the data address of the access causing the target
1066 to stop for a watchpoint. */
1067 CORE_ADDR watch_data_address
= 0;
1069 /* Fields used by the vCont action coalescing implemented in
1070 remote_resume / remote_commit_resume. remote_resume stores each
1071 thread's last resume request in these fields, so that a later
1072 remote_commit_resume knows which is the proper action for this
1073 thread to include in the vCont packet. */
1075 /* True if the last target_resume call for this thread was a step
1076 request, false if a continue request. */
1077 int last_resume_step
= 0;
1079 /* The signal specified in the last target_resume call for this
1081 gdb_signal last_resume_sig
= GDB_SIGNAL_0
;
1083 /* Whether this thread was already vCont-resumed on the remote
1085 int vcont_resumed
= 0;
1088 remote_state::remote_state ()
1093 remote_state::~remote_state ()
1095 xfree (this->last_pass_packet
);
1096 xfree (this->last_program_signals_packet
);
1097 xfree (this->finished_object
);
1098 xfree (this->finished_annex
);
1101 /* Utility: generate error from an incoming stub packet. */
1103 trace_error (char *buf
)
1106 return; /* not an error msg */
1109 case '1': /* malformed packet error */
1110 if (*++buf
== '0') /* general case: */
1111 error (_("remote.c: error in outgoing packet."));
1113 error (_("remote.c: error in outgoing packet at field #%ld."),
1114 strtol (buf
, NULL
, 16));
1116 error (_("Target returns error code '%s'."), buf
);
1120 /* Utility: wait for reply from stub, while accepting "O" packets. */
1123 remote_target::remote_get_noisy_reply ()
1125 struct remote_state
*rs
= get_remote_state ();
1127 do /* Loop on reply from remote stub. */
1131 QUIT
; /* Allow user to bail out with ^C. */
1132 getpkt (&rs
->buf
, 0);
1133 buf
= rs
->buf
.data ();
1136 else if (startswith (buf
, "qRelocInsn:"))
1139 CORE_ADDR from
, to
, org_to
;
1141 int adjusted_size
= 0;
1144 p
= buf
+ strlen ("qRelocInsn:");
1145 pp
= unpack_varlen_hex (p
, &ul
);
1147 error (_("invalid qRelocInsn packet: %s"), buf
);
1151 unpack_varlen_hex (p
, &ul
);
1158 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1161 catch (const gdb_exception
&ex
)
1163 if (ex
.error
== MEMORY_ERROR
)
1165 /* Propagate memory errors silently back to the
1166 target. The stub may have limited the range of
1167 addresses we can write to, for example. */
1171 /* Something unexpectedly bad happened. Be verbose
1172 so we can tell what, and propagate the error back
1173 to the stub, so it doesn't get stuck waiting for
1175 exception_fprintf (gdb_stderr
, ex
,
1176 _("warning: relocating instruction: "));
1183 adjusted_size
= to
- org_to
;
1185 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1189 else if (buf
[0] == 'O' && buf
[1] != 'K')
1190 remote_console_output (buf
+ 1); /* 'O' message from stub */
1192 return buf
; /* Here's the actual reply. */
1197 struct remote_arch_state
*
1198 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1200 remote_arch_state
*rsa
;
1202 auto it
= this->m_arch_states
.find (gdbarch
);
1203 if (it
== this->m_arch_states
.end ())
1205 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1206 std::forward_as_tuple (gdbarch
),
1207 std::forward_as_tuple (gdbarch
));
1208 rsa
= &p
.first
->second
;
1210 /* Make sure that the packet buffer is plenty big enough for
1211 this architecture. */
1212 if (this->buf
.size () < rsa
->remote_packet_size
)
1213 this->buf
.resize (2 * rsa
->remote_packet_size
);
1221 /* Fetch the global remote target state. */
1224 remote_target::get_remote_state ()
1226 /* Make sure that the remote architecture state has been
1227 initialized, because doing so might reallocate rs->buf. Any
1228 function which calls getpkt also needs to be mindful of changes
1229 to rs->buf, but this call limits the number of places which run
1231 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1233 return &m_remote_state
;
1236 /* Fetch the remote exec-file from the current program space. */
1239 get_remote_exec_file (void)
1241 char *remote_exec_file
;
1243 remote_exec_file
= remote_pspace_data
.get (current_program_space
);
1244 if (remote_exec_file
== NULL
)
1247 return remote_exec_file
;
1250 /* Set the remote exec file for PSPACE. */
1253 set_pspace_remote_exec_file (struct program_space
*pspace
,
1254 const char *remote_exec_file
)
1256 char *old_file
= remote_pspace_data
.get (pspace
);
1259 remote_pspace_data
.set (pspace
, xstrdup (remote_exec_file
));
1262 /* The "set/show remote exec-file" set command hook. */
1265 set_remote_exec_file (const char *ignored
, int from_tty
,
1266 struct cmd_list_element
*c
)
1268 gdb_assert (remote_exec_file_var
!= NULL
);
1269 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
1272 /* The "set/show remote exec-file" show command hook. */
1275 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1276 struct cmd_list_element
*cmd
, const char *value
)
1278 fprintf_filtered (file
, "%s\n", get_remote_exec_file ());
1282 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1284 int regnum
, num_remote_regs
, offset
;
1285 struct packet_reg
**remote_regs
;
1287 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1289 struct packet_reg
*r
= ®s
[regnum
];
1291 if (register_size (gdbarch
, regnum
) == 0)
1292 /* Do not try to fetch zero-sized (placeholder) registers. */
1295 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1300 /* Define the g/G packet format as the contents of each register
1301 with a remote protocol number, in order of ascending protocol
1304 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1305 for (num_remote_regs
= 0, regnum
= 0;
1306 regnum
< gdbarch_num_regs (gdbarch
);
1308 if (regs
[regnum
].pnum
!= -1)
1309 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1311 std::sort (remote_regs
, remote_regs
+ num_remote_regs
,
1312 [] (const packet_reg
*a
, const packet_reg
*b
)
1313 { return a
->pnum
< b
->pnum
; });
1315 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1317 remote_regs
[regnum
]->in_g_packet
= 1;
1318 remote_regs
[regnum
]->offset
= offset
;
1319 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1325 /* Given the architecture described by GDBARCH, return the remote
1326 protocol register's number and the register's offset in the g/G
1327 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1328 If the target does not have a mapping for REGNUM, return false,
1329 otherwise, return true. */
1332 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1333 int *pnum
, int *poffset
)
1335 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1337 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1339 map_regcache_remote_table (gdbarch
, regs
.data ());
1341 *pnum
= regs
[regnum
].pnum
;
1342 *poffset
= regs
[regnum
].offset
;
1347 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1349 /* Use the architecture to build a regnum<->pnum table, which will be
1350 1:1 unless a feature set specifies otherwise. */
1351 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1353 /* Record the maximum possible size of the g packet - it may turn out
1355 this->sizeof_g_packet
1356 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1358 /* Default maximum number of characters in a packet body. Many
1359 remote stubs have a hardwired buffer size of 400 bytes
1360 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1361 as the maximum packet-size to ensure that the packet and an extra
1362 NUL character can always fit in the buffer. This stops GDB
1363 trashing stubs that try to squeeze an extra NUL into what is
1364 already a full buffer (As of 1999-12-04 that was most stubs). */
1365 this->remote_packet_size
= 400 - 1;
1367 /* This one is filled in when a ``g'' packet is received. */
1368 this->actual_register_packet_size
= 0;
1370 /* Should rsa->sizeof_g_packet needs more space than the
1371 default, adjust the size accordingly. Remember that each byte is
1372 encoded as two characters. 32 is the overhead for the packet
1373 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1374 (``$NN:G...#NN'') is a better guess, the below has been padded a
1376 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1377 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1380 /* Get a pointer to the current remote target. If not connected to a
1381 remote target, return NULL. */
1383 static remote_target
*
1384 get_current_remote_target ()
1386 target_ops
*proc_target
= current_inferior ()->process_target ();
1387 return dynamic_cast<remote_target
*> (proc_target
);
1390 /* Return the current allowed size of a remote packet. This is
1391 inferred from the current architecture, and should be used to
1392 limit the length of outgoing packets. */
1394 remote_target::get_remote_packet_size ()
1396 struct remote_state
*rs
= get_remote_state ();
1397 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1399 if (rs
->explicit_packet_size
)
1400 return rs
->explicit_packet_size
;
1402 return rsa
->remote_packet_size
;
1405 static struct packet_reg
*
1406 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1409 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1413 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1415 gdb_assert (r
->regnum
== regnum
);
1420 static struct packet_reg
*
1421 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1426 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1428 struct packet_reg
*r
= &rsa
->regs
[i
];
1430 if (r
->pnum
== pnum
)
1436 /* Allow the user to specify what sequence to send to the remote
1437 when he requests a program interruption: Although ^C is usually
1438 what remote systems expect (this is the default, here), it is
1439 sometimes preferable to send a break. On other systems such
1440 as the Linux kernel, a break followed by g, which is Magic SysRq g
1441 is required in order to interrupt the execution. */
1442 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1443 const char interrupt_sequence_break
[] = "BREAK";
1444 const char interrupt_sequence_break_g
[] = "BREAK-g";
1445 static const char *const interrupt_sequence_modes
[] =
1447 interrupt_sequence_control_c
,
1448 interrupt_sequence_break
,
1449 interrupt_sequence_break_g
,
1452 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1455 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1456 struct cmd_list_element
*c
,
1459 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1460 fprintf_filtered (file
,
1461 _("Send the ASCII ETX character (Ctrl-c) "
1462 "to the remote target to interrupt the "
1463 "execution of the program.\n"));
1464 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1465 fprintf_filtered (file
,
1466 _("send a break signal to the remote target "
1467 "to interrupt the execution of the program.\n"));
1468 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1469 fprintf_filtered (file
,
1470 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1471 "the remote target to interrupt the execution "
1472 "of Linux kernel.\n"));
1474 internal_error (__FILE__
, __LINE__
,
1475 _("Invalid value for interrupt_sequence_mode: %s."),
1476 interrupt_sequence_mode
);
1479 /* This boolean variable specifies whether interrupt_sequence is sent
1480 to the remote target when gdb connects to it.
1481 This is mostly needed when you debug the Linux kernel: The Linux kernel
1482 expects BREAK g which is Magic SysRq g for connecting gdb. */
1483 static bool interrupt_on_connect
= false;
1485 /* This variable is used to implement the "set/show remotebreak" commands.
1486 Since these commands are now deprecated in favor of "set/show remote
1487 interrupt-sequence", it no longer has any effect on the code. */
1488 static bool remote_break
;
1491 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1494 interrupt_sequence_mode
= interrupt_sequence_break
;
1496 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1500 show_remotebreak (struct ui_file
*file
, int from_tty
,
1501 struct cmd_list_element
*c
,
1506 /* This variable sets the number of bits in an address that are to be
1507 sent in a memory ("M" or "m") packet. Normally, after stripping
1508 leading zeros, the entire address would be sent. This variable
1509 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1510 initial implementation of remote.c restricted the address sent in
1511 memory packets to ``host::sizeof long'' bytes - (typically 32
1512 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1513 address was never sent. Since fixing this bug may cause a break in
1514 some remote targets this variable is principally provided to
1515 facilitate backward compatibility. */
1517 static unsigned int remote_address_size
;
1520 /* User configurable variables for the number of characters in a
1521 memory read/write packet. MIN (rsa->remote_packet_size,
1522 rsa->sizeof_g_packet) is the default. Some targets need smaller
1523 values (fifo overruns, et.al.) and some users need larger values
1524 (speed up transfers). The variables ``preferred_*'' (the user
1525 request), ``current_*'' (what was actually set) and ``forced_*''
1526 (Positive - a soft limit, negative - a hard limit). */
1528 struct memory_packet_config
1535 /* The default max memory-write-packet-size, when the setting is
1536 "fixed". The 16k is historical. (It came from older GDB's using
1537 alloca for buffers and the knowledge (folklore?) that some hosts
1538 don't cope very well with large alloca calls.) */
1539 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1541 /* The minimum remote packet size for memory transfers. Ensures we
1542 can write at least one byte. */
1543 #define MIN_MEMORY_PACKET_SIZE 20
1545 /* Get the memory packet size, assuming it is fixed. */
1548 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1550 gdb_assert (config
->fixed_p
);
1552 if (config
->size
<= 0)
1553 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1555 return config
->size
;
1558 /* Compute the current size of a read/write packet. Since this makes
1559 use of ``actual_register_packet_size'' the computation is dynamic. */
1562 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1564 struct remote_state
*rs
= get_remote_state ();
1565 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1568 if (config
->fixed_p
)
1569 what_they_get
= get_fixed_memory_packet_size (config
);
1572 what_they_get
= get_remote_packet_size ();
1573 /* Limit the packet to the size specified by the user. */
1574 if (config
->size
> 0
1575 && what_they_get
> config
->size
)
1576 what_they_get
= config
->size
;
1578 /* Limit it to the size of the targets ``g'' response unless we have
1579 permission from the stub to use a larger packet size. */
1580 if (rs
->explicit_packet_size
== 0
1581 && rsa
->actual_register_packet_size
> 0
1582 && what_they_get
> rsa
->actual_register_packet_size
)
1583 what_they_get
= rsa
->actual_register_packet_size
;
1585 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1586 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1588 /* Make sure there is room in the global buffer for this packet
1589 (including its trailing NUL byte). */
1590 if (rs
->buf
.size () < what_they_get
+ 1)
1591 rs
->buf
.resize (2 * what_they_get
);
1593 return what_they_get
;
1596 /* Update the size of a read/write packet. If they user wants
1597 something really big then do a sanity check. */
1600 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1602 int fixed_p
= config
->fixed_p
;
1603 long size
= config
->size
;
1606 error (_("Argument required (integer, `fixed' or `limited')."));
1607 else if (strcmp (args
, "hard") == 0
1608 || strcmp (args
, "fixed") == 0)
1610 else if (strcmp (args
, "soft") == 0
1611 || strcmp (args
, "limit") == 0)
1617 size
= strtoul (args
, &end
, 0);
1619 error (_("Invalid %s (bad syntax)."), config
->name
);
1621 /* Instead of explicitly capping the size of a packet to or
1622 disallowing it, the user is allowed to set the size to
1623 something arbitrarily large. */
1627 if (fixed_p
&& !config
->fixed_p
)
1629 /* So that the query shows the correct value. */
1630 long query_size
= (size
<= 0
1631 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1634 if (! query (_("The target may not be able to correctly handle a %s\n"
1635 "of %ld bytes. Change the packet size? "),
1636 config
->name
, query_size
))
1637 error (_("Packet size not changed."));
1639 /* Update the config. */
1640 config
->fixed_p
= fixed_p
;
1641 config
->size
= size
;
1645 show_memory_packet_size (struct memory_packet_config
*config
)
1647 if (config
->size
== 0)
1648 printf_filtered (_("The %s is 0 (default). "), config
->name
);
1650 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1651 if (config
->fixed_p
)
1652 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1653 get_fixed_memory_packet_size (config
));
1656 remote_target
*remote
= get_current_remote_target ();
1659 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1660 remote
->get_memory_packet_size (config
));
1662 puts_filtered ("The actual limit will be further reduced "
1663 "dependent on the target.\n");
1667 /* FIXME: needs to be per-remote-target. */
1668 static struct memory_packet_config memory_write_packet_config
=
1670 "memory-write-packet-size",
1674 set_memory_write_packet_size (const char *args
, int from_tty
)
1676 set_memory_packet_size (args
, &memory_write_packet_config
);
1680 show_memory_write_packet_size (const char *args
, int from_tty
)
1682 show_memory_packet_size (&memory_write_packet_config
);
1685 /* Show the number of hardware watchpoints that can be used. */
1688 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1689 struct cmd_list_element
*c
,
1692 fprintf_filtered (file
, _("The maximum number of target hardware "
1693 "watchpoints is %s.\n"), value
);
1696 /* Show the length limit (in bytes) for hardware watchpoints. */
1699 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1700 struct cmd_list_element
*c
,
1703 fprintf_filtered (file
, _("The maximum length (in bytes) of a target "
1704 "hardware watchpoint is %s.\n"), value
);
1707 /* Show the number of hardware breakpoints that can be used. */
1710 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1711 struct cmd_list_element
*c
,
1714 fprintf_filtered (file
, _("The maximum number of target hardware "
1715 "breakpoints is %s.\n"), value
);
1718 /* Controls the maximum number of characters to display in the debug output
1719 for each remote packet. The remaining characters are omitted. */
1721 static int remote_packet_max_chars
= 512;
1723 /* Show the maximum number of characters to display for each remote packet
1724 when remote debugging is enabled. */
1727 show_remote_packet_max_chars (struct ui_file
*file
, int from_tty
,
1728 struct cmd_list_element
*c
,
1731 fprintf_filtered (file
, _("Number of remote packet characters to "
1732 "display is %s.\n"), value
);
1736 remote_target::get_memory_write_packet_size ()
1738 return get_memory_packet_size (&memory_write_packet_config
);
1741 /* FIXME: needs to be per-remote-target. */
1742 static struct memory_packet_config memory_read_packet_config
=
1744 "memory-read-packet-size",
1748 set_memory_read_packet_size (const char *args
, int from_tty
)
1750 set_memory_packet_size (args
, &memory_read_packet_config
);
1754 show_memory_read_packet_size (const char *args
, int from_tty
)
1756 show_memory_packet_size (&memory_read_packet_config
);
1760 remote_target::get_memory_read_packet_size ()
1762 long size
= get_memory_packet_size (&memory_read_packet_config
);
1764 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1765 extra buffer size argument before the memory read size can be
1766 increased beyond this. */
1767 if (size
> get_remote_packet_size ())
1768 size
= get_remote_packet_size ();
1774 struct packet_config
1779 /* If auto, GDB auto-detects support for this packet or feature,
1780 either through qSupported, or by trying the packet and looking
1781 at the response. If true, GDB assumes the target supports this
1782 packet. If false, the packet is disabled. Configs that don't
1783 have an associated command always have this set to auto. */
1784 enum auto_boolean detect
;
1786 /* Does the target support this packet? */
1787 enum packet_support support
;
1790 static enum packet_support
packet_config_support (struct packet_config
*config
);
1791 static enum packet_support
packet_support (int packet
);
1794 show_packet_config_cmd (struct packet_config
*config
)
1796 const char *support
= "internal-error";
1798 switch (packet_config_support (config
))
1801 support
= "enabled";
1803 case PACKET_DISABLE
:
1804 support
= "disabled";
1806 case PACKET_SUPPORT_UNKNOWN
:
1807 support
= "unknown";
1810 switch (config
->detect
)
1812 case AUTO_BOOLEAN_AUTO
:
1813 printf_filtered (_("Support for the `%s' packet "
1814 "is auto-detected, currently %s.\n"),
1815 config
->name
, support
);
1817 case AUTO_BOOLEAN_TRUE
:
1818 case AUTO_BOOLEAN_FALSE
:
1819 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1820 config
->name
, support
);
1826 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1827 const char *title
, int legacy
)
1833 config
->name
= name
;
1834 config
->title
= title
;
1835 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1837 show_doc
= xstrprintf ("Show current use of remote "
1838 "protocol `%s' (%s) packet.",
1840 /* set/show TITLE-packet {auto,on,off} */
1841 cmd_name
= xstrprintf ("%s-packet", title
);
1842 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1843 &config
->detect
, set_doc
,
1844 show_doc
, NULL
, /* help_doc */
1846 show_remote_protocol_packet_cmd
,
1847 &remote_set_cmdlist
, &remote_show_cmdlist
);
1848 /* The command code copies the documentation strings. */
1851 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1856 legacy_name
= xstrprintf ("%s-packet", name
);
1857 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1858 &remote_set_cmdlist
);
1859 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1860 &remote_show_cmdlist
);
1864 static enum packet_result
1865 packet_check_result (const char *buf
)
1869 /* The stub recognized the packet request. Check that the
1870 operation succeeded. */
1872 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1874 /* "Enn" - definitely an error. */
1875 return PACKET_ERROR
;
1877 /* Always treat "E." as an error. This will be used for
1878 more verbose error messages, such as E.memtypes. */
1879 if (buf
[0] == 'E' && buf
[1] == '.')
1880 return PACKET_ERROR
;
1882 /* The packet may or may not be OK. Just assume it is. */
1886 /* The stub does not support the packet. */
1887 return PACKET_UNKNOWN
;
1890 static enum packet_result
1891 packet_check_result (const gdb::char_vector
&buf
)
1893 return packet_check_result (buf
.data ());
1896 static enum packet_result
1897 packet_ok (const char *buf
, struct packet_config
*config
)
1899 enum packet_result result
;
1901 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1902 && config
->support
== PACKET_DISABLE
)
1903 internal_error (__FILE__
, __LINE__
,
1904 _("packet_ok: attempt to use a disabled packet"));
1906 result
= packet_check_result (buf
);
1911 /* The stub recognized the packet request. */
1912 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1915 fprintf_unfiltered (gdb_stdlog
,
1916 "Packet %s (%s) is supported\n",
1917 config
->name
, config
->title
);
1918 config
->support
= PACKET_ENABLE
;
1921 case PACKET_UNKNOWN
:
1922 /* The stub does not support the packet. */
1923 if (config
->detect
== AUTO_BOOLEAN_AUTO
1924 && config
->support
== PACKET_ENABLE
)
1926 /* If the stub previously indicated that the packet was
1927 supported then there is a protocol error. */
1928 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1929 config
->name
, config
->title
);
1931 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
1933 /* The user set it wrong. */
1934 error (_("Enabled packet %s (%s) not recognized by stub"),
1935 config
->name
, config
->title
);
1939 fprintf_unfiltered (gdb_stdlog
,
1940 "Packet %s (%s) is NOT supported\n",
1941 config
->name
, config
->title
);
1942 config
->support
= PACKET_DISABLE
;
1949 static enum packet_result
1950 packet_ok (const gdb::char_vector
&buf
, struct packet_config
*config
)
1952 return packet_ok (buf
.data (), config
);
1969 PACKET_vFile_pwrite
,
1971 PACKET_vFile_unlink
,
1972 PACKET_vFile_readlink
,
1975 PACKET_qXfer_features
,
1976 PACKET_qXfer_exec_file
,
1977 PACKET_qXfer_libraries
,
1978 PACKET_qXfer_libraries_svr4
,
1979 PACKET_qXfer_memory_map
,
1980 PACKET_qXfer_osdata
,
1981 PACKET_qXfer_threads
,
1982 PACKET_qXfer_statictrace_read
,
1983 PACKET_qXfer_traceframe_info
,
1989 PACKET_QPassSignals
,
1990 PACKET_QCatchSyscalls
,
1991 PACKET_QProgramSignals
,
1992 PACKET_QSetWorkingDir
,
1993 PACKET_QStartupWithShell
,
1994 PACKET_QEnvironmentHexEncoded
,
1995 PACKET_QEnvironmentReset
,
1996 PACKET_QEnvironmentUnset
,
1998 PACKET_qSearch_memory
,
2001 PACKET_QStartNoAckMode
,
2003 PACKET_qXfer_siginfo_read
,
2004 PACKET_qXfer_siginfo_write
,
2007 /* Support for conditional tracepoints. */
2008 PACKET_ConditionalTracepoints
,
2010 /* Support for target-side breakpoint conditions. */
2011 PACKET_ConditionalBreakpoints
,
2013 /* Support for target-side breakpoint commands. */
2014 PACKET_BreakpointCommands
,
2016 /* Support for fast tracepoints. */
2017 PACKET_FastTracepoints
,
2019 /* Support for static tracepoints. */
2020 PACKET_StaticTracepoints
,
2022 /* Support for installing tracepoints while a trace experiment is
2024 PACKET_InstallInTrace
,
2028 PACKET_TracepointSource
,
2031 PACKET_QDisableRandomization
,
2033 PACKET_QTBuffer_size
,
2037 PACKET_qXfer_btrace
,
2039 /* Support for the QNonStop packet. */
2042 /* Support for the QThreadEvents packet. */
2043 PACKET_QThreadEvents
,
2045 /* Support for multi-process extensions. */
2046 PACKET_multiprocess_feature
,
2048 /* Support for enabling and disabling tracepoints while a trace
2049 experiment is running. */
2050 PACKET_EnableDisableTracepoints_feature
,
2052 /* Support for collecting strings using the tracenz bytecode. */
2053 PACKET_tracenz_feature
,
2055 /* Support for continuing to run a trace experiment while GDB is
2057 PACKET_DisconnectedTracing_feature
,
2059 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2060 PACKET_augmented_libraries_svr4_read_feature
,
2062 /* Support for the qXfer:btrace-conf:read packet. */
2063 PACKET_qXfer_btrace_conf
,
2065 /* Support for the Qbtrace-conf:bts:size packet. */
2066 PACKET_Qbtrace_conf_bts_size
,
2068 /* Support for swbreak+ feature. */
2069 PACKET_swbreak_feature
,
2071 /* Support for hwbreak+ feature. */
2072 PACKET_hwbreak_feature
,
2074 /* Support for fork events. */
2075 PACKET_fork_event_feature
,
2077 /* Support for vfork events. */
2078 PACKET_vfork_event_feature
,
2080 /* Support for the Qbtrace-conf:pt:size packet. */
2081 PACKET_Qbtrace_conf_pt_size
,
2083 /* Support for exec events. */
2084 PACKET_exec_event_feature
,
2086 /* Support for query supported vCont actions. */
2087 PACKET_vContSupported
,
2089 /* Support remote CTRL-C. */
2092 /* Support TARGET_WAITKIND_NO_RESUMED. */
2098 /* FIXME: needs to be per-remote-target. Ignoring this for now,
2099 assuming all remote targets are the same server (thus all support
2100 the same packets). */
2101 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
2103 /* Returns the packet's corresponding "set remote foo-packet" command
2104 state. See struct packet_config for more details. */
2106 static enum auto_boolean
2107 packet_set_cmd_state (int packet
)
2109 return remote_protocol_packets
[packet
].detect
;
2112 /* Returns whether a given packet or feature is supported. This takes
2113 into account the state of the corresponding "set remote foo-packet"
2114 command, which may be used to bypass auto-detection. */
2116 static enum packet_support
2117 packet_config_support (struct packet_config
*config
)
2119 switch (config
->detect
)
2121 case AUTO_BOOLEAN_TRUE
:
2122 return PACKET_ENABLE
;
2123 case AUTO_BOOLEAN_FALSE
:
2124 return PACKET_DISABLE
;
2125 case AUTO_BOOLEAN_AUTO
:
2126 return config
->support
;
2128 gdb_assert_not_reached (_("bad switch"));
2132 /* Same as packet_config_support, but takes the packet's enum value as
2135 static enum packet_support
2136 packet_support (int packet
)
2138 struct packet_config
*config
= &remote_protocol_packets
[packet
];
2140 return packet_config_support (config
);
2144 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
2145 struct cmd_list_element
*c
,
2148 struct packet_config
*packet
;
2150 for (packet
= remote_protocol_packets
;
2151 packet
< &remote_protocol_packets
[PACKET_MAX
];
2154 if (&packet
->detect
== c
->var
)
2156 show_packet_config_cmd (packet
);
2160 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
2164 /* Should we try one of the 'Z' requests? */
2168 Z_PACKET_SOFTWARE_BP
,
2169 Z_PACKET_HARDWARE_BP
,
2176 /* For compatibility with older distributions. Provide a ``set remote
2177 Z-packet ...'' command that updates all the Z packet types. */
2179 static enum auto_boolean remote_Z_packet_detect
;
2182 set_remote_protocol_Z_packet_cmd (const char *args
, int from_tty
,
2183 struct cmd_list_element
*c
)
2187 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2188 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
2192 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
2193 struct cmd_list_element
*c
,
2198 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2200 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
2204 /* Returns true if the multi-process extensions are in effect. */
2207 remote_multi_process_p (struct remote_state
*rs
)
2209 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
2212 /* Returns true if fork events are supported. */
2215 remote_fork_event_p (struct remote_state
*rs
)
2217 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
2220 /* Returns true if vfork events are supported. */
2223 remote_vfork_event_p (struct remote_state
*rs
)
2225 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
2228 /* Returns true if exec events are supported. */
2231 remote_exec_event_p (struct remote_state
*rs
)
2233 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
2236 /* Insert fork catchpoint target routine. If fork events are enabled
2237 then return success, nothing more to do. */
2240 remote_target::insert_fork_catchpoint (int pid
)
2242 struct remote_state
*rs
= get_remote_state ();
2244 return !remote_fork_event_p (rs
);
2247 /* Remove fork catchpoint target routine. Nothing to do, just
2251 remote_target::remove_fork_catchpoint (int pid
)
2256 /* Insert vfork catchpoint target routine. If vfork events are enabled
2257 then return success, nothing more to do. */
2260 remote_target::insert_vfork_catchpoint (int pid
)
2262 struct remote_state
*rs
= get_remote_state ();
2264 return !remote_vfork_event_p (rs
);
2267 /* Remove vfork catchpoint target routine. Nothing to do, just
2271 remote_target::remove_vfork_catchpoint (int pid
)
2276 /* Insert exec catchpoint target routine. If exec events are
2277 enabled, just return success. */
2280 remote_target::insert_exec_catchpoint (int pid
)
2282 struct remote_state
*rs
= get_remote_state ();
2284 return !remote_exec_event_p (rs
);
2287 /* Remove exec catchpoint target routine. Nothing to do, just
2291 remote_target::remove_exec_catchpoint (int pid
)
2298 /* Take advantage of the fact that the TID field is not used, to tag
2299 special ptids with it set to != 0. */
2300 static const ptid_t
magic_null_ptid (42000, -1, 1);
2301 static const ptid_t
not_sent_ptid (42000, -2, 1);
2302 static const ptid_t
any_thread_ptid (42000, 0, 1);
2304 /* Find out if the stub attached to PID (and hence GDB should offer to
2305 detach instead of killing it when bailing out). */
2308 remote_target::remote_query_attached (int pid
)
2310 struct remote_state
*rs
= get_remote_state ();
2311 size_t size
= get_remote_packet_size ();
2313 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
2316 if (remote_multi_process_p (rs
))
2317 xsnprintf (rs
->buf
.data (), size
, "qAttached:%x", pid
);
2319 xsnprintf (rs
->buf
.data (), size
, "qAttached");
2322 getpkt (&rs
->buf
, 0);
2324 switch (packet_ok (rs
->buf
,
2325 &remote_protocol_packets
[PACKET_qAttached
]))
2328 if (strcmp (rs
->buf
.data (), "1") == 0)
2332 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
2334 case PACKET_UNKNOWN
:
2341 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2342 has been invented by GDB, instead of reported by the target. Since
2343 we can be connected to a remote system before before knowing about
2344 any inferior, mark the target with execution when we find the first
2345 inferior. If ATTACHED is 1, then we had just attached to this
2346 inferior. If it is 0, then we just created this inferior. If it
2347 is -1, then try querying the remote stub to find out if it had
2348 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2349 attempt to open this inferior's executable as the main executable
2350 if no main executable is open already. */
2353 remote_target::remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
2356 struct inferior
*inf
;
2358 /* Check whether this process we're learning about is to be
2359 considered attached, or if is to be considered to have been
2360 spawned by the stub. */
2362 attached
= remote_query_attached (pid
);
2364 if (gdbarch_has_global_solist (target_gdbarch ()))
2366 /* If the target shares code across all inferiors, then every
2367 attach adds a new inferior. */
2368 inf
= add_inferior (pid
);
2370 /* ... and every inferior is bound to the same program space.
2371 However, each inferior may still have its own address
2373 inf
->aspace
= maybe_new_address_space ();
2374 inf
->pspace
= current_program_space
;
2378 /* In the traditional debugging scenario, there's a 1-1 match
2379 between program/address spaces. We simply bind the inferior
2380 to the program space's address space. */
2381 inf
= current_inferior ();
2383 /* However, if the current inferior is already bound to a
2384 process, find some other empty inferior. */
2388 for (inferior
*it
: all_inferiors ())
2397 /* Since all inferiors were already bound to a process, add
2399 inf
= add_inferior_with_spaces ();
2401 switch_to_inferior_no_thread (inf
);
2403 inferior_appeared (inf
, pid
);
2406 inf
->attach_flag
= attached
;
2407 inf
->fake_pid_p
= fake_pid_p
;
2409 /* If no main executable is currently open then attempt to
2410 open the file that was executed to create this inferior. */
2411 if (try_open_exec
&& get_exec_file (0) == NULL
)
2412 exec_file_locate_attach (pid
, 0, 1);
2414 /* Check for exec file mismatch, and let the user solve it. */
2415 validate_exec_file (1);
2420 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2421 static remote_thread_info
*get_remote_thread_info (remote_target
*target
,
2424 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2425 according to RUNNING. */
2428 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
)
2430 struct remote_state
*rs
= get_remote_state ();
2431 struct thread_info
*thread
;
2433 /* GDB historically didn't pull threads in the initial connection
2434 setup. If the remote target doesn't even have a concept of
2435 threads (e.g., a bare-metal target), even if internally we
2436 consider that a single-threaded target, mentioning a new thread
2437 might be confusing to the user. Be silent then, preserving the
2438 age old behavior. */
2439 if (rs
->starting_up
)
2440 thread
= add_thread_silent (this, ptid
);
2442 thread
= add_thread (this, ptid
);
2444 get_remote_thread_info (thread
)->vcont_resumed
= executing
;
2445 set_executing (this, ptid
, executing
);
2446 set_running (this, ptid
, running
);
2451 /* Come here when we learn about a thread id from the remote target.
2452 It may be the first time we hear about such thread, so take the
2453 opportunity to add it to GDB's thread list. In case this is the
2454 first time we're noticing its corresponding inferior, add it to
2455 GDB's inferior list as well. EXECUTING indicates whether the
2456 thread is (internally) executing or stopped. */
2459 remote_target::remote_notice_new_inferior (ptid_t currthread
, int executing
)
2461 /* In non-stop mode, we assume new found threads are (externally)
2462 running until proven otherwise with a stop reply. In all-stop,
2463 we can only get here if all threads are stopped. */
2464 int running
= target_is_non_stop_p () ? 1 : 0;
2466 /* If this is a new thread, add it to GDB's thread list.
2467 If we leave it up to WFI to do this, bad things will happen. */
2469 thread_info
*tp
= find_thread_ptid (this, currthread
);
2470 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2472 /* We're seeing an event on a thread id we knew had exited.
2473 This has to be a new thread reusing the old id. Add it. */
2474 remote_add_thread (currthread
, running
, executing
);
2478 if (!in_thread_list (this, currthread
))
2480 struct inferior
*inf
= NULL
;
2481 int pid
= currthread
.pid ();
2483 if (inferior_ptid
.is_pid ()
2484 && pid
== inferior_ptid
.pid ())
2486 /* inferior_ptid has no thread member yet. This can happen
2487 with the vAttach -> remote_wait,"TAAthread:" path if the
2488 stub doesn't support qC. This is the first stop reported
2489 after an attach, so this is the main thread. Update the
2490 ptid in the thread list. */
2491 if (in_thread_list (this, ptid_t (pid
)))
2492 thread_change_ptid (this, inferior_ptid
, currthread
);
2495 remote_add_thread (currthread
, running
, executing
);
2496 inferior_ptid
= currthread
;
2501 if (magic_null_ptid
== inferior_ptid
)
2503 /* inferior_ptid is not set yet. This can happen with the
2504 vRun -> remote_wait,"TAAthread:" path if the stub
2505 doesn't support qC. This is the first stop reported
2506 after an attach, so this is the main thread. Update the
2507 ptid in the thread list. */
2508 thread_change_ptid (this, inferior_ptid
, currthread
);
2512 /* When connecting to a target remote, or to a target
2513 extended-remote which already was debugging an inferior, we
2514 may not know about it yet. Add it before adding its child
2515 thread, so notifications are emitted in a sensible order. */
2516 if (find_inferior_pid (this, currthread
.pid ()) == NULL
)
2518 struct remote_state
*rs
= get_remote_state ();
2519 bool fake_pid_p
= !remote_multi_process_p (rs
);
2521 inf
= remote_add_inferior (fake_pid_p
,
2522 currthread
.pid (), -1, 1);
2525 /* This is really a new thread. Add it. */
2526 thread_info
*new_thr
2527 = remote_add_thread (currthread
, running
, executing
);
2529 /* If we found a new inferior, let the common code do whatever
2530 it needs to with it (e.g., read shared libraries, insert
2531 breakpoints), unless we're just setting up an all-stop
2535 struct remote_state
*rs
= get_remote_state ();
2537 if (!rs
->starting_up
)
2538 notice_new_inferior (new_thr
, executing
, 0);
2543 /* Return THREAD's private thread data, creating it if necessary. */
2545 static remote_thread_info
*
2546 get_remote_thread_info (thread_info
*thread
)
2548 gdb_assert (thread
!= NULL
);
2550 if (thread
->priv
== NULL
)
2551 thread
->priv
.reset (new remote_thread_info
);
2553 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2556 /* Return PTID's private thread data, creating it if necessary. */
2558 static remote_thread_info
*
2559 get_remote_thread_info (remote_target
*target
, ptid_t ptid
)
2561 thread_info
*thr
= find_thread_ptid (target
, ptid
);
2562 return get_remote_thread_info (thr
);
2565 /* Call this function as a result of
2566 1) A halt indication (T packet) containing a thread id
2567 2) A direct query of currthread
2568 3) Successful execution of set thread */
2571 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2573 rs
->general_thread
= currthread
;
2576 /* If 'QPassSignals' is supported, tell the remote stub what signals
2577 it can simply pass through to the inferior without reporting. */
2580 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2582 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2584 char *pass_packet
, *p
;
2586 struct remote_state
*rs
= get_remote_state ();
2588 gdb_assert (pass_signals
.size () < 256);
2589 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2591 if (pass_signals
[i
])
2594 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2595 strcpy (pass_packet
, "QPassSignals:");
2596 p
= pass_packet
+ strlen (pass_packet
);
2597 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2599 if (pass_signals
[i
])
2602 *p
++ = tohex (i
>> 4);
2603 *p
++ = tohex (i
& 15);
2612 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2614 putpkt (pass_packet
);
2615 getpkt (&rs
->buf
, 0);
2616 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2617 if (rs
->last_pass_packet
)
2618 xfree (rs
->last_pass_packet
);
2619 rs
->last_pass_packet
= pass_packet
;
2622 xfree (pass_packet
);
2626 /* If 'QCatchSyscalls' is supported, tell the remote stub
2627 to report syscalls to GDB. */
2630 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2631 gdb::array_view
<const int> syscall_counts
)
2633 const char *catch_packet
;
2634 enum packet_result result
;
2637 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2639 /* Not supported. */
2643 if (needed
&& any_count
== 0)
2645 /* Count how many syscalls are to be caught. */
2646 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2648 if (syscall_counts
[i
] != 0)
2655 fprintf_unfiltered (gdb_stdlog
,
2656 "remote_set_syscall_catchpoint "
2657 "pid %d needed %d any_count %d n_sysno %d\n",
2658 pid
, needed
, any_count
, n_sysno
);
2661 std::string built_packet
;
2664 /* Prepare a packet with the sysno list, assuming max 8+1
2665 characters for a sysno. If the resulting packet size is too
2666 big, fallback on the non-selective packet. */
2667 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2668 built_packet
.reserve (maxpktsz
);
2669 built_packet
= "QCatchSyscalls:1";
2672 /* Add in each syscall to be caught. */
2673 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2675 if (syscall_counts
[i
] != 0)
2676 string_appendf (built_packet
, ";%zx", i
);
2679 if (built_packet
.size () > get_remote_packet_size ())
2681 /* catch_packet too big. Fallback to less efficient
2682 non selective mode, with GDB doing the filtering. */
2683 catch_packet
= "QCatchSyscalls:1";
2686 catch_packet
= built_packet
.c_str ();
2689 catch_packet
= "QCatchSyscalls:0";
2691 struct remote_state
*rs
= get_remote_state ();
2693 putpkt (catch_packet
);
2694 getpkt (&rs
->buf
, 0);
2695 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2696 if (result
== PACKET_OK
)
2702 /* If 'QProgramSignals' is supported, tell the remote stub what
2703 signals it should pass through to the inferior when detaching. */
2706 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2708 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2712 struct remote_state
*rs
= get_remote_state ();
2714 gdb_assert (signals
.size () < 256);
2715 for (size_t i
= 0; i
< signals
.size (); i
++)
2720 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2721 strcpy (packet
, "QProgramSignals:");
2722 p
= packet
+ strlen (packet
);
2723 for (size_t i
= 0; i
< signals
.size (); i
++)
2725 if (signal_pass_state (i
))
2728 *p
++ = tohex (i
>> 4);
2729 *p
++ = tohex (i
& 15);
2738 if (!rs
->last_program_signals_packet
2739 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2742 getpkt (&rs
->buf
, 0);
2743 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2744 xfree (rs
->last_program_signals_packet
);
2745 rs
->last_program_signals_packet
= packet
;
2752 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2753 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2754 thread. If GEN is set, set the general thread, if not, then set
2755 the step/continue thread. */
2757 remote_target::set_thread (ptid_t ptid
, int gen
)
2759 struct remote_state
*rs
= get_remote_state ();
2760 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2761 char *buf
= rs
->buf
.data ();
2762 char *endbuf
= buf
+ get_remote_packet_size ();
2768 *buf
++ = gen
? 'g' : 'c';
2769 if (ptid
== magic_null_ptid
)
2770 xsnprintf (buf
, endbuf
- buf
, "0");
2771 else if (ptid
== any_thread_ptid
)
2772 xsnprintf (buf
, endbuf
- buf
, "0");
2773 else if (ptid
== minus_one_ptid
)
2774 xsnprintf (buf
, endbuf
- buf
, "-1");
2776 write_ptid (buf
, endbuf
, ptid
);
2778 getpkt (&rs
->buf
, 0);
2780 rs
->general_thread
= ptid
;
2782 rs
->continue_thread
= ptid
;
2786 remote_target::set_general_thread (ptid_t ptid
)
2788 set_thread (ptid
, 1);
2792 remote_target::set_continue_thread (ptid_t ptid
)
2794 set_thread (ptid
, 0);
2797 /* Change the remote current process. Which thread within the process
2798 ends up selected isn't important, as long as it is the same process
2799 as what INFERIOR_PTID points to.
2801 This comes from that fact that there is no explicit notion of
2802 "selected process" in the protocol. The selected process for
2803 general operations is the process the selected general thread
2807 remote_target::set_general_process ()
2809 struct remote_state
*rs
= get_remote_state ();
2811 /* If the remote can't handle multiple processes, don't bother. */
2812 if (!remote_multi_process_p (rs
))
2815 /* We only need to change the remote current thread if it's pointing
2816 at some other process. */
2817 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2818 set_general_thread (inferior_ptid
);
2822 /* Return nonzero if this is the main thread that we made up ourselves
2823 to model non-threaded targets as single-threaded. */
2826 remote_thread_always_alive (ptid_t ptid
)
2828 if (ptid
== magic_null_ptid
)
2829 /* The main thread is always alive. */
2832 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2833 /* The main thread is always alive. This can happen after a
2834 vAttach, if the remote side doesn't support
2841 /* Return nonzero if the thread PTID is still alive on the remote
2845 remote_target::thread_alive (ptid_t ptid
)
2847 struct remote_state
*rs
= get_remote_state ();
2850 /* Check if this is a thread that we made up ourselves to model
2851 non-threaded targets as single-threaded. */
2852 if (remote_thread_always_alive (ptid
))
2855 p
= rs
->buf
.data ();
2856 endp
= p
+ get_remote_packet_size ();
2859 write_ptid (p
, endp
, ptid
);
2862 getpkt (&rs
->buf
, 0);
2863 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2866 /* Return a pointer to a thread name if we know it and NULL otherwise.
2867 The thread_info object owns the memory for the name. */
2870 remote_target::thread_name (struct thread_info
*info
)
2872 if (info
->priv
!= NULL
)
2874 const std::string
&name
= get_remote_thread_info (info
)->name
;
2875 return !name
.empty () ? name
.c_str () : NULL
;
2881 /* About these extended threadlist and threadinfo packets. They are
2882 variable length packets but, the fields within them are often fixed
2883 length. They are redundant enough to send over UDP as is the
2884 remote protocol in general. There is a matching unit test module
2887 /* WARNING: This threadref data structure comes from the remote O.S.,
2888 libstub protocol encoding, and remote.c. It is not particularly
2891 /* Right now, the internal structure is int. We want it to be bigger.
2892 Plan to fix this. */
2894 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2896 /* gdb_ext_thread_info is an internal GDB data structure which is
2897 equivalent to the reply of the remote threadinfo packet. */
2899 struct gdb_ext_thread_info
2901 threadref threadid
; /* External form of thread reference. */
2902 int active
; /* Has state interesting to GDB?
2904 char display
[256]; /* Brief state display, name,
2905 blocked/suspended. */
2906 char shortname
[32]; /* To be used to name threads. */
2907 char more_display
[256]; /* Long info, statistics, queue depth,
2911 /* The volume of remote transfers can be limited by submitting
2912 a mask containing bits specifying the desired information.
2913 Use a union of these values as the 'selection' parameter to
2914 get_thread_info. FIXME: Make these TAG names more thread specific. */
2916 #define TAG_THREADID 1
2917 #define TAG_EXISTS 2
2918 #define TAG_DISPLAY 4
2919 #define TAG_THREADNAME 8
2920 #define TAG_MOREDISPLAY 16
2922 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2924 static char *unpack_nibble (char *buf
, int *val
);
2926 static char *unpack_byte (char *buf
, int *value
);
2928 static char *pack_int (char *buf
, int value
);
2930 static char *unpack_int (char *buf
, int *value
);
2932 static char *unpack_string (char *src
, char *dest
, int length
);
2934 static char *pack_threadid (char *pkt
, threadref
*id
);
2936 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2938 void int_to_threadref (threadref
*id
, int value
);
2940 static int threadref_to_int (threadref
*ref
);
2942 static void copy_threadref (threadref
*dest
, threadref
*src
);
2944 static int threadmatch (threadref
*dest
, threadref
*src
);
2946 static char *pack_threadinfo_request (char *pkt
, int mode
,
2949 static char *pack_threadlist_request (char *pkt
, int startflag
,
2951 threadref
*nextthread
);
2953 static int remote_newthread_step (threadref
*ref
, void *context
);
2956 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2957 buffer we're allowed to write to. Returns
2958 BUF+CHARACTERS_WRITTEN. */
2961 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2964 struct remote_state
*rs
= get_remote_state ();
2966 if (remote_multi_process_p (rs
))
2970 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2972 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2976 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2978 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2983 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2984 last parsed char. Returns null_ptid if no thread id is found, and
2985 throws an error if the thread id has an invalid format. */
2988 read_ptid (const char *buf
, const char **obuf
)
2990 const char *p
= buf
;
2992 ULONGEST pid
= 0, tid
= 0;
2996 /* Multi-process ptid. */
2997 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2999 error (_("invalid remote ptid: %s"), p
);
3002 pp
= unpack_varlen_hex (p
+ 1, &tid
);
3005 return ptid_t (pid
, tid
, 0);
3008 /* No multi-process. Just a tid. */
3009 pp
= unpack_varlen_hex (p
, &tid
);
3011 /* Return null_ptid when no thread id is found. */
3019 /* Since the stub is not sending a process id, then default to
3020 what's in inferior_ptid, unless it's null at this point. If so,
3021 then since there's no way to know the pid of the reported
3022 threads, use the magic number. */
3023 if (inferior_ptid
== null_ptid
)
3024 pid
= magic_null_ptid
.pid ();
3026 pid
= inferior_ptid
.pid ();
3030 return ptid_t (pid
, tid
, 0);
3036 if (ch
>= 'a' && ch
<= 'f')
3037 return ch
- 'a' + 10;
3038 if (ch
>= '0' && ch
<= '9')
3040 if (ch
>= 'A' && ch
<= 'F')
3041 return ch
- 'A' + 10;
3046 stub_unpack_int (char *buff
, int fieldlength
)
3053 nibble
= stubhex (*buff
++);
3057 retval
= retval
<< 4;
3063 unpack_nibble (char *buf
, int *val
)
3065 *val
= fromhex (*buf
++);
3070 unpack_byte (char *buf
, int *value
)
3072 *value
= stub_unpack_int (buf
, 2);
3077 pack_int (char *buf
, int value
)
3079 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3080 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3081 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3082 buf
= pack_hex_byte (buf
, (value
& 0xff));
3087 unpack_int (char *buf
, int *value
)
3089 *value
= stub_unpack_int (buf
, 8);
3093 #if 0 /* Currently unused, uncomment when needed. */
3094 static char *pack_string (char *pkt
, char *string
);
3097 pack_string (char *pkt
, char *string
)
3102 len
= strlen (string
);
3104 len
= 200; /* Bigger than most GDB packets, junk??? */
3105 pkt
= pack_hex_byte (pkt
, len
);
3109 if ((ch
== '\0') || (ch
== '#'))
3110 ch
= '*'; /* Protect encapsulation. */
3115 #endif /* 0 (unused) */
3118 unpack_string (char *src
, char *dest
, int length
)
3127 pack_threadid (char *pkt
, threadref
*id
)
3130 unsigned char *altid
;
3132 altid
= (unsigned char *) id
;
3133 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3135 pkt
= pack_hex_byte (pkt
, *altid
++);
3141 unpack_threadid (char *inbuf
, threadref
*id
)
3144 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3147 altref
= (char *) id
;
3149 while (inbuf
< limit
)
3151 x
= stubhex (*inbuf
++);
3152 y
= stubhex (*inbuf
++);
3153 *altref
++ = (x
<< 4) | y
;
3158 /* Externally, threadrefs are 64 bits but internally, they are still
3159 ints. This is due to a mismatch of specifications. We would like
3160 to use 64bit thread references internally. This is an adapter
3164 int_to_threadref (threadref
*id
, int value
)
3166 unsigned char *scan
;
3168 scan
= (unsigned char *) id
;
3174 *scan
++ = (value
>> 24) & 0xff;
3175 *scan
++ = (value
>> 16) & 0xff;
3176 *scan
++ = (value
>> 8) & 0xff;
3177 *scan
++ = (value
& 0xff);
3181 threadref_to_int (threadref
*ref
)
3184 unsigned char *scan
;
3190 value
= (value
<< 8) | ((*scan
++) & 0xff);
3195 copy_threadref (threadref
*dest
, threadref
*src
)
3198 unsigned char *csrc
, *cdest
;
3200 csrc
= (unsigned char *) src
;
3201 cdest
= (unsigned char *) dest
;
3208 threadmatch (threadref
*dest
, threadref
*src
)
3210 /* Things are broken right now, so just assume we got a match. */
3212 unsigned char *srcp
, *destp
;
3214 srcp
= (char *) src
;
3215 destp
= (char *) dest
;
3219 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3226 threadid:1, # always request threadid
3233 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3236 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3238 *pkt
++ = 'q'; /* Info Query */
3239 *pkt
++ = 'P'; /* process or thread info */
3240 pkt
= pack_int (pkt
, mode
); /* mode */
3241 pkt
= pack_threadid (pkt
, id
); /* threadid */
3242 *pkt
= '\0'; /* terminate */
3246 /* These values tag the fields in a thread info response packet. */
3247 /* Tagging the fields allows us to request specific fields and to
3248 add more fields as time goes by. */
3250 #define TAG_THREADID 1 /* Echo the thread identifier. */
3251 #define TAG_EXISTS 2 /* Is this process defined enough to
3252 fetch registers and its stack? */
3253 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3254 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3255 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3259 remote_target::remote_unpack_thread_info_response (char *pkt
,
3260 threadref
*expectedref
,
3261 gdb_ext_thread_info
*info
)
3263 struct remote_state
*rs
= get_remote_state ();
3267 char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3270 /* info->threadid = 0; FIXME: implement zero_threadref. */
3272 info
->display
[0] = '\0';
3273 info
->shortname
[0] = '\0';
3274 info
->more_display
[0] = '\0';
3276 /* Assume the characters indicating the packet type have been
3278 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3279 pkt
= unpack_threadid (pkt
, &ref
);
3282 warning (_("Incomplete response to threadinfo request."));
3283 if (!threadmatch (&ref
, expectedref
))
3284 { /* This is an answer to a different request. */
3285 warning (_("ERROR RMT Thread info mismatch."));
3288 copy_threadref (&info
->threadid
, &ref
);
3290 /* Loop on tagged fields , try to bail if something goes wrong. */
3292 /* Packets are terminated with nulls. */
3293 while ((pkt
< limit
) && mask
&& *pkt
)
3295 pkt
= unpack_int (pkt
, &tag
); /* tag */
3296 pkt
= unpack_byte (pkt
, &length
); /* length */
3297 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3299 warning (_("ERROR RMT: threadinfo tag mismatch."));
3303 if (tag
== TAG_THREADID
)
3307 warning (_("ERROR RMT: length of threadid is not 16."));
3311 pkt
= unpack_threadid (pkt
, &ref
);
3312 mask
= mask
& ~TAG_THREADID
;
3315 if (tag
== TAG_EXISTS
)
3317 info
->active
= stub_unpack_int (pkt
, length
);
3319 mask
= mask
& ~(TAG_EXISTS
);
3322 warning (_("ERROR RMT: 'exists' length too long."));
3328 if (tag
== TAG_THREADNAME
)
3330 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3331 mask
= mask
& ~TAG_THREADNAME
;
3334 if (tag
== TAG_DISPLAY
)
3336 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3337 mask
= mask
& ~TAG_DISPLAY
;
3340 if (tag
== TAG_MOREDISPLAY
)
3342 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3343 mask
= mask
& ~TAG_MOREDISPLAY
;
3346 warning (_("ERROR RMT: unknown thread info tag."));
3347 break; /* Not a tag we know about. */
3353 remote_target::remote_get_threadinfo (threadref
*threadid
,
3355 gdb_ext_thread_info
*info
)
3357 struct remote_state
*rs
= get_remote_state ();
3360 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3362 getpkt (&rs
->buf
, 0);
3364 if (rs
->buf
[0] == '\0')
3367 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3372 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3375 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3376 threadref
*nextthread
)
3378 *pkt
++ = 'q'; /* info query packet */
3379 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3380 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3381 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3382 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3387 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3390 remote_target::parse_threadlist_response (char *pkt
, int result_limit
,
3391 threadref
*original_echo
,
3392 threadref
*resultlist
,
3395 struct remote_state
*rs
= get_remote_state ();
3397 int count
, resultcount
, done
;
3400 /* Assume the 'q' and 'M chars have been stripped. */
3401 limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3402 /* done parse past here */
3403 pkt
= unpack_byte (pkt
, &count
); /* count field */
3404 pkt
= unpack_nibble (pkt
, &done
);
3405 /* The first threadid is the argument threadid. */
3406 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3407 while ((count
-- > 0) && (pkt
< limit
))
3409 pkt
= unpack_threadid (pkt
, resultlist
++);
3410 if (resultcount
++ >= result_limit
)
3418 /* Fetch the next batch of threads from the remote. Returns -1 if the
3419 qL packet is not supported, 0 on error and 1 on success. */
3422 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3423 int result_limit
, int *done
, int *result_count
,
3424 threadref
*threadlist
)
3426 struct remote_state
*rs
= get_remote_state ();
3429 /* Truncate result limit to be smaller than the packet size. */
3430 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3431 >= get_remote_packet_size ())
3432 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3434 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3437 getpkt (&rs
->buf
, 0);
3438 if (rs
->buf
[0] == '\0')
3440 /* Packet not supported. */
3445 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3446 &rs
->echo_nextthread
, threadlist
, done
);
3448 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3450 /* FIXME: This is a good reason to drop the packet. */
3451 /* Possibly, there is a duplicate response. */
3453 retransmit immediatly - race conditions
3454 retransmit after timeout - yes
3456 wait for packet, then exit
3458 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3459 return 0; /* I choose simply exiting. */
3461 if (*result_count
<= 0)
3465 warning (_("RMT ERROR : failed to get remote thread list."));
3468 return result
; /* break; */
3470 if (*result_count
> result_limit
)
3473 warning (_("RMT ERROR: threadlist response longer than requested."));
3479 /* Fetch the list of remote threads, with the qL packet, and call
3480 STEPFUNCTION for each thread found. Stops iterating and returns 1
3481 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3482 STEPFUNCTION returns false. If the packet is not supported,
3486 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3487 void *context
, int looplimit
)
3489 struct remote_state
*rs
= get_remote_state ();
3490 int done
, i
, result_count
;
3498 if (loopcount
++ > looplimit
)
3501 warning (_("Remote fetch threadlist -infinite loop-."));
3504 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3505 MAXTHREADLISTRESULTS
,
3506 &done
, &result_count
,
3507 rs
->resultthreadlist
);
3510 /* Clear for later iterations. */
3512 /* Setup to resume next batch of thread references, set nextthread. */
3513 if (result_count
>= 1)
3514 copy_threadref (&rs
->nextthread
,
3515 &rs
->resultthreadlist
[result_count
- 1]);
3517 while (result_count
--)
3519 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3529 /* A thread found on the remote target. */
3533 explicit thread_item (ptid_t ptid_
)
3537 thread_item (thread_item
&&other
) = default;
3538 thread_item
&operator= (thread_item
&&other
) = default;
3540 DISABLE_COPY_AND_ASSIGN (thread_item
);
3542 /* The thread's PTID. */
3545 /* The thread's extra info. */
3548 /* The thread's name. */
3551 /* The core the thread was running on. -1 if not known. */
3554 /* The thread handle associated with the thread. */
3555 gdb::byte_vector thread_handle
;
3558 /* Context passed around to the various methods listing remote
3559 threads. As new threads are found, they're added to the ITEMS
3562 struct threads_listing_context
3564 /* Return true if this object contains an entry for a thread with ptid
3567 bool contains_thread (ptid_t ptid
) const
3569 auto match_ptid
= [&] (const thread_item
&item
)
3571 return item
.ptid
== ptid
;
3574 auto it
= std::find_if (this->items
.begin (),
3578 return it
!= this->items
.end ();
3581 /* Remove the thread with ptid PTID. */
3583 void remove_thread (ptid_t ptid
)
3585 auto match_ptid
= [&] (const thread_item
&item
)
3587 return item
.ptid
== ptid
;
3590 auto it
= std::remove_if (this->items
.begin (),
3594 if (it
!= this->items
.end ())
3595 this->items
.erase (it
);
3598 /* The threads found on the remote target. */
3599 std::vector
<thread_item
> items
;
3603 remote_newthread_step (threadref
*ref
, void *data
)
3605 struct threads_listing_context
*context
3606 = (struct threads_listing_context
*) data
;
3607 int pid
= inferior_ptid
.pid ();
3608 int lwp
= threadref_to_int (ref
);
3609 ptid_t
ptid (pid
, lwp
);
3611 context
->items
.emplace_back (ptid
);
3613 return 1; /* continue iterator */
3616 #define CRAZY_MAX_THREADS 1000
3619 remote_target::remote_current_thread (ptid_t oldpid
)
3621 struct remote_state
*rs
= get_remote_state ();
3624 getpkt (&rs
->buf
, 0);
3625 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3630 result
= read_ptid (&rs
->buf
[2], &obuf
);
3631 if (*obuf
!= '\0' && remote_debug
)
3632 fprintf_unfiltered (gdb_stdlog
,
3633 "warning: garbage in qC reply\n");
3641 /* List remote threads using the deprecated qL packet. */
3644 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3646 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3647 CRAZY_MAX_THREADS
) >= 0)
3653 #if defined(HAVE_LIBEXPAT)
3656 start_thread (struct gdb_xml_parser
*parser
,
3657 const struct gdb_xml_element
*element
,
3659 std::vector
<gdb_xml_value
> &attributes
)
3661 struct threads_listing_context
*data
3662 = (struct threads_listing_context
*) user_data
;
3663 struct gdb_xml_value
*attr
;
3665 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3666 ptid_t ptid
= read_ptid (id
, NULL
);
3668 data
->items
.emplace_back (ptid
);
3669 thread_item
&item
= data
->items
.back ();
3671 attr
= xml_find_attribute (attributes
, "core");
3673 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3675 attr
= xml_find_attribute (attributes
, "name");
3677 item
.name
= (const char *) attr
->value
.get ();
3679 attr
= xml_find_attribute (attributes
, "handle");
3681 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3685 end_thread (struct gdb_xml_parser
*parser
,
3686 const struct gdb_xml_element
*element
,
3687 void *user_data
, const char *body_text
)
3689 struct threads_listing_context
*data
3690 = (struct threads_listing_context
*) user_data
;
3692 if (body_text
!= NULL
&& *body_text
!= '\0')
3693 data
->items
.back ().extra
= body_text
;
3696 const struct gdb_xml_attribute thread_attributes
[] = {
3697 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3698 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3699 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3700 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3701 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3704 const struct gdb_xml_element thread_children
[] = {
3705 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3708 const struct gdb_xml_element threads_children
[] = {
3709 { "thread", thread_attributes
, thread_children
,
3710 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3711 start_thread
, end_thread
},
3712 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3715 const struct gdb_xml_element threads_elements
[] = {
3716 { "threads", NULL
, threads_children
,
3717 GDB_XML_EF_NONE
, NULL
, NULL
},
3718 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3723 /* List remote threads using qXfer:threads:read. */
3726 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3728 #if defined(HAVE_LIBEXPAT)
3729 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3731 gdb::optional
<gdb::char_vector
> xml
3732 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3734 if (xml
&& (*xml
)[0] != '\0')
3736 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3737 threads_elements
, xml
->data (), context
);
3747 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3750 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3752 struct remote_state
*rs
= get_remote_state ();
3754 if (rs
->use_threadinfo_query
)
3758 putpkt ("qfThreadInfo");
3759 getpkt (&rs
->buf
, 0);
3760 bufp
= rs
->buf
.data ();
3761 if (bufp
[0] != '\0') /* q packet recognized */
3763 while (*bufp
++ == 'm') /* reply contains one or more TID */
3767 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3768 context
->items
.emplace_back (ptid
);
3770 while (*bufp
++ == ','); /* comma-separated list */
3771 putpkt ("qsThreadInfo");
3772 getpkt (&rs
->buf
, 0);
3773 bufp
= rs
->buf
.data ();
3779 /* Packet not recognized. */
3780 rs
->use_threadinfo_query
= 0;
3787 /* Implement the to_update_thread_list function for the remote
3791 remote_target::update_thread_list ()
3793 struct threads_listing_context context
;
3796 /* We have a few different mechanisms to fetch the thread list. Try
3797 them all, starting with the most preferred one first, falling
3798 back to older methods. */
3799 if (remote_get_threads_with_qxfer (&context
)
3800 || remote_get_threads_with_qthreadinfo (&context
)
3801 || remote_get_threads_with_ql (&context
))
3805 if (context
.items
.empty ()
3806 && remote_thread_always_alive (inferior_ptid
))
3808 /* Some targets don't really support threads, but still
3809 reply an (empty) thread list in response to the thread
3810 listing packets, instead of replying "packet not
3811 supported". Exit early so we don't delete the main
3816 /* CONTEXT now holds the current thread list on the remote
3817 target end. Delete GDB-side threads no longer found on the
3819 for (thread_info
*tp
: all_threads_safe ())
3821 if (tp
->inf
->process_target () != this)
3824 if (!context
.contains_thread (tp
->ptid
))
3831 /* Remove any unreported fork child threads from CONTEXT so
3832 that we don't interfere with follow fork, which is where
3833 creation of such threads is handled. */
3834 remove_new_fork_children (&context
);
3836 /* And now add threads we don't know about yet to our list. */
3837 for (thread_item
&item
: context
.items
)
3839 if (item
.ptid
!= null_ptid
)
3841 /* In non-stop mode, we assume new found threads are
3842 executing until proven otherwise with a stop reply.
3843 In all-stop, we can only get here if all threads are
3845 int executing
= target_is_non_stop_p () ? 1 : 0;
3847 remote_notice_new_inferior (item
.ptid
, executing
);
3849 thread_info
*tp
= find_thread_ptid (this, item
.ptid
);
3850 remote_thread_info
*info
= get_remote_thread_info (tp
);
3851 info
->core
= item
.core
;
3852 info
->extra
= std::move (item
.extra
);
3853 info
->name
= std::move (item
.name
);
3854 info
->thread_handle
= std::move (item
.thread_handle
);
3861 /* If no thread listing method is supported, then query whether
3862 each known thread is alive, one by one, with the T packet.
3863 If the target doesn't support threads at all, then this is a
3864 no-op. See remote_thread_alive. */
3870 * Collect a descriptive string about the given thread.
3871 * The target may say anything it wants to about the thread
3872 * (typically info about its blocked / runnable state, name, etc.).
3873 * This string will appear in the info threads display.
3875 * Optional: targets are not required to implement this function.
3879 remote_target::extra_thread_info (thread_info
*tp
)
3881 struct remote_state
*rs
= get_remote_state ();
3884 struct gdb_ext_thread_info threadinfo
;
3886 if (rs
->remote_desc
== 0) /* paranoia */
3887 internal_error (__FILE__
, __LINE__
,
3888 _("remote_threads_extra_info"));
3890 if (tp
->ptid
== magic_null_ptid
3891 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
3892 /* This is the main thread which was added by GDB. The remote
3893 server doesn't know about it. */
3896 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
3898 /* If already have cached info, use it. */
3899 if (!extra
.empty ())
3900 return extra
.c_str ();
3902 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3904 /* If we're using qXfer:threads:read, then the extra info is
3905 included in the XML. So if we didn't have anything cached,
3906 it's because there's really no extra info. */
3910 if (rs
->use_threadextra_query
)
3912 char *b
= rs
->buf
.data ();
3913 char *endb
= b
+ get_remote_packet_size ();
3915 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3917 write_ptid (b
, endb
, tp
->ptid
);
3920 getpkt (&rs
->buf
, 0);
3921 if (rs
->buf
[0] != 0)
3923 extra
.resize (strlen (rs
->buf
.data ()) / 2);
3924 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
3925 return extra
.c_str ();
3929 /* If the above query fails, fall back to the old method. */
3930 rs
->use_threadextra_query
= 0;
3931 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3932 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3933 int_to_threadref (&id
, tp
->ptid
.lwp ());
3934 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3935 if (threadinfo
.active
)
3937 if (*threadinfo
.shortname
)
3938 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
3939 if (*threadinfo
.display
)
3941 if (!extra
.empty ())
3943 string_appendf (extra
, " State: %s", threadinfo
.display
);
3945 if (*threadinfo
.more_display
)
3947 if (!extra
.empty ())
3949 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
3951 return extra
.c_str ();
3958 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
3959 struct static_tracepoint_marker
*marker
)
3961 struct remote_state
*rs
= get_remote_state ();
3962 char *p
= rs
->buf
.data ();
3964 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3966 p
+= hexnumstr (p
, addr
);
3968 getpkt (&rs
->buf
, 0);
3969 p
= rs
->buf
.data ();
3972 error (_("Remote failure reply: %s"), p
);
3976 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
3983 std::vector
<static_tracepoint_marker
>
3984 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
3986 struct remote_state
*rs
= get_remote_state ();
3987 std::vector
<static_tracepoint_marker
> markers
;
3989 static_tracepoint_marker marker
;
3991 /* Ask for a first packet of static tracepoint marker
3994 getpkt (&rs
->buf
, 0);
3995 p
= rs
->buf
.data ();
3997 error (_("Remote failure reply: %s"), p
);
4003 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
4005 if (strid
== NULL
|| marker
.str_id
== strid
)
4006 markers
.push_back (std::move (marker
));
4008 while (*p
++ == ','); /* comma-separated list */
4009 /* Ask for another packet of static tracepoint definition. */
4011 getpkt (&rs
->buf
, 0);
4012 p
= rs
->buf
.data ();
4019 /* Implement the to_get_ada_task_ptid function for the remote targets. */
4022 remote_target::get_ada_task_ptid (long lwp
, long thread
)
4024 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
4028 /* Restart the remote side; this is an extended protocol operation. */
4031 remote_target::extended_remote_restart ()
4033 struct remote_state
*rs
= get_remote_state ();
4035 /* Send the restart command; for reasons I don't understand the
4036 remote side really expects a number after the "R". */
4037 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
4040 remote_fileio_reset ();
4043 /* Clean up connection to a remote debugger. */
4046 remote_target::close ()
4048 /* Make sure we leave stdin registered in the event loop. */
4051 trace_reset_local_state ();
4056 remote_target::~remote_target ()
4058 struct remote_state
*rs
= get_remote_state ();
4060 /* Check for NULL because we may get here with a partially
4061 constructed target/connection. */
4062 if (rs
->remote_desc
== nullptr)
4065 serial_close (rs
->remote_desc
);
4067 /* We are destroying the remote target, so we should discard
4068 everything of this target. */
4069 discard_pending_stop_replies_in_queue ();
4071 if (rs
->remote_async_inferior_event_token
)
4072 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4074 delete rs
->notif_state
;
4077 /* Query the remote side for the text, data and bss offsets. */
4080 remote_target::get_offsets ()
4082 struct remote_state
*rs
= get_remote_state ();
4085 int lose
, num_segments
= 0, do_sections
, do_segments
;
4086 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4087 struct symfile_segment_data
*data
;
4089 if (symfile_objfile
== NULL
)
4092 putpkt ("qOffsets");
4093 getpkt (&rs
->buf
, 0);
4094 buf
= rs
->buf
.data ();
4096 if (buf
[0] == '\000')
4097 return; /* Return silently. Stub doesn't support
4101 warning (_("Remote failure reply: %s"), buf
);
4105 /* Pick up each field in turn. This used to be done with scanf, but
4106 scanf will make trouble if CORE_ADDR size doesn't match
4107 conversion directives correctly. The following code will work
4108 with any size of CORE_ADDR. */
4109 text_addr
= data_addr
= bss_addr
= 0;
4113 if (startswith (ptr
, "Text="))
4116 /* Don't use strtol, could lose on big values. */
4117 while (*ptr
&& *ptr
!= ';')
4118 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4120 if (startswith (ptr
, ";Data="))
4123 while (*ptr
&& *ptr
!= ';')
4124 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4129 if (!lose
&& startswith (ptr
, ";Bss="))
4132 while (*ptr
&& *ptr
!= ';')
4133 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4135 if (bss_addr
!= data_addr
)
4136 warning (_("Target reported unsupported offsets: %s"), buf
);
4141 else if (startswith (ptr
, "TextSeg="))
4144 /* Don't use strtol, could lose on big values. */
4145 while (*ptr
&& *ptr
!= ';')
4146 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4149 if (startswith (ptr
, ";DataSeg="))
4152 while (*ptr
&& *ptr
!= ';')
4153 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4161 error (_("Malformed response to offset query, %s"), buf
);
4162 else if (*ptr
!= '\0')
4163 warning (_("Target reported unsupported offsets: %s"), buf
);
4165 section_offsets offs
= symfile_objfile
->section_offsets
;
4167 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
4168 do_segments
= (data
!= NULL
);
4169 do_sections
= num_segments
== 0;
4171 if (num_segments
> 0)
4173 segments
[0] = text_addr
;
4174 segments
[1] = data_addr
;
4176 /* If we have two segments, we can still try to relocate everything
4177 by assuming that the .text and .data offsets apply to the whole
4178 text and data segments. Convert the offsets given in the packet
4179 to base addresses for symfile_map_offsets_to_segments. */
4180 else if (data
&& data
->num_segments
== 2)
4182 segments
[0] = data
->segment_bases
[0] + text_addr
;
4183 segments
[1] = data
->segment_bases
[1] + data_addr
;
4186 /* If the object file has only one segment, assume that it is text
4187 rather than data; main programs with no writable data are rare,
4188 but programs with no code are useless. Of course the code might
4189 have ended up in the data segment... to detect that we would need
4190 the permissions here. */
4191 else if (data
&& data
->num_segments
== 1)
4193 segments
[0] = data
->segment_bases
[0] + text_addr
;
4196 /* There's no way to relocate by segment. */
4202 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
4203 offs
, num_segments
, segments
);
4205 if (ret
== 0 && !do_sections
)
4206 error (_("Can not handle qOffsets TextSeg "
4207 "response with this symbol file"));
4214 free_symfile_segment_data (data
);
4218 offs
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
4220 /* This is a temporary kludge to force data and bss to use the
4221 same offsets because that's what nlmconv does now. The real
4222 solution requires changes to the stub and remote.c that I
4223 don't have time to do right now. */
4225 offs
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
4226 offs
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
4229 objfile_relocate (symfile_objfile
, offs
);
4232 /* Send interrupt_sequence to remote target. */
4235 remote_target::send_interrupt_sequence ()
4237 struct remote_state
*rs
= get_remote_state ();
4239 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4240 remote_serial_write ("\x03", 1);
4241 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4242 serial_send_break (rs
->remote_desc
);
4243 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4245 serial_send_break (rs
->remote_desc
);
4246 remote_serial_write ("g", 1);
4249 internal_error (__FILE__
, __LINE__
,
4250 _("Invalid value for interrupt_sequence_mode: %s."),
4251 interrupt_sequence_mode
);
4255 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4256 and extract the PTID. Returns NULL_PTID if not found. */
4259 stop_reply_extract_thread (char *stop_reply
)
4261 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4265 /* Txx r:val ; r:val (...) */
4268 /* Look for "register" named "thread". */
4273 p1
= strchr (p
, ':');
4277 if (strncmp (p
, "thread", p1
- p
) == 0)
4278 return read_ptid (++p1
, &p
);
4280 p1
= strchr (p
, ';');
4292 /* Determine the remote side's current thread. If we have a stop
4293 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4294 "thread" register we can extract the current thread from. If not,
4295 ask the remote which is the current thread with qC. The former
4296 method avoids a roundtrip. */
4299 remote_target::get_current_thread (char *wait_status
)
4301 ptid_t ptid
= null_ptid
;
4303 /* Note we don't use remote_parse_stop_reply as that makes use of
4304 the target architecture, which we haven't yet fully determined at
4306 if (wait_status
!= NULL
)
4307 ptid
= stop_reply_extract_thread (wait_status
);
4308 if (ptid
== null_ptid
)
4309 ptid
= remote_current_thread (inferior_ptid
);
4314 /* Query the remote target for which is the current thread/process,
4315 add it to our tables, and update INFERIOR_PTID. The caller is
4316 responsible for setting the state such that the remote end is ready
4317 to return the current thread.
4319 This function is called after handling the '?' or 'vRun' packets,
4320 whose response is a stop reply from which we can also try
4321 extracting the thread. If the target doesn't support the explicit
4322 qC query, we infer the current thread from that stop reply, passed
4323 in in WAIT_STATUS, which may be NULL. */
4326 remote_target::add_current_inferior_and_thread (char *wait_status
)
4328 struct remote_state
*rs
= get_remote_state ();
4329 bool fake_pid_p
= false;
4331 inferior_ptid
= null_ptid
;
4333 /* Now, if we have thread information, update inferior_ptid. */
4334 ptid_t curr_ptid
= get_current_thread (wait_status
);
4336 if (curr_ptid
!= null_ptid
)
4338 if (!remote_multi_process_p (rs
))
4343 /* Without this, some commands which require an active target
4344 (such as kill) won't work. This variable serves (at least)
4345 double duty as both the pid of the target process (if it has
4346 such), and as a flag indicating that a target is active. */
4347 curr_ptid
= magic_null_ptid
;
4351 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4353 /* Add the main thread and switch to it. Don't try reading
4354 registers yet, since we haven't fetched the target description
4356 thread_info
*tp
= add_thread_silent (this, curr_ptid
);
4357 switch_to_thread_no_regs (tp
);
4360 /* Print info about a thread that was found already stopped on
4364 print_one_stopped_thread (struct thread_info
*thread
)
4366 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4368 switch_to_thread (thread
);
4369 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4370 set_current_sal_from_frame (get_current_frame ());
4372 thread
->suspend
.waitstatus_pending_p
= 0;
4374 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4376 enum gdb_signal sig
= ws
->value
.sig
;
4378 if (signal_print_state (sig
))
4379 gdb::observers::signal_received
.notify (sig
);
4381 gdb::observers::normal_stop
.notify (NULL
, 1);
4384 /* Process all initial stop replies the remote side sent in response
4385 to the ? packet. These indicate threads that were already stopped
4386 on initial connection. We mark these threads as stopped and print
4387 their current frame before giving the user the prompt. */
4390 remote_target::process_initial_stop_replies (int from_tty
)
4392 int pending_stop_replies
= stop_reply_queue_length ();
4393 struct thread_info
*selected
= NULL
;
4394 struct thread_info
*lowest_stopped
= NULL
;
4395 struct thread_info
*first
= NULL
;
4397 /* Consume the initial pending events. */
4398 while (pending_stop_replies
-- > 0)
4400 ptid_t waiton_ptid
= minus_one_ptid
;
4402 struct target_waitstatus ws
;
4403 int ignore_event
= 0;
4405 memset (&ws
, 0, sizeof (ws
));
4406 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4408 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4412 case TARGET_WAITKIND_IGNORE
:
4413 case TARGET_WAITKIND_NO_RESUMED
:
4414 case TARGET_WAITKIND_SIGNALLED
:
4415 case TARGET_WAITKIND_EXITED
:
4416 /* We shouldn't see these, but if we do, just ignore. */
4418 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
4422 case TARGET_WAITKIND_EXECD
:
4423 xfree (ws
.value
.execd_pathname
);
4432 thread_info
*evthread
= find_thread_ptid (this, event_ptid
);
4434 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4436 enum gdb_signal sig
= ws
.value
.sig
;
4438 /* Stubs traditionally report SIGTRAP as initial signal,
4439 instead of signal 0. Suppress it. */
4440 if (sig
== GDB_SIGNAL_TRAP
)
4442 evthread
->suspend
.stop_signal
= sig
;
4446 evthread
->suspend
.waitstatus
= ws
;
4448 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4449 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4450 evthread
->suspend
.waitstatus_pending_p
= 1;
4452 set_executing (this, event_ptid
, false);
4453 set_running (this, event_ptid
, false);
4454 get_remote_thread_info (evthread
)->vcont_resumed
= 0;
4457 /* "Notice" the new inferiors before anything related to
4458 registers/memory. */
4459 for (inferior
*inf
: all_non_exited_inferiors (this))
4461 inf
->needs_setup
= 1;
4465 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4466 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4471 /* If all-stop on top of non-stop, pause all threads. Note this
4472 records the threads' stop pc, so must be done after "noticing"
4476 stop_all_threads ();
4478 /* If all threads of an inferior were already stopped, we
4479 haven't setup the inferior yet. */
4480 for (inferior
*inf
: all_non_exited_inferiors (this))
4482 if (inf
->needs_setup
)
4484 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4485 switch_to_thread_no_regs (thread
);
4491 /* Now go over all threads that are stopped, and print their current
4492 frame. If all-stop, then if there's a signalled thread, pick
4494 for (thread_info
*thread
: all_non_exited_threads (this))
4500 thread
->set_running (false);
4501 else if (thread
->state
!= THREAD_STOPPED
)
4504 if (selected
== NULL
4505 && thread
->suspend
.waitstatus_pending_p
)
4508 if (lowest_stopped
== NULL
4509 || thread
->inf
->num
< lowest_stopped
->inf
->num
4510 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4511 lowest_stopped
= thread
;
4514 print_one_stopped_thread (thread
);
4517 /* In all-stop, we only print the status of one thread, and leave
4518 others with their status pending. */
4521 thread_info
*thread
= selected
;
4523 thread
= lowest_stopped
;
4527 print_one_stopped_thread (thread
);
4530 /* For "info program". */
4531 thread_info
*thread
= inferior_thread ();
4532 if (thread
->state
== THREAD_STOPPED
)
4533 set_last_target_status (this, inferior_ptid
, thread
->suspend
.waitstatus
);
4536 /* Start the remote connection and sync state. */
4539 remote_target::start_remote (int from_tty
, int extended_p
)
4541 struct remote_state
*rs
= get_remote_state ();
4542 struct packet_config
*noack_config
;
4543 char *wait_status
= NULL
;
4545 /* Signal other parts that we're going through the initial setup,
4546 and so things may not be stable yet. E.g., we don't try to
4547 install tracepoints until we've relocated symbols. Also, a
4548 Ctrl-C before we're connected and synced up can't interrupt the
4549 target. Instead, it offers to drop the (potentially wedged)
4551 rs
->starting_up
= 1;
4555 if (interrupt_on_connect
)
4556 send_interrupt_sequence ();
4558 /* Ack any packet which the remote side has already sent. */
4559 remote_serial_write ("+", 1);
4561 /* The first packet we send to the target is the optional "supported
4562 packets" request. If the target can answer this, it will tell us
4563 which later probes to skip. */
4564 remote_query_supported ();
4566 /* If the stub wants to get a QAllow, compose one and send it. */
4567 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4570 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4571 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4572 as a reply to known packet. For packet "vFile:setfs:" it is an
4573 invalid reply and GDB would return error in
4574 remote_hostio_set_filesystem, making remote files access impossible.
4575 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4576 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4578 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4580 putpkt (v_mustreplyempty
);
4581 getpkt (&rs
->buf
, 0);
4582 if (strcmp (rs
->buf
.data (), "OK") == 0)
4583 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4584 else if (strcmp (rs
->buf
.data (), "") != 0)
4585 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4589 /* Next, we possibly activate noack mode.
4591 If the QStartNoAckMode packet configuration is set to AUTO,
4592 enable noack mode if the stub reported a wish for it with
4595 If set to TRUE, then enable noack mode even if the stub didn't
4596 report it in qSupported. If the stub doesn't reply OK, the
4597 session ends with an error.
4599 If FALSE, then don't activate noack mode, regardless of what the
4600 stub claimed should be the default with qSupported. */
4602 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4603 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4605 putpkt ("QStartNoAckMode");
4606 getpkt (&rs
->buf
, 0);
4607 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4613 /* Tell the remote that we are using the extended protocol. */
4615 getpkt (&rs
->buf
, 0);
4618 /* Let the target know which signals it is allowed to pass down to
4620 update_signals_program_target ();
4622 /* Next, if the target can specify a description, read it. We do
4623 this before anything involving memory or registers. */
4624 target_find_description ();
4626 /* Next, now that we know something about the target, update the
4627 address spaces in the program spaces. */
4628 update_address_spaces ();
4630 /* On OSs where the list of libraries is global to all
4631 processes, we fetch them early. */
4632 if (gdbarch_has_global_solist (target_gdbarch ()))
4633 solib_add (NULL
, from_tty
, auto_solib_add
);
4635 if (target_is_non_stop_p ())
4637 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4638 error (_("Non-stop mode requested, but remote "
4639 "does not support non-stop"));
4641 putpkt ("QNonStop:1");
4642 getpkt (&rs
->buf
, 0);
4644 if (strcmp (rs
->buf
.data (), "OK") != 0)
4645 error (_("Remote refused setting non-stop mode with: %s"),
4648 /* Find about threads and processes the stub is already
4649 controlling. We default to adding them in the running state.
4650 The '?' query below will then tell us about which threads are
4652 this->update_thread_list ();
4654 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4656 /* Don't assume that the stub can operate in all-stop mode.
4657 Request it explicitly. */
4658 putpkt ("QNonStop:0");
4659 getpkt (&rs
->buf
, 0);
4661 if (strcmp (rs
->buf
.data (), "OK") != 0)
4662 error (_("Remote refused setting all-stop mode with: %s"),
4666 /* Upload TSVs regardless of whether the target is running or not. The
4667 remote stub, such as GDBserver, may have some predefined or builtin
4668 TSVs, even if the target is not running. */
4669 if (get_trace_status (current_trace_status ()) != -1)
4671 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4673 upload_trace_state_variables (&uploaded_tsvs
);
4674 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4677 /* Check whether the target is running now. */
4679 getpkt (&rs
->buf
, 0);
4681 if (!target_is_non_stop_p ())
4683 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4686 error (_("The target is not running (try extended-remote?)"));
4688 /* We're connected, but not running. Drop out before we
4689 call start_remote. */
4690 rs
->starting_up
= 0;
4695 /* Save the reply for later. */
4696 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4697 strcpy (wait_status
, rs
->buf
.data ());
4700 /* Fetch thread list. */
4701 target_update_thread_list ();
4703 /* Let the stub know that we want it to return the thread. */
4704 set_continue_thread (minus_one_ptid
);
4706 if (thread_count (this) == 0)
4708 /* Target has no concept of threads at all. GDB treats
4709 non-threaded target as single-threaded; add a main
4711 add_current_inferior_and_thread (wait_status
);
4715 /* We have thread information; select the thread the target
4716 says should be current. If we're reconnecting to a
4717 multi-threaded program, this will ideally be the thread
4718 that last reported an event before GDB disconnected. */
4719 ptid_t curr_thread
= get_current_thread (wait_status
);
4720 if (curr_thread
== null_ptid
)
4722 /* Odd... The target was able to list threads, but not
4723 tell us which thread was current (no "thread"
4724 register in T stop reply?). Just pick the first
4725 thread in the thread list then. */
4728 fprintf_unfiltered (gdb_stdlog
,
4729 "warning: couldn't determine remote "
4730 "current thread; picking first in list.\n");
4732 for (thread_info
*tp
: all_non_exited_threads (this,
4735 switch_to_thread (tp
);
4740 switch_to_thread (find_thread_ptid (this, curr_thread
));
4743 /* init_wait_for_inferior should be called before get_offsets in order
4744 to manage `inserted' flag in bp loc in a correct state.
4745 breakpoint_init_inferior, called from init_wait_for_inferior, set
4746 `inserted' flag to 0, while before breakpoint_re_set, called from
4747 start_remote, set `inserted' flag to 1. In the initialization of
4748 inferior, breakpoint_init_inferior should be called first, and then
4749 breakpoint_re_set can be called. If this order is broken, state of
4750 `inserted' flag is wrong, and cause some problems on breakpoint
4752 init_wait_for_inferior ();
4754 get_offsets (); /* Get text, data & bss offsets. */
4756 /* If we could not find a description using qXfer, and we know
4757 how to do it some other way, try again. This is not
4758 supported for non-stop; it could be, but it is tricky if
4759 there are no stopped threads when we connect. */
4760 if (remote_read_description_p (this)
4761 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4763 target_clear_description ();
4764 target_find_description ();
4767 /* Use the previously fetched status. */
4768 gdb_assert (wait_status
!= NULL
);
4769 strcpy (rs
->buf
.data (), wait_status
);
4770 rs
->cached_wait_status
= 1;
4772 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4776 /* Clear WFI global state. Do this before finding about new
4777 threads and inferiors, and setting the current inferior.
4778 Otherwise we would clear the proceed status of the current
4779 inferior when we want its stop_soon state to be preserved
4780 (see notice_new_inferior). */
4781 init_wait_for_inferior ();
4783 /* In non-stop, we will either get an "OK", meaning that there
4784 are no stopped threads at this time; or, a regular stop
4785 reply. In the latter case, there may be more than one thread
4786 stopped --- we pull them all out using the vStopped
4788 if (strcmp (rs
->buf
.data (), "OK") != 0)
4790 struct notif_client
*notif
= ¬if_client_stop
;
4792 /* remote_notif_get_pending_replies acks this one, and gets
4794 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4795 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4796 remote_notif_get_pending_events (notif
);
4799 if (thread_count (this) == 0)
4802 error (_("The target is not running (try extended-remote?)"));
4804 /* We're connected, but not running. Drop out before we
4805 call start_remote. */
4806 rs
->starting_up
= 0;
4810 /* In non-stop mode, any cached wait status will be stored in
4811 the stop reply queue. */
4812 gdb_assert (wait_status
== NULL
);
4814 /* Report all signals during attach/startup. */
4817 /* If there are already stopped threads, mark them stopped and
4818 report their stops before giving the prompt to the user. */
4819 process_initial_stop_replies (from_tty
);
4821 if (target_can_async_p ())
4825 /* If we connected to a live target, do some additional setup. */
4826 if (target_has_execution
)
4828 if (symfile_objfile
) /* No use without a symbol-file. */
4829 remote_check_symbols ();
4832 /* Possibly the target has been engaged in a trace run started
4833 previously; find out where things are at. */
4834 if (get_trace_status (current_trace_status ()) != -1)
4836 struct uploaded_tp
*uploaded_tps
= NULL
;
4838 if (current_trace_status ()->running
)
4839 printf_filtered (_("Trace is already running on the target.\n"));
4841 upload_tracepoints (&uploaded_tps
);
4843 merge_uploaded_tracepoints (&uploaded_tps
);
4846 /* Possibly the target has been engaged in a btrace record started
4847 previously; find out where things are at. */
4848 remote_btrace_maybe_reopen ();
4850 /* The thread and inferior lists are now synchronized with the
4851 target, our symbols have been relocated, and we're merged the
4852 target's tracepoints with ours. We're done with basic start
4854 rs
->starting_up
= 0;
4856 /* Maybe breakpoints are global and need to be inserted now. */
4857 if (breakpoints_should_be_inserted_now ())
4858 insert_breakpoints ();
4862 remote_target::connection_string ()
4864 remote_state
*rs
= get_remote_state ();
4866 if (rs
->remote_desc
->name
!= NULL
)
4867 return rs
->remote_desc
->name
;
4872 /* Open a connection to a remote debugger.
4873 NAME is the filename used for communication. */
4876 remote_target::open (const char *name
, int from_tty
)
4878 open_1 (name
, from_tty
, 0);
4881 /* Open a connection to a remote debugger using the extended
4882 remote gdb protocol. NAME is the filename used for communication. */
4885 extended_remote_target::open (const char *name
, int from_tty
)
4887 open_1 (name
, from_tty
, 1 /*extended_p */);
4890 /* Reset all packets back to "unknown support". Called when opening a
4891 new connection to a remote target. */
4894 reset_all_packet_configs_support (void)
4898 for (i
= 0; i
< PACKET_MAX
; i
++)
4899 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4902 /* Initialize all packet configs. */
4905 init_all_packet_configs (void)
4909 for (i
= 0; i
< PACKET_MAX
; i
++)
4911 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4912 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4916 /* Symbol look-up. */
4919 remote_target::remote_check_symbols ()
4924 /* The remote side has no concept of inferiors that aren't running
4925 yet, it only knows about running processes. If we're connected
4926 but our current inferior is not running, we should not invite the
4927 remote target to request symbol lookups related to its
4928 (unrelated) current process. */
4929 if (!target_has_execution
)
4932 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4935 /* Make sure the remote is pointing at the right process. Note
4936 there's no way to select "no process". */
4937 set_general_process ();
4939 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4940 because we need both at the same time. */
4941 gdb::char_vector
msg (get_remote_packet_size ());
4942 gdb::char_vector
reply (get_remote_packet_size ());
4944 /* Invite target to request symbol lookups. */
4946 putpkt ("qSymbol::");
4948 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4950 while (startswith (reply
.data (), "qSymbol:"))
4952 struct bound_minimal_symbol sym
;
4955 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
4958 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
4959 if (sym
.minsym
== NULL
)
4960 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
4964 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4965 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4967 /* If this is a function address, return the start of code
4968 instead of any data function descriptor. */
4969 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4971 current_top_target ());
4973 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4974 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4977 putpkt (msg
.data ());
4982 static struct serial
*
4983 remote_serial_open (const char *name
)
4985 static int udp_warning
= 0;
4987 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4988 of in ser-tcp.c, because it is the remote protocol assuming that the
4989 serial connection is reliable and not the serial connection promising
4991 if (!udp_warning
&& startswith (name
, "udp:"))
4993 warning (_("The remote protocol may be unreliable over UDP.\n"
4994 "Some events may be lost, rendering further debugging "
4999 return serial_open (name
);
5002 /* Inform the target of our permission settings. The permission flags
5003 work without this, but if the target knows the settings, it can do
5004 a couple things. First, it can add its own check, to catch cases
5005 that somehow manage to get by the permissions checks in target
5006 methods. Second, if the target is wired to disallow particular
5007 settings (for instance, a system in the field that is not set up to
5008 be able to stop at a breakpoint), it can object to any unavailable
5012 remote_target::set_permissions ()
5014 struct remote_state
*rs
= get_remote_state ();
5016 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
5017 "WriteReg:%x;WriteMem:%x;"
5018 "InsertBreak:%x;InsertTrace:%x;"
5019 "InsertFastTrace:%x;Stop:%x",
5020 may_write_registers
, may_write_memory
,
5021 may_insert_breakpoints
, may_insert_tracepoints
,
5022 may_insert_fast_tracepoints
, may_stop
);
5024 getpkt (&rs
->buf
, 0);
5026 /* If the target didn't like the packet, warn the user. Do not try
5027 to undo the user's settings, that would just be maddening. */
5028 if (strcmp (rs
->buf
.data (), "OK") != 0)
5029 warning (_("Remote refused setting permissions with: %s"),
5033 /* This type describes each known response to the qSupported
5035 struct protocol_feature
5037 /* The name of this protocol feature. */
5040 /* The default for this protocol feature. */
5041 enum packet_support default_support
;
5043 /* The function to call when this feature is reported, or after
5044 qSupported processing if the feature is not supported.
5045 The first argument points to this structure. The second
5046 argument indicates whether the packet requested support be
5047 enabled, disabled, or probed (or the default, if this function
5048 is being called at the end of processing and this feature was
5049 not reported). The third argument may be NULL; if not NULL, it
5050 is a NUL-terminated string taken from the packet following
5051 this feature's name and an equals sign. */
5052 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5053 enum packet_support
, const char *);
5055 /* The corresponding packet for this feature. Only used if
5056 FUNC is remote_supported_packet. */
5061 remote_supported_packet (remote_target
*remote
,
5062 const struct protocol_feature
*feature
,
5063 enum packet_support support
,
5064 const char *argument
)
5068 warning (_("Remote qSupported response supplied an unexpected value for"
5069 " \"%s\"."), feature
->name
);
5073 remote_protocol_packets
[feature
->packet
].support
= support
;
5077 remote_target::remote_packet_size (const protocol_feature
*feature
,
5078 enum packet_support support
, const char *value
)
5080 struct remote_state
*rs
= get_remote_state ();
5085 if (support
!= PACKET_ENABLE
)
5088 if (value
== NULL
|| *value
== '\0')
5090 warning (_("Remote target reported \"%s\" without a size."),
5096 packet_size
= strtol (value
, &value_end
, 16);
5097 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5099 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5100 feature
->name
, value
);
5104 /* Record the new maximum packet size. */
5105 rs
->explicit_packet_size
= packet_size
;
5109 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5110 enum packet_support support
, const char *value
)
5112 remote
->remote_packet_size (feature
, support
, value
);
5115 static const struct protocol_feature remote_protocol_features
[] = {
5116 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5117 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5118 PACKET_qXfer_auxv
},
5119 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5120 PACKET_qXfer_exec_file
},
5121 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5122 PACKET_qXfer_features
},
5123 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5124 PACKET_qXfer_libraries
},
5125 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5126 PACKET_qXfer_libraries_svr4
},
5127 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5128 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5129 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5130 PACKET_qXfer_memory_map
},
5131 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5132 PACKET_qXfer_osdata
},
5133 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5134 PACKET_qXfer_threads
},
5135 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5136 PACKET_qXfer_traceframe_info
},
5137 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5138 PACKET_QPassSignals
},
5139 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5140 PACKET_QCatchSyscalls
},
5141 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5142 PACKET_QProgramSignals
},
5143 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5144 PACKET_QSetWorkingDir
},
5145 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5146 PACKET_QStartupWithShell
},
5147 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5148 PACKET_QEnvironmentHexEncoded
},
5149 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5150 PACKET_QEnvironmentReset
},
5151 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5152 PACKET_QEnvironmentUnset
},
5153 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5154 PACKET_QStartNoAckMode
},
5155 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5156 PACKET_multiprocess_feature
},
5157 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5158 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5159 PACKET_qXfer_siginfo_read
},
5160 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5161 PACKET_qXfer_siginfo_write
},
5162 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5163 PACKET_ConditionalTracepoints
},
5164 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5165 PACKET_ConditionalBreakpoints
},
5166 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5167 PACKET_BreakpointCommands
},
5168 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5169 PACKET_FastTracepoints
},
5170 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5171 PACKET_StaticTracepoints
},
5172 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5173 PACKET_InstallInTrace
},
5174 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5175 PACKET_DisconnectedTracing_feature
},
5176 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5178 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5180 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5181 PACKET_TracepointSource
},
5182 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5184 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5185 PACKET_EnableDisableTracepoints_feature
},
5186 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5187 PACKET_qXfer_fdpic
},
5188 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5190 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5191 PACKET_QDisableRandomization
},
5192 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5193 { "QTBuffer:size", PACKET_DISABLE
,
5194 remote_supported_packet
, PACKET_QTBuffer_size
},
5195 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5196 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5197 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5198 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5199 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5200 PACKET_qXfer_btrace
},
5201 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5202 PACKET_qXfer_btrace_conf
},
5203 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5204 PACKET_Qbtrace_conf_bts_size
},
5205 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5206 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5207 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5208 PACKET_fork_event_feature
},
5209 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5210 PACKET_vfork_event_feature
},
5211 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5212 PACKET_exec_event_feature
},
5213 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5214 PACKET_Qbtrace_conf_pt_size
},
5215 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5216 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5217 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5220 static char *remote_support_xml
;
5222 /* Register string appended to "xmlRegisters=" in qSupported query. */
5225 register_remote_support_xml (const char *xml
)
5227 #if defined(HAVE_LIBEXPAT)
5228 if (remote_support_xml
== NULL
)
5229 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5232 char *copy
= xstrdup (remote_support_xml
+ 13);
5234 char *p
= strtok_r (copy
, ",", &saveptr
);
5238 if (strcmp (p
, xml
) == 0)
5245 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5248 remote_support_xml
= reconcat (remote_support_xml
,
5249 remote_support_xml
, ",", xml
,
5256 remote_query_supported_append (std::string
*msg
, const char *append
)
5260 msg
->append (append
);
5264 remote_target::remote_query_supported ()
5266 struct remote_state
*rs
= get_remote_state ();
5269 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5271 /* The packet support flags are handled differently for this packet
5272 than for most others. We treat an error, a disabled packet, and
5273 an empty response identically: any features which must be reported
5274 to be used will be automatically disabled. An empty buffer
5275 accomplishes this, since that is also the representation for a list
5276 containing no features. */
5279 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5283 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5284 remote_query_supported_append (&q
, "multiprocess+");
5286 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5287 remote_query_supported_append (&q
, "swbreak+");
5288 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5289 remote_query_supported_append (&q
, "hwbreak+");
5291 remote_query_supported_append (&q
, "qRelocInsn+");
5293 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5294 != AUTO_BOOLEAN_FALSE
)
5295 remote_query_supported_append (&q
, "fork-events+");
5296 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5297 != AUTO_BOOLEAN_FALSE
)
5298 remote_query_supported_append (&q
, "vfork-events+");
5299 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5300 != AUTO_BOOLEAN_FALSE
)
5301 remote_query_supported_append (&q
, "exec-events+");
5303 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5304 remote_query_supported_append (&q
, "vContSupported+");
5306 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5307 remote_query_supported_append (&q
, "QThreadEvents+");
5309 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5310 remote_query_supported_append (&q
, "no-resumed+");
5312 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5313 the qSupported:xmlRegisters=i386 handling. */
5314 if (remote_support_xml
!= NULL
5315 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5316 remote_query_supported_append (&q
, remote_support_xml
);
5318 q
= "qSupported:" + q
;
5319 putpkt (q
.c_str ());
5321 getpkt (&rs
->buf
, 0);
5323 /* If an error occured, warn, but do not return - just reset the
5324 buffer to empty and go on to disable features. */
5325 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5328 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5333 memset (seen
, 0, sizeof (seen
));
5335 next
= rs
->buf
.data ();
5338 enum packet_support is_supported
;
5339 char *p
, *end
, *name_end
, *value
;
5341 /* First separate out this item from the rest of the packet. If
5342 there's another item after this, we overwrite the separator
5343 (terminated strings are much easier to work with). */
5345 end
= strchr (p
, ';');
5348 end
= p
+ strlen (p
);
5358 warning (_("empty item in \"qSupported\" response"));
5363 name_end
= strchr (p
, '=');
5366 /* This is a name=value entry. */
5367 is_supported
= PACKET_ENABLE
;
5368 value
= name_end
+ 1;
5377 is_supported
= PACKET_ENABLE
;
5381 is_supported
= PACKET_DISABLE
;
5385 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5389 warning (_("unrecognized item \"%s\" "
5390 "in \"qSupported\" response"), p
);
5396 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5397 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5399 const struct protocol_feature
*feature
;
5402 feature
= &remote_protocol_features
[i
];
5403 feature
->func (this, feature
, is_supported
, value
);
5408 /* If we increased the packet size, make sure to increase the global
5409 buffer size also. We delay this until after parsing the entire
5410 qSupported packet, because this is the same buffer we were
5412 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5413 rs
->buf
.resize (rs
->explicit_packet_size
);
5415 /* Handle the defaults for unmentioned features. */
5416 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5419 const struct protocol_feature
*feature
;
5421 feature
= &remote_protocol_features
[i
];
5422 feature
->func (this, feature
, feature
->default_support
, NULL
);
5426 /* Serial QUIT handler for the remote serial descriptor.
5428 Defers handling a Ctrl-C until we're done with the current
5429 command/response packet sequence, unless:
5431 - We're setting up the connection. Don't send a remote interrupt
5432 request, as we're not fully synced yet. Quit immediately
5435 - The target has been resumed in the foreground
5436 (target_terminal::is_ours is false) with a synchronous resume
5437 packet, and we're blocked waiting for the stop reply, thus a
5438 Ctrl-C should be immediately sent to the target.
5440 - We get a second Ctrl-C while still within the same serial read or
5441 write. In that case the serial is seemingly wedged --- offer to
5444 - We see a second Ctrl-C without target response, after having
5445 previously interrupted the target. In that case the target/stub
5446 is probably wedged --- offer to quit/disconnect.
5450 remote_target::remote_serial_quit_handler ()
5452 struct remote_state
*rs
= get_remote_state ();
5454 if (check_quit_flag ())
5456 /* If we're starting up, we're not fully synced yet. Quit
5458 if (rs
->starting_up
)
5460 else if (rs
->got_ctrlc_during_io
)
5462 if (query (_("The target is not responding to GDB commands.\n"
5463 "Stop debugging it? ")))
5464 remote_unpush_and_throw (this);
5466 /* If ^C has already been sent once, offer to disconnect. */
5467 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5469 /* All-stop protocol, and blocked waiting for stop reply. Send
5470 an interrupt request. */
5471 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5472 target_interrupt ();
5474 rs
->got_ctrlc_during_io
= 1;
5478 /* The remote_target that is current while the quit handler is
5479 overridden with remote_serial_quit_handler. */
5480 static remote_target
*curr_quit_handler_target
;
5483 remote_serial_quit_handler ()
5485 curr_quit_handler_target
->remote_serial_quit_handler ();
5488 /* Remove the remote target from the target stack of each inferior
5489 that is using it. Upper targets depend on it so remove them
5493 remote_unpush_target (remote_target
*target
)
5495 /* We have to unpush the target from all inferiors, even those that
5497 scoped_restore_current_inferior restore_current_inferior
;
5499 for (inferior
*inf
: all_inferiors (target
))
5501 switch_to_inferior_no_thread (inf
);
5502 pop_all_targets_at_and_above (process_stratum
);
5503 generic_mourn_inferior ();
5508 remote_unpush_and_throw (remote_target
*target
)
5510 remote_unpush_target (target
);
5511 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5515 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5517 remote_target
*curr_remote
= get_current_remote_target ();
5520 error (_("To open a remote debug connection, you need to specify what\n"
5521 "serial device is attached to the remote system\n"
5522 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5524 /* If we're connected to a running target, target_preopen will kill it.
5525 Ask this question first, before target_preopen has a chance to kill
5527 if (curr_remote
!= NULL
&& !target_has_execution
)
5530 && !query (_("Already connected to a remote target. Disconnect? ")))
5531 error (_("Still connected."));
5534 /* Here the possibly existing remote target gets unpushed. */
5535 target_preopen (from_tty
);
5537 remote_fileio_reset ();
5538 reopen_exec_file ();
5541 remote_target
*remote
5542 = (extended_p
? new extended_remote_target () : new remote_target ());
5543 target_ops_up
target_holder (remote
);
5545 remote_state
*rs
= remote
->get_remote_state ();
5547 /* See FIXME above. */
5548 if (!target_async_permitted
)
5549 rs
->wait_forever_enabled_p
= 1;
5551 rs
->remote_desc
= remote_serial_open (name
);
5552 if (!rs
->remote_desc
)
5553 perror_with_name (name
);
5555 if (baud_rate
!= -1)
5557 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5559 /* The requested speed could not be set. Error out to
5560 top level after closing remote_desc. Take care to
5561 set remote_desc to NULL to avoid closing remote_desc
5563 serial_close (rs
->remote_desc
);
5564 rs
->remote_desc
= NULL
;
5565 perror_with_name (name
);
5569 serial_setparity (rs
->remote_desc
, serial_parity
);
5570 serial_raw (rs
->remote_desc
);
5572 /* If there is something sitting in the buffer we might take it as a
5573 response to a command, which would be bad. */
5574 serial_flush_input (rs
->remote_desc
);
5578 puts_filtered ("Remote debugging using ");
5579 puts_filtered (name
);
5580 puts_filtered ("\n");
5583 /* Switch to using the remote target now. */
5584 push_target (std::move (target_holder
));
5586 /* Register extra event sources in the event loop. */
5587 rs
->remote_async_inferior_event_token
5588 = create_async_event_handler (remote_async_inferior_event_handler
,
5590 rs
->notif_state
= remote_notif_state_allocate (remote
);
5592 /* Reset the target state; these things will be queried either by
5593 remote_query_supported or as they are needed. */
5594 reset_all_packet_configs_support ();
5595 rs
->cached_wait_status
= 0;
5596 rs
->explicit_packet_size
= 0;
5598 rs
->extended
= extended_p
;
5599 rs
->waiting_for_stop_reply
= 0;
5600 rs
->ctrlc_pending_p
= 0;
5601 rs
->got_ctrlc_during_io
= 0;
5603 rs
->general_thread
= not_sent_ptid
;
5604 rs
->continue_thread
= not_sent_ptid
;
5605 rs
->remote_traceframe_number
= -1;
5607 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5609 /* Probe for ability to use "ThreadInfo" query, as required. */
5610 rs
->use_threadinfo_query
= 1;
5611 rs
->use_threadextra_query
= 1;
5613 rs
->readahead_cache
.invalidate ();
5615 if (target_async_permitted
)
5617 /* FIXME: cagney/1999-09-23: During the initial connection it is
5618 assumed that the target is already ready and able to respond to
5619 requests. Unfortunately remote_start_remote() eventually calls
5620 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5621 around this. Eventually a mechanism that allows
5622 wait_for_inferior() to expect/get timeouts will be
5624 rs
->wait_forever_enabled_p
= 0;
5627 /* First delete any symbols previously loaded from shared libraries. */
5628 no_shared_libraries (NULL
, 0);
5630 /* Start the remote connection. If error() or QUIT, discard this
5631 target (we'd otherwise be in an inconsistent state) and then
5632 propogate the error on up the exception chain. This ensures that
5633 the caller doesn't stumble along blindly assuming that the
5634 function succeeded. The CLI doesn't have this problem but other
5635 UI's, such as MI do.
5637 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5638 this function should return an error indication letting the
5639 caller restore the previous state. Unfortunately the command
5640 ``target remote'' is directly wired to this function making that
5641 impossible. On a positive note, the CLI side of this problem has
5642 been fixed - the function set_cmd_context() makes it possible for
5643 all the ``target ....'' commands to share a common callback
5644 function. See cli-dump.c. */
5649 remote
->start_remote (from_tty
, extended_p
);
5651 catch (const gdb_exception
&ex
)
5653 /* Pop the partially set up target - unless something else did
5654 already before throwing the exception. */
5655 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5656 remote_unpush_target (remote
);
5661 remote_btrace_reset (rs
);
5663 if (target_async_permitted
)
5664 rs
->wait_forever_enabled_p
= 1;
5667 /* Detach the specified process. */
5670 remote_target::remote_detach_pid (int pid
)
5672 struct remote_state
*rs
= get_remote_state ();
5674 /* This should not be necessary, but the handling for D;PID in
5675 GDBserver versions prior to 8.2 incorrectly assumes that the
5676 selected process points to the same process we're detaching,
5677 leading to misbehavior (and possibly GDBserver crashing) when it
5678 does not. Since it's easy and cheap, work around it by forcing
5679 GDBserver to select GDB's current process. */
5680 set_general_process ();
5682 if (remote_multi_process_p (rs
))
5683 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5685 strcpy (rs
->buf
.data (), "D");
5688 getpkt (&rs
->buf
, 0);
5690 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5692 else if (rs
->buf
[0] == '\0')
5693 error (_("Remote doesn't know how to detach"));
5695 error (_("Can't detach process."));
5698 /* This detaches a program to which we previously attached, using
5699 inferior_ptid to identify the process. After this is done, GDB
5700 can be used to debug some other program. We better not have left
5701 any breakpoints in the target program or it'll die when it hits
5705 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5707 int pid
= inferior_ptid
.pid ();
5708 struct remote_state
*rs
= get_remote_state ();
5711 if (!target_has_execution
)
5712 error (_("No process to detach from."));
5714 target_announce_detach (from_tty
);
5716 /* Tell the remote target to detach. */
5717 remote_detach_pid (pid
);
5719 /* Exit only if this is the only active inferior. */
5720 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors (this) == 1)
5721 puts_filtered (_("Ending remote debugging.\n"));
5723 thread_info
*tp
= find_thread_ptid (this, inferior_ptid
);
5725 /* Check to see if we are detaching a fork parent. Note that if we
5726 are detaching a fork child, tp == NULL. */
5727 is_fork_parent
= (tp
!= NULL
5728 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5730 /* If doing detach-on-fork, we don't mourn, because that will delete
5731 breakpoints that should be available for the followed inferior. */
5732 if (!is_fork_parent
)
5734 /* Save the pid as a string before mourning, since that will
5735 unpush the remote target, and we need the string after. */
5736 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5738 target_mourn_inferior (inferior_ptid
);
5739 if (print_inferior_events
)
5740 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5741 inf
->num
, infpid
.c_str ());
5745 inferior_ptid
= null_ptid
;
5746 detach_inferior (current_inferior ());
5751 remote_target::detach (inferior
*inf
, int from_tty
)
5753 remote_detach_1 (inf
, from_tty
);
5757 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5759 remote_detach_1 (inf
, from_tty
);
5762 /* Target follow-fork function for remote targets. On entry, and
5763 at return, the current inferior is the fork parent.
5765 Note that although this is currently only used for extended-remote,
5766 it is named remote_follow_fork in anticipation of using it for the
5767 remote target as well. */
5770 remote_target::follow_fork (bool follow_child
, bool detach_fork
)
5772 struct remote_state
*rs
= get_remote_state ();
5773 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5775 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5776 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5778 /* When following the parent and detaching the child, we detach
5779 the child here. For the case of following the child and
5780 detaching the parent, the detach is done in the target-
5781 independent follow fork code in infrun.c. We can't use
5782 target_detach when detaching an unfollowed child because
5783 the client side doesn't know anything about the child. */
5784 if (detach_fork
&& !follow_child
)
5786 /* Detach the fork child. */
5790 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5791 child_pid
= child_ptid
.pid ();
5793 remote_detach_pid (child_pid
);
5800 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5801 in the program space of the new inferior. On entry and at return the
5802 current inferior is the exec'ing inferior. INF is the new exec'd
5803 inferior, which may be the same as the exec'ing inferior unless
5804 follow-exec-mode is "new". */
5807 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5809 /* We know that this is a target file name, so if it has the "target:"
5810 prefix we strip it off before saving it in the program space. */
5811 if (is_target_filename (execd_pathname
))
5812 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5814 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5817 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5820 remote_target::disconnect (const char *args
, int from_tty
)
5823 error (_("Argument given to \"disconnect\" when remotely debugging."));
5825 /* Make sure we unpush even the extended remote targets. Calling
5826 target_mourn_inferior won't unpush, and
5827 remote_target::mourn_inferior won't unpush if there is more than
5828 one inferior left. */
5829 remote_unpush_target (this);
5832 puts_filtered ("Ending remote debugging.\n");
5835 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5836 be chatty about it. */
5839 extended_remote_target::attach (const char *args
, int from_tty
)
5841 struct remote_state
*rs
= get_remote_state ();
5843 char *wait_status
= NULL
;
5845 pid
= parse_pid_to_attach (args
);
5847 /* Remote PID can be freely equal to getpid, do not check it here the same
5848 way as in other targets. */
5850 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5851 error (_("This target does not support attaching to a process"));
5855 const char *exec_file
= get_exec_file (0);
5858 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5859 target_pid_to_str (ptid_t (pid
)).c_str ());
5861 printf_unfiltered (_("Attaching to %s\n"),
5862 target_pid_to_str (ptid_t (pid
)).c_str ());
5865 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5867 getpkt (&rs
->buf
, 0);
5869 switch (packet_ok (rs
->buf
,
5870 &remote_protocol_packets
[PACKET_vAttach
]))
5873 if (!target_is_non_stop_p ())
5875 /* Save the reply for later. */
5876 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5877 strcpy (wait_status
, rs
->buf
.data ());
5879 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5880 error (_("Attaching to %s failed with: %s"),
5881 target_pid_to_str (ptid_t (pid
)).c_str (),
5884 case PACKET_UNKNOWN
:
5885 error (_("This target does not support attaching to a process"));
5887 error (_("Attaching to %s failed"),
5888 target_pid_to_str (ptid_t (pid
)).c_str ());
5891 set_current_inferior (remote_add_inferior (false, pid
, 1, 0));
5893 inferior_ptid
= ptid_t (pid
);
5895 if (target_is_non_stop_p ())
5897 struct thread_info
*thread
;
5899 /* Get list of threads. */
5900 update_thread_list ();
5902 thread
= first_thread_of_inferior (current_inferior ());
5904 inferior_ptid
= thread
->ptid
;
5906 inferior_ptid
= ptid_t (pid
);
5908 /* Invalidate our notion of the remote current thread. */
5909 record_currthread (rs
, minus_one_ptid
);
5913 /* Now, if we have thread information, update inferior_ptid. */
5914 inferior_ptid
= remote_current_thread (inferior_ptid
);
5916 /* Add the main thread to the thread list. */
5917 thread_info
*thr
= add_thread_silent (this, inferior_ptid
);
5918 /* Don't consider the thread stopped until we've processed the
5919 saved stop reply. */
5920 set_executing (this, thr
->ptid
, true);
5923 /* Next, if the target can specify a description, read it. We do
5924 this before anything involving memory or registers. */
5925 target_find_description ();
5927 if (!target_is_non_stop_p ())
5929 /* Use the previously fetched status. */
5930 gdb_assert (wait_status
!= NULL
);
5932 if (target_can_async_p ())
5934 struct notif_event
*reply
5935 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
5937 push_stop_reply ((struct stop_reply
*) reply
);
5943 gdb_assert (wait_status
!= NULL
);
5944 strcpy (rs
->buf
.data (), wait_status
);
5945 rs
->cached_wait_status
= 1;
5949 gdb_assert (wait_status
== NULL
);
5952 /* Implementation of the to_post_attach method. */
5955 extended_remote_target::post_attach (int pid
)
5957 /* Get text, data & bss offsets. */
5960 /* In certain cases GDB might not have had the chance to start
5961 symbol lookup up until now. This could happen if the debugged
5962 binary is not using shared libraries, the vsyscall page is not
5963 present (on Linux) and the binary itself hadn't changed since the
5964 debugging process was started. */
5965 if (symfile_objfile
!= NULL
)
5966 remote_check_symbols();
5970 /* Check for the availability of vCont. This function should also check
5974 remote_target::remote_vcont_probe ()
5976 remote_state
*rs
= get_remote_state ();
5979 strcpy (rs
->buf
.data (), "vCont?");
5981 getpkt (&rs
->buf
, 0);
5982 buf
= rs
->buf
.data ();
5984 /* Make sure that the features we assume are supported. */
5985 if (startswith (buf
, "vCont"))
5988 int support_c
, support_C
;
5990 rs
->supports_vCont
.s
= 0;
5991 rs
->supports_vCont
.S
= 0;
5994 rs
->supports_vCont
.t
= 0;
5995 rs
->supports_vCont
.r
= 0;
5996 while (p
&& *p
== ';')
5999 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6000 rs
->supports_vCont
.s
= 1;
6001 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6002 rs
->supports_vCont
.S
= 1;
6003 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6005 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6007 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6008 rs
->supports_vCont
.t
= 1;
6009 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6010 rs
->supports_vCont
.r
= 1;
6012 p
= strchr (p
, ';');
6015 /* If c, and C are not all supported, we can't use vCont. Clearing
6016 BUF will make packet_ok disable the packet. */
6017 if (!support_c
|| !support_C
)
6021 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
6022 rs
->supports_vCont_probed
= true;
6025 /* Helper function for building "vCont" resumptions. Write a
6026 resumption to P. ENDP points to one-passed-the-end of the buffer
6027 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
6028 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
6029 resumed thread should be single-stepped and/or signalled. If PTID
6030 equals minus_one_ptid, then all threads are resumed; if PTID
6031 represents a process, then all threads of the process are resumed;
6032 the thread to be stepped and/or signalled is given in the global
6036 remote_target::append_resumption (char *p
, char *endp
,
6037 ptid_t ptid
, int step
, gdb_signal siggnal
)
6039 struct remote_state
*rs
= get_remote_state ();
6041 if (step
&& siggnal
!= GDB_SIGNAL_0
)
6042 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
6044 /* GDB is willing to range step. */
6045 && use_range_stepping
6046 /* Target supports range stepping. */
6047 && rs
->supports_vCont
.r
6048 /* We don't currently support range stepping multiple
6049 threads with a wildcard (though the protocol allows it,
6050 so stubs shouldn't make an active effort to forbid
6052 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6054 struct thread_info
*tp
;
6056 if (ptid
== minus_one_ptid
)
6058 /* If we don't know about the target thread's tid, then
6059 we're resuming magic_null_ptid (see caller). */
6060 tp
= find_thread_ptid (this, magic_null_ptid
);
6063 tp
= find_thread_ptid (this, ptid
);
6064 gdb_assert (tp
!= NULL
);
6066 if (tp
->control
.may_range_step
)
6068 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6070 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6071 phex_nz (tp
->control
.step_range_start
,
6073 phex_nz (tp
->control
.step_range_end
,
6077 p
+= xsnprintf (p
, endp
- p
, ";s");
6080 p
+= xsnprintf (p
, endp
- p
, ";s");
6081 else if (siggnal
!= GDB_SIGNAL_0
)
6082 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6084 p
+= xsnprintf (p
, endp
- p
, ";c");
6086 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6090 /* All (-1) threads of process. */
6091 nptid
= ptid_t (ptid
.pid (), -1, 0);
6093 p
+= xsnprintf (p
, endp
- p
, ":");
6094 p
= write_ptid (p
, endp
, nptid
);
6096 else if (ptid
!= minus_one_ptid
)
6098 p
+= xsnprintf (p
, endp
- p
, ":");
6099 p
= write_ptid (p
, endp
, ptid
);
6105 /* Clear the thread's private info on resume. */
6108 resume_clear_thread_private_info (struct thread_info
*thread
)
6110 if (thread
->priv
!= NULL
)
6112 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6114 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6115 priv
->watch_data_address
= 0;
6119 /* Append a vCont continue-with-signal action for threads that have a
6120 non-zero stop signal. */
6123 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6126 for (thread_info
*thread
: all_non_exited_threads (this, ptid
))
6127 if (inferior_ptid
!= thread
->ptid
6128 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6130 p
= append_resumption (p
, endp
, thread
->ptid
,
6131 0, thread
->suspend
.stop_signal
);
6132 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6133 resume_clear_thread_private_info (thread
);
6139 /* Set the target running, using the packets that use Hc
6143 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6146 struct remote_state
*rs
= get_remote_state ();
6149 rs
->last_sent_signal
= siggnal
;
6150 rs
->last_sent_step
= step
;
6152 /* The c/s/C/S resume packets use Hc, so set the continue
6154 if (ptid
== minus_one_ptid
)
6155 set_continue_thread (any_thread_ptid
);
6157 set_continue_thread (ptid
);
6159 for (thread_info
*thread
: all_non_exited_threads (this))
6160 resume_clear_thread_private_info (thread
);
6162 buf
= rs
->buf
.data ();
6163 if (::execution_direction
== EXEC_REVERSE
)
6165 /* We don't pass signals to the target in reverse exec mode. */
6166 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6167 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6170 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6171 error (_("Remote reverse-step not supported."));
6172 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6173 error (_("Remote reverse-continue not supported."));
6175 strcpy (buf
, step
? "bs" : "bc");
6177 else if (siggnal
!= GDB_SIGNAL_0
)
6179 buf
[0] = step
? 'S' : 'C';
6180 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6181 buf
[2] = tohex (((int) siggnal
) & 0xf);
6185 strcpy (buf
, step
? "s" : "c");
6190 /* Resume the remote inferior by using a "vCont" packet. The thread
6191 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6192 resumed thread should be single-stepped and/or signalled. If PTID
6193 equals minus_one_ptid, then all threads are resumed; the thread to
6194 be stepped and/or signalled is given in the global INFERIOR_PTID.
6195 This function returns non-zero iff it resumes the inferior.
6197 This function issues a strict subset of all possible vCont commands
6201 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6202 enum gdb_signal siggnal
)
6204 struct remote_state
*rs
= get_remote_state ();
6208 /* No reverse execution actions defined for vCont. */
6209 if (::execution_direction
== EXEC_REVERSE
)
6212 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6213 remote_vcont_probe ();
6215 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6218 p
= rs
->buf
.data ();
6219 endp
= p
+ get_remote_packet_size ();
6221 /* If we could generate a wider range of packets, we'd have to worry
6222 about overflowing BUF. Should there be a generic
6223 "multi-part-packet" packet? */
6225 p
+= xsnprintf (p
, endp
- p
, "vCont");
6227 if (ptid
== magic_null_ptid
)
6229 /* MAGIC_NULL_PTID means that we don't have any active threads,
6230 so we don't have any TID numbers the inferior will
6231 understand. Make sure to only send forms that do not specify
6233 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6235 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6237 /* Resume all threads (of all processes, or of a single
6238 process), with preference for INFERIOR_PTID. This assumes
6239 inferior_ptid belongs to the set of all threads we are about
6241 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6243 /* Step inferior_ptid, with or without signal. */
6244 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6247 /* Also pass down any pending signaled resumption for other
6248 threads not the current. */
6249 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6251 /* And continue others without a signal. */
6252 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6256 /* Scheduler locking; resume only PTID. */
6257 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6260 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6263 if (target_is_non_stop_p ())
6265 /* In non-stop, the stub replies to vCont with "OK". The stop
6266 reply will be reported asynchronously by means of a `%Stop'
6268 getpkt (&rs
->buf
, 0);
6269 if (strcmp (rs
->buf
.data (), "OK") != 0)
6270 error (_("Unexpected vCont reply in non-stop mode: %s"),
6277 /* Tell the remote machine to resume. */
6280 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6282 struct remote_state
*rs
= get_remote_state ();
6284 /* When connected in non-stop mode, the core resumes threads
6285 individually. Resuming remote threads directly in target_resume
6286 would thus result in sending one packet per thread. Instead, to
6287 minimize roundtrip latency, here we just store the resume
6288 request; the actual remote resumption will be done in
6289 target_commit_resume / remote_commit_resume, where we'll be able
6290 to do vCont action coalescing. */
6291 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6293 remote_thread_info
*remote_thr
;
6295 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6296 remote_thr
= get_remote_thread_info (this, inferior_ptid
);
6298 remote_thr
= get_remote_thread_info (this, ptid
);
6300 remote_thr
->last_resume_step
= step
;
6301 remote_thr
->last_resume_sig
= siggnal
;
6305 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6306 (explained in remote-notif.c:handle_notification) so
6307 remote_notif_process is not called. We need find a place where
6308 it is safe to start a 'vNotif' sequence. It is good to do it
6309 before resuming inferior, because inferior was stopped and no RSP
6310 traffic at that moment. */
6311 if (!target_is_non_stop_p ())
6312 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6314 rs
->last_resume_exec_dir
= ::execution_direction
;
6316 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6317 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6318 remote_resume_with_hc (ptid
, step
, siggnal
);
6320 /* We are about to start executing the inferior, let's register it
6321 with the event loop. NOTE: this is the one place where all the
6322 execution commands end up. We could alternatively do this in each
6323 of the execution commands in infcmd.c. */
6324 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6325 into infcmd.c in order to allow inferior function calls to work
6326 NOT asynchronously. */
6327 if (target_can_async_p ())
6330 /* We've just told the target to resume. The remote server will
6331 wait for the inferior to stop, and then send a stop reply. In
6332 the mean time, we can't start another command/query ourselves
6333 because the stub wouldn't be ready to process it. This applies
6334 only to the base all-stop protocol, however. In non-stop (which
6335 only supports vCont), the stub replies with an "OK", and is
6336 immediate able to process further serial input. */
6337 if (!target_is_non_stop_p ())
6338 rs
->waiting_for_stop_reply
= 1;
6341 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6343 /* Private per-inferior info for target remote processes. */
6345 struct remote_inferior
: public private_inferior
6347 /* Whether we can send a wildcard vCont for this process. */
6348 bool may_wildcard_vcont
= true;
6351 /* Get the remote private inferior data associated to INF. */
6353 static remote_inferior
*
6354 get_remote_inferior (inferior
*inf
)
6356 if (inf
->priv
== NULL
)
6357 inf
->priv
.reset (new remote_inferior
);
6359 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6362 /* Class used to track the construction of a vCont packet in the
6363 outgoing packet buffer. This is used to send multiple vCont
6364 packets if we have more actions than would fit a single packet. */
6369 explicit vcont_builder (remote_target
*remote
)
6376 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6381 /* The remote target. */
6382 remote_target
*m_remote
;
6384 /* Pointer to the first action. P points here if no action has been
6386 char *m_first_action
;
6388 /* Where the next action will be appended. */
6391 /* The end of the buffer. Must never write past this. */
6395 /* Prepare the outgoing buffer for a new vCont packet. */
6398 vcont_builder::restart ()
6400 struct remote_state
*rs
= m_remote
->get_remote_state ();
6402 m_p
= rs
->buf
.data ();
6403 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6404 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6405 m_first_action
= m_p
;
6408 /* If the vCont packet being built has any action, send it to the
6412 vcont_builder::flush ()
6414 struct remote_state
*rs
;
6416 if (m_p
== m_first_action
)
6419 rs
= m_remote
->get_remote_state ();
6420 m_remote
->putpkt (rs
->buf
);
6421 m_remote
->getpkt (&rs
->buf
, 0);
6422 if (strcmp (rs
->buf
.data (), "OK") != 0)
6423 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6426 /* The largest action is range-stepping, with its two addresses. This
6427 is more than sufficient. If a new, bigger action is created, it'll
6428 quickly trigger a failed assertion in append_resumption (and we'll
6430 #define MAX_ACTION_SIZE 200
6432 /* Append a new vCont action in the outgoing packet being built. If
6433 the action doesn't fit the packet along with previous actions, push
6434 what we've got so far to the remote end and start over a new vCont
6435 packet (with the new action). */
6438 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6440 char buf
[MAX_ACTION_SIZE
+ 1];
6442 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6443 ptid
, step
, siggnal
);
6445 /* Check whether this new action would fit in the vCont packet along
6446 with previous actions. If not, send what we've got so far and
6447 start a new vCont packet. */
6448 size_t rsize
= endp
- buf
;
6449 if (rsize
> m_endp
- m_p
)
6454 /* Should now fit. */
6455 gdb_assert (rsize
<= m_endp
- m_p
);
6458 memcpy (m_p
, buf
, rsize
);
6463 /* to_commit_resume implementation. */
6466 remote_target::commit_resume ()
6468 int any_process_wildcard
;
6469 int may_global_wildcard_vcont
;
6471 /* If connected in all-stop mode, we'd send the remote resume
6472 request directly from remote_resume. Likewise if
6473 reverse-debugging, as there are no defined vCont actions for
6474 reverse execution. */
6475 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6478 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6479 instead of resuming all threads of each process individually.
6480 However, if any thread of a process must remain halted, we can't
6481 send wildcard resumes and must send one action per thread.
6483 Care must be taken to not resume threads/processes the server
6484 side already told us are stopped, but the core doesn't know about
6485 yet, because the events are still in the vStopped notification
6488 #1 => vCont s:p1.1;c
6490 #3 <= %Stopped T05 p1.1
6495 #8 (infrun handles the stop for p1.1 and continues stepping)
6496 #9 => vCont s:p1.1;c
6498 The last vCont above would resume thread p1.2 by mistake, because
6499 the server has no idea that the event for p1.2 had not been
6502 The server side must similarly ignore resume actions for the
6503 thread that has a pending %Stopped notification (and any other
6504 threads with events pending), until GDB acks the notification
6505 with vStopped. Otherwise, e.g., the following case is
6508 #1 => g (or any other packet)
6510 #3 <= %Stopped T05 p1.2
6511 #4 => vCont s:p1.1;c
6514 Above, the server must not resume thread p1.2. GDB can't know
6515 that p1.2 stopped until it acks the %Stopped notification, and
6516 since from GDB's perspective all threads should be running, it
6519 Finally, special care must also be given to handling fork/vfork
6520 events. A (v)fork event actually tells us that two processes
6521 stopped -- the parent and the child. Until we follow the fork,
6522 we must not resume the child. Therefore, if we have a pending
6523 fork follow, we must not send a global wildcard resume action
6524 (vCont;c). We can still send process-wide wildcards though. */
6526 /* Start by assuming a global wildcard (vCont;c) is possible. */
6527 may_global_wildcard_vcont
= 1;
6529 /* And assume every process is individually wildcard-able too. */
6530 for (inferior
*inf
: all_non_exited_inferiors (this))
6532 remote_inferior
*priv
= get_remote_inferior (inf
);
6534 priv
->may_wildcard_vcont
= true;
6537 /* Check for any pending events (not reported or processed yet) and
6538 disable process and global wildcard resumes appropriately. */
6539 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6541 for (thread_info
*tp
: all_non_exited_threads (this))
6543 /* If a thread of a process is not meant to be resumed, then we
6544 can't wildcard that process. */
6547 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6549 /* And if we can't wildcard a process, we can't wildcard
6550 everything either. */
6551 may_global_wildcard_vcont
= 0;
6555 /* If a thread is the parent of an unfollowed fork, then we
6556 can't do a global wildcard, as that would resume the fork
6558 if (is_pending_fork_parent_thread (tp
))
6559 may_global_wildcard_vcont
= 0;
6562 /* Now let's build the vCont packet(s). Actions must be appended
6563 from narrower to wider scopes (thread -> process -> global). If
6564 we end up with too many actions for a single packet vcont_builder
6565 flushes the current vCont packet to the remote side and starts a
6567 struct vcont_builder
vcont_builder (this);
6569 /* Threads first. */
6570 for (thread_info
*tp
: all_non_exited_threads (this))
6572 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6574 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6577 gdb_assert (!thread_is_in_step_over_chain (tp
));
6579 if (!remote_thr
->last_resume_step
6580 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6581 && get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6583 /* We'll send a wildcard resume instead. */
6584 remote_thr
->vcont_resumed
= 1;
6588 vcont_builder
.push_action (tp
->ptid
,
6589 remote_thr
->last_resume_step
,
6590 remote_thr
->last_resume_sig
);
6591 remote_thr
->vcont_resumed
= 1;
6594 /* Now check whether we can send any process-wide wildcard. This is
6595 to avoid sending a global wildcard in the case nothing is
6596 supposed to be resumed. */
6597 any_process_wildcard
= 0;
6599 for (inferior
*inf
: all_non_exited_inferiors (this))
6601 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6603 any_process_wildcard
= 1;
6608 if (any_process_wildcard
)
6610 /* If all processes are wildcard-able, then send a single "c"
6611 action, otherwise, send an "all (-1) threads of process"
6612 continue action for each running process, if any. */
6613 if (may_global_wildcard_vcont
)
6615 vcont_builder
.push_action (minus_one_ptid
,
6616 false, GDB_SIGNAL_0
);
6620 for (inferior
*inf
: all_non_exited_inferiors (this))
6622 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6624 vcont_builder
.push_action (ptid_t (inf
->pid
),
6625 false, GDB_SIGNAL_0
);
6631 vcont_builder
.flush ();
6636 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6637 thread, all threads of a remote process, or all threads of all
6641 remote_target::remote_stop_ns (ptid_t ptid
)
6643 struct remote_state
*rs
= get_remote_state ();
6644 char *p
= rs
->buf
.data ();
6645 char *endp
= p
+ get_remote_packet_size ();
6647 /* FIXME: This supports_vCont_probed check is a workaround until
6648 packet_support is per-connection. */
6649 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
6650 || !rs
->supports_vCont_probed
)
6651 remote_vcont_probe ();
6653 if (!rs
->supports_vCont
.t
)
6654 error (_("Remote server does not support stopping threads"));
6656 if (ptid
== minus_one_ptid
6657 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6658 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6663 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6666 /* All (-1) threads of process. */
6667 nptid
= ptid_t (ptid
.pid (), -1, 0);
6670 /* Small optimization: if we already have a stop reply for
6671 this thread, no use in telling the stub we want this
6673 if (peek_stop_reply (ptid
))
6679 write_ptid (p
, endp
, nptid
);
6682 /* In non-stop, we get an immediate OK reply. The stop reply will
6683 come in asynchronously by notification. */
6685 getpkt (&rs
->buf
, 0);
6686 if (strcmp (rs
->buf
.data (), "OK") != 0)
6687 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6691 /* All-stop version of target_interrupt. Sends a break or a ^C to
6692 interrupt the remote target. It is undefined which thread of which
6693 process reports the interrupt. */
6696 remote_target::remote_interrupt_as ()
6698 struct remote_state
*rs
= get_remote_state ();
6700 rs
->ctrlc_pending_p
= 1;
6702 /* If the inferior is stopped already, but the core didn't know
6703 about it yet, just ignore the request. The cached wait status
6704 will be collected in remote_wait. */
6705 if (rs
->cached_wait_status
)
6708 /* Send interrupt_sequence to remote target. */
6709 send_interrupt_sequence ();
6712 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6713 the remote target. It is undefined which thread of which process
6714 reports the interrupt. Throws an error if the packet is not
6715 supported by the server. */
6718 remote_target::remote_interrupt_ns ()
6720 struct remote_state
*rs
= get_remote_state ();
6721 char *p
= rs
->buf
.data ();
6722 char *endp
= p
+ get_remote_packet_size ();
6724 xsnprintf (p
, endp
- p
, "vCtrlC");
6726 /* In non-stop, we get an immediate OK reply. The stop reply will
6727 come in asynchronously by notification. */
6729 getpkt (&rs
->buf
, 0);
6731 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6735 case PACKET_UNKNOWN
:
6736 error (_("No support for interrupting the remote target."));
6738 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6742 /* Implement the to_stop function for the remote targets. */
6745 remote_target::stop (ptid_t ptid
)
6748 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6750 if (target_is_non_stop_p ())
6751 remote_stop_ns (ptid
);
6754 /* We don't currently have a way to transparently pause the
6755 remote target in all-stop mode. Interrupt it instead. */
6756 remote_interrupt_as ();
6760 /* Implement the to_interrupt function for the remote targets. */
6763 remote_target::interrupt ()
6766 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6768 if (target_is_non_stop_p ())
6769 remote_interrupt_ns ();
6771 remote_interrupt_as ();
6774 /* Implement the to_pass_ctrlc function for the remote targets. */
6777 remote_target::pass_ctrlc ()
6779 struct remote_state
*rs
= get_remote_state ();
6782 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6784 /* If we're starting up, we're not fully synced yet. Quit
6786 if (rs
->starting_up
)
6788 /* If ^C has already been sent once, offer to disconnect. */
6789 else if (rs
->ctrlc_pending_p
)
6792 target_interrupt ();
6795 /* Ask the user what to do when an interrupt is received. */
6798 remote_target::interrupt_query ()
6800 struct remote_state
*rs
= get_remote_state ();
6802 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6804 if (query (_("The target is not responding to interrupt requests.\n"
6805 "Stop debugging it? ")))
6807 remote_unpush_target (this);
6808 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6813 if (query (_("Interrupted while waiting for the program.\n"
6814 "Give up waiting? ")))
6819 /* Enable/disable target terminal ownership. Most targets can use
6820 terminal groups to control terminal ownership. Remote targets are
6821 different in that explicit transfer of ownership to/from GDB/target
6825 remote_target::terminal_inferior ()
6827 /* NOTE: At this point we could also register our selves as the
6828 recipient of all input. Any characters typed could then be
6829 passed on down to the target. */
6833 remote_target::terminal_ours ()
6838 remote_console_output (const char *msg
)
6842 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6845 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6849 gdb_stdtarg
->puts (tb
);
6851 gdb_stdtarg
->flush ();
6854 struct stop_reply
: public notif_event
6858 /* The identifier of the thread about this event */
6861 /* The remote state this event is associated with. When the remote
6862 connection, represented by a remote_state object, is closed,
6863 all the associated stop_reply events should be released. */
6864 struct remote_state
*rs
;
6866 struct target_waitstatus ws
;
6868 /* The architecture associated with the expedited registers. */
6871 /* Expedited registers. This makes remote debugging a bit more
6872 efficient for those targets that provide critical registers as
6873 part of their normal status mechanism (as another roundtrip to
6874 fetch them is avoided). */
6875 std::vector
<cached_reg_t
> regcache
;
6877 enum target_stop_reason stop_reason
;
6879 CORE_ADDR watch_data_address
;
6884 /* Return the length of the stop reply queue. */
6887 remote_target::stop_reply_queue_length ()
6889 remote_state
*rs
= get_remote_state ();
6890 return rs
->stop_reply_queue
.size ();
6894 remote_notif_stop_parse (remote_target
*remote
,
6895 struct notif_client
*self
, const char *buf
,
6896 struct notif_event
*event
)
6898 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6902 remote_notif_stop_ack (remote_target
*remote
,
6903 struct notif_client
*self
, const char *buf
,
6904 struct notif_event
*event
)
6906 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6909 putpkt (remote
, self
->ack_command
);
6911 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6913 /* We got an unknown stop reply. */
6914 error (_("Unknown stop reply"));
6917 remote
->push_stop_reply (stop_reply
);
6921 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
6922 struct notif_client
*self
)
6924 /* We can't get pending events in remote_notif_process for
6925 notification stop, and we have to do this in remote_wait_ns
6926 instead. If we fetch all queued events from stub, remote stub
6927 may exit and we have no chance to process them back in
6929 remote_state
*rs
= remote
->get_remote_state ();
6930 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
6934 stop_reply::~stop_reply ()
6936 for (cached_reg_t
®
: regcache
)
6940 static notif_event_up
6941 remote_notif_stop_alloc_reply ()
6943 return notif_event_up (new struct stop_reply ());
6946 /* A client of notification Stop. */
6948 struct notif_client notif_client_stop
=
6952 remote_notif_stop_parse
,
6953 remote_notif_stop_ack
,
6954 remote_notif_stop_can_get_pending_events
,
6955 remote_notif_stop_alloc_reply
,
6959 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6960 the pid of the process that owns the threads we want to check, or
6961 -1 if we want to check all threads. */
6964 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6967 if (ws
->kind
== TARGET_WAITKIND_FORKED
6968 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6970 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
6977 /* Return the thread's pending status used to determine whether the
6978 thread is a fork parent stopped at a fork event. */
6980 static struct target_waitstatus
*
6981 thread_pending_fork_status (struct thread_info
*thread
)
6983 if (thread
->suspend
.waitstatus_pending_p
)
6984 return &thread
->suspend
.waitstatus
;
6986 return &thread
->pending_follow
;
6989 /* Determine if THREAD is a pending fork parent thread. */
6992 is_pending_fork_parent_thread (struct thread_info
*thread
)
6994 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6997 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
7000 /* If CONTEXT contains any fork child threads that have not been
7001 reported yet, remove them from the CONTEXT list. If such a
7002 thread exists it is because we are stopped at a fork catchpoint
7003 and have not yet called follow_fork, which will set up the
7004 host-side data structures for the new process. */
7007 remote_target::remove_new_fork_children (threads_listing_context
*context
)
7010 struct notif_client
*notif
= ¬if_client_stop
;
7012 /* For any threads stopped at a fork event, remove the corresponding
7013 fork child threads from the CONTEXT list. */
7014 for (thread_info
*thread
: all_non_exited_threads (this))
7016 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
7018 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
7019 context
->remove_thread (ws
->value
.related_pid
);
7022 /* Check for any pending fork events (not reported or processed yet)
7023 in process PID and remove those fork child threads from the
7024 CONTEXT list as well. */
7025 remote_notif_get_pending_events (notif
);
7026 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7027 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7028 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
7029 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
7030 context
->remove_thread (event
->ws
.value
.related_pid
);
7033 /* Check whether any event pending in the vStopped queue would prevent
7034 a global or process wildcard vCont action. Clear
7035 *may_global_wildcard if we can't do a global wildcard (vCont;c),
7036 and clear the event inferior's may_wildcard_vcont flag if we can't
7037 do a process-wide wildcard resume (vCont;c:pPID.-1). */
7040 remote_target::check_pending_events_prevent_wildcard_vcont
7041 (int *may_global_wildcard
)
7043 struct notif_client
*notif
= ¬if_client_stop
;
7045 remote_notif_get_pending_events (notif
);
7046 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7048 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
7049 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
7052 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7053 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
7054 *may_global_wildcard
= 0;
7056 struct inferior
*inf
= find_inferior_ptid (this, event
->ptid
);
7058 /* This may be the first time we heard about this process.
7059 Regardless, we must not do a global wildcard resume, otherwise
7060 we'd resume this process too. */
7061 *may_global_wildcard
= 0;
7063 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7067 /* Discard all pending stop replies of inferior INF. */
7070 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7072 struct stop_reply
*reply
;
7073 struct remote_state
*rs
= get_remote_state ();
7074 struct remote_notif_state
*rns
= rs
->notif_state
;
7076 /* This function can be notified when an inferior exists. When the
7077 target is not remote, the notification state is NULL. */
7078 if (rs
->remote_desc
== NULL
)
7081 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7083 /* Discard the in-flight notification. */
7084 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7087 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7090 /* Discard the stop replies we have already pulled with
7092 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7093 rs
->stop_reply_queue
.end (),
7094 [=] (const stop_reply_up
&event
)
7096 return event
->ptid
.pid () == inf
->pid
;
7098 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7101 /* Discard the stop replies for RS in stop_reply_queue. */
7104 remote_target::discard_pending_stop_replies_in_queue ()
7106 remote_state
*rs
= get_remote_state ();
7108 /* Discard the stop replies we have already pulled with
7110 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7111 rs
->stop_reply_queue
.end (),
7112 [=] (const stop_reply_up
&event
)
7114 return event
->rs
== rs
;
7116 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7119 /* Remove the first reply in 'stop_reply_queue' which matches
7123 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7125 remote_state
*rs
= get_remote_state ();
7127 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7128 rs
->stop_reply_queue
.end (),
7129 [=] (const stop_reply_up
&event
)
7131 return event
->ptid
.matches (ptid
);
7133 struct stop_reply
*result
;
7134 if (iter
== rs
->stop_reply_queue
.end ())
7138 result
= iter
->release ();
7139 rs
->stop_reply_queue
.erase (iter
);
7143 fprintf_unfiltered (gdb_stdlog
,
7144 "notif: discard queued event: 'Stop' in %s\n",
7145 target_pid_to_str (ptid
).c_str ());
7150 /* Look for a queued stop reply belonging to PTID. If one is found,
7151 remove it from the queue, and return it. Returns NULL if none is
7152 found. If there are still queued events left to process, tell the
7153 event loop to get back to target_wait soon. */
7156 remote_target::queued_stop_reply (ptid_t ptid
)
7158 remote_state
*rs
= get_remote_state ();
7159 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7161 if (!rs
->stop_reply_queue
.empty ())
7163 /* There's still at least an event left. */
7164 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7170 /* Push a fully parsed stop reply in the stop reply queue. Since we
7171 know that we now have at least one queued event left to pass to the
7172 core side, tell the event loop to get back to target_wait soon. */
7175 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7177 remote_state
*rs
= get_remote_state ();
7178 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7181 fprintf_unfiltered (gdb_stdlog
,
7182 "notif: push 'Stop' %s to queue %d\n",
7183 target_pid_to_str (new_event
->ptid
).c_str (),
7184 int (rs
->stop_reply_queue
.size ()));
7186 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7189 /* Returns true if we have a stop reply for PTID. */
7192 remote_target::peek_stop_reply (ptid_t ptid
)
7194 remote_state
*rs
= get_remote_state ();
7195 for (auto &event
: rs
->stop_reply_queue
)
7196 if (ptid
== event
->ptid
7197 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7202 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7203 starting with P and ending with PEND matches PREFIX. */
7206 strprefix (const char *p
, const char *pend
, const char *prefix
)
7208 for ( ; p
< pend
; p
++, prefix
++)
7211 return *prefix
== '\0';
7214 /* Parse the stop reply in BUF. Either the function succeeds, and the
7215 result is stored in EVENT, or throws an error. */
7218 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7220 remote_arch_state
*rsa
= NULL
;
7225 event
->ptid
= null_ptid
;
7226 event
->rs
= get_remote_state ();
7227 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7228 event
->ws
.value
.integer
= 0;
7229 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7230 event
->regcache
.clear ();
7235 case 'T': /* Status with PC, SP, FP, ... */
7236 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7237 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7239 n... = register number
7240 r... = register contents
7243 p
= &buf
[3]; /* after Txx */
7249 p1
= strchr (p
, ':');
7251 error (_("Malformed packet(a) (missing colon): %s\n\
7255 error (_("Malformed packet(a) (missing register number): %s\n\
7259 /* Some "registers" are actually extended stop information.
7260 Note if you're adding a new entry here: GDB 7.9 and
7261 earlier assume that all register "numbers" that start
7262 with an hex digit are real register numbers. Make sure
7263 the server only sends such a packet if it knows the
7264 client understands it. */
7266 if (strprefix (p
, p1
, "thread"))
7267 event
->ptid
= read_ptid (++p1
, &p
);
7268 else if (strprefix (p
, p1
, "syscall_entry"))
7272 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7273 p
= unpack_varlen_hex (++p1
, &sysno
);
7274 event
->ws
.value
.syscall_number
= (int) sysno
;
7276 else if (strprefix (p
, p1
, "syscall_return"))
7280 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7281 p
= unpack_varlen_hex (++p1
, &sysno
);
7282 event
->ws
.value
.syscall_number
= (int) sysno
;
7284 else if (strprefix (p
, p1
, "watch")
7285 || strprefix (p
, p1
, "rwatch")
7286 || strprefix (p
, p1
, "awatch"))
7288 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7289 p
= unpack_varlen_hex (++p1
, &addr
);
7290 event
->watch_data_address
= (CORE_ADDR
) addr
;
7292 else if (strprefix (p
, p1
, "swbreak"))
7294 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7296 /* Make sure the stub doesn't forget to indicate support
7298 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7299 error (_("Unexpected swbreak stop reason"));
7301 /* The value part is documented as "must be empty",
7302 though we ignore it, in case we ever decide to make
7303 use of it in a backward compatible way. */
7304 p
= strchrnul (p1
+ 1, ';');
7306 else if (strprefix (p
, p1
, "hwbreak"))
7308 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7310 /* Make sure the stub doesn't forget to indicate support
7312 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7313 error (_("Unexpected hwbreak stop reason"));
7316 p
= strchrnul (p1
+ 1, ';');
7318 else if (strprefix (p
, p1
, "library"))
7320 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7321 p
= strchrnul (p1
+ 1, ';');
7323 else if (strprefix (p
, p1
, "replaylog"))
7325 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7326 /* p1 will indicate "begin" or "end", but it makes
7327 no difference for now, so ignore it. */
7328 p
= strchrnul (p1
+ 1, ';');
7330 else if (strprefix (p
, p1
, "core"))
7334 p
= unpack_varlen_hex (++p1
, &c
);
7337 else if (strprefix (p
, p1
, "fork"))
7339 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7340 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7342 else if (strprefix (p
, p1
, "vfork"))
7344 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7345 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7347 else if (strprefix (p
, p1
, "vforkdone"))
7349 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7350 p
= strchrnul (p1
+ 1, ';');
7352 else if (strprefix (p
, p1
, "exec"))
7357 /* Determine the length of the execd pathname. */
7358 p
= unpack_varlen_hex (++p1
, &ignored
);
7359 pathlen
= (p
- p1
) / 2;
7361 /* Save the pathname for event reporting and for
7362 the next run command. */
7363 gdb::unique_xmalloc_ptr
<char[]> pathname
7364 ((char *) xmalloc (pathlen
+ 1));
7365 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7366 pathname
[pathlen
] = '\0';
7368 /* This is freed during event handling. */
7369 event
->ws
.value
.execd_pathname
= pathname
.release ();
7370 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7372 /* Skip the registers included in this packet, since
7373 they may be for an architecture different from the
7374 one used by the original program. */
7377 else if (strprefix (p
, p1
, "create"))
7379 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7380 p
= strchrnul (p1
+ 1, ';');
7389 p
= strchrnul (p1
+ 1, ';');
7394 /* Maybe a real ``P'' register number. */
7395 p_temp
= unpack_varlen_hex (p
, &pnum
);
7396 /* If the first invalid character is the colon, we got a
7397 register number. Otherwise, it's an unknown stop
7401 /* If we haven't parsed the event's thread yet, find
7402 it now, in order to find the architecture of the
7403 reported expedited registers. */
7404 if (event
->ptid
== null_ptid
)
7406 /* If there is no thread-id information then leave
7407 the event->ptid as null_ptid. Later in
7408 process_stop_reply we will pick a suitable
7410 const char *thr
= strstr (p1
+ 1, ";thread:");
7412 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7419 = (event
->ptid
== null_ptid
7421 : find_inferior_ptid (this, event
->ptid
));
7422 /* If this is the first time we learn anything
7423 about this process, skip the registers
7424 included in this packet, since we don't yet
7425 know which architecture to use to parse them.
7426 We'll determine the architecture later when
7427 we process the stop reply and retrieve the
7428 target description, via
7429 remote_notice_new_inferior ->
7430 post_create_inferior. */
7433 p
= strchrnul (p1
+ 1, ';');
7438 event
->arch
= inf
->gdbarch
;
7439 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7443 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7444 cached_reg_t cached_reg
;
7447 error (_("Remote sent bad register number %s: %s\n\
7449 hex_string (pnum
), p
, buf
);
7451 cached_reg
.num
= reg
->regnum
;
7452 cached_reg
.data
= (gdb_byte
*)
7453 xmalloc (register_size (event
->arch
, reg
->regnum
));
7456 fieldsize
= hex2bin (p
, cached_reg
.data
,
7457 register_size (event
->arch
, reg
->regnum
));
7459 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7460 warning (_("Remote reply is too short: %s"), buf
);
7462 event
->regcache
.push_back (cached_reg
);
7466 /* Not a number. Silently skip unknown optional
7468 p
= strchrnul (p1
+ 1, ';');
7473 error (_("Remote register badly formatted: %s\nhere: %s"),
7478 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7482 case 'S': /* Old style status, just signal only. */
7486 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7487 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7488 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7489 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7491 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7494 case 'w': /* Thread exited. */
7498 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7499 p
= unpack_varlen_hex (&buf
[1], &value
);
7500 event
->ws
.value
.integer
= value
;
7502 error (_("stop reply packet badly formatted: %s"), buf
);
7503 event
->ptid
= read_ptid (++p
, NULL
);
7506 case 'W': /* Target exited. */
7511 /* GDB used to accept only 2 hex chars here. Stubs should
7512 only send more if they detect GDB supports multi-process
7514 p
= unpack_varlen_hex (&buf
[1], &value
);
7518 /* The remote process exited. */
7519 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7520 event
->ws
.value
.integer
= value
;
7524 /* The remote process exited with a signal. */
7525 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7526 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7527 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7529 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7532 /* If no process is specified, return null_ptid, and let the
7533 caller figure out the right process to use. */
7543 else if (startswith (p
, "process:"))
7547 p
+= sizeof ("process:") - 1;
7548 unpack_varlen_hex (p
, &upid
);
7552 error (_("unknown stop reply packet: %s"), buf
);
7555 error (_("unknown stop reply packet: %s"), buf
);
7556 event
->ptid
= ptid_t (pid
);
7560 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7561 event
->ptid
= minus_one_ptid
;
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 then use the first
7669 non-exited thread in the current target. */
7670 if (ptid
== null_ptid
)
7672 /* Some stop events apply to all threads in an inferior, while others
7673 only apply to a single thread. */
7674 bool is_stop_for_all_threads
7675 = (status
->kind
== TARGET_WAITKIND_EXITED
7676 || status
->kind
== TARGET_WAITKIND_SIGNALLED
);
7678 for (thread_info
*thr
: all_non_exited_threads (this))
7680 if (ptid
!= null_ptid
7681 && (!is_stop_for_all_threads
7682 || ptid
.pid () != thr
->ptid
.pid ()))
7684 static bool warned
= false;
7688 /* If you are seeing this warning then the remote target
7689 has stopped without specifying a thread-id, but the
7690 target does have multiple threads (or inferiors), and
7691 so GDB is having to guess which thread stopped.
7693 Examples of what might cause this are the target
7694 sending and 'S' stop packet, or a 'T' stop packet and
7695 not including a thread-id.
7697 Additionally, the target might send a 'W' or 'X
7698 packet without including a process-id, when the target
7699 has multiple running inferiors. */
7700 if (is_stop_for_all_threads
)
7701 warning (_("multi-inferior target stopped without "
7702 "sending a process-id, using first "
7703 "non-exited inferior"));
7705 warning (_("multi-threaded target stopped without "
7706 "sending a thread-id, using first "
7707 "non-exited thread"));
7713 /* If this is a stop for all threads then don't use a particular
7714 threads ptid, instead create a new ptid where only the pid
7716 if (is_stop_for_all_threads
)
7717 ptid
= ptid_t (thr
->ptid
.pid ());
7721 gdb_assert (ptid
!= null_ptid
);
7724 if (status
->kind
!= TARGET_WAITKIND_EXITED
7725 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7726 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7728 /* Expedited registers. */
7729 if (!stop_reply
->regcache
.empty ())
7731 struct regcache
*regcache
7732 = get_thread_arch_regcache (this, ptid
, stop_reply
->arch
);
7734 for (cached_reg_t
®
: stop_reply
->regcache
)
7736 regcache
->raw_supply (reg
.num
, reg
.data
);
7740 stop_reply
->regcache
.clear ();
7743 remote_notice_new_inferior (ptid
, 0);
7744 remote_thread_info
*remote_thr
= get_remote_thread_info (this, ptid
);
7745 remote_thr
->core
= stop_reply
->core
;
7746 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7747 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7748 remote_thr
->vcont_resumed
= 0;
7755 /* The non-stop mode version of target_wait. */
7758 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7760 struct remote_state
*rs
= get_remote_state ();
7761 struct stop_reply
*stop_reply
;
7765 /* If in non-stop mode, get out of getpkt even if a
7766 notification is received. */
7768 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7771 if (ret
!= -1 && !is_notif
)
7774 case 'E': /* Error of some sort. */
7775 /* We're out of sync with the target now. Did it continue
7776 or not? We can't tell which thread it was in non-stop,
7777 so just ignore this. */
7778 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7780 case 'O': /* Console output. */
7781 remote_console_output (&rs
->buf
[1]);
7784 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7788 /* Acknowledge a pending stop reply that may have arrived in the
7790 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7791 remote_notif_get_pending_events (¬if_client_stop
);
7793 /* If indeed we noticed a stop reply, we're done. */
7794 stop_reply
= queued_stop_reply (ptid
);
7795 if (stop_reply
!= NULL
)
7796 return process_stop_reply (stop_reply
, status
);
7798 /* Still no event. If we're just polling for an event, then
7799 return to the event loop. */
7800 if (options
& TARGET_WNOHANG
)
7802 status
->kind
= TARGET_WAITKIND_IGNORE
;
7803 return minus_one_ptid
;
7806 /* Otherwise do a blocking wait. */
7807 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7811 /* Return the first resumed thread. */
7814 first_remote_resumed_thread (remote_target
*target
)
7816 for (thread_info
*tp
: all_non_exited_threads (target
, minus_one_ptid
))
7822 /* Wait until the remote machine stops, then return, storing status in
7823 STATUS just as `wait' would. */
7826 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
, int options
)
7828 struct remote_state
*rs
= get_remote_state ();
7829 ptid_t event_ptid
= null_ptid
;
7831 struct stop_reply
*stop_reply
;
7835 status
->kind
= TARGET_WAITKIND_IGNORE
;
7836 status
->value
.integer
= 0;
7838 stop_reply
= queued_stop_reply (ptid
);
7839 if (stop_reply
!= NULL
)
7840 return process_stop_reply (stop_reply
, status
);
7842 if (rs
->cached_wait_status
)
7843 /* Use the cached wait status, but only once. */
7844 rs
->cached_wait_status
= 0;
7849 int forever
= ((options
& TARGET_WNOHANG
) == 0
7850 && rs
->wait_forever_enabled_p
);
7852 if (!rs
->waiting_for_stop_reply
)
7854 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7855 return minus_one_ptid
;
7858 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7859 _never_ wait for ever -> test on target_is_async_p().
7860 However, before we do that we need to ensure that the caller
7861 knows how to take the target into/out of async mode. */
7862 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
7864 /* GDB gets a notification. Return to core as this event is
7866 if (ret
!= -1 && is_notif
)
7867 return minus_one_ptid
;
7869 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7870 return minus_one_ptid
;
7873 buf
= rs
->buf
.data ();
7875 /* Assume that the target has acknowledged Ctrl-C unless we receive
7876 an 'F' or 'O' packet. */
7877 if (buf
[0] != 'F' && buf
[0] != 'O')
7878 rs
->ctrlc_pending_p
= 0;
7882 case 'E': /* Error of some sort. */
7883 /* We're out of sync with the target now. Did it continue or
7884 not? Not is more likely, so report a stop. */
7885 rs
->waiting_for_stop_reply
= 0;
7887 warning (_("Remote failure reply: %s"), buf
);
7888 status
->kind
= TARGET_WAITKIND_STOPPED
;
7889 status
->value
.sig
= GDB_SIGNAL_0
;
7891 case 'F': /* File-I/O request. */
7892 /* GDB may access the inferior memory while handling the File-I/O
7893 request, but we don't want GDB accessing memory while waiting
7894 for a stop reply. See the comments in putpkt_binary. Set
7895 waiting_for_stop_reply to 0 temporarily. */
7896 rs
->waiting_for_stop_reply
= 0;
7897 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
7898 rs
->ctrlc_pending_p
= 0;
7899 /* GDB handled the File-I/O request, and the target is running
7900 again. Keep waiting for events. */
7901 rs
->waiting_for_stop_reply
= 1;
7903 case 'N': case 'T': case 'S': case 'X': case 'W':
7905 /* There is a stop reply to handle. */
7906 rs
->waiting_for_stop_reply
= 0;
7909 = (struct stop_reply
*) remote_notif_parse (this,
7913 event_ptid
= process_stop_reply (stop_reply
, status
);
7916 case 'O': /* Console output. */
7917 remote_console_output (buf
+ 1);
7920 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7922 /* Zero length reply means that we tried 'S' or 'C' and the
7923 remote system doesn't support it. */
7924 target_terminal::ours_for_output ();
7926 ("Can't send signals to this remote system. %s not sent.\n",
7927 gdb_signal_to_name (rs
->last_sent_signal
));
7928 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7929 target_terminal::inferior ();
7931 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7937 warning (_("Invalid remote reply: %s"), buf
);
7941 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7942 return minus_one_ptid
;
7943 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7945 /* Nothing interesting happened. If we're doing a non-blocking
7946 poll, we're done. Otherwise, go back to waiting. */
7947 if (options
& TARGET_WNOHANG
)
7948 return minus_one_ptid
;
7952 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7953 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7955 if (event_ptid
!= null_ptid
)
7956 record_currthread (rs
, event_ptid
);
7958 event_ptid
= first_remote_resumed_thread (this);
7962 /* A process exit. Invalidate our notion of current thread. */
7963 record_currthread (rs
, minus_one_ptid
);
7964 /* It's possible that the packet did not include a pid. */
7965 if (event_ptid
== null_ptid
)
7966 event_ptid
= first_remote_resumed_thread (this);
7967 /* EVENT_PTID could still be NULL_PTID. Double-check. */
7968 if (event_ptid
== null_ptid
)
7969 event_ptid
= magic_null_ptid
;
7975 /* Wait until the remote machine stops, then return, storing status in
7976 STATUS just as `wait' would. */
7979 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7983 if (target_is_non_stop_p ())
7984 event_ptid
= wait_ns (ptid
, status
, options
);
7986 event_ptid
= wait_as (ptid
, status
, options
);
7988 if (target_is_async_p ())
7990 remote_state
*rs
= get_remote_state ();
7992 /* If there are are events left in the queue tell the event loop
7994 if (!rs
->stop_reply_queue
.empty ())
7995 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
8001 /* Fetch a single register using a 'p' packet. */
8004 remote_target::fetch_register_using_p (struct regcache
*regcache
,
8007 struct gdbarch
*gdbarch
= regcache
->arch ();
8008 struct remote_state
*rs
= get_remote_state ();
8010 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8013 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
8016 if (reg
->pnum
== -1)
8019 p
= rs
->buf
.data ();
8021 p
+= hexnumstr (p
, reg
->pnum
);
8024 getpkt (&rs
->buf
, 0);
8026 buf
= rs
->buf
.data ();
8028 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
8032 case PACKET_UNKNOWN
:
8035 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
8036 gdbarch_register_name (regcache
->arch (),
8041 /* If this register is unfetchable, tell the regcache. */
8044 regcache
->raw_supply (reg
->regnum
, NULL
);
8048 /* Otherwise, parse and supply the value. */
8054 error (_("fetch_register_using_p: early buf termination"));
8056 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8059 regcache
->raw_supply (reg
->regnum
, regp
);
8063 /* Fetch the registers included in the target's 'g' packet. */
8066 remote_target::send_g_packet ()
8068 struct remote_state
*rs
= get_remote_state ();
8071 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
8073 getpkt (&rs
->buf
, 0);
8074 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8075 error (_("Could not read registers; remote failure reply '%s'"),
8078 /* We can get out of synch in various cases. If the first character
8079 in the buffer is not a hex character, assume that has happened
8080 and try to fetch another packet to read. */
8081 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
8082 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
8083 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
8084 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
8087 fprintf_unfiltered (gdb_stdlog
,
8088 "Bad register packet; fetching a new packet\n");
8089 getpkt (&rs
->buf
, 0);
8092 buf_len
= strlen (rs
->buf
.data ());
8094 /* Sanity check the received packet. */
8095 if (buf_len
% 2 != 0)
8096 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
8102 remote_target::process_g_packet (struct regcache
*regcache
)
8104 struct gdbarch
*gdbarch
= regcache
->arch ();
8105 struct remote_state
*rs
= get_remote_state ();
8106 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8111 buf_len
= strlen (rs
->buf
.data ());
8113 /* Further sanity checks, with knowledge of the architecture. */
8114 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
8115 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8117 rsa
->sizeof_g_packet
, buf_len
/ 2,
8120 /* Save the size of the packet sent to us by the target. It is used
8121 as a heuristic when determining the max size of packets that the
8122 target can safely receive. */
8123 if (rsa
->actual_register_packet_size
== 0)
8124 rsa
->actual_register_packet_size
= buf_len
;
8126 /* If this is smaller than we guessed the 'g' packet would be,
8127 update our records. A 'g' reply that doesn't include a register's
8128 value implies either that the register is not available, or that
8129 the 'p' packet must be used. */
8130 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8132 long sizeof_g_packet
= buf_len
/ 2;
8134 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8136 long offset
= rsa
->regs
[i
].offset
;
8137 long reg_size
= register_size (gdbarch
, i
);
8139 if (rsa
->regs
[i
].pnum
== -1)
8142 if (offset
>= sizeof_g_packet
)
8143 rsa
->regs
[i
].in_g_packet
= 0;
8144 else if (offset
+ reg_size
> sizeof_g_packet
)
8145 error (_("Truncated register %d in remote 'g' packet"), i
);
8147 rsa
->regs
[i
].in_g_packet
= 1;
8150 /* Looks valid enough, we can assume this is the correct length
8151 for a 'g' packet. It's important not to adjust
8152 rsa->sizeof_g_packet if we have truncated registers otherwise
8153 this "if" won't be run the next time the method is called
8154 with a packet of the same size and one of the internal errors
8155 below will trigger instead. */
8156 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8159 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8161 /* Unimplemented registers read as all bits zero. */
8162 memset (regs
, 0, rsa
->sizeof_g_packet
);
8164 /* Reply describes registers byte by byte, each byte encoded as two
8165 hex characters. Suck them all up, then supply them to the
8166 register cacheing/storage mechanism. */
8168 p
= rs
->buf
.data ();
8169 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8171 if (p
[0] == 0 || p
[1] == 0)
8172 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8173 internal_error (__FILE__
, __LINE__
,
8174 _("unexpected end of 'g' packet reply"));
8176 if (p
[0] == 'x' && p
[1] == 'x')
8177 regs
[i
] = 0; /* 'x' */
8179 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8183 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8185 struct packet_reg
*r
= &rsa
->regs
[i
];
8186 long reg_size
= register_size (gdbarch
, i
);
8190 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8191 /* This shouldn't happen - we adjusted in_g_packet above. */
8192 internal_error (__FILE__
, __LINE__
,
8193 _("unexpected end of 'g' packet reply"));
8194 else if (rs
->buf
[r
->offset
* 2] == 'x')
8196 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8197 /* The register isn't available, mark it as such (at
8198 the same time setting the value to zero). */
8199 regcache
->raw_supply (r
->regnum
, NULL
);
8202 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8208 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8211 process_g_packet (regcache
);
8214 /* Make the remote selected traceframe match GDB's selected
8218 remote_target::set_remote_traceframe ()
8221 struct remote_state
*rs
= get_remote_state ();
8223 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8226 /* Avoid recursion, remote_trace_find calls us again. */
8227 rs
->remote_traceframe_number
= get_traceframe_number ();
8229 newnum
= target_trace_find (tfind_number
,
8230 get_traceframe_number (), 0, 0, NULL
);
8232 /* Should not happen. If it does, all bets are off. */
8233 if (newnum
!= get_traceframe_number ())
8234 warning (_("could not set remote traceframe"));
8238 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8240 struct gdbarch
*gdbarch
= regcache
->arch ();
8241 struct remote_state
*rs
= get_remote_state ();
8242 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8245 set_remote_traceframe ();
8246 set_general_thread (regcache
->ptid ());
8250 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8252 gdb_assert (reg
!= NULL
);
8254 /* If this register might be in the 'g' packet, try that first -
8255 we are likely to read more than one register. If this is the
8256 first 'g' packet, we might be overly optimistic about its
8257 contents, so fall back to 'p'. */
8258 if (reg
->in_g_packet
)
8260 fetch_registers_using_g (regcache
);
8261 if (reg
->in_g_packet
)
8265 if (fetch_register_using_p (regcache
, reg
))
8268 /* This register is not available. */
8269 regcache
->raw_supply (reg
->regnum
, NULL
);
8274 fetch_registers_using_g (regcache
);
8276 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8277 if (!rsa
->regs
[i
].in_g_packet
)
8278 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8280 /* This register is not available. */
8281 regcache
->raw_supply (i
, NULL
);
8285 /* Prepare to store registers. Since we may send them all (using a
8286 'G' request), we have to read out the ones we don't want to change
8290 remote_target::prepare_to_store (struct regcache
*regcache
)
8292 struct remote_state
*rs
= get_remote_state ();
8293 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8296 /* Make sure the entire registers array is valid. */
8297 switch (packet_support (PACKET_P
))
8299 case PACKET_DISABLE
:
8300 case PACKET_SUPPORT_UNKNOWN
:
8301 /* Make sure all the necessary registers are cached. */
8302 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8303 if (rsa
->regs
[i
].in_g_packet
)
8304 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8311 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8312 packet was not recognized. */
8315 remote_target::store_register_using_P (const struct regcache
*regcache
,
8318 struct gdbarch
*gdbarch
= regcache
->arch ();
8319 struct remote_state
*rs
= get_remote_state ();
8320 /* Try storing a single register. */
8321 char *buf
= rs
->buf
.data ();
8322 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8325 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8328 if (reg
->pnum
== -1)
8331 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8332 p
= buf
+ strlen (buf
);
8333 regcache
->raw_collect (reg
->regnum
, regp
);
8334 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8336 getpkt (&rs
->buf
, 0);
8338 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8343 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8344 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8345 case PACKET_UNKNOWN
:
8348 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8352 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8353 contents of the register cache buffer. FIXME: ignores errors. */
8356 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8358 struct remote_state
*rs
= get_remote_state ();
8359 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8363 /* Extract all the registers in the regcache copying them into a
8368 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8369 memset (regs
, 0, rsa
->sizeof_g_packet
);
8370 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8372 struct packet_reg
*r
= &rsa
->regs
[i
];
8375 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8379 /* Command describes registers byte by byte,
8380 each byte encoded as two hex characters. */
8381 p
= rs
->buf
.data ();
8383 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8385 getpkt (&rs
->buf
, 0);
8386 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8387 error (_("Could not write registers; remote failure reply '%s'"),
8391 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8392 of the register cache buffer. FIXME: ignores errors. */
8395 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8397 struct gdbarch
*gdbarch
= regcache
->arch ();
8398 struct remote_state
*rs
= get_remote_state ();
8399 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8402 set_remote_traceframe ();
8403 set_general_thread (regcache
->ptid ());
8407 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8409 gdb_assert (reg
!= NULL
);
8411 /* Always prefer to store registers using the 'P' packet if
8412 possible; we often change only a small number of registers.
8413 Sometimes we change a larger number; we'd need help from a
8414 higher layer to know to use 'G'. */
8415 if (store_register_using_P (regcache
, reg
))
8418 /* For now, don't complain if we have no way to write the
8419 register. GDB loses track of unavailable registers too
8420 easily. Some day, this may be an error. We don't have
8421 any way to read the register, either... */
8422 if (!reg
->in_g_packet
)
8425 store_registers_using_G (regcache
);
8429 store_registers_using_G (regcache
);
8431 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8432 if (!rsa
->regs
[i
].in_g_packet
)
8433 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8434 /* See above for why we do not issue an error here. */
8439 /* Return the number of hex digits in num. */
8442 hexnumlen (ULONGEST num
)
8446 for (i
= 0; num
!= 0; i
++)
8449 return std::max (i
, 1);
8452 /* Set BUF to the minimum number of hex digits representing NUM. */
8455 hexnumstr (char *buf
, ULONGEST num
)
8457 int len
= hexnumlen (num
);
8459 return hexnumnstr (buf
, num
, len
);
8463 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8466 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8472 for (i
= width
- 1; i
>= 0; i
--)
8474 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8481 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8484 remote_address_masked (CORE_ADDR addr
)
8486 unsigned int address_size
= remote_address_size
;
8488 /* If "remoteaddresssize" was not set, default to target address size. */
8490 address_size
= gdbarch_addr_bit (target_gdbarch ());
8492 if (address_size
> 0
8493 && address_size
< (sizeof (ULONGEST
) * 8))
8495 /* Only create a mask when that mask can safely be constructed
8496 in a ULONGEST variable. */
8499 mask
= (mask
<< address_size
) - 1;
8505 /* Determine whether the remote target supports binary downloading.
8506 This is accomplished by sending a no-op memory write of zero length
8507 to the target at the specified address. It does not suffice to send
8508 the whole packet, since many stubs strip the eighth bit and
8509 subsequently compute a wrong checksum, which causes real havoc with
8512 NOTE: This can still lose if the serial line is not eight-bit
8513 clean. In cases like this, the user should clear "remote
8517 remote_target::check_binary_download (CORE_ADDR addr
)
8519 struct remote_state
*rs
= get_remote_state ();
8521 switch (packet_support (PACKET_X
))
8523 case PACKET_DISABLE
:
8527 case PACKET_SUPPORT_UNKNOWN
:
8531 p
= rs
->buf
.data ();
8533 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8535 p
+= hexnumstr (p
, (ULONGEST
) 0);
8539 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8540 getpkt (&rs
->buf
, 0);
8542 if (rs
->buf
[0] == '\0')
8545 fprintf_unfiltered (gdb_stdlog
,
8546 "binary downloading NOT "
8547 "supported by target\n");
8548 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8553 fprintf_unfiltered (gdb_stdlog
,
8554 "binary downloading supported by target\n");
8555 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8562 /* Helper function to resize the payload in order to try to get a good
8563 alignment. We try to write an amount of data such that the next write will
8564 start on an address aligned on REMOTE_ALIGN_WRITES. */
8567 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8569 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8572 /* Write memory data directly to the remote machine.
8573 This does not inform the data cache; the data cache uses this.
8574 HEADER is the starting part of the packet.
8575 MEMADDR is the address in the remote memory space.
8576 MYADDR is the address of the buffer in our space.
8577 LEN_UNITS is the number of addressable units to write.
8578 UNIT_SIZE is the length in bytes of an addressable unit.
8579 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8580 should send data as binary ('X'), or hex-encoded ('M').
8582 The function creates packet of the form
8583 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8585 where encoding of <DATA> is terminated by PACKET_FORMAT.
8587 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8590 Return the transferred status, error or OK (an
8591 'enum target_xfer_status' value). Save the number of addressable units
8592 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8594 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8595 exchange between gdb and the stub could look like (?? in place of the
8601 -> $M1000,3:eeeeffffeeee#??
8605 <- eeeeffffeeeedddd */
8608 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8609 const gdb_byte
*myaddr
,
8612 ULONGEST
*xfered_len_units
,
8613 char packet_format
, int use_length
)
8615 struct remote_state
*rs
= get_remote_state ();
8621 int payload_capacity_bytes
;
8622 int payload_length_bytes
;
8624 if (packet_format
!= 'X' && packet_format
!= 'M')
8625 internal_error (__FILE__
, __LINE__
,
8626 _("remote_write_bytes_aux: bad packet format"));
8629 return TARGET_XFER_EOF
;
8631 payload_capacity_bytes
= get_memory_write_packet_size ();
8633 /* The packet buffer will be large enough for the payload;
8634 get_memory_packet_size ensures this. */
8637 /* Compute the size of the actual payload by subtracting out the
8638 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8640 payload_capacity_bytes
-= strlen ("$,:#NN");
8642 /* The comma won't be used. */
8643 payload_capacity_bytes
+= 1;
8644 payload_capacity_bytes
-= strlen (header
);
8645 payload_capacity_bytes
-= hexnumlen (memaddr
);
8647 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8649 strcat (rs
->buf
.data (), header
);
8650 p
= rs
->buf
.data () + strlen (header
);
8652 /* Compute a best guess of the number of bytes actually transfered. */
8653 if (packet_format
== 'X')
8655 /* Best guess at number of bytes that will fit. */
8656 todo_units
= std::min (len_units
,
8657 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8659 payload_capacity_bytes
-= hexnumlen (todo_units
);
8660 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8664 /* Number of bytes that will fit. */
8666 = std::min (len_units
,
8667 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8669 payload_capacity_bytes
-= hexnumlen (todo_units
);
8670 todo_units
= std::min (todo_units
,
8671 (payload_capacity_bytes
/ unit_size
) / 2);
8674 if (todo_units
<= 0)
8675 internal_error (__FILE__
, __LINE__
,
8676 _("minimum packet size too small to write data"));
8678 /* If we already need another packet, then try to align the end
8679 of this packet to a useful boundary. */
8680 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8681 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8683 /* Append "<memaddr>". */
8684 memaddr
= remote_address_masked (memaddr
);
8685 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8692 /* Append the length and retain its location and size. It may need to be
8693 adjusted once the packet body has been created. */
8695 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8703 /* Append the packet body. */
8704 if (packet_format
== 'X')
8706 /* Binary mode. Send target system values byte by byte, in
8707 increasing byte addresses. Only escape certain critical
8709 payload_length_bytes
=
8710 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8711 &units_written
, payload_capacity_bytes
);
8713 /* If not all TODO units fit, then we'll need another packet. Make
8714 a second try to keep the end of the packet aligned. Don't do
8715 this if the packet is tiny. */
8716 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8720 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8722 if (new_todo_units
!= units_written
)
8723 payload_length_bytes
=
8724 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8725 (gdb_byte
*) p
, &units_written
,
8726 payload_capacity_bytes
);
8729 p
+= payload_length_bytes
;
8730 if (use_length
&& units_written
< todo_units
)
8732 /* Escape chars have filled up the buffer prematurely,
8733 and we have actually sent fewer units than planned.
8734 Fix-up the length field of the packet. Use the same
8735 number of characters as before. */
8736 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8738 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8743 /* Normal mode: Send target system values byte by byte, in
8744 increasing byte addresses. Each byte is encoded as a two hex
8746 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8747 units_written
= todo_units
;
8750 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8751 getpkt (&rs
->buf
, 0);
8753 if (rs
->buf
[0] == 'E')
8754 return TARGET_XFER_E_IO
;
8756 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8757 send fewer units than we'd planned. */
8758 *xfered_len_units
= (ULONGEST
) units_written
;
8759 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8762 /* Write memory data directly to the remote machine.
8763 This does not inform the data cache; the data cache uses this.
8764 MEMADDR is the address in the remote memory space.
8765 MYADDR is the address of the buffer in our space.
8766 LEN is the number of bytes.
8768 Return the transferred status, error or OK (an
8769 'enum target_xfer_status' value). Save the number of bytes
8770 transferred in *XFERED_LEN. Only transfer a single packet. */
8773 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8774 ULONGEST len
, int unit_size
,
8775 ULONGEST
*xfered_len
)
8777 const char *packet_format
= NULL
;
8779 /* Check whether the target supports binary download. */
8780 check_binary_download (memaddr
);
8782 switch (packet_support (PACKET_X
))
8785 packet_format
= "X";
8787 case PACKET_DISABLE
:
8788 packet_format
= "M";
8790 case PACKET_SUPPORT_UNKNOWN
:
8791 internal_error (__FILE__
, __LINE__
,
8792 _("remote_write_bytes: bad internal state"));
8794 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8797 return remote_write_bytes_aux (packet_format
,
8798 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8799 packet_format
[0], 1);
8802 /* Read memory data directly from the remote machine.
8803 This does not use the data cache; the data cache uses this.
8804 MEMADDR is the address in the remote memory space.
8805 MYADDR is the address of the buffer in our space.
8806 LEN_UNITS is the number of addressable memory units to read..
8807 UNIT_SIZE is the length in bytes of an addressable unit.
8809 Return the transferred status, error or OK (an
8810 'enum target_xfer_status' value). Save the number of bytes
8811 transferred in *XFERED_LEN_UNITS.
8813 See the comment of remote_write_bytes_aux for an example of
8814 memory read/write exchange between gdb and the stub. */
8817 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8819 int unit_size
, ULONGEST
*xfered_len_units
)
8821 struct remote_state
*rs
= get_remote_state ();
8822 int buf_size_bytes
; /* Max size of packet output buffer. */
8827 buf_size_bytes
= get_memory_read_packet_size ();
8828 /* The packet buffer will be large enough for the payload;
8829 get_memory_packet_size ensures this. */
8831 /* Number of units that will fit. */
8832 todo_units
= std::min (len_units
,
8833 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8835 /* Construct "m"<memaddr>","<len>". */
8836 memaddr
= remote_address_masked (memaddr
);
8837 p
= rs
->buf
.data ();
8839 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8841 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8844 getpkt (&rs
->buf
, 0);
8845 if (rs
->buf
[0] == 'E'
8846 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8847 && rs
->buf
[3] == '\0')
8848 return TARGET_XFER_E_IO
;
8849 /* Reply describes memory byte by byte, each byte encoded as two hex
8851 p
= rs
->buf
.data ();
8852 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8853 /* Return what we have. Let higher layers handle partial reads. */
8854 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8855 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8858 /* Using the set of read-only target sections of remote, read live
8861 For interface/parameters/return description see target.h,
8865 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
8869 ULONGEST
*xfered_len
)
8871 struct target_section
*secp
;
8872 struct target_section_table
*table
;
8874 secp
= target_section_by_addr (this, memaddr
);
8876 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
8878 struct target_section
*p
;
8879 ULONGEST memend
= memaddr
+ len
;
8881 table
= target_get_section_table (this);
8883 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8885 if (memaddr
>= p
->addr
)
8887 if (memend
<= p
->endaddr
)
8889 /* Entire transfer is within this section. */
8890 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8893 else if (memaddr
>= p
->endaddr
)
8895 /* This section ends before the transfer starts. */
8900 /* This section overlaps the transfer. Just do half. */
8901 len
= p
->endaddr
- memaddr
;
8902 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8909 return TARGET_XFER_EOF
;
8912 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8913 first if the requested memory is unavailable in traceframe.
8914 Otherwise, fall back to remote_read_bytes_1. */
8917 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
8918 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8919 ULONGEST
*xfered_len
)
8922 return TARGET_XFER_EOF
;
8924 if (get_traceframe_number () != -1)
8926 std::vector
<mem_range
> available
;
8928 /* If we fail to get the set of available memory, then the
8929 target does not support querying traceframe info, and so we
8930 attempt reading from the traceframe anyway (assuming the
8931 target implements the old QTro packet then). */
8932 if (traceframe_available_memory (&available
, memaddr
, len
))
8934 if (available
.empty () || available
[0].start
!= memaddr
)
8936 enum target_xfer_status res
;
8938 /* Don't read into the traceframe's available
8940 if (!available
.empty ())
8942 LONGEST oldlen
= len
;
8944 len
= available
[0].start
- memaddr
;
8945 gdb_assert (len
<= oldlen
);
8948 /* This goes through the topmost target again. */
8949 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
8950 len
, unit_size
, xfered_len
);
8951 if (res
== TARGET_XFER_OK
)
8952 return TARGET_XFER_OK
;
8955 /* No use trying further, we know some memory starting
8956 at MEMADDR isn't available. */
8958 return (*xfered_len
!= 0) ?
8959 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
8963 /* Don't try to read more than how much is available, in
8964 case the target implements the deprecated QTro packet to
8965 cater for older GDBs (the target's knowledge of read-only
8966 sections may be outdated by now). */
8967 len
= available
[0].length
;
8971 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8976 /* Sends a packet with content determined by the printf format string
8977 FORMAT and the remaining arguments, then gets the reply. Returns
8978 whether the packet was a success, a failure, or unknown. */
8981 remote_target::remote_send_printf (const char *format
, ...)
8983 struct remote_state
*rs
= get_remote_state ();
8984 int max_size
= get_remote_packet_size ();
8987 va_start (ap
, format
);
8990 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
8994 if (size
>= max_size
)
8995 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8997 if (putpkt (rs
->buf
) < 0)
8998 error (_("Communication problem with target."));
9001 getpkt (&rs
->buf
, 0);
9003 return packet_check_result (rs
->buf
);
9006 /* Flash writing can take quite some time. We'll set
9007 effectively infinite timeout for flash operations.
9008 In future, we'll need to decide on a better approach. */
9009 static const int remote_flash_timeout
= 1000;
9012 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
9014 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
9015 enum packet_result ret
;
9016 scoped_restore restore_timeout
9017 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9019 ret
= remote_send_printf ("vFlashErase:%s,%s",
9020 phex (address
, addr_size
),
9024 case PACKET_UNKNOWN
:
9025 error (_("Remote target does not support flash erase"));
9027 error (_("Error erasing flash with vFlashErase packet"));
9034 remote_target::remote_flash_write (ULONGEST address
,
9035 ULONGEST length
, ULONGEST
*xfered_len
,
9036 const gdb_byte
*data
)
9038 scoped_restore restore_timeout
9039 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9040 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
9045 remote_target::flash_done ()
9049 scoped_restore restore_timeout
9050 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9052 ret
= remote_send_printf ("vFlashDone");
9056 case PACKET_UNKNOWN
:
9057 error (_("Remote target does not support vFlashDone"));
9059 error (_("Error finishing flash operation"));
9066 remote_target::files_info ()
9068 puts_filtered ("Debugging a target over a serial line.\n");
9071 /* Stuff for dealing with the packets which are part of this protocol.
9072 See comment at top of file for details. */
9074 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
9075 error to higher layers. Called when a serial error is detected.
9076 The exception message is STRING, followed by a colon and a blank,
9077 the system error message for errno at function entry and final dot
9078 for output compatibility with throw_perror_with_name. */
9081 unpush_and_perror (remote_target
*target
, const char *string
)
9083 int saved_errno
= errno
;
9085 remote_unpush_target (target
);
9086 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
9087 safe_strerror (saved_errno
));
9090 /* Read a single character from the remote end. The current quit
9091 handler is overridden to avoid quitting in the middle of packet
9092 sequence, as that would break communication with the remote server.
9093 See remote_serial_quit_handler for more detail. */
9096 remote_target::readchar (int timeout
)
9099 struct remote_state
*rs
= get_remote_state ();
9102 scoped_restore restore_quit_target
9103 = make_scoped_restore (&curr_quit_handler_target
, this);
9104 scoped_restore restore_quit
9105 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9107 rs
->got_ctrlc_during_io
= 0;
9109 ch
= serial_readchar (rs
->remote_desc
, timeout
);
9111 if (rs
->got_ctrlc_during_io
)
9118 switch ((enum serial_rc
) ch
)
9121 remote_unpush_target (this);
9122 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9125 unpush_and_perror (this, _("Remote communication error. "
9126 "Target disconnected."));
9128 case SERIAL_TIMEOUT
:
9134 /* Wrapper for serial_write that closes the target and throws if
9135 writing fails. The current quit handler is overridden to avoid
9136 quitting in the middle of packet sequence, as that would break
9137 communication with the remote server. See
9138 remote_serial_quit_handler for more detail. */
9141 remote_target::remote_serial_write (const char *str
, int len
)
9143 struct remote_state
*rs
= get_remote_state ();
9145 scoped_restore restore_quit_target
9146 = make_scoped_restore (&curr_quit_handler_target
, this);
9147 scoped_restore restore_quit
9148 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9150 rs
->got_ctrlc_during_io
= 0;
9152 if (serial_write (rs
->remote_desc
, str
, len
))
9154 unpush_and_perror (this, _("Remote communication error. "
9155 "Target disconnected."));
9158 if (rs
->got_ctrlc_during_io
)
9162 /* Return a string representing an escaped version of BUF, of len N.
9163 E.g. \n is converted to \\n, \t to \\t, etc. */
9166 escape_buffer (const char *buf
, int n
)
9170 stb
.putstrn (buf
, n
, '\\');
9171 return std::move (stb
.string ());
9174 /* Display a null-terminated packet on stdout, for debugging, using C
9178 print_packet (const char *buf
)
9180 puts_filtered ("\"");
9181 fputstr_filtered (buf
, '"', gdb_stdout
);
9182 puts_filtered ("\"");
9186 remote_target::putpkt (const char *buf
)
9188 return putpkt_binary (buf
, strlen (buf
));
9191 /* Wrapper around remote_target::putpkt to avoid exporting
9195 putpkt (remote_target
*remote
, const char *buf
)
9197 return remote
->putpkt (buf
);
9200 /* Send a packet to the remote machine, with error checking. The data
9201 of the packet is in BUF. The string in BUF can be at most
9202 get_remote_packet_size () - 5 to account for the $, # and checksum,
9203 and for a possible /0 if we are debugging (remote_debug) and want
9204 to print the sent packet as a string. */
9207 remote_target::putpkt_binary (const char *buf
, int cnt
)
9209 struct remote_state
*rs
= get_remote_state ();
9211 unsigned char csum
= 0;
9212 gdb::def_vector
<char> data (cnt
+ 6);
9213 char *buf2
= data
.data ();
9219 /* Catch cases like trying to read memory or listing threads while
9220 we're waiting for a stop reply. The remote server wouldn't be
9221 ready to handle this request, so we'd hang and timeout. We don't
9222 have to worry about this in synchronous mode, because in that
9223 case it's not possible to issue a command while the target is
9224 running. This is not a problem in non-stop mode, because in that
9225 case, the stub is always ready to process serial input. */
9226 if (!target_is_non_stop_p ()
9227 && target_is_async_p ()
9228 && rs
->waiting_for_stop_reply
)
9230 error (_("Cannot execute this command while the target is running.\n"
9231 "Use the \"interrupt\" command to stop the target\n"
9232 "and then try again."));
9235 /* We're sending out a new packet. Make sure we don't look at a
9236 stale cached response. */
9237 rs
->cached_wait_status
= 0;
9239 /* Copy the packet into buffer BUF2, encapsulating it
9240 and giving it a checksum. */
9245 for (i
= 0; i
< cnt
; i
++)
9251 *p
++ = tohex ((csum
>> 4) & 0xf);
9252 *p
++ = tohex (csum
& 0xf);
9254 /* Send it over and over until we get a positive ack. */
9258 int started_error_output
= 0;
9264 int len
= (int) (p
- buf2
);
9267 if (remote_packet_max_chars
< 0)
9270 max_chars
= remote_packet_max_chars
;
9273 = escape_buffer (buf2
, std::min (len
, max_chars
));
9275 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9277 if (len
> max_chars
)
9278 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9281 fprintf_unfiltered (gdb_stdlog
, "...");
9283 gdb_flush (gdb_stdlog
);
9285 remote_serial_write (buf2
, p
- buf2
);
9287 /* If this is a no acks version of the remote protocol, send the
9288 packet and move on. */
9292 /* Read until either a timeout occurs (-2) or '+' is read.
9293 Handle any notification that arrives in the mean time. */
9296 ch
= readchar (remote_timeout
);
9304 case SERIAL_TIMEOUT
:
9307 if (started_error_output
)
9309 putchar_unfiltered ('\n');
9310 started_error_output
= 0;
9319 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9323 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9325 case SERIAL_TIMEOUT
:
9329 break; /* Retransmit buffer. */
9333 fprintf_unfiltered (gdb_stdlog
,
9334 "Packet instead of Ack, ignoring it\n");
9335 /* It's probably an old response sent because an ACK
9336 was lost. Gobble up the packet and ack it so it
9337 doesn't get retransmitted when we resend this
9340 remote_serial_write ("+", 1);
9341 continue; /* Now, go look for +. */
9348 /* If we got a notification, handle it, and go back to looking
9350 /* We've found the start of a notification. Now
9351 collect the data. */
9352 val
= read_frame (&rs
->buf
);
9357 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9359 fprintf_unfiltered (gdb_stdlog
,
9360 " Notification received: %s\n",
9363 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9364 /* We're in sync now, rewait for the ack. */
9371 if (!started_error_output
)
9373 started_error_output
= 1;
9374 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9376 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9377 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9386 if (!started_error_output
)
9388 started_error_output
= 1;
9389 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9391 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9395 break; /* Here to retransmit. */
9399 /* This is wrong. If doing a long backtrace, the user should be
9400 able to get out next time we call QUIT, without anything as
9401 violent as interrupt_query. If we want to provide a way out of
9402 here without getting to the next QUIT, it should be based on
9403 hitting ^C twice as in remote_wait. */
9415 /* Come here after finding the start of a frame when we expected an
9416 ack. Do our best to discard the rest of this packet. */
9419 remote_target::skip_frame ()
9425 c
= readchar (remote_timeout
);
9428 case SERIAL_TIMEOUT
:
9429 /* Nothing we can do. */
9432 /* Discard the two bytes of checksum and stop. */
9433 c
= readchar (remote_timeout
);
9435 c
= readchar (remote_timeout
);
9438 case '*': /* Run length encoding. */
9439 /* Discard the repeat count. */
9440 c
= readchar (remote_timeout
);
9445 /* A regular character. */
9451 /* Come here after finding the start of the frame. Collect the rest
9452 into *BUF, verifying the checksum, length, and handling run-length
9453 compression. NUL terminate the buffer. If there is not enough room,
9456 Returns -1 on error, number of characters in buffer (ignoring the
9457 trailing NULL) on success. (could be extended to return one of the
9458 SERIAL status indications). */
9461 remote_target::read_frame (gdb::char_vector
*buf_p
)
9466 char *buf
= buf_p
->data ();
9467 struct remote_state
*rs
= get_remote_state ();
9474 c
= readchar (remote_timeout
);
9477 case SERIAL_TIMEOUT
:
9479 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9483 fputs_filtered ("Saw new packet start in middle of old one\n",
9485 return -1; /* Start a new packet, count retries. */
9488 unsigned char pktcsum
;
9494 check_0
= readchar (remote_timeout
);
9496 check_1
= readchar (remote_timeout
);
9498 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9501 fputs_filtered ("Timeout in checksum, retrying\n",
9505 else if (check_0
< 0 || check_1
< 0)
9508 fputs_filtered ("Communication error in checksum\n",
9513 /* Don't recompute the checksum; with no ack packets we
9514 don't have any way to indicate a packet retransmission
9519 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9520 if (csum
== pktcsum
)
9525 std::string str
= escape_buffer (buf
, bc
);
9527 fprintf_unfiltered (gdb_stdlog
,
9528 "Bad checksum, sentsum=0x%x, "
9529 "csum=0x%x, buf=%s\n",
9530 pktcsum
, csum
, str
.c_str ());
9532 /* Number of characters in buffer ignoring trailing
9536 case '*': /* Run length encoding. */
9541 c
= readchar (remote_timeout
);
9543 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9545 /* The character before ``*'' is repeated. */
9547 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9549 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9551 /* Make some more room in the buffer. */
9552 buf_p
->resize (buf_p
->size () + repeat
);
9553 buf
= buf_p
->data ();
9556 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9562 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9566 if (bc
>= buf_p
->size () - 1)
9568 /* Make some more room in the buffer. */
9569 buf_p
->resize (buf_p
->size () * 2);
9570 buf
= buf_p
->data ();
9580 /* Set this to the maximum number of seconds to wait instead of waiting forever
9581 in target_wait(). If this timer times out, then it generates an error and
9582 the command is aborted. This replaces most of the need for timeouts in the
9583 GDB test suite, and makes it possible to distinguish between a hung target
9584 and one with slow communications. */
9586 static int watchdog
= 0;
9588 show_watchdog (struct ui_file
*file
, int from_tty
,
9589 struct cmd_list_element
*c
, const char *value
)
9591 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9594 /* Read a packet from the remote machine, with error checking, and
9595 store it in *BUF. Resize *BUF if necessary to hold the result. If
9596 FOREVER, wait forever rather than timing out; this is used (in
9597 synchronous mode) to wait for a target that is is executing user
9599 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9600 don't have to change all the calls to getpkt to deal with the
9601 return value, because at the moment I don't know what the right
9602 thing to do it for those. */
9605 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9607 getpkt_sane (buf
, forever
);
9611 /* Read a packet from the remote machine, with error checking, and
9612 store it in *BUF. Resize *BUF if necessary to hold the result. If
9613 FOREVER, wait forever rather than timing out; this is used (in
9614 synchronous mode) to wait for a target that is is executing user
9615 code to stop. If FOREVER == 0, this function is allowed to time
9616 out gracefully and return an indication of this to the caller.
9617 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9618 consider receiving a notification enough reason to return to the
9619 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9620 holds a notification or not (a regular packet). */
9623 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9624 int forever
, int expecting_notif
,
9627 struct remote_state
*rs
= get_remote_state ();
9633 /* We're reading a new response. Make sure we don't look at a
9634 previously cached response. */
9635 rs
->cached_wait_status
= 0;
9637 strcpy (buf
->data (), "timeout");
9640 timeout
= watchdog
> 0 ? watchdog
: -1;
9641 else if (expecting_notif
)
9642 timeout
= 0; /* There should already be a char in the buffer. If
9645 timeout
= remote_timeout
;
9649 /* Process any number of notifications, and then return when
9653 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9655 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9657 /* This can loop forever if the remote side sends us
9658 characters continuously, but if it pauses, we'll get
9659 SERIAL_TIMEOUT from readchar because of timeout. Then
9660 we'll count that as a retry.
9662 Note that even when forever is set, we will only wait
9663 forever prior to the start of a packet. After that, we
9664 expect characters to arrive at a brisk pace. They should
9665 show up within remote_timeout intervals. */
9667 c
= readchar (timeout
);
9668 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9670 if (c
== SERIAL_TIMEOUT
)
9672 if (expecting_notif
)
9673 return -1; /* Don't complain, it's normal to not get
9674 anything in this case. */
9676 if (forever
) /* Watchdog went off? Kill the target. */
9678 remote_unpush_target (this);
9679 throw_error (TARGET_CLOSE_ERROR
,
9680 _("Watchdog timeout has expired. "
9681 "Target detached."));
9684 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9688 /* We've found the start of a packet or notification.
9689 Now collect the data. */
9690 val
= read_frame (buf
);
9695 remote_serial_write ("-", 1);
9698 if (tries
> MAX_TRIES
)
9700 /* We have tried hard enough, and just can't receive the
9701 packet/notification. Give up. */
9702 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9704 /* Skip the ack char if we're in no-ack mode. */
9705 if (!rs
->noack_mode
)
9706 remote_serial_write ("+", 1);
9710 /* If we got an ordinary packet, return that to our caller. */
9717 if (remote_packet_max_chars
< 0)
9720 max_chars
= remote_packet_max_chars
;
9723 = escape_buffer (buf
->data (),
9724 std::min (val
, max_chars
));
9726 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9729 if (val
> max_chars
)
9730 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9733 fprintf_unfiltered (gdb_stdlog
, "\n");
9736 /* Skip the ack char if we're in no-ack mode. */
9737 if (!rs
->noack_mode
)
9738 remote_serial_write ("+", 1);
9739 if (is_notif
!= NULL
)
9744 /* If we got a notification, handle it, and go back to looking
9748 gdb_assert (c
== '%');
9752 std::string str
= escape_buffer (buf
->data (), val
);
9754 fprintf_unfiltered (gdb_stdlog
,
9755 " Notification received: %s\n",
9758 if (is_notif
!= NULL
)
9761 handle_notification (rs
->notif_state
, buf
->data ());
9763 /* Notifications require no acknowledgement. */
9765 if (expecting_notif
)
9772 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9774 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9778 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9781 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9784 /* Kill any new fork children of process PID that haven't been
9785 processed by follow_fork. */
9788 remote_target::kill_new_fork_children (int pid
)
9790 remote_state
*rs
= get_remote_state ();
9791 struct notif_client
*notif
= ¬if_client_stop
;
9793 /* Kill the fork child threads of any threads in process PID
9794 that are stopped at a fork event. */
9795 for (thread_info
*thread
: all_non_exited_threads (this))
9797 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9799 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9801 int child_pid
= ws
->value
.related_pid
.pid ();
9804 res
= remote_vkill (child_pid
);
9806 error (_("Can't kill fork child process %d"), child_pid
);
9810 /* Check for any pending fork events (not reported or processed yet)
9811 in process PID and kill those fork child threads as well. */
9812 remote_notif_get_pending_events (notif
);
9813 for (auto &event
: rs
->stop_reply_queue
)
9814 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9816 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9819 res
= remote_vkill (child_pid
);
9821 error (_("Can't kill fork child process %d"), child_pid
);
9826 /* Target hook to kill the current inferior. */
9829 remote_target::kill ()
9832 int pid
= inferior_ptid
.pid ();
9833 struct remote_state
*rs
= get_remote_state ();
9835 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9837 /* If we're stopped while forking and we haven't followed yet,
9838 kill the child task. We need to do this before killing the
9839 parent task because if this is a vfork then the parent will
9841 kill_new_fork_children (pid
);
9843 res
= remote_vkill (pid
);
9846 target_mourn_inferior (inferior_ptid
);
9851 /* If we are in 'target remote' mode and we are killing the only
9852 inferior, then we will tell gdbserver to exit and unpush the
9854 if (res
== -1 && !remote_multi_process_p (rs
)
9855 && number_of_live_inferiors (this) == 1)
9859 /* We've killed the remote end, we get to mourn it. If we are
9860 not in extended mode, mourning the inferior also unpushes
9861 remote_ops from the target stack, which closes the remote
9863 target_mourn_inferior (inferior_ptid
);
9868 error (_("Can't kill process"));
9871 /* Send a kill request to the target using the 'vKill' packet. */
9874 remote_target::remote_vkill (int pid
)
9876 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9879 remote_state
*rs
= get_remote_state ();
9881 /* Tell the remote target to detach. */
9882 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
9884 getpkt (&rs
->buf
, 0);
9886 switch (packet_ok (rs
->buf
,
9887 &remote_protocol_packets
[PACKET_vKill
]))
9893 case PACKET_UNKNOWN
:
9896 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9900 /* Send a kill request to the target using the 'k' packet. */
9903 remote_target::remote_kill_k ()
9905 /* Catch errors so the user can quit from gdb even when we
9906 aren't on speaking terms with the remote system. */
9911 catch (const gdb_exception_error
&ex
)
9913 if (ex
.error
== TARGET_CLOSE_ERROR
)
9915 /* If we got an (EOF) error that caused the target
9916 to go away, then we're done, that's what we wanted.
9917 "k" is susceptible to cause a premature EOF, given
9918 that the remote server isn't actually required to
9919 reply to "k", and it can happen that it doesn't
9920 even get to reply ACK to the "k". */
9924 /* Otherwise, something went wrong. We didn't actually kill
9925 the target. Just propagate the exception, and let the
9926 user or higher layers decide what to do. */
9932 remote_target::mourn_inferior ()
9934 struct remote_state
*rs
= get_remote_state ();
9936 /* We're no longer interested in notification events of an inferior
9937 that exited or was killed/detached. */
9938 discard_pending_stop_replies (current_inferior ());
9940 /* In 'target remote' mode with one inferior, we close the connection. */
9941 if (!rs
->extended
&& number_of_live_inferiors (this) <= 1)
9943 remote_unpush_target (this);
9947 /* In case we got here due to an error, but we're going to stay
9949 rs
->waiting_for_stop_reply
= 0;
9951 /* If the current general thread belonged to the process we just
9952 detached from or has exited, the remote side current general
9953 thread becomes undefined. Considering a case like this:
9955 - We just got here due to a detach.
9956 - The process that we're detaching from happens to immediately
9957 report a global breakpoint being hit in non-stop mode, in the
9958 same thread we had selected before.
9959 - GDB attaches to this process again.
9960 - This event happens to be the next event we handle.
9962 GDB would consider that the current general thread didn't need to
9963 be set on the stub side (with Hg), since for all it knew,
9964 GENERAL_THREAD hadn't changed.
9966 Notice that although in all-stop mode, the remote server always
9967 sets the current thread to the thread reporting the stop event,
9968 that doesn't happen in non-stop mode; in non-stop, the stub *must
9969 not* change the current thread when reporting a breakpoint hit,
9970 due to the decoupling of event reporting and event handling.
9972 To keep things simple, we always invalidate our notion of the
9974 record_currthread (rs
, minus_one_ptid
);
9976 /* Call common code to mark the inferior as not running. */
9977 generic_mourn_inferior ();
9981 extended_remote_target::supports_disable_randomization ()
9983 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9987 remote_target::extended_remote_disable_randomization (int val
)
9989 struct remote_state
*rs
= get_remote_state ();
9992 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9993 "QDisableRandomization:%x", val
);
9995 reply
= remote_get_noisy_reply ();
9997 error (_("Target does not support QDisableRandomization."));
9998 if (strcmp (reply
, "OK") != 0)
9999 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
10003 remote_target::extended_remote_run (const std::string
&args
)
10005 struct remote_state
*rs
= get_remote_state ();
10007 const char *remote_exec_file
= get_remote_exec_file ();
10009 /* If the user has disabled vRun support, or we have detected that
10010 support is not available, do not try it. */
10011 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
10014 strcpy (rs
->buf
.data (), "vRun;");
10015 len
= strlen (rs
->buf
.data ());
10017 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
10018 error (_("Remote file name too long for run packet"));
10019 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
10020 strlen (remote_exec_file
));
10022 if (!args
.empty ())
10026 gdb_argv
argv (args
.c_str ());
10027 for (i
= 0; argv
[i
] != NULL
; i
++)
10029 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
10030 error (_("Argument list too long for run packet"));
10031 rs
->buf
[len
++] = ';';
10032 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
10037 rs
->buf
[len
++] = '\0';
10040 getpkt (&rs
->buf
, 0);
10042 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
10045 /* We have a wait response. All is well. */
10047 case PACKET_UNKNOWN
:
10050 if (remote_exec_file
[0] == '\0')
10051 error (_("Running the default executable on the remote target failed; "
10052 "try \"set remote exec-file\"?"));
10054 error (_("Running \"%s\" on the remote target failed"),
10057 gdb_assert_not_reached (_("bad switch"));
10061 /* Helper function to send set/unset environment packets. ACTION is
10062 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
10063 or "QEnvironmentUnsetVariable". VALUE is the variable to be
10067 remote_target::send_environment_packet (const char *action
,
10068 const char *packet
,
10071 remote_state
*rs
= get_remote_state ();
10073 /* Convert the environment variable to an hex string, which
10074 is the best format to be transmitted over the wire. */
10075 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
10078 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10079 "%s:%s", packet
, encoded_value
.c_str ());
10082 getpkt (&rs
->buf
, 0);
10083 if (strcmp (rs
->buf
.data (), "OK") != 0)
10084 warning (_("Unable to %s environment variable '%s' on remote."),
10088 /* Helper function to handle the QEnvironment* packets. */
10091 remote_target::extended_remote_environment_support ()
10093 remote_state
*rs
= get_remote_state ();
10095 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
10097 putpkt ("QEnvironmentReset");
10098 getpkt (&rs
->buf
, 0);
10099 if (strcmp (rs
->buf
.data (), "OK") != 0)
10100 warning (_("Unable to reset environment on remote."));
10103 gdb_environ
*e
= ¤t_inferior ()->environment
;
10105 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
10106 for (const std::string
&el
: e
->user_set_env ())
10107 send_environment_packet ("set", "QEnvironmentHexEncoded",
10110 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
10111 for (const std::string
&el
: e
->user_unset_env ())
10112 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10115 /* Helper function to set the current working directory for the
10116 inferior in the remote target. */
10119 remote_target::extended_remote_set_inferior_cwd ()
10121 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10123 const char *inferior_cwd
= get_inferior_cwd ();
10124 remote_state
*rs
= get_remote_state ();
10126 if (inferior_cwd
!= NULL
)
10128 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10129 strlen (inferior_cwd
));
10131 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10132 "QSetWorkingDir:%s", hexpath
.c_str ());
10136 /* An empty inferior_cwd means that the user wants us to
10137 reset the remote server's inferior's cwd. */
10138 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10139 "QSetWorkingDir:");
10143 getpkt (&rs
->buf
, 0);
10144 if (packet_ok (rs
->buf
,
10145 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10148 Remote replied unexpectedly while setting the inferior's working\n\
10155 /* In the extended protocol we want to be able to do things like
10156 "run" and have them basically work as expected. So we need
10157 a special create_inferior function. We support changing the
10158 executable file and the command line arguments, but not the
10162 extended_remote_target::create_inferior (const char *exec_file
,
10163 const std::string
&args
,
10164 char **env
, int from_tty
)
10168 struct remote_state
*rs
= get_remote_state ();
10169 const char *remote_exec_file
= get_remote_exec_file ();
10171 /* If running asynchronously, register the target file descriptor
10172 with the event loop. */
10173 if (target_can_async_p ())
10176 /* Disable address space randomization if requested (and supported). */
10177 if (supports_disable_randomization ())
10178 extended_remote_disable_randomization (disable_randomization
);
10180 /* If startup-with-shell is on, we inform gdbserver to start the
10181 remote inferior using a shell. */
10182 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10184 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10185 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10187 getpkt (&rs
->buf
, 0);
10188 if (strcmp (rs
->buf
.data (), "OK") != 0)
10190 Remote replied unexpectedly while setting startup-with-shell: %s"),
10194 extended_remote_environment_support ();
10196 extended_remote_set_inferior_cwd ();
10198 /* Now restart the remote server. */
10199 run_worked
= extended_remote_run (args
) != -1;
10202 /* vRun was not supported. Fail if we need it to do what the
10204 if (remote_exec_file
[0])
10205 error (_("Remote target does not support \"set remote exec-file\""));
10206 if (!args
.empty ())
10207 error (_("Remote target does not support \"set args\" or run ARGS"));
10209 /* Fall back to "R". */
10210 extended_remote_restart ();
10213 /* vRun's success return is a stop reply. */
10214 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10215 add_current_inferior_and_thread (stop_reply
);
10217 /* Get updated offsets, if the stub uses qOffsets. */
10222 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10223 the list of conditions (in agent expression bytecode format), if any, the
10224 target needs to evaluate. The output is placed into the packet buffer
10225 started from BUF and ended at BUF_END. */
10228 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10229 struct bp_target_info
*bp_tgt
, char *buf
,
10232 if (bp_tgt
->conditions
.empty ())
10235 buf
+= strlen (buf
);
10236 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10239 /* Send conditions to the target. */
10240 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10242 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10243 buf
+= strlen (buf
);
10244 for (int i
= 0; i
< aexpr
->len
; ++i
)
10245 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10252 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10253 struct bp_target_info
*bp_tgt
, char *buf
)
10255 if (bp_tgt
->tcommands
.empty ())
10258 buf
+= strlen (buf
);
10260 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10261 buf
+= strlen (buf
);
10263 /* Concatenate all the agent expressions that are commands into the
10265 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10267 sprintf (buf
, "X%x,", aexpr
->len
);
10268 buf
+= strlen (buf
);
10269 for (int i
= 0; i
< aexpr
->len
; ++i
)
10270 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10275 /* Insert a breakpoint. On targets that have software breakpoint
10276 support, we ask the remote target to do the work; on targets
10277 which don't, we insert a traditional memory breakpoint. */
10280 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10281 struct bp_target_info
*bp_tgt
)
10283 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10284 If it succeeds, then set the support to PACKET_ENABLE. If it
10285 fails, and the user has explicitly requested the Z support then
10286 report an error, otherwise, mark it disabled and go on. */
10288 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10290 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10291 struct remote_state
*rs
;
10294 /* Make sure the remote is pointing at the right process, if
10296 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10297 set_general_process ();
10299 rs
= get_remote_state ();
10300 p
= rs
->buf
.data ();
10301 endbuf
= p
+ get_remote_packet_size ();
10306 addr
= (ULONGEST
) remote_address_masked (addr
);
10307 p
+= hexnumstr (p
, addr
);
10308 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10310 if (supports_evaluation_of_breakpoint_conditions ())
10311 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10313 if (can_run_breakpoint_commands ())
10314 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10317 getpkt (&rs
->buf
, 0);
10319 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10325 case PACKET_UNKNOWN
:
10330 /* If this breakpoint has target-side commands but this stub doesn't
10331 support Z0 packets, throw error. */
10332 if (!bp_tgt
->tcommands
.empty ())
10333 throw_error (NOT_SUPPORTED_ERROR
, _("\
10334 Target doesn't support breakpoints that have target side commands."));
10336 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10340 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10341 struct bp_target_info
*bp_tgt
,
10342 enum remove_bp_reason reason
)
10344 CORE_ADDR addr
= bp_tgt
->placed_address
;
10345 struct remote_state
*rs
= get_remote_state ();
10347 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10349 char *p
= rs
->buf
.data ();
10350 char *endbuf
= p
+ get_remote_packet_size ();
10352 /* Make sure the remote is pointing at the right process, if
10354 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10355 set_general_process ();
10361 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10362 p
+= hexnumstr (p
, addr
);
10363 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10366 getpkt (&rs
->buf
, 0);
10368 return (rs
->buf
[0] == 'E');
10371 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10374 static enum Z_packet_type
10375 watchpoint_to_Z_packet (int type
)
10380 return Z_PACKET_WRITE_WP
;
10383 return Z_PACKET_READ_WP
;
10386 return Z_PACKET_ACCESS_WP
;
10389 internal_error (__FILE__
, __LINE__
,
10390 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10395 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10396 enum target_hw_bp_type type
, struct expression
*cond
)
10398 struct remote_state
*rs
= get_remote_state ();
10399 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10401 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10403 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10406 /* Make sure the remote is pointing at the right process, if
10408 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10409 set_general_process ();
10411 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10412 p
= strchr (rs
->buf
.data (), '\0');
10413 addr
= remote_address_masked (addr
);
10414 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10415 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10418 getpkt (&rs
->buf
, 0);
10420 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10424 case PACKET_UNKNOWN
:
10429 internal_error (__FILE__
, __LINE__
,
10430 _("remote_insert_watchpoint: reached end of function"));
10434 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10435 CORE_ADDR start
, int length
)
10437 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10439 return diff
< length
;
10444 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10445 enum target_hw_bp_type type
, struct expression
*cond
)
10447 struct remote_state
*rs
= get_remote_state ();
10448 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10450 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10452 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10455 /* Make sure the remote is pointing at the right process, if
10457 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10458 set_general_process ();
10460 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10461 p
= strchr (rs
->buf
.data (), '\0');
10462 addr
= remote_address_masked (addr
);
10463 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10464 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10466 getpkt (&rs
->buf
, 0);
10468 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10471 case PACKET_UNKNOWN
:
10476 internal_error (__FILE__
, __LINE__
,
10477 _("remote_remove_watchpoint: reached end of function"));
10481 static int remote_hw_watchpoint_limit
= -1;
10482 static int remote_hw_watchpoint_length_limit
= -1;
10483 static int remote_hw_breakpoint_limit
= -1;
10486 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10488 if (remote_hw_watchpoint_length_limit
== 0)
10490 else if (remote_hw_watchpoint_length_limit
< 0)
10492 else if (len
<= remote_hw_watchpoint_length_limit
)
10499 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10501 if (type
== bp_hardware_breakpoint
)
10503 if (remote_hw_breakpoint_limit
== 0)
10505 else if (remote_hw_breakpoint_limit
< 0)
10507 else if (cnt
<= remote_hw_breakpoint_limit
)
10512 if (remote_hw_watchpoint_limit
== 0)
10514 else if (remote_hw_watchpoint_limit
< 0)
10518 else if (cnt
<= remote_hw_watchpoint_limit
)
10524 /* The to_stopped_by_sw_breakpoint method of target remote. */
10527 remote_target::stopped_by_sw_breakpoint ()
10529 struct thread_info
*thread
= inferior_thread ();
10531 return (thread
->priv
!= NULL
10532 && (get_remote_thread_info (thread
)->stop_reason
10533 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10536 /* The to_supports_stopped_by_sw_breakpoint method of target
10540 remote_target::supports_stopped_by_sw_breakpoint ()
10542 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10545 /* The to_stopped_by_hw_breakpoint method of target remote. */
10548 remote_target::stopped_by_hw_breakpoint ()
10550 struct thread_info
*thread
= inferior_thread ();
10552 return (thread
->priv
!= NULL
10553 && (get_remote_thread_info (thread
)->stop_reason
10554 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10557 /* The to_supports_stopped_by_hw_breakpoint method of target
10561 remote_target::supports_stopped_by_hw_breakpoint ()
10563 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10567 remote_target::stopped_by_watchpoint ()
10569 struct thread_info
*thread
= inferior_thread ();
10571 return (thread
->priv
!= NULL
10572 && (get_remote_thread_info (thread
)->stop_reason
10573 == TARGET_STOPPED_BY_WATCHPOINT
));
10577 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10579 struct thread_info
*thread
= inferior_thread ();
10581 if (thread
->priv
!= NULL
10582 && (get_remote_thread_info (thread
)->stop_reason
10583 == TARGET_STOPPED_BY_WATCHPOINT
))
10585 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10594 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10595 struct bp_target_info
*bp_tgt
)
10597 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10598 struct remote_state
*rs
;
10602 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10605 /* Make sure the remote is pointing at the right process, if
10607 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10608 set_general_process ();
10610 rs
= get_remote_state ();
10611 p
= rs
->buf
.data ();
10612 endbuf
= p
+ get_remote_packet_size ();
10618 addr
= remote_address_masked (addr
);
10619 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10620 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10622 if (supports_evaluation_of_breakpoint_conditions ())
10623 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10625 if (can_run_breakpoint_commands ())
10626 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10629 getpkt (&rs
->buf
, 0);
10631 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10634 if (rs
->buf
[1] == '.')
10636 message
= strchr (&rs
->buf
[2], '.');
10638 error (_("Remote failure reply: %s"), message
+ 1);
10641 case PACKET_UNKNOWN
:
10646 internal_error (__FILE__
, __LINE__
,
10647 _("remote_insert_hw_breakpoint: reached end of function"));
10652 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10653 struct bp_target_info
*bp_tgt
)
10656 struct remote_state
*rs
= get_remote_state ();
10657 char *p
= rs
->buf
.data ();
10658 char *endbuf
= p
+ get_remote_packet_size ();
10660 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10663 /* Make sure the remote is pointing at the right process, if
10665 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10666 set_general_process ();
10672 addr
= remote_address_masked (bp_tgt
->placed_address
);
10673 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10674 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10677 getpkt (&rs
->buf
, 0);
10679 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10682 case PACKET_UNKNOWN
:
10687 internal_error (__FILE__
, __LINE__
,
10688 _("remote_remove_hw_breakpoint: reached end of function"));
10691 /* Verify memory using the "qCRC:" request. */
10694 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10696 struct remote_state
*rs
= get_remote_state ();
10697 unsigned long host_crc
, target_crc
;
10700 /* It doesn't make sense to use qCRC if the remote target is
10701 connected but not running. */
10702 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10704 enum packet_result result
;
10706 /* Make sure the remote is pointing at the right process. */
10707 set_general_process ();
10709 /* FIXME: assumes lma can fit into long. */
10710 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10711 (long) lma
, (long) size
);
10714 /* Be clever; compute the host_crc before waiting for target
10716 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10718 getpkt (&rs
->buf
, 0);
10720 result
= packet_ok (rs
->buf
,
10721 &remote_protocol_packets
[PACKET_qCRC
]);
10722 if (result
== PACKET_ERROR
)
10724 else if (result
== PACKET_OK
)
10726 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10727 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10729 return (host_crc
== target_crc
);
10733 return simple_verify_memory (this, data
, lma
, size
);
10736 /* compare-sections command
10738 With no arguments, compares each loadable section in the exec bfd
10739 with the same memory range on the target, and reports mismatches.
10740 Useful for verifying the image on the target against the exec file. */
10743 compare_sections_command (const char *args
, int from_tty
)
10746 const char *sectname
;
10747 bfd_size_type size
;
10750 int mismatched
= 0;
10755 error (_("command cannot be used without an exec file"));
10757 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10763 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10765 if (!(s
->flags
& SEC_LOAD
))
10766 continue; /* Skip non-loadable section. */
10768 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10769 continue; /* Skip writeable sections */
10771 size
= bfd_section_size (s
);
10773 continue; /* Skip zero-length section. */
10775 sectname
= bfd_section_name (s
);
10776 if (args
&& strcmp (args
, sectname
) != 0)
10777 continue; /* Not the section selected by user. */
10779 matched
= 1; /* Do this section. */
10782 gdb::byte_vector
sectdata (size
);
10783 bfd_get_section_contents (exec_bfd
, s
, sectdata
.data (), 0, size
);
10785 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10788 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10789 paddress (target_gdbarch (), lma
),
10790 paddress (target_gdbarch (), lma
+ size
));
10792 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10793 paddress (target_gdbarch (), lma
),
10794 paddress (target_gdbarch (), lma
+ size
));
10796 printf_filtered ("matched.\n");
10799 printf_filtered ("MIS-MATCHED!\n");
10803 if (mismatched
> 0)
10804 warning (_("One or more sections of the target image does not match\n\
10805 the loaded file\n"));
10806 if (args
&& !matched
)
10807 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10810 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10811 into remote target. The number of bytes written to the remote
10812 target is returned, or -1 for error. */
10815 remote_target::remote_write_qxfer (const char *object_name
,
10816 const char *annex
, const gdb_byte
*writebuf
,
10817 ULONGEST offset
, LONGEST len
,
10818 ULONGEST
*xfered_len
,
10819 struct packet_config
*packet
)
10823 struct remote_state
*rs
= get_remote_state ();
10824 int max_size
= get_memory_write_packet_size ();
10826 if (packet_config_support (packet
) == PACKET_DISABLE
)
10827 return TARGET_XFER_E_IO
;
10829 /* Insert header. */
10830 i
= snprintf (rs
->buf
.data (), max_size
,
10831 "qXfer:%s:write:%s:%s:",
10832 object_name
, annex
? annex
: "",
10833 phex_nz (offset
, sizeof offset
));
10834 max_size
-= (i
+ 1);
10836 /* Escape as much data as fits into rs->buf. */
10837 buf_len
= remote_escape_output
10838 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10840 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10841 || getpkt_sane (&rs
->buf
, 0) < 0
10842 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10843 return TARGET_XFER_E_IO
;
10845 unpack_varlen_hex (rs
->buf
.data (), &n
);
10848 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10851 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10852 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10853 number of bytes read is returned, or 0 for EOF, or -1 for error.
10854 The number of bytes read may be less than LEN without indicating an
10855 EOF. PACKET is checked and updated to indicate whether the remote
10856 target supports this object. */
10859 remote_target::remote_read_qxfer (const char *object_name
,
10861 gdb_byte
*readbuf
, ULONGEST offset
,
10863 ULONGEST
*xfered_len
,
10864 struct packet_config
*packet
)
10866 struct remote_state
*rs
= get_remote_state ();
10867 LONGEST i
, n
, packet_len
;
10869 if (packet_config_support (packet
) == PACKET_DISABLE
)
10870 return TARGET_XFER_E_IO
;
10872 /* Check whether we've cached an end-of-object packet that matches
10874 if (rs
->finished_object
)
10876 if (strcmp (object_name
, rs
->finished_object
) == 0
10877 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10878 && offset
== rs
->finished_offset
)
10879 return TARGET_XFER_EOF
;
10882 /* Otherwise, we're now reading something different. Discard
10884 xfree (rs
->finished_object
);
10885 xfree (rs
->finished_annex
);
10886 rs
->finished_object
= NULL
;
10887 rs
->finished_annex
= NULL
;
10890 /* Request only enough to fit in a single packet. The actual data
10891 may not, since we don't know how much of it will need to be escaped;
10892 the target is free to respond with slightly less data. We subtract
10893 five to account for the response type and the protocol frame. */
10894 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10895 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
10896 "qXfer:%s:read:%s:%s,%s",
10897 object_name
, annex
? annex
: "",
10898 phex_nz (offset
, sizeof offset
),
10899 phex_nz (n
, sizeof n
));
10900 i
= putpkt (rs
->buf
);
10902 return TARGET_XFER_E_IO
;
10905 packet_len
= getpkt_sane (&rs
->buf
, 0);
10906 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10907 return TARGET_XFER_E_IO
;
10909 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10910 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
10912 /* 'm' means there is (or at least might be) more data after this
10913 batch. That does not make sense unless there's at least one byte
10914 of data in this reply. */
10915 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10916 error (_("Remote qXfer reply contained no data."));
10918 /* Got some data. */
10919 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
10920 packet_len
- 1, readbuf
, n
);
10922 /* 'l' is an EOF marker, possibly including a final block of data,
10923 or possibly empty. If we have the final block of a non-empty
10924 object, record this fact to bypass a subsequent partial read. */
10925 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10927 rs
->finished_object
= xstrdup (object_name
);
10928 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10929 rs
->finished_offset
= offset
+ i
;
10933 return TARGET_XFER_EOF
;
10937 return TARGET_XFER_OK
;
10941 enum target_xfer_status
10942 remote_target::xfer_partial (enum target_object object
,
10943 const char *annex
, gdb_byte
*readbuf
,
10944 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10945 ULONGEST
*xfered_len
)
10947 struct remote_state
*rs
;
10951 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10953 set_remote_traceframe ();
10954 set_general_thread (inferior_ptid
);
10956 rs
= get_remote_state ();
10958 /* Handle memory using the standard memory routines. */
10959 if (object
== TARGET_OBJECT_MEMORY
)
10961 /* If the remote target is connected but not running, we should
10962 pass this request down to a lower stratum (e.g. the executable
10964 if (!target_has_execution
)
10965 return TARGET_XFER_EOF
;
10967 if (writebuf
!= NULL
)
10968 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10971 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
10975 /* Handle extra signal info using qxfer packets. */
10976 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10979 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
10980 xfered_len
, &remote_protocol_packets
10981 [PACKET_qXfer_siginfo_read
]);
10983 return remote_write_qxfer ("siginfo", annex
,
10984 writebuf
, offset
, len
, xfered_len
,
10985 &remote_protocol_packets
10986 [PACKET_qXfer_siginfo_write
]);
10989 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10992 return remote_read_qxfer ("statictrace", annex
,
10993 readbuf
, offset
, len
, xfered_len
,
10994 &remote_protocol_packets
10995 [PACKET_qXfer_statictrace_read
]);
10997 return TARGET_XFER_E_IO
;
11000 /* Only handle flash writes. */
11001 if (writebuf
!= NULL
)
11005 case TARGET_OBJECT_FLASH
:
11006 return remote_flash_write (offset
, len
, xfered_len
,
11010 return TARGET_XFER_E_IO
;
11014 /* Map pre-existing objects onto letters. DO NOT do this for new
11015 objects!!! Instead specify new query packets. */
11018 case TARGET_OBJECT_AVR
:
11022 case TARGET_OBJECT_AUXV
:
11023 gdb_assert (annex
== NULL
);
11024 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
11026 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
11028 case TARGET_OBJECT_AVAILABLE_FEATURES
:
11029 return remote_read_qxfer
11030 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
11031 &remote_protocol_packets
[PACKET_qXfer_features
]);
11033 case TARGET_OBJECT_LIBRARIES
:
11034 return remote_read_qxfer
11035 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
11036 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
11038 case TARGET_OBJECT_LIBRARIES_SVR4
:
11039 return remote_read_qxfer
11040 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
11041 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
11043 case TARGET_OBJECT_MEMORY_MAP
:
11044 gdb_assert (annex
== NULL
);
11045 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
11047 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
11049 case TARGET_OBJECT_OSDATA
:
11050 /* Should only get here if we're connected. */
11051 gdb_assert (rs
->remote_desc
);
11052 return remote_read_qxfer
11053 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
11054 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
11056 case TARGET_OBJECT_THREADS
:
11057 gdb_assert (annex
== NULL
);
11058 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
11060 &remote_protocol_packets
[PACKET_qXfer_threads
]);
11062 case TARGET_OBJECT_TRACEFRAME_INFO
:
11063 gdb_assert (annex
== NULL
);
11064 return remote_read_qxfer
11065 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
11066 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
11068 case TARGET_OBJECT_FDPIC
:
11069 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
11071 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
11073 case TARGET_OBJECT_OPENVMS_UIB
:
11074 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
11076 &remote_protocol_packets
[PACKET_qXfer_uib
]);
11078 case TARGET_OBJECT_BTRACE
:
11079 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
11081 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
11083 case TARGET_OBJECT_BTRACE_CONF
:
11084 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
11086 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
11088 case TARGET_OBJECT_EXEC_FILE
:
11089 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
11091 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
11094 return TARGET_XFER_E_IO
;
11097 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
11098 large enough let the caller deal with it. */
11099 if (len
< get_remote_packet_size ())
11100 return TARGET_XFER_E_IO
;
11101 len
= get_remote_packet_size ();
11103 /* Except for querying the minimum buffer size, target must be open. */
11104 if (!rs
->remote_desc
)
11105 error (_("remote query is only available after target open"));
11107 gdb_assert (annex
!= NULL
);
11108 gdb_assert (readbuf
!= NULL
);
11110 p2
= rs
->buf
.data ();
11112 *p2
++ = query_type
;
11114 /* We used one buffer char for the remote protocol q command and
11115 another for the query type. As the remote protocol encapsulation
11116 uses 4 chars plus one extra in case we are debugging
11117 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11120 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11122 /* Bad caller may have sent forbidden characters. */
11123 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11128 gdb_assert (annex
[i
] == '\0');
11130 i
= putpkt (rs
->buf
);
11132 return TARGET_XFER_E_IO
;
11134 getpkt (&rs
->buf
, 0);
11135 strcpy ((char *) readbuf
, rs
->buf
.data ());
11137 *xfered_len
= strlen ((char *) readbuf
);
11138 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11141 /* Implementation of to_get_memory_xfer_limit. */
11144 remote_target::get_memory_xfer_limit ()
11146 return get_memory_write_packet_size ();
11150 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11151 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11152 CORE_ADDR
*found_addrp
)
11154 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11155 struct remote_state
*rs
= get_remote_state ();
11156 int max_size
= get_memory_write_packet_size ();
11157 struct packet_config
*packet
=
11158 &remote_protocol_packets
[PACKET_qSearch_memory
];
11159 /* Number of packet bytes used to encode the pattern;
11160 this could be more than PATTERN_LEN due to escape characters. */
11161 int escaped_pattern_len
;
11162 /* Amount of pattern that was encodable in the packet. */
11163 int used_pattern_len
;
11166 ULONGEST found_addr
;
11168 /* Don't go to the target if we don't have to. This is done before
11169 checking packet_config_support to avoid the possibility that a
11170 success for this edge case means the facility works in
11172 if (pattern_len
> search_space_len
)
11174 if (pattern_len
== 0)
11176 *found_addrp
= start_addr
;
11180 /* If we already know the packet isn't supported, fall back to the simple
11181 way of searching memory. */
11183 if (packet_config_support (packet
) == PACKET_DISABLE
)
11185 /* Target doesn't provided special support, fall back and use the
11186 standard support (copy memory and do the search here). */
11187 return simple_search_memory (this, start_addr
, search_space_len
,
11188 pattern
, pattern_len
, found_addrp
);
11191 /* Make sure the remote is pointing at the right process. */
11192 set_general_process ();
11194 /* Insert header. */
11195 i
= snprintf (rs
->buf
.data (), max_size
,
11196 "qSearch:memory:%s;%s;",
11197 phex_nz (start_addr
, addr_size
),
11198 phex_nz (search_space_len
, sizeof (search_space_len
)));
11199 max_size
-= (i
+ 1);
11201 /* Escape as much data as fits into rs->buf. */
11202 escaped_pattern_len
=
11203 remote_escape_output (pattern
, pattern_len
, 1,
11204 (gdb_byte
*) rs
->buf
.data () + i
,
11205 &used_pattern_len
, max_size
);
11207 /* Bail if the pattern is too large. */
11208 if (used_pattern_len
!= pattern_len
)
11209 error (_("Pattern is too large to transmit to remote target."));
11211 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11212 || getpkt_sane (&rs
->buf
, 0) < 0
11213 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11215 /* The request may not have worked because the command is not
11216 supported. If so, fall back to the simple way. */
11217 if (packet_config_support (packet
) == PACKET_DISABLE
)
11219 return simple_search_memory (this, start_addr
, search_space_len
,
11220 pattern
, pattern_len
, found_addrp
);
11225 if (rs
->buf
[0] == '0')
11227 else if (rs
->buf
[0] == '1')
11230 if (rs
->buf
[1] != ',')
11231 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11232 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11233 *found_addrp
= found_addr
;
11236 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11242 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11244 struct remote_state
*rs
= get_remote_state ();
11245 char *p
= rs
->buf
.data ();
11247 if (!rs
->remote_desc
)
11248 error (_("remote rcmd is only available after target open"));
11250 /* Send a NULL command across as an empty command. */
11251 if (command
== NULL
)
11254 /* The query prefix. */
11255 strcpy (rs
->buf
.data (), "qRcmd,");
11256 p
= strchr (rs
->buf
.data (), '\0');
11258 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11259 > get_remote_packet_size ())
11260 error (_("\"monitor\" command ``%s'' is too long."), command
);
11262 /* Encode the actual command. */
11263 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11265 if (putpkt (rs
->buf
) < 0)
11266 error (_("Communication problem with target."));
11268 /* get/display the response */
11273 /* XXX - see also remote_get_noisy_reply(). */
11274 QUIT
; /* Allow user to bail out with ^C. */
11276 if (getpkt_sane (&rs
->buf
, 0) == -1)
11278 /* Timeout. Continue to (try to) read responses.
11279 This is better than stopping with an error, assuming the stub
11280 is still executing the (long) monitor command.
11281 If needed, the user can interrupt gdb using C-c, obtaining
11282 an effect similar to stop on timeout. */
11285 buf
= rs
->buf
.data ();
11286 if (buf
[0] == '\0')
11287 error (_("Target does not support this command."));
11288 if (buf
[0] == 'O' && buf
[1] != 'K')
11290 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11293 if (strcmp (buf
, "OK") == 0)
11295 if (strlen (buf
) == 3 && buf
[0] == 'E'
11296 && isdigit (buf
[1]) && isdigit (buf
[2]))
11298 error (_("Protocol error with Rcmd"));
11300 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11302 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11304 fputc_unfiltered (c
, outbuf
);
11310 std::vector
<mem_region
>
11311 remote_target::memory_map ()
11313 std::vector
<mem_region
> result
;
11314 gdb::optional
<gdb::char_vector
> text
11315 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11318 result
= parse_memory_map (text
->data ());
11324 packet_command (const char *args
, int from_tty
)
11326 remote_target
*remote
= get_current_remote_target ();
11328 if (remote
== nullptr)
11329 error (_("command can only be used with remote target"));
11331 remote
->packet_command (args
, from_tty
);
11335 remote_target::packet_command (const char *args
, int from_tty
)
11338 error (_("remote-packet command requires packet text as argument"));
11340 puts_filtered ("sending: ");
11341 print_packet (args
);
11342 puts_filtered ("\n");
11345 remote_state
*rs
= get_remote_state ();
11347 getpkt (&rs
->buf
, 0);
11348 puts_filtered ("received: ");
11349 print_packet (rs
->buf
.data ());
11350 puts_filtered ("\n");
11354 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11356 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11358 static void threadset_test_cmd (char *cmd
, int tty
);
11360 static void threadalive_test (char *cmd
, int tty
);
11362 static void threadlist_test_cmd (char *cmd
, int tty
);
11364 int get_and_display_threadinfo (threadref
*ref
);
11366 static void threadinfo_test_cmd (char *cmd
, int tty
);
11368 static int thread_display_step (threadref
*ref
, void *context
);
11370 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11372 static void init_remote_threadtests (void);
11374 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11377 threadset_test_cmd (const char *cmd
, int tty
)
11379 int sample_thread
= SAMPLE_THREAD
;
11381 printf_filtered (_("Remote threadset test\n"));
11382 set_general_thread (sample_thread
);
11387 threadalive_test (const char *cmd
, int tty
)
11389 int sample_thread
= SAMPLE_THREAD
;
11390 int pid
= inferior_ptid
.pid ();
11391 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11393 if (remote_thread_alive (ptid
))
11394 printf_filtered ("PASS: Thread alive test\n");
11396 printf_filtered ("FAIL: Thread alive test\n");
11399 void output_threadid (char *title
, threadref
*ref
);
11402 output_threadid (char *title
, threadref
*ref
)
11406 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11408 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11412 threadlist_test_cmd (const char *cmd
, int tty
)
11415 threadref nextthread
;
11416 int done
, result_count
;
11417 threadref threadlist
[3];
11419 printf_filtered ("Remote Threadlist test\n");
11420 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11421 &result_count
, &threadlist
[0]))
11422 printf_filtered ("FAIL: threadlist test\n");
11425 threadref
*scan
= threadlist
;
11426 threadref
*limit
= scan
+ result_count
;
11428 while (scan
< limit
)
11429 output_threadid (" thread ", scan
++);
11434 display_thread_info (struct gdb_ext_thread_info
*info
)
11436 output_threadid ("Threadid: ", &info
->threadid
);
11437 printf_filtered ("Name: %s\n ", info
->shortname
);
11438 printf_filtered ("State: %s\n", info
->display
);
11439 printf_filtered ("other: %s\n\n", info
->more_display
);
11443 get_and_display_threadinfo (threadref
*ref
)
11447 struct gdb_ext_thread_info threadinfo
;
11449 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11450 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11451 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11452 display_thread_info (&threadinfo
);
11457 threadinfo_test_cmd (const char *cmd
, int tty
)
11459 int athread
= SAMPLE_THREAD
;
11463 int_to_threadref (&thread
, athread
);
11464 printf_filtered ("Remote Threadinfo test\n");
11465 if (!get_and_display_threadinfo (&thread
))
11466 printf_filtered ("FAIL cannot get thread info\n");
11470 thread_display_step (threadref
*ref
, void *context
)
11472 /* output_threadid(" threadstep ",ref); *//* simple test */
11473 return get_and_display_threadinfo (ref
);
11477 threadlist_update_test_cmd (const char *cmd
, int tty
)
11479 printf_filtered ("Remote Threadlist update test\n");
11480 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11484 init_remote_threadtests (void)
11486 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11487 _("Fetch and print the remote list of "
11488 "thread identifiers, one pkt only."));
11489 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11490 _("Fetch and display info about one thread."));
11491 add_com ("tset", class_obscure
, threadset_test_cmd
,
11492 _("Test setting to a different thread."));
11493 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11494 _("Iterate through updating all remote thread info."));
11495 add_com ("talive", class_obscure
, threadalive_test
,
11496 _("Remote thread alive test."));
11501 /* Convert a thread ID to a string. */
11504 remote_target::pid_to_str (ptid_t ptid
)
11506 struct remote_state
*rs
= get_remote_state ();
11508 if (ptid
== null_ptid
)
11509 return normal_pid_to_str (ptid
);
11510 else if (ptid
.is_pid ())
11512 /* Printing an inferior target id. */
11514 /* When multi-process extensions are off, there's no way in the
11515 remote protocol to know the remote process id, if there's any
11516 at all. There's one exception --- when we're connected with
11517 target extended-remote, and we manually attached to a process
11518 with "attach PID". We don't record anywhere a flag that
11519 allows us to distinguish that case from the case of
11520 connecting with extended-remote and the stub already being
11521 attached to a process, and reporting yes to qAttached, hence
11522 no smart special casing here. */
11523 if (!remote_multi_process_p (rs
))
11524 return "Remote target";
11526 return normal_pid_to_str (ptid
);
11530 if (magic_null_ptid
== ptid
)
11531 return "Thread <main>";
11532 else if (remote_multi_process_p (rs
))
11533 if (ptid
.lwp () == 0)
11534 return normal_pid_to_str (ptid
);
11536 return string_printf ("Thread %d.%ld",
11537 ptid
.pid (), ptid
.lwp ());
11539 return string_printf ("Thread %ld", ptid
.lwp ());
11543 /* Get the address of the thread local variable in OBJFILE which is
11544 stored at OFFSET within the thread local storage for thread PTID. */
11547 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11550 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11552 struct remote_state
*rs
= get_remote_state ();
11553 char *p
= rs
->buf
.data ();
11554 char *endp
= p
+ get_remote_packet_size ();
11555 enum packet_result result
;
11557 strcpy (p
, "qGetTLSAddr:");
11559 p
= write_ptid (p
, endp
, ptid
);
11561 p
+= hexnumstr (p
, offset
);
11563 p
+= hexnumstr (p
, lm
);
11567 getpkt (&rs
->buf
, 0);
11568 result
= packet_ok (rs
->buf
,
11569 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11570 if (result
== PACKET_OK
)
11574 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11577 else if (result
== PACKET_UNKNOWN
)
11578 throw_error (TLS_GENERIC_ERROR
,
11579 _("Remote target doesn't support qGetTLSAddr packet"));
11581 throw_error (TLS_GENERIC_ERROR
,
11582 _("Remote target failed to process qGetTLSAddr request"));
11585 throw_error (TLS_GENERIC_ERROR
,
11586 _("TLS not supported or disabled on this target"));
11591 /* Provide thread local base, i.e. Thread Information Block address.
11592 Returns 1 if ptid is found and thread_local_base is non zero. */
11595 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11597 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11599 struct remote_state
*rs
= get_remote_state ();
11600 char *p
= rs
->buf
.data ();
11601 char *endp
= p
+ get_remote_packet_size ();
11602 enum packet_result result
;
11604 strcpy (p
, "qGetTIBAddr:");
11606 p
= write_ptid (p
, endp
, ptid
);
11610 getpkt (&rs
->buf
, 0);
11611 result
= packet_ok (rs
->buf
,
11612 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11613 if (result
== PACKET_OK
)
11616 unpack_varlen_hex (rs
->buf
.data (), &val
);
11618 *addr
= (CORE_ADDR
) val
;
11621 else if (result
== PACKET_UNKNOWN
)
11622 error (_("Remote target doesn't support qGetTIBAddr packet"));
11624 error (_("Remote target failed to process qGetTIBAddr request"));
11627 error (_("qGetTIBAddr not supported or disabled on this target"));
11632 /* Support for inferring a target description based on the current
11633 architecture and the size of a 'g' packet. While the 'g' packet
11634 can have any size (since optional registers can be left off the
11635 end), some sizes are easily recognizable given knowledge of the
11636 approximate architecture. */
11638 struct remote_g_packet_guess
11640 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11647 const struct target_desc
*tdesc
;
11650 struct remote_g_packet_data
: public allocate_on_obstack
11652 std::vector
<remote_g_packet_guess
> guesses
;
11655 static struct gdbarch_data
*remote_g_packet_data_handle
;
11658 remote_g_packet_data_init (struct obstack
*obstack
)
11660 return new (obstack
) remote_g_packet_data
;
11664 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11665 const struct target_desc
*tdesc
)
11667 struct remote_g_packet_data
*data
11668 = ((struct remote_g_packet_data
*)
11669 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11671 gdb_assert (tdesc
!= NULL
);
11673 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11674 if (guess
.bytes
== bytes
)
11675 internal_error (__FILE__
, __LINE__
,
11676 _("Duplicate g packet description added for size %d"),
11679 data
->guesses
.emplace_back (bytes
, tdesc
);
11682 /* Return true if remote_read_description would do anything on this target
11683 and architecture, false otherwise. */
11686 remote_read_description_p (struct target_ops
*target
)
11688 struct remote_g_packet_data
*data
11689 = ((struct remote_g_packet_data
*)
11690 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11692 return !data
->guesses
.empty ();
11695 const struct target_desc
*
11696 remote_target::read_description ()
11698 struct remote_g_packet_data
*data
11699 = ((struct remote_g_packet_data
*)
11700 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11702 /* Do not try this during initial connection, when we do not know
11703 whether there is a running but stopped thread. */
11704 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
11705 return beneath ()->read_description ();
11707 if (!data
->guesses
.empty ())
11709 int bytes
= send_g_packet ();
11711 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11712 if (guess
.bytes
== bytes
)
11713 return guess
.tdesc
;
11715 /* We discard the g packet. A minor optimization would be to
11716 hold on to it, and fill the register cache once we have selected
11717 an architecture, but it's too tricky to do safely. */
11720 return beneath ()->read_description ();
11723 /* Remote file transfer support. This is host-initiated I/O, not
11724 target-initiated; for target-initiated, see remote-fileio.c. */
11726 /* If *LEFT is at least the length of STRING, copy STRING to
11727 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11728 decrease *LEFT. Otherwise raise an error. */
11731 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11733 int len
= strlen (string
);
11736 error (_("Packet too long for target."));
11738 memcpy (*buffer
, string
, len
);
11742 /* NUL-terminate the buffer as a convenience, if there is
11748 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11749 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11750 decrease *LEFT. Otherwise raise an error. */
11753 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11756 if (2 * len
> *left
)
11757 error (_("Packet too long for target."));
11759 bin2hex (bytes
, *buffer
, len
);
11760 *buffer
+= 2 * len
;
11763 /* NUL-terminate the buffer as a convenience, if there is
11769 /* If *LEFT is large enough, convert VALUE to hex and add it to
11770 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11771 decrease *LEFT. Otherwise raise an error. */
11774 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11776 int len
= hexnumlen (value
);
11779 error (_("Packet too long for target."));
11781 hexnumstr (*buffer
, value
);
11785 /* NUL-terminate the buffer as a convenience, if there is
11791 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11792 value, *REMOTE_ERRNO to the remote error number or zero if none
11793 was included, and *ATTACHMENT to point to the start of the annex
11794 if any. The length of the packet isn't needed here; there may
11795 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11797 Return 0 if the packet could be parsed, -1 if it could not. If
11798 -1 is returned, the other variables may not be initialized. */
11801 remote_hostio_parse_result (char *buffer
, int *retcode
,
11802 int *remote_errno
, char **attachment
)
11807 *attachment
= NULL
;
11809 if (buffer
[0] != 'F')
11813 *retcode
= strtol (&buffer
[1], &p
, 16);
11814 if (errno
!= 0 || p
== &buffer
[1])
11817 /* Check for ",errno". */
11821 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11822 if (errno
!= 0 || p
+ 1 == p2
)
11827 /* Check for ";attachment". If there is no attachment, the
11828 packet should end here. */
11831 *attachment
= p
+ 1;
11834 else if (*p
== '\0')
11840 /* Send a prepared I/O packet to the target and read its response.
11841 The prepared packet is in the global RS->BUF before this function
11842 is called, and the answer is there when we return.
11844 COMMAND_BYTES is the length of the request to send, which may include
11845 binary data. WHICH_PACKET is the packet configuration to check
11846 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11847 is set to the error number and -1 is returned. Otherwise the value
11848 returned by the function is returned.
11850 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11851 attachment is expected; an error will be reported if there's a
11852 mismatch. If one is found, *ATTACHMENT will be set to point into
11853 the packet buffer and *ATTACHMENT_LEN will be set to the
11854 attachment's length. */
11857 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11858 int *remote_errno
, char **attachment
,
11859 int *attachment_len
)
11861 struct remote_state
*rs
= get_remote_state ();
11862 int ret
, bytes_read
;
11863 char *attachment_tmp
;
11865 if (packet_support (which_packet
) == PACKET_DISABLE
)
11867 *remote_errno
= FILEIO_ENOSYS
;
11871 putpkt_binary (rs
->buf
.data (), command_bytes
);
11872 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11874 /* If it timed out, something is wrong. Don't try to parse the
11876 if (bytes_read
< 0)
11878 *remote_errno
= FILEIO_EINVAL
;
11882 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11885 *remote_errno
= FILEIO_EINVAL
;
11887 case PACKET_UNKNOWN
:
11888 *remote_errno
= FILEIO_ENOSYS
;
11894 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
11897 *remote_errno
= FILEIO_EINVAL
;
11901 /* Make sure we saw an attachment if and only if we expected one. */
11902 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11903 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11905 *remote_errno
= FILEIO_EINVAL
;
11909 /* If an attachment was found, it must point into the packet buffer;
11910 work out how many bytes there were. */
11911 if (attachment_tmp
!= NULL
)
11913 *attachment
= attachment_tmp
;
11914 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
11920 /* See declaration.h. */
11923 readahead_cache::invalidate ()
11928 /* See declaration.h. */
11931 readahead_cache::invalidate_fd (int fd
)
11933 if (this->fd
== fd
)
11937 /* Set the filesystem remote_hostio functions that take FILENAME
11938 arguments will use. Return 0 on success, or -1 if an error
11939 occurs (and set *REMOTE_ERRNO). */
11942 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
11945 struct remote_state
*rs
= get_remote_state ();
11946 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11947 char *p
= rs
->buf
.data ();
11948 int left
= get_remote_packet_size () - 1;
11952 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11955 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11958 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11960 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11961 remote_buffer_add_string (&p
, &left
, arg
);
11963 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
11964 remote_errno
, NULL
, NULL
);
11966 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11970 rs
->fs_pid
= required_pid
;
11975 /* Implementation of to_fileio_open. */
11978 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
11979 int flags
, int mode
, int warn_if_slow
,
11982 struct remote_state
*rs
= get_remote_state ();
11983 char *p
= rs
->buf
.data ();
11984 int left
= get_remote_packet_size () - 1;
11988 static int warning_issued
= 0;
11990 printf_unfiltered (_("Reading %s from remote target...\n"),
11993 if (!warning_issued
)
11995 warning (_("File transfers from remote targets can be slow."
11996 " Use \"set sysroot\" to access files locally"
11998 warning_issued
= 1;
12002 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12005 remote_buffer_add_string (&p
, &left
, "vFile:open:");
12007 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12008 strlen (filename
));
12009 remote_buffer_add_string (&p
, &left
, ",");
12011 remote_buffer_add_int (&p
, &left
, flags
);
12012 remote_buffer_add_string (&p
, &left
, ",");
12014 remote_buffer_add_int (&p
, &left
, mode
);
12016 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
12017 remote_errno
, NULL
, NULL
);
12021 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
12022 int flags
, int mode
, int warn_if_slow
,
12025 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
12029 /* Implementation of to_fileio_pwrite. */
12032 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12033 ULONGEST offset
, int *remote_errno
)
12035 struct remote_state
*rs
= get_remote_state ();
12036 char *p
= rs
->buf
.data ();
12037 int left
= get_remote_packet_size ();
12040 rs
->readahead_cache
.invalidate_fd (fd
);
12042 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
12044 remote_buffer_add_int (&p
, &left
, fd
);
12045 remote_buffer_add_string (&p
, &left
, ",");
12047 remote_buffer_add_int (&p
, &left
, offset
);
12048 remote_buffer_add_string (&p
, &left
, ",");
12050 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
12051 (get_remote_packet_size ()
12052 - (p
- rs
->buf
.data ())));
12054 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
12055 remote_errno
, NULL
, NULL
);
12059 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12060 ULONGEST offset
, int *remote_errno
)
12062 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
12065 /* Helper for the implementation of to_fileio_pread. Read the file
12066 from the remote side with vFile:pread. */
12069 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
12070 ULONGEST offset
, int *remote_errno
)
12072 struct remote_state
*rs
= get_remote_state ();
12073 char *p
= rs
->buf
.data ();
12075 int left
= get_remote_packet_size ();
12076 int ret
, attachment_len
;
12079 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
12081 remote_buffer_add_int (&p
, &left
, fd
);
12082 remote_buffer_add_string (&p
, &left
, ",");
12084 remote_buffer_add_int (&p
, &left
, len
);
12085 remote_buffer_add_string (&p
, &left
, ",");
12087 remote_buffer_add_int (&p
, &left
, offset
);
12089 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
12090 remote_errno
, &attachment
,
12096 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12098 if (read_len
!= ret
)
12099 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
12104 /* See declaration.h. */
12107 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12111 && this->offset
<= offset
12112 && offset
< this->offset
+ this->bufsize
)
12114 ULONGEST max
= this->offset
+ this->bufsize
;
12116 if (offset
+ len
> max
)
12117 len
= max
- offset
;
12119 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12126 /* Implementation of to_fileio_pread. */
12129 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12130 ULONGEST offset
, int *remote_errno
)
12133 struct remote_state
*rs
= get_remote_state ();
12134 readahead_cache
*cache
= &rs
->readahead_cache
;
12136 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12139 cache
->hit_count
++;
12142 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12143 pulongest (cache
->hit_count
));
12147 cache
->miss_count
++;
12149 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12150 pulongest (cache
->miss_count
));
12153 cache
->offset
= offset
;
12154 cache
->bufsize
= get_remote_packet_size ();
12155 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12157 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12158 cache
->offset
, remote_errno
);
12161 cache
->invalidate_fd (fd
);
12165 cache
->bufsize
= ret
;
12166 return cache
->pread (fd
, read_buf
, len
, offset
);
12170 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12171 ULONGEST offset
, int *remote_errno
)
12173 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12176 /* Implementation of to_fileio_close. */
12179 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12181 struct remote_state
*rs
= get_remote_state ();
12182 char *p
= rs
->buf
.data ();
12183 int left
= get_remote_packet_size () - 1;
12185 rs
->readahead_cache
.invalidate_fd (fd
);
12187 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12189 remote_buffer_add_int (&p
, &left
, fd
);
12191 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12192 remote_errno
, NULL
, NULL
);
12196 remote_target::fileio_close (int fd
, int *remote_errno
)
12198 return remote_hostio_close (fd
, remote_errno
);
12201 /* Implementation of to_fileio_unlink. */
12204 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12207 struct remote_state
*rs
= get_remote_state ();
12208 char *p
= rs
->buf
.data ();
12209 int left
= get_remote_packet_size () - 1;
12211 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12214 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12216 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12217 strlen (filename
));
12219 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12220 remote_errno
, NULL
, NULL
);
12224 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12227 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12230 /* Implementation of to_fileio_readlink. */
12232 gdb::optional
<std::string
>
12233 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12236 struct remote_state
*rs
= get_remote_state ();
12237 char *p
= rs
->buf
.data ();
12239 int left
= get_remote_packet_size ();
12240 int len
, attachment_len
;
12243 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12246 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12248 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12249 strlen (filename
));
12251 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12252 remote_errno
, &attachment
,
12258 std::string
ret (len
, '\0');
12260 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12261 (gdb_byte
*) &ret
[0], len
);
12262 if (read_len
!= len
)
12263 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12268 /* Implementation of to_fileio_fstat. */
12271 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12273 struct remote_state
*rs
= get_remote_state ();
12274 char *p
= rs
->buf
.data ();
12275 int left
= get_remote_packet_size ();
12276 int attachment_len
, ret
;
12278 struct fio_stat fst
;
12281 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12283 remote_buffer_add_int (&p
, &left
, fd
);
12285 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12286 remote_errno
, &attachment
,
12290 if (*remote_errno
!= FILEIO_ENOSYS
)
12293 /* Strictly we should return -1, ENOSYS here, but when
12294 "set sysroot remote:" was implemented in August 2008
12295 BFD's need for a stat function was sidestepped with
12296 this hack. This was not remedied until March 2015
12297 so we retain the previous behavior to avoid breaking
12300 Note that the memset is a March 2015 addition; older
12301 GDBs set st_size *and nothing else* so the structure
12302 would have garbage in all other fields. This might
12303 break something but retaining the previous behavior
12304 here would be just too wrong. */
12306 memset (st
, 0, sizeof (struct stat
));
12307 st
->st_size
= INT_MAX
;
12311 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12312 (gdb_byte
*) &fst
, sizeof (fst
));
12314 if (read_len
!= ret
)
12315 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12317 if (read_len
!= sizeof (fst
))
12318 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12319 read_len
, (int) sizeof (fst
));
12321 remote_fileio_to_host_stat (&fst
, st
);
12326 /* Implementation of to_filesystem_is_local. */
12329 remote_target::filesystem_is_local ()
12331 /* Valgrind GDB presents itself as a remote target but works
12332 on the local filesystem: it does not implement remote get
12333 and users are not expected to set a sysroot. To handle
12334 this case we treat the remote filesystem as local if the
12335 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12336 does not support vFile:open. */
12337 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12339 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12341 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12343 int fd
, remote_errno
;
12345 /* Try opening a file to probe support. The supplied
12346 filename is irrelevant, we only care about whether
12347 the stub recognizes the packet or not. */
12348 fd
= remote_hostio_open (NULL
, "just probing",
12349 FILEIO_O_RDONLY
, 0700, 0,
12353 remote_hostio_close (fd
, &remote_errno
);
12355 ps
= packet_support (PACKET_vFile_open
);
12358 if (ps
== PACKET_DISABLE
)
12360 static int warning_issued
= 0;
12362 if (!warning_issued
)
12364 warning (_("remote target does not support file"
12365 " transfer, attempting to access files"
12366 " from local filesystem."));
12367 warning_issued
= 1;
12378 remote_fileio_errno_to_host (int errnum
)
12384 case FILEIO_ENOENT
:
12392 case FILEIO_EACCES
:
12394 case FILEIO_EFAULT
:
12398 case FILEIO_EEXIST
:
12400 case FILEIO_ENODEV
:
12402 case FILEIO_ENOTDIR
:
12404 case FILEIO_EISDIR
:
12406 case FILEIO_EINVAL
:
12408 case FILEIO_ENFILE
:
12410 case FILEIO_EMFILE
:
12414 case FILEIO_ENOSPC
:
12416 case FILEIO_ESPIPE
:
12420 case FILEIO_ENOSYS
:
12422 case FILEIO_ENAMETOOLONG
:
12423 return ENAMETOOLONG
;
12429 remote_hostio_error (int errnum
)
12431 int host_error
= remote_fileio_errno_to_host (errnum
);
12433 if (host_error
== -1)
12434 error (_("Unknown remote I/O error %d"), errnum
);
12436 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12439 /* A RAII wrapper around a remote file descriptor. */
12441 class scoped_remote_fd
12444 scoped_remote_fd (remote_target
*remote
, int fd
)
12445 : m_remote (remote
), m_fd (fd
)
12449 ~scoped_remote_fd ()
12456 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12460 /* Swallow exception before it escapes the dtor. If
12461 something goes wrong, likely the connection is gone,
12462 and there's nothing else that can be done. */
12467 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12469 /* Release ownership of the file descriptor, and return it. */
12470 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12477 /* Return the owned file descriptor. */
12478 int get () const noexcept
12484 /* The remote target. */
12485 remote_target
*m_remote
;
12487 /* The owned remote I/O file descriptor. */
12492 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12494 remote_target
*remote
= get_current_remote_target ();
12496 if (remote
== nullptr)
12497 error (_("command can only be used with remote target"));
12499 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12503 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12506 int retcode
, remote_errno
, bytes
, io_size
;
12507 int bytes_in_buffer
;
12511 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12513 perror_with_name (local_file
);
12515 scoped_remote_fd fd
12516 (this, remote_hostio_open (NULL
,
12517 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12519 0700, 0, &remote_errno
));
12520 if (fd
.get () == -1)
12521 remote_hostio_error (remote_errno
);
12523 /* Send up to this many bytes at once. They won't all fit in the
12524 remote packet limit, so we'll transfer slightly fewer. */
12525 io_size
= get_remote_packet_size ();
12526 gdb::byte_vector
buffer (io_size
);
12528 bytes_in_buffer
= 0;
12531 while (bytes_in_buffer
|| !saw_eof
)
12535 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12536 io_size
- bytes_in_buffer
,
12540 if (ferror (file
.get ()))
12541 error (_("Error reading %s."), local_file
);
12544 /* EOF. Unless there is something still in the
12545 buffer from the last iteration, we are done. */
12547 if (bytes_in_buffer
== 0)
12555 bytes
+= bytes_in_buffer
;
12556 bytes_in_buffer
= 0;
12558 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12559 offset
, &remote_errno
);
12562 remote_hostio_error (remote_errno
);
12563 else if (retcode
== 0)
12564 error (_("Remote write of %d bytes returned 0!"), bytes
);
12565 else if (retcode
< bytes
)
12567 /* Short write. Save the rest of the read data for the next
12569 bytes_in_buffer
= bytes
- retcode
;
12570 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12576 if (remote_hostio_close (fd
.release (), &remote_errno
))
12577 remote_hostio_error (remote_errno
);
12580 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12584 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12586 remote_target
*remote
= get_current_remote_target ();
12588 if (remote
== nullptr)
12589 error (_("command can only be used with remote target"));
12591 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12595 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12598 int remote_errno
, bytes
, io_size
;
12601 scoped_remote_fd fd
12602 (this, remote_hostio_open (NULL
,
12603 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12605 if (fd
.get () == -1)
12606 remote_hostio_error (remote_errno
);
12608 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12610 perror_with_name (local_file
);
12612 /* Send up to this many bytes at once. They won't all fit in the
12613 remote packet limit, so we'll transfer slightly fewer. */
12614 io_size
= get_remote_packet_size ();
12615 gdb::byte_vector
buffer (io_size
);
12620 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12623 /* Success, but no bytes, means end-of-file. */
12626 remote_hostio_error (remote_errno
);
12630 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12632 perror_with_name (local_file
);
12635 if (remote_hostio_close (fd
.release (), &remote_errno
))
12636 remote_hostio_error (remote_errno
);
12639 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12643 remote_file_delete (const char *remote_file
, int from_tty
)
12645 remote_target
*remote
= get_current_remote_target ();
12647 if (remote
== nullptr)
12648 error (_("command can only be used with remote target"));
12650 remote
->remote_file_delete (remote_file
, from_tty
);
12654 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12656 int retcode
, remote_errno
;
12658 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12660 remote_hostio_error (remote_errno
);
12663 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12667 remote_put_command (const char *args
, int from_tty
)
12670 error_no_arg (_("file to put"));
12672 gdb_argv
argv (args
);
12673 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12674 error (_("Invalid parameters to remote put"));
12676 remote_file_put (argv
[0], argv
[1], from_tty
);
12680 remote_get_command (const char *args
, int from_tty
)
12683 error_no_arg (_("file to get"));
12685 gdb_argv
argv (args
);
12686 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12687 error (_("Invalid parameters to remote get"));
12689 remote_file_get (argv
[0], argv
[1], from_tty
);
12693 remote_delete_command (const char *args
, int from_tty
)
12696 error_no_arg (_("file to delete"));
12698 gdb_argv
argv (args
);
12699 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12700 error (_("Invalid parameters to remote delete"));
12702 remote_file_delete (argv
[0], from_tty
);
12706 remote_command (const char *args
, int from_tty
)
12708 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12712 remote_target::can_execute_reverse ()
12714 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12715 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12722 remote_target::supports_non_stop ()
12728 remote_target::supports_disable_randomization ()
12730 /* Only supported in extended mode. */
12735 remote_target::supports_multi_process ()
12737 struct remote_state
*rs
= get_remote_state ();
12739 return remote_multi_process_p (rs
);
12743 remote_supports_cond_tracepoints ()
12745 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12749 remote_target::supports_evaluation_of_breakpoint_conditions ()
12751 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12755 remote_supports_fast_tracepoints ()
12757 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12761 remote_supports_static_tracepoints ()
12763 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12767 remote_supports_install_in_trace ()
12769 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12773 remote_target::supports_enable_disable_tracepoint ()
12775 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12780 remote_target::supports_string_tracing ()
12782 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12786 remote_target::can_run_breakpoint_commands ()
12788 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12792 remote_target::trace_init ()
12794 struct remote_state
*rs
= get_remote_state ();
12797 remote_get_noisy_reply ();
12798 if (strcmp (rs
->buf
.data (), "OK") != 0)
12799 error (_("Target does not support this command."));
12802 /* Recursive routine to walk through command list including loops, and
12803 download packets for each command. */
12806 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12807 struct command_line
*cmds
)
12809 struct remote_state
*rs
= get_remote_state ();
12810 struct command_line
*cmd
;
12812 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12814 QUIT
; /* Allow user to bail out with ^C. */
12815 strcpy (rs
->buf
.data (), "QTDPsrc:");
12816 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12817 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12818 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12820 remote_get_noisy_reply ();
12821 if (strcmp (rs
->buf
.data (), "OK"))
12822 warning (_("Target does not support source download."));
12824 if (cmd
->control_type
== while_control
12825 || cmd
->control_type
== while_stepping_control
)
12827 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12829 QUIT
; /* Allow user to bail out with ^C. */
12830 strcpy (rs
->buf
.data (), "QTDPsrc:");
12831 encode_source_string (num
, addr
, "cmd", "end",
12832 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12833 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12835 remote_get_noisy_reply ();
12836 if (strcmp (rs
->buf
.data (), "OK"))
12837 warning (_("Target does not support source download."));
12843 remote_target::download_tracepoint (struct bp_location
*loc
)
12847 std::vector
<std::string
> tdp_actions
;
12848 std::vector
<std::string
> stepping_actions
;
12850 struct breakpoint
*b
= loc
->owner
;
12851 struct tracepoint
*t
= (struct tracepoint
*) b
;
12852 struct remote_state
*rs
= get_remote_state ();
12854 const char *err_msg
= _("Tracepoint packet too large for target.");
12857 /* We use a buffer other than rs->buf because we'll build strings
12858 across multiple statements, and other statements in between could
12860 gdb::char_vector
buf (get_remote_packet_size ());
12862 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12864 tpaddr
= loc
->address
;
12865 strcpy (addrbuf
, phex (tpaddr
, sizeof (CORE_ADDR
)));
12866 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12867 b
->number
, addrbuf
, /* address */
12868 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12869 t
->step_count
, t
->pass_count
);
12871 if (ret
< 0 || ret
>= buf
.size ())
12872 error ("%s", err_msg
);
12874 /* Fast tracepoints are mostly handled by the target, but we can
12875 tell the target how big of an instruction block should be moved
12877 if (b
->type
== bp_fast_tracepoint
)
12879 /* Only test for support at download time; we may not know
12880 target capabilities at definition time. */
12881 if (remote_supports_fast_tracepoints ())
12883 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12886 size_left
= buf
.size () - strlen (buf
.data ());
12887 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12889 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12891 if (ret
< 0 || ret
>= size_left
)
12892 error ("%s", err_msg
);
12895 /* If it passed validation at definition but fails now,
12896 something is very wrong. */
12897 internal_error (__FILE__
, __LINE__
,
12898 _("Fast tracepoint not "
12899 "valid during download"));
12902 /* Fast tracepoints are functionally identical to regular
12903 tracepoints, so don't take lack of support as a reason to
12904 give up on the trace run. */
12905 warning (_("Target does not support fast tracepoints, "
12906 "downloading %d as regular tracepoint"), b
->number
);
12908 else if (b
->type
== bp_static_tracepoint
)
12910 /* Only test for support at download time; we may not know
12911 target capabilities at definition time. */
12912 if (remote_supports_static_tracepoints ())
12914 struct static_tracepoint_marker marker
;
12916 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12918 size_left
= buf
.size () - strlen (buf
.data ());
12919 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12922 if (ret
< 0 || ret
>= size_left
)
12923 error ("%s", err_msg
);
12926 error (_("Static tracepoint not valid during download"));
12929 /* Fast tracepoints are functionally identical to regular
12930 tracepoints, so don't take lack of support as a reason
12931 to give up on the trace run. */
12932 error (_("Target does not support static tracepoints"));
12934 /* If the tracepoint has a conditional, make it into an agent
12935 expression and append to the definition. */
12938 /* Only test support at download time, we may not know target
12939 capabilities at definition time. */
12940 if (remote_supports_cond_tracepoints ())
12942 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
12945 size_left
= buf
.size () - strlen (buf
.data ());
12947 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12948 size_left
, ":X%x,", aexpr
->len
);
12950 if (ret
< 0 || ret
>= size_left
)
12951 error ("%s", err_msg
);
12953 size_left
= buf
.size () - strlen (buf
.data ());
12955 /* Two bytes to encode each aexpr byte, plus the terminating
12957 if (aexpr
->len
* 2 + 1 > size_left
)
12958 error ("%s", err_msg
);
12960 pkt
= buf
.data () + strlen (buf
.data ());
12962 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12963 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12967 warning (_("Target does not support conditional tracepoints, "
12968 "ignoring tp %d cond"), b
->number
);
12971 if (b
->commands
|| *default_collect
)
12973 size_left
= buf
.size () - strlen (buf
.data ());
12975 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12978 if (ret
< 0 || ret
>= size_left
)
12979 error ("%s", err_msg
);
12982 putpkt (buf
.data ());
12983 remote_get_noisy_reply ();
12984 if (strcmp (rs
->buf
.data (), "OK"))
12985 error (_("Target does not support tracepoints."));
12987 /* do_single_steps (t); */
12988 for (auto action_it
= tdp_actions
.begin ();
12989 action_it
!= tdp_actions
.end (); action_it
++)
12991 QUIT
; /* Allow user to bail out with ^C. */
12993 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
12994 || !stepping_actions
.empty ());
12996 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
12997 b
->number
, addrbuf
, /* address */
12998 action_it
->c_str (),
12999 has_more
? '-' : 0);
13001 if (ret
< 0 || ret
>= buf
.size ())
13002 error ("%s", err_msg
);
13004 putpkt (buf
.data ());
13005 remote_get_noisy_reply ();
13006 if (strcmp (rs
->buf
.data (), "OK"))
13007 error (_("Error on target while setting tracepoints."));
13010 for (auto action_it
= stepping_actions
.begin ();
13011 action_it
!= stepping_actions
.end (); action_it
++)
13013 QUIT
; /* Allow user to bail out with ^C. */
13015 bool is_first
= action_it
== stepping_actions
.begin ();
13016 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
13018 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
13019 b
->number
, addrbuf
, /* address */
13020 is_first
? "S" : "",
13021 action_it
->c_str (),
13022 has_more
? "-" : "");
13024 if (ret
< 0 || ret
>= buf
.size ())
13025 error ("%s", err_msg
);
13027 putpkt (buf
.data ());
13028 remote_get_noisy_reply ();
13029 if (strcmp (rs
->buf
.data (), "OK"))
13030 error (_("Error on target while setting tracepoints."));
13033 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
13035 if (b
->location
!= NULL
)
13037 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13039 if (ret
< 0 || ret
>= buf
.size ())
13040 error ("%s", err_msg
);
13042 encode_source_string (b
->number
, loc
->address
, "at",
13043 event_location_to_string (b
->location
.get ()),
13044 buf
.data () + strlen (buf
.data ()),
13045 buf
.size () - strlen (buf
.data ()));
13046 putpkt (buf
.data ());
13047 remote_get_noisy_reply ();
13048 if (strcmp (rs
->buf
.data (), "OK"))
13049 warning (_("Target does not support source download."));
13051 if (b
->cond_string
)
13053 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13055 if (ret
< 0 || ret
>= buf
.size ())
13056 error ("%s", err_msg
);
13058 encode_source_string (b
->number
, loc
->address
,
13059 "cond", b
->cond_string
,
13060 buf
.data () + strlen (buf
.data ()),
13061 buf
.size () - strlen (buf
.data ()));
13062 putpkt (buf
.data ());
13063 remote_get_noisy_reply ();
13064 if (strcmp (rs
->buf
.data (), "OK"))
13065 warning (_("Target does not support source download."));
13067 remote_download_command_source (b
->number
, loc
->address
,
13068 breakpoint_commands (b
));
13073 remote_target::can_download_tracepoint ()
13075 struct remote_state
*rs
= get_remote_state ();
13076 struct trace_status
*ts
;
13079 /* Don't try to install tracepoints until we've relocated our
13080 symbols, and fetched and merged the target's tracepoint list with
13082 if (rs
->starting_up
)
13085 ts
= current_trace_status ();
13086 status
= get_trace_status (ts
);
13088 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
13091 /* If we are in a tracing experiment, but remote stub doesn't support
13092 installing tracepoint in trace, we have to return. */
13093 if (!remote_supports_install_in_trace ())
13101 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
13103 struct remote_state
*rs
= get_remote_state ();
13106 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13107 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13109 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13110 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13111 >= get_remote_packet_size ())
13112 error (_("Trace state variable name too long for tsv definition packet"));
13113 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13116 remote_get_noisy_reply ();
13117 if (rs
->buf
[0] == '\0')
13118 error (_("Target does not support this command."));
13119 if (strcmp (rs
->buf
.data (), "OK") != 0)
13120 error (_("Error on target while downloading trace state variable."));
13124 remote_target::enable_tracepoint (struct bp_location
*location
)
13126 struct remote_state
*rs
= get_remote_state ();
13128 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13129 location
->owner
->number
,
13130 phex (location
->address
, sizeof (CORE_ADDR
)));
13132 remote_get_noisy_reply ();
13133 if (rs
->buf
[0] == '\0')
13134 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13135 if (strcmp (rs
->buf
.data (), "OK") != 0)
13136 error (_("Error on target while enabling tracepoint."));
13140 remote_target::disable_tracepoint (struct bp_location
*location
)
13142 struct remote_state
*rs
= get_remote_state ();
13144 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13145 location
->owner
->number
,
13146 phex (location
->address
, sizeof (CORE_ADDR
)));
13148 remote_get_noisy_reply ();
13149 if (rs
->buf
[0] == '\0')
13150 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13151 if (strcmp (rs
->buf
.data (), "OK") != 0)
13152 error (_("Error on target while disabling tracepoint."));
13156 remote_target::trace_set_readonly_regions ()
13159 bfd_size_type size
;
13165 return; /* No information to give. */
13167 struct remote_state
*rs
= get_remote_state ();
13169 strcpy (rs
->buf
.data (), "QTro");
13170 offset
= strlen (rs
->buf
.data ());
13171 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
13173 char tmp1
[40], tmp2
[40];
13176 if ((s
->flags
& SEC_LOAD
) == 0 ||
13177 /* (s->flags & SEC_CODE) == 0 || */
13178 (s
->flags
& SEC_READONLY
) == 0)
13182 vma
= bfd_section_vma (s
);
13183 size
= bfd_section_size (s
);
13184 sprintf_vma (tmp1
, vma
);
13185 sprintf_vma (tmp2
, vma
+ size
);
13186 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13187 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13189 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13191 Too many sections for read-only sections definition packet."));
13194 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13196 offset
+= sec_length
;
13201 getpkt (&rs
->buf
, 0);
13206 remote_target::trace_start ()
13208 struct remote_state
*rs
= get_remote_state ();
13210 putpkt ("QTStart");
13211 remote_get_noisy_reply ();
13212 if (rs
->buf
[0] == '\0')
13213 error (_("Target does not support this command."));
13214 if (strcmp (rs
->buf
.data (), "OK") != 0)
13215 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13219 remote_target::get_trace_status (struct trace_status
*ts
)
13221 /* Initialize it just to avoid a GCC false warning. */
13223 enum packet_result result
;
13224 struct remote_state
*rs
= get_remote_state ();
13226 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13229 /* FIXME we need to get register block size some other way. */
13230 trace_regblock_size
13231 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13233 putpkt ("qTStatus");
13237 p
= remote_get_noisy_reply ();
13239 catch (const gdb_exception_error
&ex
)
13241 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13243 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13249 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13251 /* If the remote target doesn't do tracing, flag it. */
13252 if (result
== PACKET_UNKNOWN
)
13255 /* We're working with a live target. */
13256 ts
->filename
= NULL
;
13259 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13261 /* Function 'parse_trace_status' sets default value of each field of
13262 'ts' at first, so we don't have to do it here. */
13263 parse_trace_status (p
, ts
);
13265 return ts
->running
;
13269 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13270 struct uploaded_tp
*utp
)
13272 struct remote_state
*rs
= get_remote_state ();
13274 struct bp_location
*loc
;
13275 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13276 size_t size
= get_remote_packet_size ();
13281 tp
->traceframe_usage
= 0;
13282 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13284 /* If the tracepoint was never downloaded, don't go asking for
13286 if (tp
->number_on_target
== 0)
13288 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13289 phex_nz (loc
->address
, 0));
13291 reply
= remote_get_noisy_reply ();
13292 if (reply
&& *reply
)
13295 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13301 utp
->hit_count
= 0;
13302 utp
->traceframe_usage
= 0;
13303 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13304 phex_nz (utp
->addr
, 0));
13306 reply
= remote_get_noisy_reply ();
13307 if (reply
&& *reply
)
13310 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13316 remote_target::trace_stop ()
13318 struct remote_state
*rs
= get_remote_state ();
13321 remote_get_noisy_reply ();
13322 if (rs
->buf
[0] == '\0')
13323 error (_("Target does not support this command."));
13324 if (strcmp (rs
->buf
.data (), "OK") != 0)
13325 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13329 remote_target::trace_find (enum trace_find_type type
, int num
,
13330 CORE_ADDR addr1
, CORE_ADDR addr2
,
13333 struct remote_state
*rs
= get_remote_state ();
13334 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13336 int target_frameno
= -1, target_tracept
= -1;
13338 /* Lookups other than by absolute frame number depend on the current
13339 trace selected, so make sure it is correct on the remote end
13341 if (type
!= tfind_number
)
13342 set_remote_traceframe ();
13344 p
= rs
->buf
.data ();
13345 strcpy (p
, "QTFrame:");
13346 p
= strchr (p
, '\0');
13350 xsnprintf (p
, endbuf
- p
, "%x", num
);
13353 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13356 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13359 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13360 phex_nz (addr2
, 0));
13362 case tfind_outside
:
13363 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13364 phex_nz (addr2
, 0));
13367 error (_("Unknown trace find type %d"), type
);
13371 reply
= remote_get_noisy_reply ();
13372 if (*reply
== '\0')
13373 error (_("Target does not support this command."));
13375 while (reply
&& *reply
)
13380 target_frameno
= (int) strtol (p
, &reply
, 16);
13382 error (_("Unable to parse trace frame number"));
13383 /* Don't update our remote traceframe number cache on failure
13384 to select a remote traceframe. */
13385 if (target_frameno
== -1)
13390 target_tracept
= (int) strtol (p
, &reply
, 16);
13392 error (_("Unable to parse tracepoint number"));
13394 case 'O': /* "OK"? */
13395 if (reply
[1] == 'K' && reply
[2] == '\0')
13398 error (_("Bogus reply from target: %s"), reply
);
13401 error (_("Bogus reply from target: %s"), reply
);
13404 *tpp
= target_tracept
;
13406 rs
->remote_traceframe_number
= target_frameno
;
13407 return target_frameno
;
13411 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13413 struct remote_state
*rs
= get_remote_state ();
13417 set_remote_traceframe ();
13419 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13421 reply
= remote_get_noisy_reply ();
13422 if (reply
&& *reply
)
13426 unpack_varlen_hex (reply
+ 1, &uval
);
13427 *val
= (LONGEST
) uval
;
13435 remote_target::save_trace_data (const char *filename
)
13437 struct remote_state
*rs
= get_remote_state ();
13440 p
= rs
->buf
.data ();
13441 strcpy (p
, "QTSave:");
13443 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13444 >= get_remote_packet_size ())
13445 error (_("Remote file name too long for trace save packet"));
13446 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13449 reply
= remote_get_noisy_reply ();
13450 if (*reply
== '\0')
13451 error (_("Target does not support this command."));
13452 if (strcmp (reply
, "OK") != 0)
13453 error (_("Bogus reply from target: %s"), reply
);
13457 /* This is basically a memory transfer, but needs to be its own packet
13458 because we don't know how the target actually organizes its trace
13459 memory, plus we want to be able to ask for as much as possible, but
13460 not be unhappy if we don't get as much as we ask for. */
13463 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13465 struct remote_state
*rs
= get_remote_state ();
13470 p
= rs
->buf
.data ();
13471 strcpy (p
, "qTBuffer:");
13473 p
+= hexnumstr (p
, offset
);
13475 p
+= hexnumstr (p
, len
);
13479 reply
= remote_get_noisy_reply ();
13480 if (reply
&& *reply
)
13482 /* 'l' by itself means we're at the end of the buffer and
13483 there is nothing more to get. */
13487 /* Convert the reply into binary. Limit the number of bytes to
13488 convert according to our passed-in buffer size, rather than
13489 what was returned in the packet; if the target is
13490 unexpectedly generous and gives us a bigger reply than we
13491 asked for, we don't want to crash. */
13492 rslt
= hex2bin (reply
, buf
, len
);
13496 /* Something went wrong, flag as an error. */
13501 remote_target::set_disconnected_tracing (int val
)
13503 struct remote_state
*rs
= get_remote_state ();
13505 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13509 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13510 "QTDisconnected:%x", val
);
13512 reply
= remote_get_noisy_reply ();
13513 if (*reply
== '\0')
13514 error (_("Target does not support this command."));
13515 if (strcmp (reply
, "OK") != 0)
13516 error (_("Bogus reply from target: %s"), reply
);
13519 warning (_("Target does not support disconnected tracing."));
13523 remote_target::core_of_thread (ptid_t ptid
)
13525 thread_info
*info
= find_thread_ptid (this, ptid
);
13527 if (info
!= NULL
&& info
->priv
!= NULL
)
13528 return get_remote_thread_info (info
)->core
;
13534 remote_target::set_circular_trace_buffer (int val
)
13536 struct remote_state
*rs
= get_remote_state ();
13539 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13540 "QTBuffer:circular:%x", val
);
13542 reply
= remote_get_noisy_reply ();
13543 if (*reply
== '\0')
13544 error (_("Target does not support this command."));
13545 if (strcmp (reply
, "OK") != 0)
13546 error (_("Bogus reply from target: %s"), reply
);
13550 remote_target::traceframe_info ()
13552 gdb::optional
<gdb::char_vector
> text
13553 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13556 return parse_traceframe_info (text
->data ());
13561 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13562 instruction on which a fast tracepoint may be placed. Returns -1
13563 if the packet is not supported, and 0 if the minimum instruction
13564 length is unknown. */
13567 remote_target::get_min_fast_tracepoint_insn_len ()
13569 struct remote_state
*rs
= get_remote_state ();
13572 /* If we're not debugging a process yet, the IPA can't be
13574 if (!target_has_execution
)
13577 /* Make sure the remote is pointing at the right process. */
13578 set_general_process ();
13580 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13582 reply
= remote_get_noisy_reply ();
13583 if (*reply
== '\0')
13587 ULONGEST min_insn_len
;
13589 unpack_varlen_hex (reply
, &min_insn_len
);
13591 return (int) min_insn_len
;
13596 remote_target::set_trace_buffer_size (LONGEST val
)
13598 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13600 struct remote_state
*rs
= get_remote_state ();
13601 char *buf
= rs
->buf
.data ();
13602 char *endbuf
= buf
+ get_remote_packet_size ();
13603 enum packet_result result
;
13605 gdb_assert (val
>= 0 || val
== -1);
13606 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13607 /* Send -1 as literal "-1" to avoid host size dependency. */
13611 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13614 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13617 remote_get_noisy_reply ();
13618 result
= packet_ok (rs
->buf
,
13619 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13621 if (result
!= PACKET_OK
)
13622 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13627 remote_target::set_trace_notes (const char *user
, const char *notes
,
13628 const char *stop_notes
)
13630 struct remote_state
*rs
= get_remote_state ();
13632 char *buf
= rs
->buf
.data ();
13633 char *endbuf
= buf
+ get_remote_packet_size ();
13636 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13639 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13640 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13646 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13647 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13653 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13654 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13658 /* Ensure the buffer is terminated. */
13662 reply
= remote_get_noisy_reply ();
13663 if (*reply
== '\0')
13666 if (strcmp (reply
, "OK") != 0)
13667 error (_("Bogus reply from target: %s"), reply
);
13673 remote_target::use_agent (bool use
)
13675 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13677 struct remote_state
*rs
= get_remote_state ();
13679 /* If the stub supports QAgent. */
13680 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13682 getpkt (&rs
->buf
, 0);
13684 if (strcmp (rs
->buf
.data (), "OK") == 0)
13695 remote_target::can_use_agent ()
13697 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13700 struct btrace_target_info
13702 /* The ptid of the traced thread. */
13705 /* The obtained branch trace configuration. */
13706 struct btrace_config conf
;
13709 /* Reset our idea of our target's btrace configuration. */
13712 remote_btrace_reset (remote_state
*rs
)
13714 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13717 /* Synchronize the configuration with the target. */
13720 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13722 struct packet_config
*packet
;
13723 struct remote_state
*rs
;
13724 char *buf
, *pos
, *endbuf
;
13726 rs
= get_remote_state ();
13727 buf
= rs
->buf
.data ();
13728 endbuf
= buf
+ get_remote_packet_size ();
13730 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13731 if (packet_config_support (packet
) == PACKET_ENABLE
13732 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13735 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13739 getpkt (&rs
->buf
, 0);
13741 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13743 if (buf
[0] == 'E' && buf
[1] == '.')
13744 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13746 error (_("Failed to configure the BTS buffer size."));
13749 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13752 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13753 if (packet_config_support (packet
) == PACKET_ENABLE
13754 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13757 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13761 getpkt (&rs
->buf
, 0);
13763 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13765 if (buf
[0] == 'E' && buf
[1] == '.')
13766 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13768 error (_("Failed to configure the trace buffer size."));
13771 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13775 /* Read the current thread's btrace configuration from the target and
13776 store it into CONF. */
13779 btrace_read_config (struct btrace_config
*conf
)
13781 gdb::optional
<gdb::char_vector
> xml
13782 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13784 parse_xml_btrace_conf (conf
, xml
->data ());
13787 /* Maybe reopen target btrace. */
13790 remote_target::remote_btrace_maybe_reopen ()
13792 struct remote_state
*rs
= get_remote_state ();
13793 int btrace_target_pushed
= 0;
13794 #if !defined (HAVE_LIBIPT)
13798 /* Don't bother walking the entirety of the remote thread list when
13799 we know the feature isn't supported by the remote. */
13800 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13803 scoped_restore_current_thread restore_thread
;
13805 for (thread_info
*tp
: all_non_exited_threads (this))
13807 set_general_thread (tp
->ptid
);
13809 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13810 btrace_read_config (&rs
->btrace_config
);
13812 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13815 #if !defined (HAVE_LIBIPT)
13816 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13821 warning (_("Target is recording using Intel Processor Trace "
13822 "but support was disabled at compile time."));
13827 #endif /* !defined (HAVE_LIBIPT) */
13829 /* Push target, once, but before anything else happens. This way our
13830 changes to the threads will be cleaned up by unpushing the target
13831 in case btrace_read_config () throws. */
13832 if (!btrace_target_pushed
)
13834 btrace_target_pushed
= 1;
13835 record_btrace_push_target ();
13836 printf_filtered (_("Target is recording using %s.\n"),
13837 btrace_format_string (rs
->btrace_config
.format
));
13840 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13841 tp
->btrace
.target
->ptid
= tp
->ptid
;
13842 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13846 /* Enable branch tracing. */
13848 struct btrace_target_info
*
13849 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13851 struct btrace_target_info
*tinfo
= NULL
;
13852 struct packet_config
*packet
= NULL
;
13853 struct remote_state
*rs
= get_remote_state ();
13854 char *buf
= rs
->buf
.data ();
13855 char *endbuf
= buf
+ get_remote_packet_size ();
13857 switch (conf
->format
)
13859 case BTRACE_FORMAT_BTS
:
13860 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13863 case BTRACE_FORMAT_PT
:
13864 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13868 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13869 error (_("Target does not support branch tracing."));
13871 btrace_sync_conf (conf
);
13873 set_general_thread (ptid
);
13875 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13877 getpkt (&rs
->buf
, 0);
13879 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13881 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13882 error (_("Could not enable branch tracing for %s: %s"),
13883 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
13885 error (_("Could not enable branch tracing for %s."),
13886 target_pid_to_str (ptid
).c_str ());
13889 tinfo
= XCNEW (struct btrace_target_info
);
13890 tinfo
->ptid
= ptid
;
13892 /* If we fail to read the configuration, we lose some information, but the
13893 tracing itself is not impacted. */
13896 btrace_read_config (&tinfo
->conf
);
13898 catch (const gdb_exception_error
&err
)
13900 if (err
.message
!= NULL
)
13901 warning ("%s", err
.what ());
13907 /* Disable branch tracing. */
13910 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
13912 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13913 struct remote_state
*rs
= get_remote_state ();
13914 char *buf
= rs
->buf
.data ();
13915 char *endbuf
= buf
+ get_remote_packet_size ();
13917 if (packet_config_support (packet
) != PACKET_ENABLE
)
13918 error (_("Target does not support branch tracing."));
13920 set_general_thread (tinfo
->ptid
);
13922 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13924 getpkt (&rs
->buf
, 0);
13926 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13928 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13929 error (_("Could not disable branch tracing for %s: %s"),
13930 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
13932 error (_("Could not disable branch tracing for %s."),
13933 target_pid_to_str (tinfo
->ptid
).c_str ());
13939 /* Teardown branch tracing. */
13942 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
13944 /* We must not talk to the target during teardown. */
13948 /* Read the branch trace. */
13951 remote_target::read_btrace (struct btrace_data
*btrace
,
13952 struct btrace_target_info
*tinfo
,
13953 enum btrace_read_type type
)
13955 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13958 if (packet_config_support (packet
) != PACKET_ENABLE
)
13959 error (_("Target does not support branch tracing."));
13961 #if !defined(HAVE_LIBEXPAT)
13962 error (_("Cannot process branch tracing result. XML parsing not supported."));
13967 case BTRACE_READ_ALL
:
13970 case BTRACE_READ_NEW
:
13973 case BTRACE_READ_DELTA
:
13977 internal_error (__FILE__
, __LINE__
,
13978 _("Bad branch tracing read type: %u."),
13979 (unsigned int) type
);
13982 gdb::optional
<gdb::char_vector
> xml
13983 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
13985 return BTRACE_ERR_UNKNOWN
;
13987 parse_xml_btrace (btrace
, xml
->data ());
13989 return BTRACE_ERR_NONE
;
13992 const struct btrace_config
*
13993 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
13995 return &tinfo
->conf
;
13999 remote_target::augmented_libraries_svr4_read ()
14001 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
14005 /* Implementation of to_load. */
14008 remote_target::load (const char *name
, int from_tty
)
14010 generic_load (name
, from_tty
);
14013 /* Accepts an integer PID; returns a string representing a file that
14014 can be opened on the remote side to get the symbols for the child
14015 process. Returns NULL if the operation is not supported. */
14018 remote_target::pid_to_exec_file (int pid
)
14020 static gdb::optional
<gdb::char_vector
> filename
;
14021 char *annex
= NULL
;
14023 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
14026 inferior
*inf
= find_inferior_pid (this, pid
);
14028 internal_error (__FILE__
, __LINE__
,
14029 _("not currently attached to process %d"), pid
);
14031 if (!inf
->fake_pid_p
)
14033 const int annex_size
= 9;
14035 annex
= (char *) alloca (annex_size
);
14036 xsnprintf (annex
, annex_size
, "%x", pid
);
14039 filename
= target_read_stralloc (current_top_target (),
14040 TARGET_OBJECT_EXEC_FILE
, annex
);
14042 return filename
? filename
->data () : nullptr;
14045 /* Implement the to_can_do_single_step target_ops method. */
14048 remote_target::can_do_single_step ()
14050 /* We can only tell whether target supports single step or not by
14051 supported s and S vCont actions if the stub supports vContSupported
14052 feature. If the stub doesn't support vContSupported feature,
14053 we have conservatively to think target doesn't supports single
14055 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
14057 struct remote_state
*rs
= get_remote_state ();
14059 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14060 remote_vcont_probe ();
14062 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
14068 /* Implementation of the to_execution_direction method for the remote
14071 enum exec_direction_kind
14072 remote_target::execution_direction ()
14074 struct remote_state
*rs
= get_remote_state ();
14076 return rs
->last_resume_exec_dir
;
14079 /* Return pointer to the thread_info struct which corresponds to
14080 THREAD_HANDLE (having length HANDLE_LEN). */
14083 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
14087 for (thread_info
*tp
: all_non_exited_threads (this))
14089 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14091 if (tp
->inf
== inf
&& priv
!= NULL
)
14093 if (handle_len
!= priv
->thread_handle
.size ())
14094 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14095 handle_len
, priv
->thread_handle
.size ());
14096 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14106 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
14108 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14109 return priv
->thread_handle
;
14113 remote_target::can_async_p ()
14115 struct remote_state
*rs
= get_remote_state ();
14117 /* We don't go async if the user has explicitly prevented it with the
14118 "maint set target-async" command. */
14119 if (!target_async_permitted
)
14122 /* We're async whenever the serial device is. */
14123 return serial_can_async_p (rs
->remote_desc
);
14127 remote_target::is_async_p ()
14129 struct remote_state
*rs
= get_remote_state ();
14131 if (!target_async_permitted
)
14132 /* We only enable async when the user specifically asks for it. */
14135 /* We're async whenever the serial device is. */
14136 return serial_is_async_p (rs
->remote_desc
);
14139 /* Pass the SERIAL event on and up to the client. One day this code
14140 will be able to delay notifying the client of an event until the
14141 point where an entire packet has been received. */
14143 static serial_event_ftype remote_async_serial_handler
;
14146 remote_async_serial_handler (struct serial
*scb
, void *context
)
14148 /* Don't propogate error information up to the client. Instead let
14149 the client find out about the error by querying the target. */
14150 inferior_event_handler (INF_REG_EVENT
, NULL
);
14154 remote_async_inferior_event_handler (gdb_client_data data
)
14156 inferior_event_handler (INF_REG_EVENT
, data
);
14160 remote_target::async_wait_fd ()
14162 struct remote_state
*rs
= get_remote_state ();
14163 return rs
->remote_desc
->fd
;
14167 remote_target::async (int enable
)
14169 struct remote_state
*rs
= get_remote_state ();
14173 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14175 /* If there are pending events in the stop reply queue tell the
14176 event loop to process them. */
14177 if (!rs
->stop_reply_queue
.empty ())
14178 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14179 /* For simplicity, below we clear the pending events token
14180 without remembering whether it is marked, so here we always
14181 mark it. If there's actually no pending notification to
14182 process, this ends up being a no-op (other than a spurious
14183 event-loop wakeup). */
14184 if (target_is_non_stop_p ())
14185 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14189 serial_async (rs
->remote_desc
, NULL
, NULL
);
14190 /* If the core is disabling async, it doesn't want to be
14191 disturbed with target events. Clear all async event sources
14193 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14194 if (target_is_non_stop_p ())
14195 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14199 /* Implementation of the to_thread_events method. */
14202 remote_target::thread_events (int enable
)
14204 struct remote_state
*rs
= get_remote_state ();
14205 size_t size
= get_remote_packet_size ();
14207 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14210 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14212 getpkt (&rs
->buf
, 0);
14214 switch (packet_ok (rs
->buf
,
14215 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14218 if (strcmp (rs
->buf
.data (), "OK") != 0)
14219 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14222 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14224 case PACKET_UNKNOWN
:
14230 set_remote_cmd (const char *args
, int from_tty
)
14232 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
14236 show_remote_cmd (const char *args
, int from_tty
)
14238 /* We can't just use cmd_show_list here, because we want to skip
14239 the redundant "show remote Z-packet" and the legacy aliases. */
14240 struct cmd_list_element
*list
= remote_show_cmdlist
;
14241 struct ui_out
*uiout
= current_uiout
;
14243 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14244 for (; list
!= NULL
; list
= list
->next
)
14245 if (strcmp (list
->name
, "Z-packet") == 0)
14247 else if (list
->type
== not_set_cmd
)
14248 /* Alias commands are exactly like the original, except they
14249 don't have the normal type. */
14253 ui_out_emit_tuple
option_emitter (uiout
, "option");
14255 uiout
->field_string ("name", list
->name
);
14256 uiout
->text (": ");
14257 if (list
->type
== show_cmd
)
14258 do_show_command (NULL
, from_tty
, list
);
14260 cmd_func (list
, NULL
, from_tty
);
14265 /* Function to be called whenever a new objfile (shlib) is detected. */
14267 remote_new_objfile (struct objfile
*objfile
)
14269 remote_target
*remote
= get_current_remote_target ();
14271 if (remote
!= NULL
) /* Have a remote connection. */
14272 remote
->remote_check_symbols ();
14275 /* Pull all the tracepoints defined on the target and create local
14276 data structures representing them. We don't want to create real
14277 tracepoints yet, we don't want to mess up the user's existing
14281 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14283 struct remote_state
*rs
= get_remote_state ();
14286 /* Ask for a first packet of tracepoint definition. */
14288 getpkt (&rs
->buf
, 0);
14289 p
= rs
->buf
.data ();
14290 while (*p
&& *p
!= 'l')
14292 parse_tracepoint_definition (p
, utpp
);
14293 /* Ask for another packet of tracepoint definition. */
14295 getpkt (&rs
->buf
, 0);
14296 p
= rs
->buf
.data ();
14302 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14304 struct remote_state
*rs
= get_remote_state ();
14307 /* Ask for a first packet of variable definition. */
14309 getpkt (&rs
->buf
, 0);
14310 p
= rs
->buf
.data ();
14311 while (*p
&& *p
!= 'l')
14313 parse_tsv_definition (p
, utsvp
);
14314 /* Ask for another packet of variable definition. */
14316 getpkt (&rs
->buf
, 0);
14317 p
= rs
->buf
.data ();
14322 /* The "set/show range-stepping" show hook. */
14325 show_range_stepping (struct ui_file
*file
, int from_tty
,
14326 struct cmd_list_element
*c
,
14329 fprintf_filtered (file
,
14330 _("Debugger's willingness to use range stepping "
14331 "is %s.\n"), value
);
14334 /* Return true if the vCont;r action is supported by the remote
14338 remote_target::vcont_r_supported ()
14340 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14341 remote_vcont_probe ();
14343 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14344 && get_remote_state ()->supports_vCont
.r
);
14347 /* The "set/show range-stepping" set hook. */
14350 set_range_stepping (const char *ignore_args
, int from_tty
,
14351 struct cmd_list_element
*c
)
14353 /* When enabling, check whether range stepping is actually supported
14354 by the target, and warn if not. */
14355 if (use_range_stepping
)
14357 remote_target
*remote
= get_current_remote_target ();
14359 || !remote
->vcont_r_supported ())
14360 warning (_("Range stepping is not supported by the current target"));
14364 void _initialize_remote ();
14366 _initialize_remote ()
14368 struct cmd_list_element
*cmd
;
14369 const char *cmd_name
;
14371 /* architecture specific data */
14372 remote_g_packet_data_handle
=
14373 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14375 add_target (remote_target_info
, remote_target::open
);
14376 add_target (extended_remote_target_info
, extended_remote_target::open
);
14378 /* Hook into new objfile notification. */
14379 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14382 init_remote_threadtests ();
14385 /* set/show remote ... */
14387 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14388 Remote protocol specific variables.\n\
14389 Configure various remote-protocol specific variables such as\n\
14390 the packets being used."),
14391 &remote_set_cmdlist
, "set remote ",
14392 0 /* allow-unknown */, &setlist
);
14393 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14394 Remote protocol specific variables.\n\
14395 Configure various remote-protocol specific variables such as\n\
14396 the packets being used."),
14397 &remote_show_cmdlist
, "show remote ",
14398 0 /* allow-unknown */, &showlist
);
14400 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14401 Compare section data on target to the exec file.\n\
14402 Argument is a single section name (default: all loaded sections).\n\
14403 To compare only read-only loaded sections, specify the -r option."),
14406 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14407 Send an arbitrary packet to a remote target.\n\
14408 maintenance packet TEXT\n\
14409 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14410 this command sends the string TEXT to the inferior, and displays the\n\
14411 response packet. GDB supplies the initial `$' character, and the\n\
14412 terminating `#' character and checksum."),
14415 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14416 Set whether to send break if interrupted."), _("\
14417 Show whether to send break if interrupted."), _("\
14418 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14419 set_remotebreak
, show_remotebreak
,
14420 &setlist
, &showlist
);
14421 cmd_name
= "remotebreak";
14422 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14423 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14424 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14425 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14426 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14428 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14429 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14431 Set interrupt sequence to remote target."), _("\
14432 Show interrupt sequence to remote target."), _("\
14433 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14434 NULL
, show_interrupt_sequence
,
14435 &remote_set_cmdlist
,
14436 &remote_show_cmdlist
);
14438 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14439 &interrupt_on_connect
, _("\
14440 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14441 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14442 If set, interrupt sequence is sent to remote target."),
14444 &remote_set_cmdlist
, &remote_show_cmdlist
);
14446 /* Install commands for configuring memory read/write packets. */
14448 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14449 Set the maximum number of bytes per memory write packet (deprecated)."),
14451 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14452 Show the maximum number of bytes per memory write packet (deprecated)."),
14454 add_cmd ("memory-write-packet-size", no_class
,
14455 set_memory_write_packet_size
, _("\
14456 Set the maximum number of bytes per memory-write packet.\n\
14457 Specify the number of bytes in a packet or 0 (zero) for the\n\
14458 default packet size. The actual limit is further reduced\n\
14459 dependent on the target. Specify ``fixed'' to disable the\n\
14460 further restriction and ``limit'' to enable that restriction."),
14461 &remote_set_cmdlist
);
14462 add_cmd ("memory-read-packet-size", no_class
,
14463 set_memory_read_packet_size
, _("\
14464 Set the maximum number of bytes per memory-read packet.\n\
14465 Specify the number of bytes in a packet or 0 (zero) for the\n\
14466 default packet size. The actual limit is further reduced\n\
14467 dependent on the target. Specify ``fixed'' to disable the\n\
14468 further restriction and ``limit'' to enable that restriction."),
14469 &remote_set_cmdlist
);
14470 add_cmd ("memory-write-packet-size", no_class
,
14471 show_memory_write_packet_size
,
14472 _("Show the maximum number of bytes per memory-write packet."),
14473 &remote_show_cmdlist
);
14474 add_cmd ("memory-read-packet-size", no_class
,
14475 show_memory_read_packet_size
,
14476 _("Show the maximum number of bytes per memory-read packet."),
14477 &remote_show_cmdlist
);
14479 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14480 &remote_hw_watchpoint_limit
, _("\
14481 Set the maximum number of target hardware watchpoints."), _("\
14482 Show the maximum number of target hardware watchpoints."), _("\
14483 Specify \"unlimited\" for unlimited hardware watchpoints."),
14484 NULL
, show_hardware_watchpoint_limit
,
14485 &remote_set_cmdlist
,
14486 &remote_show_cmdlist
);
14487 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14489 &remote_hw_watchpoint_length_limit
, _("\
14490 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14491 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14492 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14493 NULL
, show_hardware_watchpoint_length_limit
,
14494 &remote_set_cmdlist
, &remote_show_cmdlist
);
14495 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14496 &remote_hw_breakpoint_limit
, _("\
14497 Set the maximum number of target hardware breakpoints."), _("\
14498 Show the maximum number of target hardware breakpoints."), _("\
14499 Specify \"unlimited\" for unlimited hardware breakpoints."),
14500 NULL
, show_hardware_breakpoint_limit
,
14501 &remote_set_cmdlist
, &remote_show_cmdlist
);
14503 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14504 &remote_address_size
, _("\
14505 Set the maximum size of the address (in bits) in a memory packet."), _("\
14506 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14508 NULL
, /* FIXME: i18n: */
14509 &setlist
, &showlist
);
14511 init_all_packet_configs ();
14513 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14514 "X", "binary-download", 1);
14516 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14517 "vCont", "verbose-resume", 0);
14519 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14520 "QPassSignals", "pass-signals", 0);
14522 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14523 "QCatchSyscalls", "catch-syscalls", 0);
14525 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14526 "QProgramSignals", "program-signals", 0);
14528 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14529 "QSetWorkingDir", "set-working-dir", 0);
14531 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14532 "QStartupWithShell", "startup-with-shell", 0);
14534 add_packet_config_cmd (&remote_protocol_packets
14535 [PACKET_QEnvironmentHexEncoded
],
14536 "QEnvironmentHexEncoded", "environment-hex-encoded",
14539 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14540 "QEnvironmentReset", "environment-reset",
14543 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14544 "QEnvironmentUnset", "environment-unset",
14547 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14548 "qSymbol", "symbol-lookup", 0);
14550 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14551 "P", "set-register", 1);
14553 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14554 "p", "fetch-register", 1);
14556 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14557 "Z0", "software-breakpoint", 0);
14559 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14560 "Z1", "hardware-breakpoint", 0);
14562 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14563 "Z2", "write-watchpoint", 0);
14565 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14566 "Z3", "read-watchpoint", 0);
14568 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14569 "Z4", "access-watchpoint", 0);
14571 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14572 "qXfer:auxv:read", "read-aux-vector", 0);
14574 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14575 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14577 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14578 "qXfer:features:read", "target-features", 0);
14580 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14581 "qXfer:libraries:read", "library-info", 0);
14583 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14584 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14586 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14587 "qXfer:memory-map:read", "memory-map", 0);
14589 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14590 "qXfer:osdata:read", "osdata", 0);
14592 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14593 "qXfer:threads:read", "threads", 0);
14595 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14596 "qXfer:siginfo:read", "read-siginfo-object", 0);
14598 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14599 "qXfer:siginfo:write", "write-siginfo-object", 0);
14601 add_packet_config_cmd
14602 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14603 "qXfer:traceframe-info:read", "traceframe-info", 0);
14605 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14606 "qXfer:uib:read", "unwind-info-block", 0);
14608 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14609 "qGetTLSAddr", "get-thread-local-storage-address",
14612 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14613 "qGetTIBAddr", "get-thread-information-block-address",
14616 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14617 "bc", "reverse-continue", 0);
14619 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14620 "bs", "reverse-step", 0);
14622 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14623 "qSupported", "supported-packets", 0);
14625 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14626 "qSearch:memory", "search-memory", 0);
14628 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14629 "qTStatus", "trace-status", 0);
14631 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14632 "vFile:setfs", "hostio-setfs", 0);
14634 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14635 "vFile:open", "hostio-open", 0);
14637 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14638 "vFile:pread", "hostio-pread", 0);
14640 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14641 "vFile:pwrite", "hostio-pwrite", 0);
14643 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14644 "vFile:close", "hostio-close", 0);
14646 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14647 "vFile:unlink", "hostio-unlink", 0);
14649 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14650 "vFile:readlink", "hostio-readlink", 0);
14652 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14653 "vFile:fstat", "hostio-fstat", 0);
14655 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14656 "vAttach", "attach", 0);
14658 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14661 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14662 "QStartNoAckMode", "noack", 0);
14664 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14665 "vKill", "kill", 0);
14667 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14668 "qAttached", "query-attached", 0);
14670 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14671 "ConditionalTracepoints",
14672 "conditional-tracepoints", 0);
14674 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14675 "ConditionalBreakpoints",
14676 "conditional-breakpoints", 0);
14678 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14679 "BreakpointCommands",
14680 "breakpoint-commands", 0);
14682 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14683 "FastTracepoints", "fast-tracepoints", 0);
14685 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14686 "TracepointSource", "TracepointSource", 0);
14688 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14689 "QAllow", "allow", 0);
14691 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14692 "StaticTracepoints", "static-tracepoints", 0);
14694 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14695 "InstallInTrace", "install-in-trace", 0);
14697 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14698 "qXfer:statictrace:read", "read-sdata-object", 0);
14700 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14701 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14703 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14704 "QDisableRandomization", "disable-randomization", 0);
14706 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14707 "QAgent", "agent", 0);
14709 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14710 "QTBuffer:size", "trace-buffer-size", 0);
14712 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14713 "Qbtrace:off", "disable-btrace", 0);
14715 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14716 "Qbtrace:bts", "enable-btrace-bts", 0);
14718 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14719 "Qbtrace:pt", "enable-btrace-pt", 0);
14721 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14722 "qXfer:btrace", "read-btrace", 0);
14724 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14725 "qXfer:btrace-conf", "read-btrace-conf", 0);
14727 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14728 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14730 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14731 "multiprocess-feature", "multiprocess-feature", 0);
14733 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14734 "swbreak-feature", "swbreak-feature", 0);
14736 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14737 "hwbreak-feature", "hwbreak-feature", 0);
14739 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14740 "fork-event-feature", "fork-event-feature", 0);
14742 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14743 "vfork-event-feature", "vfork-event-feature", 0);
14745 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14746 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14748 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14749 "vContSupported", "verbose-resume-supported", 0);
14751 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14752 "exec-event-feature", "exec-event-feature", 0);
14754 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14755 "vCtrlC", "ctrl-c", 0);
14757 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14758 "QThreadEvents", "thread-events", 0);
14760 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14761 "N stop reply", "no-resumed-stop-reply", 0);
14763 /* Assert that we've registered "set remote foo-packet" commands
14764 for all packet configs. */
14768 for (i
= 0; i
< PACKET_MAX
; i
++)
14770 /* Ideally all configs would have a command associated. Some
14771 still don't though. */
14776 case PACKET_QNonStop
:
14777 case PACKET_EnableDisableTracepoints_feature
:
14778 case PACKET_tracenz_feature
:
14779 case PACKET_DisconnectedTracing_feature
:
14780 case PACKET_augmented_libraries_svr4_read_feature
:
14782 /* Additions to this list need to be well justified:
14783 pre-existing packets are OK; new packets are not. */
14791 /* This catches both forgetting to add a config command, and
14792 forgetting to remove a packet from the exception list. */
14793 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14797 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14798 Z sub-packet has its own set and show commands, but users may
14799 have sets to this variable in their .gdbinit files (or in their
14801 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14802 &remote_Z_packet_detect
, _("\
14803 Set use of remote protocol `Z' packets."), _("\
14804 Show use of remote protocol `Z' packets."), _("\
14805 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14807 set_remote_protocol_Z_packet_cmd
,
14808 show_remote_protocol_Z_packet_cmd
,
14809 /* FIXME: i18n: Use of remote protocol
14810 `Z' packets is %s. */
14811 &remote_set_cmdlist
, &remote_show_cmdlist
);
14813 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14814 Manipulate files on the remote system.\n\
14815 Transfer files to and from the remote target system."),
14816 &remote_cmdlist
, "remote ",
14817 0 /* allow-unknown */, &cmdlist
);
14819 add_cmd ("put", class_files
, remote_put_command
,
14820 _("Copy a local file to the remote system."),
14823 add_cmd ("get", class_files
, remote_get_command
,
14824 _("Copy a remote file to the local system."),
14827 add_cmd ("delete", class_files
, remote_delete_command
,
14828 _("Delete a remote file."),
14831 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14832 &remote_exec_file_var
, _("\
14833 Set the remote pathname for \"run\"."), _("\
14834 Show the remote pathname for \"run\"."), NULL
,
14835 set_remote_exec_file
,
14836 show_remote_exec_file
,
14837 &remote_set_cmdlist
,
14838 &remote_show_cmdlist
);
14840 add_setshow_boolean_cmd ("range-stepping", class_run
,
14841 &use_range_stepping
, _("\
14842 Enable or disable range stepping."), _("\
14843 Show whether target-assisted range stepping is enabled."), _("\
14844 If on, and the target supports it, when stepping a source line, GDB\n\
14845 tells the target to step the corresponding range of addresses itself instead\n\
14846 of issuing multiple single-steps. This speeds up source level\n\
14847 stepping. If off, GDB always issues single-steps, even if range\n\
14848 stepping is supported by the target. The default is on."),
14849 set_range_stepping
,
14850 show_range_stepping
,
14854 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
14855 Set watchdog timer."), _("\
14856 Show watchdog timer."), _("\
14857 When non-zero, this timeout is used instead of waiting forever for a target\n\
14858 to finish a low-level step or continue operation. If the specified amount\n\
14859 of time passes without a response from the target, an error occurs."),
14862 &setlist
, &showlist
);
14864 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
14865 &remote_packet_max_chars
, _("\
14866 Set the maximum number of characters to display for each remote packet."), _("\
14867 Show the maximum number of characters to display for each remote packet."), _("\
14868 Specify \"unlimited\" to display all the characters."),
14869 NULL
, show_remote_packet_max_chars
,
14870 &setdebuglist
, &showdebuglist
);
14872 /* Eventually initialize fileio. See fileio.c */
14873 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);