1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* See the GDB User Guide for details of the GDB remote protocol. */
30 #include "process-stratum-target.h"
33 #include "gdb-stabs.h"
34 #include "gdbthread.h"
36 #include "remote-notif.h"
39 #include "observable.h"
41 #include "cli/cli-decode.h"
42 #include "cli/cli-setshow.h"
43 #include "target-descriptions.h"
45 #include "gdbsupport/filestuff.h"
46 #include "gdbsupport/rsp-low.h"
50 #include "gdbsupport/gdb_sys_time.h"
52 #include "event-loop.h"
53 #include "event-top.h"
59 #include "gdbcore.h" /* for exec_bfd */
61 #include "remote-fileio.h"
62 #include "gdb/fileio.h"
64 #include "xml-support.h"
66 #include "memory-map.h"
68 #include "tracepoint.h"
71 #include "gdbsupport/agent.h"
73 #include "record-btrace.h"
75 #include "gdbsupport/scoped_restore.h"
76 #include "gdbsupport/environ.h"
77 #include "gdbsupport/byte-vector.h"
79 #include <unordered_map>
81 /* The remote target. */
83 static const char remote_doc
[] = N_("\
84 Use a remote computer via a serial line, using a gdb-specific protocol.\n\
85 Specify the serial device it is connected to\n\
86 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
88 #define OPAQUETHREADBYTES 8
90 /* a 64 bit opaque identifier */
91 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
93 struct gdb_ext_thread_info
;
94 struct threads_listing_context
;
95 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
96 struct protocol_feature
;
100 typedef std::unique_ptr
<stop_reply
> stop_reply_up
;
102 /* Generic configuration support for packets the stub optionally
103 supports. Allows the user to specify the use of the packet as well
104 as allowing GDB to auto-detect support in the remote stub. */
108 PACKET_SUPPORT_UNKNOWN
= 0,
113 /* Analyze a packet's return value and update the packet config
123 struct threads_listing_context
;
125 /* Stub vCont actions support.
127 Each field is a boolean flag indicating whether the stub reports
128 support for the corresponding action. */
130 struct vCont_action_support
145 /* About this many threadids fit in a packet. */
147 #define MAXTHREADLISTRESULTS 32
149 /* Data for the vFile:pread readahead cache. */
151 struct readahead_cache
153 /* Invalidate the readahead cache. */
156 /* Invalidate the readahead cache if it is holding data for FD. */
157 void invalidate_fd (int fd
);
159 /* Serve pread from the readahead cache. Returns number of bytes
160 read, or 0 if the request can't be served from the cache. */
161 int pread (int fd
, gdb_byte
*read_buf
, size_t len
, ULONGEST offset
);
163 /* The file descriptor for the file that is being cached. -1 if the
167 /* The offset into the file that the cache buffer corresponds
171 /* The buffer holding the cache contents. */
172 gdb_byte
*buf
= nullptr;
173 /* The buffer's size. We try to read as much as fits into a packet
177 /* Cache hit and miss counters. */
178 ULONGEST hit_count
= 0;
179 ULONGEST miss_count
= 0;
182 /* Description of the remote protocol for a given architecture. */
186 long offset
; /* Offset into G packet. */
187 long regnum
; /* GDB's internal register number. */
188 LONGEST pnum
; /* Remote protocol register number. */
189 int in_g_packet
; /* Always part of G packet. */
190 /* long size in bytes; == register_size (target_gdbarch (), regnum);
192 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
196 struct remote_arch_state
198 explicit remote_arch_state (struct gdbarch
*gdbarch
);
200 /* Description of the remote protocol registers. */
201 long sizeof_g_packet
;
203 /* Description of the remote protocol registers indexed by REGNUM
204 (making an array gdbarch_num_regs in size). */
205 std::unique_ptr
<packet_reg
[]> regs
;
207 /* This is the size (in chars) of the first response to the ``g''
208 packet. It is used as a heuristic when determining the maximum
209 size of memory-read and memory-write packets. A target will
210 typically only reserve a buffer large enough to hold the ``g''
211 packet. The size does not include packet overhead (headers and
213 long actual_register_packet_size
;
215 /* This is the maximum size (in chars) of a non read/write packet.
216 It is also used as a cap on the size of read/write packets. */
217 long remote_packet_size
;
220 /* Description of the remote protocol state for the currently
221 connected target. This is per-target state, and independent of the
222 selected architecture. */
231 /* Get the remote arch state for GDBARCH. */
232 struct remote_arch_state
*get_remote_arch_state (struct gdbarch
*gdbarch
);
236 /* A buffer to use for incoming packets, and its current size. The
237 buffer is grown dynamically for larger incoming packets.
238 Outgoing packets may also be constructed in this buffer.
239 The size of the buffer is always at least REMOTE_PACKET_SIZE;
240 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
242 gdb::char_vector buf
;
244 /* True if we're going through initial connection setup (finding out
245 about the remote side's threads, relocating symbols, etc.). */
246 bool starting_up
= false;
248 /* If we negotiated packet size explicitly (and thus can bypass
249 heuristics for the largest packet size that will not overflow
250 a buffer in the stub), this will be set to that packet size.
251 Otherwise zero, meaning to use the guessed size. */
252 long explicit_packet_size
= 0;
254 /* remote_wait is normally called when the target is running and
255 waits for a stop reply packet. But sometimes we need to call it
256 when the target is already stopped. We can send a "?" packet
257 and have remote_wait read the response. Or, if we already have
258 the response, we can stash it in BUF and tell remote_wait to
259 skip calling getpkt. This flag is set when BUF contains a
260 stop reply packet and the target is not waiting. */
261 int cached_wait_status
= 0;
263 /* True, if in no ack mode. That is, neither GDB nor the stub will
264 expect acks from each other. The connection is assumed to be
266 bool noack_mode
= false;
268 /* True if we're connected in extended remote mode. */
269 bool extended
= false;
271 /* True if we resumed the target and we're waiting for the target to
272 stop. In the mean time, we can't start another command/query.
273 The remote server wouldn't be ready to process it, so we'd
274 timeout waiting for a reply that would never come and eventually
275 we'd close the connection. This can happen in asynchronous mode
276 because we allow GDB commands while the target is running. */
277 bool waiting_for_stop_reply
= false;
279 /* The status of the stub support for the various vCont actions. */
280 vCont_action_support supports_vCont
;
281 /* Whether vCont support was probed already. This is a workaround
282 until packet_support is per-connection. */
283 bool supports_vCont_probed
;
285 /* True if the user has pressed Ctrl-C, but the target hasn't
286 responded to that. */
287 bool ctrlc_pending_p
= false;
289 /* True if we saw a Ctrl-C while reading or writing from/to the
290 remote descriptor. At that point it is not safe to send a remote
291 interrupt packet, so we instead remember we saw the Ctrl-C and
292 process it once we're done with sending/receiving the current
293 packet, which should be shortly. If however that takes too long,
294 and the user presses Ctrl-C again, we offer to disconnect. */
295 bool got_ctrlc_during_io
= false;
297 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
298 remote_open knows that we don't have a file open when the program
300 struct serial
*remote_desc
= nullptr;
302 /* These are the threads which we last sent to the remote system. The
303 TID member will be -1 for all or -2 for not sent yet. */
304 ptid_t general_thread
= null_ptid
;
305 ptid_t continue_thread
= null_ptid
;
307 /* This is the traceframe which we last selected on the remote system.
308 It will be -1 if no traceframe is selected. */
309 int remote_traceframe_number
= -1;
311 char *last_pass_packet
= nullptr;
313 /* The last QProgramSignals packet sent to the target. We bypass
314 sending a new program signals list down to the target if the new
315 packet is exactly the same as the last we sent. IOW, we only let
316 the target know about program signals list changes. */
317 char *last_program_signals_packet
= nullptr;
319 gdb_signal last_sent_signal
= GDB_SIGNAL_0
;
321 bool last_sent_step
= false;
323 /* The execution direction of the last resume we got. */
324 exec_direction_kind last_resume_exec_dir
= EXEC_FORWARD
;
326 char *finished_object
= nullptr;
327 char *finished_annex
= nullptr;
328 ULONGEST finished_offset
= 0;
330 /* Should we try the 'ThreadInfo' query packet?
332 This variable (NOT available to the user: auto-detect only!)
333 determines whether GDB will use the new, simpler "ThreadInfo"
334 query or the older, more complex syntax for thread queries.
335 This is an auto-detect variable (set to true at each connect,
336 and set to false when the target fails to recognize it). */
337 bool use_threadinfo_query
= false;
338 bool use_threadextra_query
= false;
340 threadref echo_nextthread
{};
341 threadref nextthread
{};
342 threadref resultthreadlist
[MAXTHREADLISTRESULTS
] {};
344 /* The state of remote notification. */
345 struct remote_notif_state
*notif_state
= nullptr;
347 /* The branch trace configuration. */
348 struct btrace_config btrace_config
{};
350 /* The argument to the last "vFile:setfs:" packet we sent, used
351 to avoid sending repeated unnecessary "vFile:setfs:" packets.
352 Initialized to -1 to indicate that no "vFile:setfs:" packet
353 has yet been sent. */
356 /* A readahead cache for vFile:pread. Often, reading a binary
357 involves a sequence of small reads. E.g., when parsing an ELF
358 file. A readahead cache helps mostly the case of remote
359 debugging on a connection with higher latency, due to the
360 request/reply nature of the RSP. We only cache data for a single
361 file descriptor at a time. */
362 struct readahead_cache readahead_cache
;
364 /* The list of already fetched and acknowledged stop events. This
365 queue is used for notification Stop, and other notifications
366 don't need queue for their events, because the notification
367 events of Stop can't be consumed immediately, so that events
368 should be queued first, and be consumed by remote_wait_{ns,as}
369 one per time. Other notifications can consume their events
370 immediately, so queue is not needed for them. */
371 std::vector
<stop_reply_up
> stop_reply_queue
;
373 /* Asynchronous signal handle registered as event loop source for
374 when we have pending events ready to be passed to the core. */
375 struct async_event_handler
*remote_async_inferior_event_token
= nullptr;
377 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
378 ``forever'' still use the normal timeout mechanism. This is
379 currently used by the ASYNC code to guarentee that target reads
380 during the initial connect always time-out. Once getpkt has been
381 modified to return a timeout indication and, in turn
382 remote_wait()/wait_for_inferior() have gained a timeout parameter
384 int wait_forever_enabled_p
= 1;
387 /* Mapping of remote protocol data for each gdbarch. Usually there
388 is only one entry here, though we may see more with stubs that
389 support multi-process. */
390 std::unordered_map
<struct gdbarch
*, remote_arch_state
>
394 static const target_info remote_target_info
= {
396 N_("Remote serial target in gdb-specific protocol"),
400 class remote_target
: public process_stratum_target
403 remote_target () = default;
404 ~remote_target () override
;
406 const target_info
&info () const override
407 { return remote_target_info
; }
409 const char *connection_string () override
;
411 thread_control_capabilities
get_thread_control_capabilities () override
412 { return tc_schedlock
; }
414 /* Open a remote connection. */
415 static void open (const char *, int);
417 void close () override
;
419 void detach (inferior
*, int) override
;
420 void disconnect (const char *, int) override
;
422 void commit_resume () override
;
423 void resume (ptid_t
, int, enum gdb_signal
) override
;
424 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
426 void fetch_registers (struct regcache
*, int) override
;
427 void store_registers (struct regcache
*, int) override
;
428 void prepare_to_store (struct regcache
*) override
;
430 void files_info () override
;
432 int insert_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
434 int remove_breakpoint (struct gdbarch
*, struct bp_target_info
*,
435 enum remove_bp_reason
) override
;
438 bool stopped_by_sw_breakpoint () override
;
439 bool supports_stopped_by_sw_breakpoint () override
;
441 bool stopped_by_hw_breakpoint () override
;
443 bool supports_stopped_by_hw_breakpoint () override
;
445 bool stopped_by_watchpoint () override
;
447 bool stopped_data_address (CORE_ADDR
*) override
;
449 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
451 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
453 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
455 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
457 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
459 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
460 struct expression
*) override
;
462 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
463 struct expression
*) override
;
465 void kill () override
;
467 void load (const char *, int) override
;
469 void mourn_inferior () override
;
471 void pass_signals (gdb::array_view
<const unsigned char>) override
;
473 int set_syscall_catchpoint (int, bool, int,
474 gdb::array_view
<const int>) override
;
476 void program_signals (gdb::array_view
<const unsigned char>) override
;
478 bool thread_alive (ptid_t ptid
) override
;
480 const char *thread_name (struct thread_info
*) override
;
482 void update_thread_list () override
;
484 std::string
pid_to_str (ptid_t
) override
;
486 const char *extra_thread_info (struct thread_info
*) override
;
488 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
490 thread_info
*thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
492 inferior
*inf
) override
;
494 gdb::byte_vector
thread_info_to_thread_handle (struct thread_info
*tp
)
497 void stop (ptid_t
) override
;
499 void interrupt () override
;
501 void pass_ctrlc () override
;
503 enum target_xfer_status
xfer_partial (enum target_object object
,
506 const gdb_byte
*writebuf
,
507 ULONGEST offset
, ULONGEST len
,
508 ULONGEST
*xfered_len
) override
;
510 ULONGEST
get_memory_xfer_limit () override
;
512 void rcmd (const char *command
, struct ui_file
*output
) override
;
514 char *pid_to_exec_file (int pid
) override
;
516 void log_command (const char *cmd
) override
518 serial_log_command (this, cmd
);
521 CORE_ADDR
get_thread_local_address (ptid_t ptid
,
522 CORE_ADDR load_module_addr
,
523 CORE_ADDR offset
) override
;
525 bool can_execute_reverse () override
;
527 std::vector
<mem_region
> memory_map () override
;
529 void flash_erase (ULONGEST address
, LONGEST length
) override
;
531 void flash_done () override
;
533 const struct target_desc
*read_description () override
;
535 int search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
536 const gdb_byte
*pattern
, ULONGEST pattern_len
,
537 CORE_ADDR
*found_addrp
) override
;
539 bool can_async_p () override
;
541 bool is_async_p () override
;
543 void async (int) override
;
545 int async_wait_fd () override
;
547 void thread_events (int) override
;
549 int can_do_single_step () override
;
551 void terminal_inferior () override
;
553 void terminal_ours () override
;
555 bool supports_non_stop () override
;
557 bool supports_multi_process () override
;
559 bool supports_disable_randomization () override
;
561 bool filesystem_is_local () override
;
564 int fileio_open (struct inferior
*inf
, const char *filename
,
565 int flags
, int mode
, int warn_if_slow
,
566 int *target_errno
) override
;
568 int fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
569 ULONGEST offset
, int *target_errno
) override
;
571 int fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
572 ULONGEST offset
, int *target_errno
) override
;
574 int fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
) override
;
576 int fileio_close (int fd
, int *target_errno
) override
;
578 int fileio_unlink (struct inferior
*inf
,
579 const char *filename
,
580 int *target_errno
) override
;
582 gdb::optional
<std::string
>
583 fileio_readlink (struct inferior
*inf
,
584 const char *filename
,
585 int *target_errno
) override
;
587 bool supports_enable_disable_tracepoint () override
;
589 bool supports_string_tracing () override
;
591 bool supports_evaluation_of_breakpoint_conditions () override
;
593 bool can_run_breakpoint_commands () override
;
595 void trace_init () override
;
597 void download_tracepoint (struct bp_location
*location
) override
;
599 bool can_download_tracepoint () override
;
601 void download_trace_state_variable (const trace_state_variable
&tsv
) override
;
603 void enable_tracepoint (struct bp_location
*location
) override
;
605 void disable_tracepoint (struct bp_location
*location
) override
;
607 void trace_set_readonly_regions () override
;
609 void trace_start () override
;
611 int get_trace_status (struct trace_status
*ts
) override
;
613 void get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
616 void trace_stop () override
;
618 int trace_find (enum trace_find_type type
, int num
,
619 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
) override
;
621 bool get_trace_state_variable_value (int tsv
, LONGEST
*val
) override
;
623 int save_trace_data (const char *filename
) override
;
625 int upload_tracepoints (struct uploaded_tp
**utpp
) override
;
627 int upload_trace_state_variables (struct uploaded_tsv
**utsvp
) override
;
629 LONGEST
get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
) override
;
631 int get_min_fast_tracepoint_insn_len () override
;
633 void set_disconnected_tracing (int val
) override
;
635 void set_circular_trace_buffer (int val
) override
;
637 void set_trace_buffer_size (LONGEST val
) override
;
639 bool set_trace_notes (const char *user
, const char *notes
,
640 const char *stopnotes
) override
;
642 int core_of_thread (ptid_t ptid
) override
;
644 int verify_memory (const gdb_byte
*data
,
645 CORE_ADDR memaddr
, ULONGEST size
) override
;
648 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
650 void set_permissions () override
;
652 bool static_tracepoint_marker_at (CORE_ADDR
,
653 struct static_tracepoint_marker
*marker
)
656 std::vector
<static_tracepoint_marker
>
657 static_tracepoint_markers_by_strid (const char *id
) override
;
659 traceframe_info_up
traceframe_info () override
;
661 bool use_agent (bool use
) override
;
662 bool can_use_agent () override
;
664 struct btrace_target_info
*enable_btrace (ptid_t ptid
,
665 const struct btrace_config
*conf
) override
;
667 void disable_btrace (struct btrace_target_info
*tinfo
) override
;
669 void teardown_btrace (struct btrace_target_info
*tinfo
) override
;
671 enum btrace_error
read_btrace (struct btrace_data
*data
,
672 struct btrace_target_info
*btinfo
,
673 enum btrace_read_type type
) override
;
675 const struct btrace_config
*btrace_conf (const struct btrace_target_info
*) override
;
676 bool augmented_libraries_svr4_read () override
;
677 int follow_fork (int, int) override
;
678 void follow_exec (struct inferior
*, const char *) override
;
679 int insert_fork_catchpoint (int) override
;
680 int remove_fork_catchpoint (int) override
;
681 int insert_vfork_catchpoint (int) override
;
682 int remove_vfork_catchpoint (int) override
;
683 int insert_exec_catchpoint (int) override
;
684 int remove_exec_catchpoint (int) override
;
685 enum exec_direction_kind
execution_direction () override
;
687 public: /* Remote specific methods. */
689 void remote_download_command_source (int num
, ULONGEST addr
,
690 struct command_line
*cmds
);
692 void remote_file_put (const char *local_file
, const char *remote_file
,
694 void remote_file_get (const char *remote_file
, const char *local_file
,
696 void remote_file_delete (const char *remote_file
, int from_tty
);
698 int remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
699 ULONGEST offset
, int *remote_errno
);
700 int remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
701 ULONGEST offset
, int *remote_errno
);
702 int remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
703 ULONGEST offset
, int *remote_errno
);
705 int remote_hostio_send_command (int command_bytes
, int which_packet
,
706 int *remote_errno
, char **attachment
,
707 int *attachment_len
);
708 int remote_hostio_set_filesystem (struct inferior
*inf
,
710 /* We should get rid of this and use fileio_open directly. */
711 int remote_hostio_open (struct inferior
*inf
, const char *filename
,
712 int flags
, int mode
, int warn_if_slow
,
714 int remote_hostio_close (int fd
, int *remote_errno
);
716 int remote_hostio_unlink (inferior
*inf
, const char *filename
,
719 struct remote_state
*get_remote_state ();
721 long get_remote_packet_size (void);
722 long get_memory_packet_size (struct memory_packet_config
*config
);
724 long get_memory_write_packet_size ();
725 long get_memory_read_packet_size ();
727 char *append_pending_thread_resumptions (char *p
, char *endp
,
729 static void open_1 (const char *name
, int from_tty
, int extended_p
);
730 void start_remote (int from_tty
, int extended_p
);
731 void remote_detach_1 (struct inferior
*inf
, int from_tty
);
733 char *append_resumption (char *p
, char *endp
,
734 ptid_t ptid
, int step
, gdb_signal siggnal
);
735 int remote_resume_with_vcont (ptid_t ptid
, int step
,
738 void add_current_inferior_and_thread (char *wait_status
);
740 ptid_t
wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
742 ptid_t
wait_as (ptid_t ptid
, target_waitstatus
*status
,
745 ptid_t
process_stop_reply (struct stop_reply
*stop_reply
,
746 target_waitstatus
*status
);
748 void remote_notice_new_inferior (ptid_t currthread
, int executing
);
750 void process_initial_stop_replies (int from_tty
);
752 thread_info
*remote_add_thread (ptid_t ptid
, bool running
, bool executing
);
754 void btrace_sync_conf (const btrace_config
*conf
);
756 void remote_btrace_maybe_reopen ();
758 void remove_new_fork_children (threads_listing_context
*context
);
759 void kill_new_fork_children (int pid
);
760 void discard_pending_stop_replies (struct inferior
*inf
);
761 int stop_reply_queue_length ();
763 void check_pending_events_prevent_wildcard_vcont
764 (int *may_global_wildcard_vcont
);
766 void discard_pending_stop_replies_in_queue ();
767 struct stop_reply
*remote_notif_remove_queued_reply (ptid_t ptid
);
768 struct stop_reply
*queued_stop_reply (ptid_t ptid
);
769 int peek_stop_reply (ptid_t ptid
);
770 void remote_parse_stop_reply (const char *buf
, stop_reply
*event
);
772 void remote_stop_ns (ptid_t ptid
);
773 void remote_interrupt_as ();
774 void remote_interrupt_ns ();
776 char *remote_get_noisy_reply ();
777 int remote_query_attached (int pid
);
778 inferior
*remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
781 ptid_t
remote_current_thread (ptid_t oldpid
);
782 ptid_t
get_current_thread (char *wait_status
);
784 void set_thread (ptid_t ptid
, int gen
);
785 void set_general_thread (ptid_t ptid
);
786 void set_continue_thread (ptid_t ptid
);
787 void set_general_process ();
789 char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
791 int remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
792 gdb_ext_thread_info
*info
);
793 int remote_get_threadinfo (threadref
*threadid
, int fieldset
,
794 gdb_ext_thread_info
*info
);
796 int parse_threadlist_response (char *pkt
, int result_limit
,
797 threadref
*original_echo
,
798 threadref
*resultlist
,
800 int remote_get_threadlist (int startflag
, threadref
*nextthread
,
801 int result_limit
, int *done
, int *result_count
,
802 threadref
*threadlist
);
804 int remote_threadlist_iterator (rmt_thread_action stepfunction
,
805 void *context
, int looplimit
);
807 int remote_get_threads_with_ql (threads_listing_context
*context
);
808 int remote_get_threads_with_qxfer (threads_listing_context
*context
);
809 int remote_get_threads_with_qthreadinfo (threads_listing_context
*context
);
811 void extended_remote_restart ();
815 void remote_check_symbols ();
817 void remote_supported_packet (const struct protocol_feature
*feature
,
818 enum packet_support support
,
819 const char *argument
);
821 void remote_query_supported ();
823 void remote_packet_size (const protocol_feature
*feature
,
824 packet_support support
, const char *value
);
826 void remote_serial_quit_handler ();
828 void remote_detach_pid (int pid
);
830 void remote_vcont_probe ();
832 void remote_resume_with_hc (ptid_t ptid
, int step
,
835 void send_interrupt_sequence ();
836 void interrupt_query ();
838 void remote_notif_get_pending_events (notif_client
*nc
);
840 int fetch_register_using_p (struct regcache
*regcache
,
842 int send_g_packet ();
843 void process_g_packet (struct regcache
*regcache
);
844 void fetch_registers_using_g (struct regcache
*regcache
);
845 int store_register_using_P (const struct regcache
*regcache
,
847 void store_registers_using_G (const struct regcache
*regcache
);
849 void set_remote_traceframe ();
851 void check_binary_download (CORE_ADDR addr
);
853 target_xfer_status
remote_write_bytes_aux (const char *header
,
855 const gdb_byte
*myaddr
,
858 ULONGEST
*xfered_len_units
,
862 target_xfer_status
remote_write_bytes (CORE_ADDR memaddr
,
863 const gdb_byte
*myaddr
, ULONGEST len
,
864 int unit_size
, ULONGEST
*xfered_len
);
866 target_xfer_status
remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
868 int unit_size
, ULONGEST
*xfered_len_units
);
870 target_xfer_status
remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
874 ULONGEST
*xfered_len
);
876 target_xfer_status
remote_read_bytes (CORE_ADDR memaddr
,
877 gdb_byte
*myaddr
, ULONGEST len
,
879 ULONGEST
*xfered_len
);
881 packet_result
remote_send_printf (const char *format
, ...)
882 ATTRIBUTE_PRINTF (2, 3);
884 target_xfer_status
remote_flash_write (ULONGEST address
,
885 ULONGEST length
, ULONGEST
*xfered_len
,
886 const gdb_byte
*data
);
888 int readchar (int timeout
);
890 void remote_serial_write (const char *str
, int len
);
892 int putpkt (const char *buf
);
893 int putpkt_binary (const char *buf
, int cnt
);
895 int putpkt (const gdb::char_vector
&buf
)
897 return putpkt (buf
.data ());
901 long read_frame (gdb::char_vector
*buf_p
);
902 void getpkt (gdb::char_vector
*buf
, int forever
);
903 int getpkt_or_notif_sane_1 (gdb::char_vector
*buf
, int forever
,
904 int expecting_notif
, int *is_notif
);
905 int getpkt_sane (gdb::char_vector
*buf
, int forever
);
906 int getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
908 int remote_vkill (int pid
);
909 void remote_kill_k ();
911 void extended_remote_disable_randomization (int val
);
912 int extended_remote_run (const std::string
&args
);
914 void send_environment_packet (const char *action
,
918 void extended_remote_environment_support ();
919 void extended_remote_set_inferior_cwd ();
921 target_xfer_status
remote_write_qxfer (const char *object_name
,
923 const gdb_byte
*writebuf
,
924 ULONGEST offset
, LONGEST len
,
925 ULONGEST
*xfered_len
,
926 struct packet_config
*packet
);
928 target_xfer_status
remote_read_qxfer (const char *object_name
,
930 gdb_byte
*readbuf
, ULONGEST offset
,
932 ULONGEST
*xfered_len
,
933 struct packet_config
*packet
);
935 void push_stop_reply (struct stop_reply
*new_event
);
937 bool vcont_r_supported ();
939 void packet_command (const char *args
, int from_tty
);
941 private: /* data fields */
943 /* The remote state. Don't reference this directly. Use the
944 get_remote_state method instead. */
945 remote_state m_remote_state
;
948 static const target_info extended_remote_target_info
= {
950 N_("Extended remote serial target in gdb-specific protocol"),
954 /* Set up the extended remote target by extending the standard remote
955 target and adding to it. */
957 class extended_remote_target final
: public remote_target
960 const target_info
&info () const override
961 { return extended_remote_target_info
; }
963 /* Open an extended-remote connection. */
964 static void open (const char *, int);
966 bool can_create_inferior () override
{ return true; }
967 void create_inferior (const char *, const std::string
&,
968 char **, int) override
;
970 void detach (inferior
*, int) override
;
972 bool can_attach () override
{ return true; }
973 void attach (const char *, int) override
;
975 void post_attach (int) override
;
976 bool supports_disable_randomization () override
;
979 /* Per-program-space data key. */
980 static const struct program_space_key
<char, gdb::xfree_deleter
<char>>
983 /* The variable registered as the control variable used by the
984 remote exec-file commands. While the remote exec-file setting is
985 per-program-space, the set/show machinery uses this as the
986 location of the remote exec-file value. */
987 static char *remote_exec_file_var
;
989 /* The size to align memory write packets, when practical. The protocol
990 does not guarantee any alignment, and gdb will generate short
991 writes and unaligned writes, but even as a best-effort attempt this
992 can improve bulk transfers. For instance, if a write is misaligned
993 relative to the target's data bus, the stub may need to make an extra
994 round trip fetching data from the target. This doesn't make a
995 huge difference, but it's easy to do, so we try to be helpful.
997 The alignment chosen is arbitrary; usually data bus width is
998 important here, not the possibly larger cache line size. */
999 enum { REMOTE_ALIGN_WRITES
= 16 };
1001 /* Prototypes for local functions. */
1003 static int hexnumlen (ULONGEST num
);
1005 static int stubhex (int ch
);
1007 static int hexnumstr (char *, ULONGEST
);
1009 static int hexnumnstr (char *, ULONGEST
, int);
1011 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
1013 static void print_packet (const char *);
1015 static int stub_unpack_int (char *buff
, int fieldlength
);
1017 struct packet_config
;
1019 static void show_packet_config_cmd (struct packet_config
*config
);
1021 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
1023 struct cmd_list_element
*c
,
1026 static ptid_t
read_ptid (const char *buf
, const char **obuf
);
1028 static void remote_async_inferior_event_handler (gdb_client_data
);
1030 static bool remote_read_description_p (struct target_ops
*target
);
1032 static void remote_console_output (const char *msg
);
1034 static void remote_btrace_reset (remote_state
*rs
);
1036 static void remote_unpush_and_throw (remote_target
*target
);
1040 static struct cmd_list_element
*remote_cmdlist
;
1042 /* For "set remote" and "show remote". */
1044 static struct cmd_list_element
*remote_set_cmdlist
;
1045 static struct cmd_list_element
*remote_show_cmdlist
;
1047 /* Controls whether GDB is willing to use range stepping. */
1049 static bool use_range_stepping
= true;
1051 /* Private data that we'll store in (struct thread_info)->priv. */
1052 struct remote_thread_info
: public private_thread_info
1058 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1059 sequence of bytes. */
1060 gdb::byte_vector thread_handle
;
1062 /* Whether the target stopped for a breakpoint/watchpoint. */
1063 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1065 /* This is set to the data address of the access causing the target
1066 to stop for a watchpoint. */
1067 CORE_ADDR watch_data_address
= 0;
1069 /* Fields used by the vCont action coalescing implemented in
1070 remote_resume / remote_commit_resume. remote_resume stores each
1071 thread's last resume request in these fields, so that a later
1072 remote_commit_resume knows which is the proper action for this
1073 thread to include in the vCont packet. */
1075 /* True if the last target_resume call for this thread was a step
1076 request, false if a continue request. */
1077 int last_resume_step
= 0;
1079 /* The signal specified in the last target_resume call for this
1081 gdb_signal last_resume_sig
= GDB_SIGNAL_0
;
1083 /* Whether this thread was already vCont-resumed on the remote
1085 int vcont_resumed
= 0;
1088 remote_state::remote_state ()
1093 remote_state::~remote_state ()
1095 xfree (this->last_pass_packet
);
1096 xfree (this->last_program_signals_packet
);
1097 xfree (this->finished_object
);
1098 xfree (this->finished_annex
);
1101 /* Utility: generate error from an incoming stub packet. */
1103 trace_error (char *buf
)
1106 return; /* not an error msg */
1109 case '1': /* malformed packet error */
1110 if (*++buf
== '0') /* general case: */
1111 error (_("remote.c: error in outgoing packet."));
1113 error (_("remote.c: error in outgoing packet at field #%ld."),
1114 strtol (buf
, NULL
, 16));
1116 error (_("Target returns error code '%s'."), buf
);
1120 /* Utility: wait for reply from stub, while accepting "O" packets. */
1123 remote_target::remote_get_noisy_reply ()
1125 struct remote_state
*rs
= get_remote_state ();
1127 do /* Loop on reply from remote stub. */
1131 QUIT
; /* Allow user to bail out with ^C. */
1132 getpkt (&rs
->buf
, 0);
1133 buf
= rs
->buf
.data ();
1136 else if (startswith (buf
, "qRelocInsn:"))
1139 CORE_ADDR from
, to
, org_to
;
1141 int adjusted_size
= 0;
1144 p
= buf
+ strlen ("qRelocInsn:");
1145 pp
= unpack_varlen_hex (p
, &ul
);
1147 error (_("invalid qRelocInsn packet: %s"), buf
);
1151 unpack_varlen_hex (p
, &ul
);
1158 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1161 catch (const gdb_exception
&ex
)
1163 if (ex
.error
== MEMORY_ERROR
)
1165 /* Propagate memory errors silently back to the
1166 target. The stub may have limited the range of
1167 addresses we can write to, for example. */
1171 /* Something unexpectedly bad happened. Be verbose
1172 so we can tell what, and propagate the error back
1173 to the stub, so it doesn't get stuck waiting for
1175 exception_fprintf (gdb_stderr
, ex
,
1176 _("warning: relocating instruction: "));
1183 adjusted_size
= to
- org_to
;
1185 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1189 else if (buf
[0] == 'O' && buf
[1] != 'K')
1190 remote_console_output (buf
+ 1); /* 'O' message from stub */
1192 return buf
; /* Here's the actual reply. */
1197 struct remote_arch_state
*
1198 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1200 remote_arch_state
*rsa
;
1202 auto it
= this->m_arch_states
.find (gdbarch
);
1203 if (it
== this->m_arch_states
.end ())
1205 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1206 std::forward_as_tuple (gdbarch
),
1207 std::forward_as_tuple (gdbarch
));
1208 rsa
= &p
.first
->second
;
1210 /* Make sure that the packet buffer is plenty big enough for
1211 this architecture. */
1212 if (this->buf
.size () < rsa
->remote_packet_size
)
1213 this->buf
.resize (2 * rsa
->remote_packet_size
);
1221 /* Fetch the global remote target state. */
1224 remote_target::get_remote_state ()
1226 /* Make sure that the remote architecture state has been
1227 initialized, because doing so might reallocate rs->buf. Any
1228 function which calls getpkt also needs to be mindful of changes
1229 to rs->buf, but this call limits the number of places which run
1231 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1233 return &m_remote_state
;
1236 /* Fetch the remote exec-file from the current program space. */
1239 get_remote_exec_file (void)
1241 char *remote_exec_file
;
1243 remote_exec_file
= remote_pspace_data
.get (current_program_space
);
1244 if (remote_exec_file
== NULL
)
1247 return remote_exec_file
;
1250 /* Set the remote exec file for PSPACE. */
1253 set_pspace_remote_exec_file (struct program_space
*pspace
,
1254 const char *remote_exec_file
)
1256 char *old_file
= remote_pspace_data
.get (pspace
);
1259 remote_pspace_data
.set (pspace
, xstrdup (remote_exec_file
));
1262 /* The "set/show remote exec-file" set command hook. */
1265 set_remote_exec_file (const char *ignored
, int from_tty
,
1266 struct cmd_list_element
*c
)
1268 gdb_assert (remote_exec_file_var
!= NULL
);
1269 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
1272 /* The "set/show remote exec-file" show command hook. */
1275 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1276 struct cmd_list_element
*cmd
, const char *value
)
1278 fprintf_filtered (file
, "%s\n", get_remote_exec_file ());
1282 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1284 int regnum
, num_remote_regs
, offset
;
1285 struct packet_reg
**remote_regs
;
1287 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1289 struct packet_reg
*r
= ®s
[regnum
];
1291 if (register_size (gdbarch
, regnum
) == 0)
1292 /* Do not try to fetch zero-sized (placeholder) registers. */
1295 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1300 /* Define the g/G packet format as the contents of each register
1301 with a remote protocol number, in order of ascending protocol
1304 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1305 for (num_remote_regs
= 0, regnum
= 0;
1306 regnum
< gdbarch_num_regs (gdbarch
);
1308 if (regs
[regnum
].pnum
!= -1)
1309 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1311 std::sort (remote_regs
, remote_regs
+ num_remote_regs
,
1312 [] (const packet_reg
*a
, const packet_reg
*b
)
1313 { return a
->pnum
< b
->pnum
; });
1315 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1317 remote_regs
[regnum
]->in_g_packet
= 1;
1318 remote_regs
[regnum
]->offset
= offset
;
1319 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1325 /* Given the architecture described by GDBARCH, return the remote
1326 protocol register's number and the register's offset in the g/G
1327 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1328 If the target does not have a mapping for REGNUM, return false,
1329 otherwise, return true. */
1332 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1333 int *pnum
, int *poffset
)
1335 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1337 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1339 map_regcache_remote_table (gdbarch
, regs
.data ());
1341 *pnum
= regs
[regnum
].pnum
;
1342 *poffset
= regs
[regnum
].offset
;
1347 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1349 /* Use the architecture to build a regnum<->pnum table, which will be
1350 1:1 unless a feature set specifies otherwise. */
1351 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1353 /* Record the maximum possible size of the g packet - it may turn out
1355 this->sizeof_g_packet
1356 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1358 /* Default maximum number of characters in a packet body. Many
1359 remote stubs have a hardwired buffer size of 400 bytes
1360 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1361 as the maximum packet-size to ensure that the packet and an extra
1362 NUL character can always fit in the buffer. This stops GDB
1363 trashing stubs that try to squeeze an extra NUL into what is
1364 already a full buffer (As of 1999-12-04 that was most stubs). */
1365 this->remote_packet_size
= 400 - 1;
1367 /* This one is filled in when a ``g'' packet is received. */
1368 this->actual_register_packet_size
= 0;
1370 /* Should rsa->sizeof_g_packet needs more space than the
1371 default, adjust the size accordingly. Remember that each byte is
1372 encoded as two characters. 32 is the overhead for the packet
1373 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1374 (``$NN:G...#NN'') is a better guess, the below has been padded a
1376 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1377 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1380 /* Get a pointer to the current remote target. If not connected to a
1381 remote target, return NULL. */
1383 static remote_target
*
1384 get_current_remote_target ()
1386 target_ops
*proc_target
= current_inferior ()->process_target ();
1387 return dynamic_cast<remote_target
*> (proc_target
);
1390 /* Return the current allowed size of a remote packet. This is
1391 inferred from the current architecture, and should be used to
1392 limit the length of outgoing packets. */
1394 remote_target::get_remote_packet_size ()
1396 struct remote_state
*rs
= get_remote_state ();
1397 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1399 if (rs
->explicit_packet_size
)
1400 return rs
->explicit_packet_size
;
1402 return rsa
->remote_packet_size
;
1405 static struct packet_reg
*
1406 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1409 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1413 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1415 gdb_assert (r
->regnum
== regnum
);
1420 static struct packet_reg
*
1421 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1426 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1428 struct packet_reg
*r
= &rsa
->regs
[i
];
1430 if (r
->pnum
== pnum
)
1436 /* Allow the user to specify what sequence to send to the remote
1437 when he requests a program interruption: Although ^C is usually
1438 what remote systems expect (this is the default, here), it is
1439 sometimes preferable to send a break. On other systems such
1440 as the Linux kernel, a break followed by g, which is Magic SysRq g
1441 is required in order to interrupt the execution. */
1442 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1443 const char interrupt_sequence_break
[] = "BREAK";
1444 const char interrupt_sequence_break_g
[] = "BREAK-g";
1445 static const char *const interrupt_sequence_modes
[] =
1447 interrupt_sequence_control_c
,
1448 interrupt_sequence_break
,
1449 interrupt_sequence_break_g
,
1452 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1455 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1456 struct cmd_list_element
*c
,
1459 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1460 fprintf_filtered (file
,
1461 _("Send the ASCII ETX character (Ctrl-c) "
1462 "to the remote target to interrupt the "
1463 "execution of the program.\n"));
1464 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1465 fprintf_filtered (file
,
1466 _("send a break signal to the remote target "
1467 "to interrupt the execution of the program.\n"));
1468 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1469 fprintf_filtered (file
,
1470 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1471 "the remote target to interrupt the execution "
1472 "of Linux kernel.\n"));
1474 internal_error (__FILE__
, __LINE__
,
1475 _("Invalid value for interrupt_sequence_mode: %s."),
1476 interrupt_sequence_mode
);
1479 /* This boolean variable specifies whether interrupt_sequence is sent
1480 to the remote target when gdb connects to it.
1481 This is mostly needed when you debug the Linux kernel: The Linux kernel
1482 expects BREAK g which is Magic SysRq g for connecting gdb. */
1483 static bool interrupt_on_connect
= false;
1485 /* This variable is used to implement the "set/show remotebreak" commands.
1486 Since these commands are now deprecated in favor of "set/show remote
1487 interrupt-sequence", it no longer has any effect on the code. */
1488 static bool remote_break
;
1491 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1494 interrupt_sequence_mode
= interrupt_sequence_break
;
1496 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1500 show_remotebreak (struct ui_file
*file
, int from_tty
,
1501 struct cmd_list_element
*c
,
1506 /* This variable sets the number of bits in an address that are to be
1507 sent in a memory ("M" or "m") packet. Normally, after stripping
1508 leading zeros, the entire address would be sent. This variable
1509 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1510 initial implementation of remote.c restricted the address sent in
1511 memory packets to ``host::sizeof long'' bytes - (typically 32
1512 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1513 address was never sent. Since fixing this bug may cause a break in
1514 some remote targets this variable is principally provided to
1515 facilitate backward compatibility. */
1517 static unsigned int remote_address_size
;
1520 /* User configurable variables for the number of characters in a
1521 memory read/write packet. MIN (rsa->remote_packet_size,
1522 rsa->sizeof_g_packet) is the default. Some targets need smaller
1523 values (fifo overruns, et.al.) and some users need larger values
1524 (speed up transfers). The variables ``preferred_*'' (the user
1525 request), ``current_*'' (what was actually set) and ``forced_*''
1526 (Positive - a soft limit, negative - a hard limit). */
1528 struct memory_packet_config
1535 /* The default max memory-write-packet-size, when the setting is
1536 "fixed". The 16k is historical. (It came from older GDB's using
1537 alloca for buffers and the knowledge (folklore?) that some hosts
1538 don't cope very well with large alloca calls.) */
1539 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1541 /* The minimum remote packet size for memory transfers. Ensures we
1542 can write at least one byte. */
1543 #define MIN_MEMORY_PACKET_SIZE 20
1545 /* Get the memory packet size, assuming it is fixed. */
1548 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1550 gdb_assert (config
->fixed_p
);
1552 if (config
->size
<= 0)
1553 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1555 return config
->size
;
1558 /* Compute the current size of a read/write packet. Since this makes
1559 use of ``actual_register_packet_size'' the computation is dynamic. */
1562 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1564 struct remote_state
*rs
= get_remote_state ();
1565 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1568 if (config
->fixed_p
)
1569 what_they_get
= get_fixed_memory_packet_size (config
);
1572 what_they_get
= get_remote_packet_size ();
1573 /* Limit the packet to the size specified by the user. */
1574 if (config
->size
> 0
1575 && what_they_get
> config
->size
)
1576 what_they_get
= config
->size
;
1578 /* Limit it to the size of the targets ``g'' response unless we have
1579 permission from the stub to use a larger packet size. */
1580 if (rs
->explicit_packet_size
== 0
1581 && rsa
->actual_register_packet_size
> 0
1582 && what_they_get
> rsa
->actual_register_packet_size
)
1583 what_they_get
= rsa
->actual_register_packet_size
;
1585 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1586 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1588 /* Make sure there is room in the global buffer for this packet
1589 (including its trailing NUL byte). */
1590 if (rs
->buf
.size () < what_they_get
+ 1)
1591 rs
->buf
.resize (2 * what_they_get
);
1593 return what_they_get
;
1596 /* Update the size of a read/write packet. If they user wants
1597 something really big then do a sanity check. */
1600 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1602 int fixed_p
= config
->fixed_p
;
1603 long size
= config
->size
;
1606 error (_("Argument required (integer, `fixed' or `limited')."));
1607 else if (strcmp (args
, "hard") == 0
1608 || strcmp (args
, "fixed") == 0)
1610 else if (strcmp (args
, "soft") == 0
1611 || strcmp (args
, "limit") == 0)
1617 size
= strtoul (args
, &end
, 0);
1619 error (_("Invalid %s (bad syntax)."), config
->name
);
1621 /* Instead of explicitly capping the size of a packet to or
1622 disallowing it, the user is allowed to set the size to
1623 something arbitrarily large. */
1627 if (fixed_p
&& !config
->fixed_p
)
1629 /* So that the query shows the correct value. */
1630 long query_size
= (size
<= 0
1631 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1634 if (! query (_("The target may not be able to correctly handle a %s\n"
1635 "of %ld bytes. Change the packet size? "),
1636 config
->name
, query_size
))
1637 error (_("Packet size not changed."));
1639 /* Update the config. */
1640 config
->fixed_p
= fixed_p
;
1641 config
->size
= size
;
1645 show_memory_packet_size (struct memory_packet_config
*config
)
1647 if (config
->size
== 0)
1648 printf_filtered (_("The %s is 0 (default). "), config
->name
);
1650 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1651 if (config
->fixed_p
)
1652 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1653 get_fixed_memory_packet_size (config
));
1656 remote_target
*remote
= get_current_remote_target ();
1659 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1660 remote
->get_memory_packet_size (config
));
1662 puts_filtered ("The actual limit will be further reduced "
1663 "dependent on the target.\n");
1667 /* FIXME: needs to be per-remote-target. */
1668 static struct memory_packet_config memory_write_packet_config
=
1670 "memory-write-packet-size",
1674 set_memory_write_packet_size (const char *args
, int from_tty
)
1676 set_memory_packet_size (args
, &memory_write_packet_config
);
1680 show_memory_write_packet_size (const char *args
, int from_tty
)
1682 show_memory_packet_size (&memory_write_packet_config
);
1685 /* Show the number of hardware watchpoints that can be used. */
1688 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1689 struct cmd_list_element
*c
,
1692 fprintf_filtered (file
, _("The maximum number of target hardware "
1693 "watchpoints is %s.\n"), value
);
1696 /* Show the length limit (in bytes) for hardware watchpoints. */
1699 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1700 struct cmd_list_element
*c
,
1703 fprintf_filtered (file
, _("The maximum length (in bytes) of a target "
1704 "hardware watchpoint is %s.\n"), value
);
1707 /* Show the number of hardware breakpoints that can be used. */
1710 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1711 struct cmd_list_element
*c
,
1714 fprintf_filtered (file
, _("The maximum number of target hardware "
1715 "breakpoints is %s.\n"), value
);
1718 /* Controls the maximum number of characters to display in the debug output
1719 for each remote packet. The remaining characters are omitted. */
1721 static int remote_packet_max_chars
= 512;
1723 /* Show the maximum number of characters to display for each remote packet
1724 when remote debugging is enabled. */
1727 show_remote_packet_max_chars (struct ui_file
*file
, int from_tty
,
1728 struct cmd_list_element
*c
,
1731 fprintf_filtered (file
, _("Number of remote packet characters to "
1732 "display is %s.\n"), value
);
1736 remote_target::get_memory_write_packet_size ()
1738 return get_memory_packet_size (&memory_write_packet_config
);
1741 /* FIXME: needs to be per-remote-target. */
1742 static struct memory_packet_config memory_read_packet_config
=
1744 "memory-read-packet-size",
1748 set_memory_read_packet_size (const char *args
, int from_tty
)
1750 set_memory_packet_size (args
, &memory_read_packet_config
);
1754 show_memory_read_packet_size (const char *args
, int from_tty
)
1756 show_memory_packet_size (&memory_read_packet_config
);
1760 remote_target::get_memory_read_packet_size ()
1762 long size
= get_memory_packet_size (&memory_read_packet_config
);
1764 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1765 extra buffer size argument before the memory read size can be
1766 increased beyond this. */
1767 if (size
> get_remote_packet_size ())
1768 size
= get_remote_packet_size ();
1774 struct packet_config
1779 /* If auto, GDB auto-detects support for this packet or feature,
1780 either through qSupported, or by trying the packet and looking
1781 at the response. If true, GDB assumes the target supports this
1782 packet. If false, the packet is disabled. Configs that don't
1783 have an associated command always have this set to auto. */
1784 enum auto_boolean detect
;
1786 /* Does the target support this packet? */
1787 enum packet_support support
;
1790 static enum packet_support
packet_config_support (struct packet_config
*config
);
1791 static enum packet_support
packet_support (int packet
);
1794 show_packet_config_cmd (struct packet_config
*config
)
1796 const char *support
= "internal-error";
1798 switch (packet_config_support (config
))
1801 support
= "enabled";
1803 case PACKET_DISABLE
:
1804 support
= "disabled";
1806 case PACKET_SUPPORT_UNKNOWN
:
1807 support
= "unknown";
1810 switch (config
->detect
)
1812 case AUTO_BOOLEAN_AUTO
:
1813 printf_filtered (_("Support for the `%s' packet "
1814 "is auto-detected, currently %s.\n"),
1815 config
->name
, support
);
1817 case AUTO_BOOLEAN_TRUE
:
1818 case AUTO_BOOLEAN_FALSE
:
1819 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1820 config
->name
, support
);
1826 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1827 const char *title
, int legacy
)
1833 config
->name
= name
;
1834 config
->title
= title
;
1835 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1837 show_doc
= xstrprintf ("Show current use of remote "
1838 "protocol `%s' (%s) packet.",
1840 /* set/show TITLE-packet {auto,on,off} */
1841 cmd_name
= xstrprintf ("%s-packet", title
);
1842 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1843 &config
->detect
, set_doc
,
1844 show_doc
, NULL
, /* help_doc */
1846 show_remote_protocol_packet_cmd
,
1847 &remote_set_cmdlist
, &remote_show_cmdlist
);
1848 /* The command code copies the documentation strings. */
1851 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1856 legacy_name
= xstrprintf ("%s-packet", name
);
1857 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1858 &remote_set_cmdlist
);
1859 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1860 &remote_show_cmdlist
);
1864 static enum packet_result
1865 packet_check_result (const char *buf
)
1869 /* The stub recognized the packet request. Check that the
1870 operation succeeded. */
1872 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1874 /* "Enn" - definitely an error. */
1875 return PACKET_ERROR
;
1877 /* Always treat "E." as an error. This will be used for
1878 more verbose error messages, such as E.memtypes. */
1879 if (buf
[0] == 'E' && buf
[1] == '.')
1880 return PACKET_ERROR
;
1882 /* The packet may or may not be OK. Just assume it is. */
1886 /* The stub does not support the packet. */
1887 return PACKET_UNKNOWN
;
1890 static enum packet_result
1891 packet_check_result (const gdb::char_vector
&buf
)
1893 return packet_check_result (buf
.data ());
1896 static enum packet_result
1897 packet_ok (const char *buf
, struct packet_config
*config
)
1899 enum packet_result result
;
1901 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1902 && config
->support
== PACKET_DISABLE
)
1903 internal_error (__FILE__
, __LINE__
,
1904 _("packet_ok: attempt to use a disabled packet"));
1906 result
= packet_check_result (buf
);
1911 /* The stub recognized the packet request. */
1912 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1915 fprintf_unfiltered (gdb_stdlog
,
1916 "Packet %s (%s) is supported\n",
1917 config
->name
, config
->title
);
1918 config
->support
= PACKET_ENABLE
;
1921 case PACKET_UNKNOWN
:
1922 /* The stub does not support the packet. */
1923 if (config
->detect
== AUTO_BOOLEAN_AUTO
1924 && config
->support
== PACKET_ENABLE
)
1926 /* If the stub previously indicated that the packet was
1927 supported then there is a protocol error. */
1928 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1929 config
->name
, config
->title
);
1931 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
1933 /* The user set it wrong. */
1934 error (_("Enabled packet %s (%s) not recognized by stub"),
1935 config
->name
, config
->title
);
1939 fprintf_unfiltered (gdb_stdlog
,
1940 "Packet %s (%s) is NOT supported\n",
1941 config
->name
, config
->title
);
1942 config
->support
= PACKET_DISABLE
;
1949 static enum packet_result
1950 packet_ok (const gdb::char_vector
&buf
, struct packet_config
*config
)
1952 return packet_ok (buf
.data (), config
);
1969 PACKET_vFile_pwrite
,
1971 PACKET_vFile_unlink
,
1972 PACKET_vFile_readlink
,
1975 PACKET_qXfer_features
,
1976 PACKET_qXfer_exec_file
,
1977 PACKET_qXfer_libraries
,
1978 PACKET_qXfer_libraries_svr4
,
1979 PACKET_qXfer_memory_map
,
1980 PACKET_qXfer_osdata
,
1981 PACKET_qXfer_threads
,
1982 PACKET_qXfer_statictrace_read
,
1983 PACKET_qXfer_traceframe_info
,
1989 PACKET_QPassSignals
,
1990 PACKET_QCatchSyscalls
,
1991 PACKET_QProgramSignals
,
1992 PACKET_QSetWorkingDir
,
1993 PACKET_QStartupWithShell
,
1994 PACKET_QEnvironmentHexEncoded
,
1995 PACKET_QEnvironmentReset
,
1996 PACKET_QEnvironmentUnset
,
1998 PACKET_qSearch_memory
,
2001 PACKET_QStartNoAckMode
,
2003 PACKET_qXfer_siginfo_read
,
2004 PACKET_qXfer_siginfo_write
,
2007 /* Support for conditional tracepoints. */
2008 PACKET_ConditionalTracepoints
,
2010 /* Support for target-side breakpoint conditions. */
2011 PACKET_ConditionalBreakpoints
,
2013 /* Support for target-side breakpoint commands. */
2014 PACKET_BreakpointCommands
,
2016 /* Support for fast tracepoints. */
2017 PACKET_FastTracepoints
,
2019 /* Support for static tracepoints. */
2020 PACKET_StaticTracepoints
,
2022 /* Support for installing tracepoints while a trace experiment is
2024 PACKET_InstallInTrace
,
2028 PACKET_TracepointSource
,
2031 PACKET_QDisableRandomization
,
2033 PACKET_QTBuffer_size
,
2037 PACKET_qXfer_btrace
,
2039 /* Support for the QNonStop packet. */
2042 /* Support for the QThreadEvents packet. */
2043 PACKET_QThreadEvents
,
2045 /* Support for multi-process extensions. */
2046 PACKET_multiprocess_feature
,
2048 /* Support for enabling and disabling tracepoints while a trace
2049 experiment is running. */
2050 PACKET_EnableDisableTracepoints_feature
,
2052 /* Support for collecting strings using the tracenz bytecode. */
2053 PACKET_tracenz_feature
,
2055 /* Support for continuing to run a trace experiment while GDB is
2057 PACKET_DisconnectedTracing_feature
,
2059 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2060 PACKET_augmented_libraries_svr4_read_feature
,
2062 /* Support for the qXfer:btrace-conf:read packet. */
2063 PACKET_qXfer_btrace_conf
,
2065 /* Support for the Qbtrace-conf:bts:size packet. */
2066 PACKET_Qbtrace_conf_bts_size
,
2068 /* Support for swbreak+ feature. */
2069 PACKET_swbreak_feature
,
2071 /* Support for hwbreak+ feature. */
2072 PACKET_hwbreak_feature
,
2074 /* Support for fork events. */
2075 PACKET_fork_event_feature
,
2077 /* Support for vfork events. */
2078 PACKET_vfork_event_feature
,
2080 /* Support for the Qbtrace-conf:pt:size packet. */
2081 PACKET_Qbtrace_conf_pt_size
,
2083 /* Support for exec events. */
2084 PACKET_exec_event_feature
,
2086 /* Support for query supported vCont actions. */
2087 PACKET_vContSupported
,
2089 /* Support remote CTRL-C. */
2092 /* Support TARGET_WAITKIND_NO_RESUMED. */
2098 /* FIXME: needs to be per-remote-target. Ignoring this for now,
2099 assuming all remote targets are the same server (thus all support
2100 the same packets). */
2101 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
2103 /* Returns the packet's corresponding "set remote foo-packet" command
2104 state. See struct packet_config for more details. */
2106 static enum auto_boolean
2107 packet_set_cmd_state (int packet
)
2109 return remote_protocol_packets
[packet
].detect
;
2112 /* Returns whether a given packet or feature is supported. This takes
2113 into account the state of the corresponding "set remote foo-packet"
2114 command, which may be used to bypass auto-detection. */
2116 static enum packet_support
2117 packet_config_support (struct packet_config
*config
)
2119 switch (config
->detect
)
2121 case AUTO_BOOLEAN_TRUE
:
2122 return PACKET_ENABLE
;
2123 case AUTO_BOOLEAN_FALSE
:
2124 return PACKET_DISABLE
;
2125 case AUTO_BOOLEAN_AUTO
:
2126 return config
->support
;
2128 gdb_assert_not_reached (_("bad switch"));
2132 /* Same as packet_config_support, but takes the packet's enum value as
2135 static enum packet_support
2136 packet_support (int packet
)
2138 struct packet_config
*config
= &remote_protocol_packets
[packet
];
2140 return packet_config_support (config
);
2144 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
2145 struct cmd_list_element
*c
,
2148 struct packet_config
*packet
;
2150 for (packet
= remote_protocol_packets
;
2151 packet
< &remote_protocol_packets
[PACKET_MAX
];
2154 if (&packet
->detect
== c
->var
)
2156 show_packet_config_cmd (packet
);
2160 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
2164 /* Should we try one of the 'Z' requests? */
2168 Z_PACKET_SOFTWARE_BP
,
2169 Z_PACKET_HARDWARE_BP
,
2176 /* For compatibility with older distributions. Provide a ``set remote
2177 Z-packet ...'' command that updates all the Z packet types. */
2179 static enum auto_boolean remote_Z_packet_detect
;
2182 set_remote_protocol_Z_packet_cmd (const char *args
, int from_tty
,
2183 struct cmd_list_element
*c
)
2187 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2188 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
2192 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
2193 struct cmd_list_element
*c
,
2198 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2200 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
2204 /* Returns true if the multi-process extensions are in effect. */
2207 remote_multi_process_p (struct remote_state
*rs
)
2209 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
2212 /* Returns true if fork events are supported. */
2215 remote_fork_event_p (struct remote_state
*rs
)
2217 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
2220 /* Returns true if vfork events are supported. */
2223 remote_vfork_event_p (struct remote_state
*rs
)
2225 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
2228 /* Returns true if exec events are supported. */
2231 remote_exec_event_p (struct remote_state
*rs
)
2233 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
2236 /* Insert fork catchpoint target routine. If fork events are enabled
2237 then return success, nothing more to do. */
2240 remote_target::insert_fork_catchpoint (int pid
)
2242 struct remote_state
*rs
= get_remote_state ();
2244 return !remote_fork_event_p (rs
);
2247 /* Remove fork catchpoint target routine. Nothing to do, just
2251 remote_target::remove_fork_catchpoint (int pid
)
2256 /* Insert vfork catchpoint target routine. If vfork events are enabled
2257 then return success, nothing more to do. */
2260 remote_target::insert_vfork_catchpoint (int pid
)
2262 struct remote_state
*rs
= get_remote_state ();
2264 return !remote_vfork_event_p (rs
);
2267 /* Remove vfork catchpoint target routine. Nothing to do, just
2271 remote_target::remove_vfork_catchpoint (int pid
)
2276 /* Insert exec catchpoint target routine. If exec events are
2277 enabled, just return success. */
2280 remote_target::insert_exec_catchpoint (int pid
)
2282 struct remote_state
*rs
= get_remote_state ();
2284 return !remote_exec_event_p (rs
);
2287 /* Remove exec catchpoint target routine. Nothing to do, just
2291 remote_target::remove_exec_catchpoint (int pid
)
2298 /* Take advantage of the fact that the TID field is not used, to tag
2299 special ptids with it set to != 0. */
2300 static const ptid_t
magic_null_ptid (42000, -1, 1);
2301 static const ptid_t
not_sent_ptid (42000, -2, 1);
2302 static const ptid_t
any_thread_ptid (42000, 0, 1);
2304 /* Find out if the stub attached to PID (and hence GDB should offer to
2305 detach instead of killing it when bailing out). */
2308 remote_target::remote_query_attached (int pid
)
2310 struct remote_state
*rs
= get_remote_state ();
2311 size_t size
= get_remote_packet_size ();
2313 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
2316 if (remote_multi_process_p (rs
))
2317 xsnprintf (rs
->buf
.data (), size
, "qAttached:%x", pid
);
2319 xsnprintf (rs
->buf
.data (), size
, "qAttached");
2322 getpkt (&rs
->buf
, 0);
2324 switch (packet_ok (rs
->buf
,
2325 &remote_protocol_packets
[PACKET_qAttached
]))
2328 if (strcmp (rs
->buf
.data (), "1") == 0)
2332 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
2334 case PACKET_UNKNOWN
:
2341 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2342 has been invented by GDB, instead of reported by the target. Since
2343 we can be connected to a remote system before before knowing about
2344 any inferior, mark the target with execution when we find the first
2345 inferior. If ATTACHED is 1, then we had just attached to this
2346 inferior. If it is 0, then we just created this inferior. If it
2347 is -1, then try querying the remote stub to find out if it had
2348 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2349 attempt to open this inferior's executable as the main executable
2350 if no main executable is open already. */
2353 remote_target::remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
2356 struct inferior
*inf
;
2358 /* Check whether this process we're learning about is to be
2359 considered attached, or if is to be considered to have been
2360 spawned by the stub. */
2362 attached
= remote_query_attached (pid
);
2364 if (gdbarch_has_global_solist (target_gdbarch ()))
2366 /* If the target shares code across all inferiors, then every
2367 attach adds a new inferior. */
2368 inf
= add_inferior (pid
);
2370 /* ... and every inferior is bound to the same program space.
2371 However, each inferior may still have its own address
2373 inf
->aspace
= maybe_new_address_space ();
2374 inf
->pspace
= current_program_space
;
2378 /* In the traditional debugging scenario, there's a 1-1 match
2379 between program/address spaces. We simply bind the inferior
2380 to the program space's address space. */
2381 inf
= current_inferior ();
2383 /* However, if the current inferior is already bound to a
2384 process, find some other empty inferior. */
2388 for (inferior
*it
: all_inferiors ())
2397 /* Since all inferiors were already bound to a process, add
2399 inf
= add_inferior_with_spaces ();
2401 switch_to_inferior_no_thread (inf
);
2403 inferior_appeared (inf
, pid
);
2406 inf
->attach_flag
= attached
;
2407 inf
->fake_pid_p
= fake_pid_p
;
2409 /* If no main executable is currently open then attempt to
2410 open the file that was executed to create this inferior. */
2411 if (try_open_exec
&& get_exec_file (0) == NULL
)
2412 exec_file_locate_attach (pid
, 0, 1);
2414 /* Check for exec file mismatch, and let the user solve it. */
2415 validate_exec_file (1);
2420 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2421 static remote_thread_info
*get_remote_thread_info (remote_target
*target
,
2424 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2425 according to RUNNING. */
2428 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
)
2430 struct remote_state
*rs
= get_remote_state ();
2431 struct thread_info
*thread
;
2433 /* GDB historically didn't pull threads in the initial connection
2434 setup. If the remote target doesn't even have a concept of
2435 threads (e.g., a bare-metal target), even if internally we
2436 consider that a single-threaded target, mentioning a new thread
2437 might be confusing to the user. Be silent then, preserving the
2438 age old behavior. */
2439 if (rs
->starting_up
)
2440 thread
= add_thread_silent (this, ptid
);
2442 thread
= add_thread (this, ptid
);
2444 get_remote_thread_info (thread
)->vcont_resumed
= executing
;
2445 set_executing (this, ptid
, executing
);
2446 set_running (this, ptid
, running
);
2451 /* Come here when we learn about a thread id from the remote target.
2452 It may be the first time we hear about such thread, so take the
2453 opportunity to add it to GDB's thread list. In case this is the
2454 first time we're noticing its corresponding inferior, add it to
2455 GDB's inferior list as well. EXECUTING indicates whether the
2456 thread is (internally) executing or stopped. */
2459 remote_target::remote_notice_new_inferior (ptid_t currthread
, int executing
)
2461 /* In non-stop mode, we assume new found threads are (externally)
2462 running until proven otherwise with a stop reply. In all-stop,
2463 we can only get here if all threads are stopped. */
2464 int running
= target_is_non_stop_p () ? 1 : 0;
2466 /* If this is a new thread, add it to GDB's thread list.
2467 If we leave it up to WFI to do this, bad things will happen. */
2469 thread_info
*tp
= find_thread_ptid (this, currthread
);
2470 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2472 /* We're seeing an event on a thread id we knew had exited.
2473 This has to be a new thread reusing the old id. Add it. */
2474 remote_add_thread (currthread
, running
, executing
);
2478 if (!in_thread_list (this, currthread
))
2480 struct inferior
*inf
= NULL
;
2481 int pid
= currthread
.pid ();
2483 if (inferior_ptid
.is_pid ()
2484 && pid
== inferior_ptid
.pid ())
2486 /* inferior_ptid has no thread member yet. This can happen
2487 with the vAttach -> remote_wait,"TAAthread:" path if the
2488 stub doesn't support qC. This is the first stop reported
2489 after an attach, so this is the main thread. Update the
2490 ptid in the thread list. */
2491 if (in_thread_list (this, ptid_t (pid
)))
2492 thread_change_ptid (this, inferior_ptid
, currthread
);
2495 remote_add_thread (currthread
, running
, executing
);
2496 inferior_ptid
= currthread
;
2501 if (magic_null_ptid
== inferior_ptid
)
2503 /* inferior_ptid is not set yet. This can happen with the
2504 vRun -> remote_wait,"TAAthread:" path if the stub
2505 doesn't support qC. This is the first stop reported
2506 after an attach, so this is the main thread. Update the
2507 ptid in the thread list. */
2508 thread_change_ptid (this, inferior_ptid
, currthread
);
2512 /* When connecting to a target remote, or to a target
2513 extended-remote which already was debugging an inferior, we
2514 may not know about it yet. Add it before adding its child
2515 thread, so notifications are emitted in a sensible order. */
2516 if (find_inferior_pid (this, currthread
.pid ()) == NULL
)
2518 struct remote_state
*rs
= get_remote_state ();
2519 bool fake_pid_p
= !remote_multi_process_p (rs
);
2521 inf
= remote_add_inferior (fake_pid_p
,
2522 currthread
.pid (), -1, 1);
2525 /* This is really a new thread. Add it. */
2526 thread_info
*new_thr
2527 = remote_add_thread (currthread
, running
, executing
);
2529 /* If we found a new inferior, let the common code do whatever
2530 it needs to with it (e.g., read shared libraries, insert
2531 breakpoints), unless we're just setting up an all-stop
2535 struct remote_state
*rs
= get_remote_state ();
2537 if (!rs
->starting_up
)
2538 notice_new_inferior (new_thr
, executing
, 0);
2543 /* Return THREAD's private thread data, creating it if necessary. */
2545 static remote_thread_info
*
2546 get_remote_thread_info (thread_info
*thread
)
2548 gdb_assert (thread
!= NULL
);
2550 if (thread
->priv
== NULL
)
2551 thread
->priv
.reset (new remote_thread_info
);
2553 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2556 /* Return PTID's private thread data, creating it if necessary. */
2558 static remote_thread_info
*
2559 get_remote_thread_info (remote_target
*target
, ptid_t ptid
)
2561 thread_info
*thr
= find_thread_ptid (target
, ptid
);
2562 return get_remote_thread_info (thr
);
2565 /* Call this function as a result of
2566 1) A halt indication (T packet) containing a thread id
2567 2) A direct query of currthread
2568 3) Successful execution of set thread */
2571 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2573 rs
->general_thread
= currthread
;
2576 /* If 'QPassSignals' is supported, tell the remote stub what signals
2577 it can simply pass through to the inferior without reporting. */
2580 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2582 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2584 char *pass_packet
, *p
;
2586 struct remote_state
*rs
= get_remote_state ();
2588 gdb_assert (pass_signals
.size () < 256);
2589 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2591 if (pass_signals
[i
])
2594 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2595 strcpy (pass_packet
, "QPassSignals:");
2596 p
= pass_packet
+ strlen (pass_packet
);
2597 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2599 if (pass_signals
[i
])
2602 *p
++ = tohex (i
>> 4);
2603 *p
++ = tohex (i
& 15);
2612 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2614 putpkt (pass_packet
);
2615 getpkt (&rs
->buf
, 0);
2616 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2617 if (rs
->last_pass_packet
)
2618 xfree (rs
->last_pass_packet
);
2619 rs
->last_pass_packet
= pass_packet
;
2622 xfree (pass_packet
);
2626 /* If 'QCatchSyscalls' is supported, tell the remote stub
2627 to report syscalls to GDB. */
2630 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2631 gdb::array_view
<const int> syscall_counts
)
2633 const char *catch_packet
;
2634 enum packet_result result
;
2637 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2639 /* Not supported. */
2643 if (needed
&& any_count
== 0)
2645 /* Count how many syscalls are to be caught. */
2646 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2648 if (syscall_counts
[i
] != 0)
2655 fprintf_unfiltered (gdb_stdlog
,
2656 "remote_set_syscall_catchpoint "
2657 "pid %d needed %d any_count %d n_sysno %d\n",
2658 pid
, needed
, any_count
, n_sysno
);
2661 std::string built_packet
;
2664 /* Prepare a packet with the sysno list, assuming max 8+1
2665 characters for a sysno. If the resulting packet size is too
2666 big, fallback on the non-selective packet. */
2667 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2668 built_packet
.reserve (maxpktsz
);
2669 built_packet
= "QCatchSyscalls:1";
2672 /* Add in each syscall to be caught. */
2673 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2675 if (syscall_counts
[i
] != 0)
2676 string_appendf (built_packet
, ";%zx", i
);
2679 if (built_packet
.size () > get_remote_packet_size ())
2681 /* catch_packet too big. Fallback to less efficient
2682 non selective mode, with GDB doing the filtering. */
2683 catch_packet
= "QCatchSyscalls:1";
2686 catch_packet
= built_packet
.c_str ();
2689 catch_packet
= "QCatchSyscalls:0";
2691 struct remote_state
*rs
= get_remote_state ();
2693 putpkt (catch_packet
);
2694 getpkt (&rs
->buf
, 0);
2695 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2696 if (result
== PACKET_OK
)
2702 /* If 'QProgramSignals' is supported, tell the remote stub what
2703 signals it should pass through to the inferior when detaching. */
2706 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2708 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2712 struct remote_state
*rs
= get_remote_state ();
2714 gdb_assert (signals
.size () < 256);
2715 for (size_t i
= 0; i
< signals
.size (); i
++)
2720 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2721 strcpy (packet
, "QProgramSignals:");
2722 p
= packet
+ strlen (packet
);
2723 for (size_t i
= 0; i
< signals
.size (); i
++)
2725 if (signal_pass_state (i
))
2728 *p
++ = tohex (i
>> 4);
2729 *p
++ = tohex (i
& 15);
2738 if (!rs
->last_program_signals_packet
2739 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2742 getpkt (&rs
->buf
, 0);
2743 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2744 xfree (rs
->last_program_signals_packet
);
2745 rs
->last_program_signals_packet
= packet
;
2752 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2753 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2754 thread. If GEN is set, set the general thread, if not, then set
2755 the step/continue thread. */
2757 remote_target::set_thread (ptid_t ptid
, int gen
)
2759 struct remote_state
*rs
= get_remote_state ();
2760 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2761 char *buf
= rs
->buf
.data ();
2762 char *endbuf
= buf
+ get_remote_packet_size ();
2768 *buf
++ = gen
? 'g' : 'c';
2769 if (ptid
== magic_null_ptid
)
2770 xsnprintf (buf
, endbuf
- buf
, "0");
2771 else if (ptid
== any_thread_ptid
)
2772 xsnprintf (buf
, endbuf
- buf
, "0");
2773 else if (ptid
== minus_one_ptid
)
2774 xsnprintf (buf
, endbuf
- buf
, "-1");
2776 write_ptid (buf
, endbuf
, ptid
);
2778 getpkt (&rs
->buf
, 0);
2780 rs
->general_thread
= ptid
;
2782 rs
->continue_thread
= ptid
;
2786 remote_target::set_general_thread (ptid_t ptid
)
2788 set_thread (ptid
, 1);
2792 remote_target::set_continue_thread (ptid_t ptid
)
2794 set_thread (ptid
, 0);
2797 /* Change the remote current process. Which thread within the process
2798 ends up selected isn't important, as long as it is the same process
2799 as what INFERIOR_PTID points to.
2801 This comes from that fact that there is no explicit notion of
2802 "selected process" in the protocol. The selected process for
2803 general operations is the process the selected general thread
2807 remote_target::set_general_process ()
2809 struct remote_state
*rs
= get_remote_state ();
2811 /* If the remote can't handle multiple processes, don't bother. */
2812 if (!remote_multi_process_p (rs
))
2815 /* We only need to change the remote current thread if it's pointing
2816 at some other process. */
2817 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2818 set_general_thread (inferior_ptid
);
2822 /* Return nonzero if this is the main thread that we made up ourselves
2823 to model non-threaded targets as single-threaded. */
2826 remote_thread_always_alive (ptid_t ptid
)
2828 if (ptid
== magic_null_ptid
)
2829 /* The main thread is always alive. */
2832 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2833 /* The main thread is always alive. This can happen after a
2834 vAttach, if the remote side doesn't support
2841 /* Return nonzero if the thread PTID is still alive on the remote
2845 remote_target::thread_alive (ptid_t ptid
)
2847 struct remote_state
*rs
= get_remote_state ();
2850 /* Check if this is a thread that we made up ourselves to model
2851 non-threaded targets as single-threaded. */
2852 if (remote_thread_always_alive (ptid
))
2855 p
= rs
->buf
.data ();
2856 endp
= p
+ get_remote_packet_size ();
2859 write_ptid (p
, endp
, ptid
);
2862 getpkt (&rs
->buf
, 0);
2863 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2866 /* Return a pointer to a thread name if we know it and NULL otherwise.
2867 The thread_info object owns the memory for the name. */
2870 remote_target::thread_name (struct thread_info
*info
)
2872 if (info
->priv
!= NULL
)
2874 const std::string
&name
= get_remote_thread_info (info
)->name
;
2875 return !name
.empty () ? name
.c_str () : NULL
;
2881 /* About these extended threadlist and threadinfo packets. They are
2882 variable length packets but, the fields within them are often fixed
2883 length. They are redundant enough to send over UDP as is the
2884 remote protocol in general. There is a matching unit test module
2887 /* WARNING: This threadref data structure comes from the remote O.S.,
2888 libstub protocol encoding, and remote.c. It is not particularly
2891 /* Right now, the internal structure is int. We want it to be bigger.
2892 Plan to fix this. */
2894 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2896 /* gdb_ext_thread_info is an internal GDB data structure which is
2897 equivalent to the reply of the remote threadinfo packet. */
2899 struct gdb_ext_thread_info
2901 threadref threadid
; /* External form of thread reference. */
2902 int active
; /* Has state interesting to GDB?
2904 char display
[256]; /* Brief state display, name,
2905 blocked/suspended. */
2906 char shortname
[32]; /* To be used to name threads. */
2907 char more_display
[256]; /* Long info, statistics, queue depth,
2911 /* The volume of remote transfers can be limited by submitting
2912 a mask containing bits specifying the desired information.
2913 Use a union of these values as the 'selection' parameter to
2914 get_thread_info. FIXME: Make these TAG names more thread specific. */
2916 #define TAG_THREADID 1
2917 #define TAG_EXISTS 2
2918 #define TAG_DISPLAY 4
2919 #define TAG_THREADNAME 8
2920 #define TAG_MOREDISPLAY 16
2922 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2924 static char *unpack_nibble (char *buf
, int *val
);
2926 static char *unpack_byte (char *buf
, int *value
);
2928 static char *pack_int (char *buf
, int value
);
2930 static char *unpack_int (char *buf
, int *value
);
2932 static char *unpack_string (char *src
, char *dest
, int length
);
2934 static char *pack_threadid (char *pkt
, threadref
*id
);
2936 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2938 void int_to_threadref (threadref
*id
, int value
);
2940 static int threadref_to_int (threadref
*ref
);
2942 static void copy_threadref (threadref
*dest
, threadref
*src
);
2944 static int threadmatch (threadref
*dest
, threadref
*src
);
2946 static char *pack_threadinfo_request (char *pkt
, int mode
,
2949 static char *pack_threadlist_request (char *pkt
, int startflag
,
2951 threadref
*nextthread
);
2953 static int remote_newthread_step (threadref
*ref
, void *context
);
2956 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2957 buffer we're allowed to write to. Returns
2958 BUF+CHARACTERS_WRITTEN. */
2961 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2964 struct remote_state
*rs
= get_remote_state ();
2966 if (remote_multi_process_p (rs
))
2970 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2972 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2976 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2978 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2983 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2984 last parsed char. Returns null_ptid if no thread id is found, and
2985 throws an error if the thread id has an invalid format. */
2988 read_ptid (const char *buf
, const char **obuf
)
2990 const char *p
= buf
;
2992 ULONGEST pid
= 0, tid
= 0;
2996 /* Multi-process ptid. */
2997 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2999 error (_("invalid remote ptid: %s"), p
);
3002 pp
= unpack_varlen_hex (p
+ 1, &tid
);
3005 return ptid_t (pid
, tid
, 0);
3008 /* No multi-process. Just a tid. */
3009 pp
= unpack_varlen_hex (p
, &tid
);
3011 /* Return null_ptid when no thread id is found. */
3019 /* Since the stub is not sending a process id, then default to
3020 what's in inferior_ptid, unless it's null at this point. If so,
3021 then since there's no way to know the pid of the reported
3022 threads, use the magic number. */
3023 if (inferior_ptid
== null_ptid
)
3024 pid
= magic_null_ptid
.pid ();
3026 pid
= inferior_ptid
.pid ();
3030 return ptid_t (pid
, tid
, 0);
3036 if (ch
>= 'a' && ch
<= 'f')
3037 return ch
- 'a' + 10;
3038 if (ch
>= '0' && ch
<= '9')
3040 if (ch
>= 'A' && ch
<= 'F')
3041 return ch
- 'A' + 10;
3046 stub_unpack_int (char *buff
, int fieldlength
)
3053 nibble
= stubhex (*buff
++);
3057 retval
= retval
<< 4;
3063 unpack_nibble (char *buf
, int *val
)
3065 *val
= fromhex (*buf
++);
3070 unpack_byte (char *buf
, int *value
)
3072 *value
= stub_unpack_int (buf
, 2);
3077 pack_int (char *buf
, int value
)
3079 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3080 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3081 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3082 buf
= pack_hex_byte (buf
, (value
& 0xff));
3087 unpack_int (char *buf
, int *value
)
3089 *value
= stub_unpack_int (buf
, 8);
3093 #if 0 /* Currently unused, uncomment when needed. */
3094 static char *pack_string (char *pkt
, char *string
);
3097 pack_string (char *pkt
, char *string
)
3102 len
= strlen (string
);
3104 len
= 200; /* Bigger than most GDB packets, junk??? */
3105 pkt
= pack_hex_byte (pkt
, len
);
3109 if ((ch
== '\0') || (ch
== '#'))
3110 ch
= '*'; /* Protect encapsulation. */
3115 #endif /* 0 (unused) */
3118 unpack_string (char *src
, char *dest
, int length
)
3127 pack_threadid (char *pkt
, threadref
*id
)
3130 unsigned char *altid
;
3132 altid
= (unsigned char *) id
;
3133 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3135 pkt
= pack_hex_byte (pkt
, *altid
++);
3141 unpack_threadid (char *inbuf
, threadref
*id
)
3144 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3147 altref
= (char *) id
;
3149 while (inbuf
< limit
)
3151 x
= stubhex (*inbuf
++);
3152 y
= stubhex (*inbuf
++);
3153 *altref
++ = (x
<< 4) | y
;
3158 /* Externally, threadrefs are 64 bits but internally, they are still
3159 ints. This is due to a mismatch of specifications. We would like
3160 to use 64bit thread references internally. This is an adapter
3164 int_to_threadref (threadref
*id
, int value
)
3166 unsigned char *scan
;
3168 scan
= (unsigned char *) id
;
3174 *scan
++ = (value
>> 24) & 0xff;
3175 *scan
++ = (value
>> 16) & 0xff;
3176 *scan
++ = (value
>> 8) & 0xff;
3177 *scan
++ = (value
& 0xff);
3181 threadref_to_int (threadref
*ref
)
3184 unsigned char *scan
;
3190 value
= (value
<< 8) | ((*scan
++) & 0xff);
3195 copy_threadref (threadref
*dest
, threadref
*src
)
3198 unsigned char *csrc
, *cdest
;
3200 csrc
= (unsigned char *) src
;
3201 cdest
= (unsigned char *) dest
;
3208 threadmatch (threadref
*dest
, threadref
*src
)
3210 /* Things are broken right now, so just assume we got a match. */
3212 unsigned char *srcp
, *destp
;
3214 srcp
= (char *) src
;
3215 destp
= (char *) dest
;
3219 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3226 threadid:1, # always request threadid
3233 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3236 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3238 *pkt
++ = 'q'; /* Info Query */
3239 *pkt
++ = 'P'; /* process or thread info */
3240 pkt
= pack_int (pkt
, mode
); /* mode */
3241 pkt
= pack_threadid (pkt
, id
); /* threadid */
3242 *pkt
= '\0'; /* terminate */
3246 /* These values tag the fields in a thread info response packet. */
3247 /* Tagging the fields allows us to request specific fields and to
3248 add more fields as time goes by. */
3250 #define TAG_THREADID 1 /* Echo the thread identifier. */
3251 #define TAG_EXISTS 2 /* Is this process defined enough to
3252 fetch registers and its stack? */
3253 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3254 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3255 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3259 remote_target::remote_unpack_thread_info_response (char *pkt
,
3260 threadref
*expectedref
,
3261 gdb_ext_thread_info
*info
)
3263 struct remote_state
*rs
= get_remote_state ();
3267 char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3270 /* info->threadid = 0; FIXME: implement zero_threadref. */
3272 info
->display
[0] = '\0';
3273 info
->shortname
[0] = '\0';
3274 info
->more_display
[0] = '\0';
3276 /* Assume the characters indicating the packet type have been
3278 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3279 pkt
= unpack_threadid (pkt
, &ref
);
3282 warning (_("Incomplete response to threadinfo request."));
3283 if (!threadmatch (&ref
, expectedref
))
3284 { /* This is an answer to a different request. */
3285 warning (_("ERROR RMT Thread info mismatch."));
3288 copy_threadref (&info
->threadid
, &ref
);
3290 /* Loop on tagged fields , try to bail if something goes wrong. */
3292 /* Packets are terminated with nulls. */
3293 while ((pkt
< limit
) && mask
&& *pkt
)
3295 pkt
= unpack_int (pkt
, &tag
); /* tag */
3296 pkt
= unpack_byte (pkt
, &length
); /* length */
3297 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3299 warning (_("ERROR RMT: threadinfo tag mismatch."));
3303 if (tag
== TAG_THREADID
)
3307 warning (_("ERROR RMT: length of threadid is not 16."));
3311 pkt
= unpack_threadid (pkt
, &ref
);
3312 mask
= mask
& ~TAG_THREADID
;
3315 if (tag
== TAG_EXISTS
)
3317 info
->active
= stub_unpack_int (pkt
, length
);
3319 mask
= mask
& ~(TAG_EXISTS
);
3322 warning (_("ERROR RMT: 'exists' length too long."));
3328 if (tag
== TAG_THREADNAME
)
3330 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3331 mask
= mask
& ~TAG_THREADNAME
;
3334 if (tag
== TAG_DISPLAY
)
3336 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3337 mask
= mask
& ~TAG_DISPLAY
;
3340 if (tag
== TAG_MOREDISPLAY
)
3342 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3343 mask
= mask
& ~TAG_MOREDISPLAY
;
3346 warning (_("ERROR RMT: unknown thread info tag."));
3347 break; /* Not a tag we know about. */
3353 remote_target::remote_get_threadinfo (threadref
*threadid
,
3355 gdb_ext_thread_info
*info
)
3357 struct remote_state
*rs
= get_remote_state ();
3360 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3362 getpkt (&rs
->buf
, 0);
3364 if (rs
->buf
[0] == '\0')
3367 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3372 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3375 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3376 threadref
*nextthread
)
3378 *pkt
++ = 'q'; /* info query packet */
3379 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3380 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3381 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3382 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3387 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3390 remote_target::parse_threadlist_response (char *pkt
, int result_limit
,
3391 threadref
*original_echo
,
3392 threadref
*resultlist
,
3395 struct remote_state
*rs
= get_remote_state ();
3397 int count
, resultcount
, done
;
3400 /* Assume the 'q' and 'M chars have been stripped. */
3401 limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3402 /* done parse past here */
3403 pkt
= unpack_byte (pkt
, &count
); /* count field */
3404 pkt
= unpack_nibble (pkt
, &done
);
3405 /* The first threadid is the argument threadid. */
3406 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3407 while ((count
-- > 0) && (pkt
< limit
))
3409 pkt
= unpack_threadid (pkt
, resultlist
++);
3410 if (resultcount
++ >= result_limit
)
3418 /* Fetch the next batch of threads from the remote. Returns -1 if the
3419 qL packet is not supported, 0 on error and 1 on success. */
3422 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3423 int result_limit
, int *done
, int *result_count
,
3424 threadref
*threadlist
)
3426 struct remote_state
*rs
= get_remote_state ();
3429 /* Truncate result limit to be smaller than the packet size. */
3430 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3431 >= get_remote_packet_size ())
3432 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3434 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3437 getpkt (&rs
->buf
, 0);
3438 if (rs
->buf
[0] == '\0')
3440 /* Packet not supported. */
3445 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3446 &rs
->echo_nextthread
, threadlist
, done
);
3448 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3450 /* FIXME: This is a good reason to drop the packet. */
3451 /* Possibly, there is a duplicate response. */
3453 retransmit immediatly - race conditions
3454 retransmit after timeout - yes
3456 wait for packet, then exit
3458 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3459 return 0; /* I choose simply exiting. */
3461 if (*result_count
<= 0)
3465 warning (_("RMT ERROR : failed to get remote thread list."));
3468 return result
; /* break; */
3470 if (*result_count
> result_limit
)
3473 warning (_("RMT ERROR: threadlist response longer than requested."));
3479 /* Fetch the list of remote threads, with the qL packet, and call
3480 STEPFUNCTION for each thread found. Stops iterating and returns 1
3481 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3482 STEPFUNCTION returns false. If the packet is not supported,
3486 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3487 void *context
, int looplimit
)
3489 struct remote_state
*rs
= get_remote_state ();
3490 int done
, i
, result_count
;
3498 if (loopcount
++ > looplimit
)
3501 warning (_("Remote fetch threadlist -infinite loop-."));
3504 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3505 MAXTHREADLISTRESULTS
,
3506 &done
, &result_count
,
3507 rs
->resultthreadlist
);
3510 /* Clear for later iterations. */
3512 /* Setup to resume next batch of thread references, set nextthread. */
3513 if (result_count
>= 1)
3514 copy_threadref (&rs
->nextthread
,
3515 &rs
->resultthreadlist
[result_count
- 1]);
3517 while (result_count
--)
3519 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3529 /* A thread found on the remote target. */
3533 explicit thread_item (ptid_t ptid_
)
3537 thread_item (thread_item
&&other
) = default;
3538 thread_item
&operator= (thread_item
&&other
) = default;
3540 DISABLE_COPY_AND_ASSIGN (thread_item
);
3542 /* The thread's PTID. */
3545 /* The thread's extra info. */
3548 /* The thread's name. */
3551 /* The core the thread was running on. -1 if not known. */
3554 /* The thread handle associated with the thread. */
3555 gdb::byte_vector thread_handle
;
3558 /* Context passed around to the various methods listing remote
3559 threads. As new threads are found, they're added to the ITEMS
3562 struct threads_listing_context
3564 /* Return true if this object contains an entry for a thread with ptid
3567 bool contains_thread (ptid_t ptid
) const
3569 auto match_ptid
= [&] (const thread_item
&item
)
3571 return item
.ptid
== ptid
;
3574 auto it
= std::find_if (this->items
.begin (),
3578 return it
!= this->items
.end ();
3581 /* Remove the thread with ptid PTID. */
3583 void remove_thread (ptid_t ptid
)
3585 auto match_ptid
= [&] (const thread_item
&item
)
3587 return item
.ptid
== ptid
;
3590 auto it
= std::remove_if (this->items
.begin (),
3594 if (it
!= this->items
.end ())
3595 this->items
.erase (it
);
3598 /* The threads found on the remote target. */
3599 std::vector
<thread_item
> items
;
3603 remote_newthread_step (threadref
*ref
, void *data
)
3605 struct threads_listing_context
*context
3606 = (struct threads_listing_context
*) data
;
3607 int pid
= inferior_ptid
.pid ();
3608 int lwp
= threadref_to_int (ref
);
3609 ptid_t
ptid (pid
, lwp
);
3611 context
->items
.emplace_back (ptid
);
3613 return 1; /* continue iterator */
3616 #define CRAZY_MAX_THREADS 1000
3619 remote_target::remote_current_thread (ptid_t oldpid
)
3621 struct remote_state
*rs
= get_remote_state ();
3624 getpkt (&rs
->buf
, 0);
3625 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3630 result
= read_ptid (&rs
->buf
[2], &obuf
);
3631 if (*obuf
!= '\0' && remote_debug
)
3632 fprintf_unfiltered (gdb_stdlog
,
3633 "warning: garbage in qC reply\n");
3641 /* List remote threads using the deprecated qL packet. */
3644 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3646 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3647 CRAZY_MAX_THREADS
) >= 0)
3653 #if defined(HAVE_LIBEXPAT)
3656 start_thread (struct gdb_xml_parser
*parser
,
3657 const struct gdb_xml_element
*element
,
3659 std::vector
<gdb_xml_value
> &attributes
)
3661 struct threads_listing_context
*data
3662 = (struct threads_listing_context
*) user_data
;
3663 struct gdb_xml_value
*attr
;
3665 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3666 ptid_t ptid
= read_ptid (id
, NULL
);
3668 data
->items
.emplace_back (ptid
);
3669 thread_item
&item
= data
->items
.back ();
3671 attr
= xml_find_attribute (attributes
, "core");
3673 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3675 attr
= xml_find_attribute (attributes
, "name");
3677 item
.name
= (const char *) attr
->value
.get ();
3679 attr
= xml_find_attribute (attributes
, "handle");
3681 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3685 end_thread (struct gdb_xml_parser
*parser
,
3686 const struct gdb_xml_element
*element
,
3687 void *user_data
, const char *body_text
)
3689 struct threads_listing_context
*data
3690 = (struct threads_listing_context
*) user_data
;
3692 if (body_text
!= NULL
&& *body_text
!= '\0')
3693 data
->items
.back ().extra
= body_text
;
3696 const struct gdb_xml_attribute thread_attributes
[] = {
3697 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3698 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3699 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3700 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3701 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3704 const struct gdb_xml_element thread_children
[] = {
3705 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3708 const struct gdb_xml_element threads_children
[] = {
3709 { "thread", thread_attributes
, thread_children
,
3710 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3711 start_thread
, end_thread
},
3712 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3715 const struct gdb_xml_element threads_elements
[] = {
3716 { "threads", NULL
, threads_children
,
3717 GDB_XML_EF_NONE
, NULL
, NULL
},
3718 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3723 /* List remote threads using qXfer:threads:read. */
3726 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3728 #if defined(HAVE_LIBEXPAT)
3729 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3731 gdb::optional
<gdb::char_vector
> xml
3732 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3734 if (xml
&& (*xml
)[0] != '\0')
3736 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3737 threads_elements
, xml
->data (), context
);
3747 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3750 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3752 struct remote_state
*rs
= get_remote_state ();
3754 if (rs
->use_threadinfo_query
)
3758 putpkt ("qfThreadInfo");
3759 getpkt (&rs
->buf
, 0);
3760 bufp
= rs
->buf
.data ();
3761 if (bufp
[0] != '\0') /* q packet recognized */
3763 while (*bufp
++ == 'm') /* reply contains one or more TID */
3767 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3768 context
->items
.emplace_back (ptid
);
3770 while (*bufp
++ == ','); /* comma-separated list */
3771 putpkt ("qsThreadInfo");
3772 getpkt (&rs
->buf
, 0);
3773 bufp
= rs
->buf
.data ();
3779 /* Packet not recognized. */
3780 rs
->use_threadinfo_query
= 0;
3787 /* Implement the to_update_thread_list function for the remote
3791 remote_target::update_thread_list ()
3793 struct threads_listing_context context
;
3796 /* We have a few different mechanisms to fetch the thread list. Try
3797 them all, starting with the most preferred one first, falling
3798 back to older methods. */
3799 if (remote_get_threads_with_qxfer (&context
)
3800 || remote_get_threads_with_qthreadinfo (&context
)
3801 || remote_get_threads_with_ql (&context
))
3805 if (context
.items
.empty ()
3806 && remote_thread_always_alive (inferior_ptid
))
3808 /* Some targets don't really support threads, but still
3809 reply an (empty) thread list in response to the thread
3810 listing packets, instead of replying "packet not
3811 supported". Exit early so we don't delete the main
3816 /* CONTEXT now holds the current thread list on the remote
3817 target end. Delete GDB-side threads no longer found on the
3819 for (thread_info
*tp
: all_threads_safe ())
3821 if (tp
->inf
->process_target () != this)
3824 if (!context
.contains_thread (tp
->ptid
))
3831 /* Remove any unreported fork child threads from CONTEXT so
3832 that we don't interfere with follow fork, which is where
3833 creation of such threads is handled. */
3834 remove_new_fork_children (&context
);
3836 /* And now add threads we don't know about yet to our list. */
3837 for (thread_item
&item
: context
.items
)
3839 if (item
.ptid
!= null_ptid
)
3841 /* In non-stop mode, we assume new found threads are
3842 executing until proven otherwise with a stop reply.
3843 In all-stop, we can only get here if all threads are
3845 int executing
= target_is_non_stop_p () ? 1 : 0;
3847 remote_notice_new_inferior (item
.ptid
, executing
);
3849 thread_info
*tp
= find_thread_ptid (this, item
.ptid
);
3850 remote_thread_info
*info
= get_remote_thread_info (tp
);
3851 info
->core
= item
.core
;
3852 info
->extra
= std::move (item
.extra
);
3853 info
->name
= std::move (item
.name
);
3854 info
->thread_handle
= std::move (item
.thread_handle
);
3861 /* If no thread listing method is supported, then query whether
3862 each known thread is alive, one by one, with the T packet.
3863 If the target doesn't support threads at all, then this is a
3864 no-op. See remote_thread_alive. */
3870 * Collect a descriptive string about the given thread.
3871 * The target may say anything it wants to about the thread
3872 * (typically info about its blocked / runnable state, name, etc.).
3873 * This string will appear in the info threads display.
3875 * Optional: targets are not required to implement this function.
3879 remote_target::extra_thread_info (thread_info
*tp
)
3881 struct remote_state
*rs
= get_remote_state ();
3884 struct gdb_ext_thread_info threadinfo
;
3886 if (rs
->remote_desc
== 0) /* paranoia */
3887 internal_error (__FILE__
, __LINE__
,
3888 _("remote_threads_extra_info"));
3890 if (tp
->ptid
== magic_null_ptid
3891 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
3892 /* This is the main thread which was added by GDB. The remote
3893 server doesn't know about it. */
3896 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
3898 /* If already have cached info, use it. */
3899 if (!extra
.empty ())
3900 return extra
.c_str ();
3902 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3904 /* If we're using qXfer:threads:read, then the extra info is
3905 included in the XML. So if we didn't have anything cached,
3906 it's because there's really no extra info. */
3910 if (rs
->use_threadextra_query
)
3912 char *b
= rs
->buf
.data ();
3913 char *endb
= b
+ get_remote_packet_size ();
3915 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3917 write_ptid (b
, endb
, tp
->ptid
);
3920 getpkt (&rs
->buf
, 0);
3921 if (rs
->buf
[0] != 0)
3923 extra
.resize (strlen (rs
->buf
.data ()) / 2);
3924 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
3925 return extra
.c_str ();
3929 /* If the above query fails, fall back to the old method. */
3930 rs
->use_threadextra_query
= 0;
3931 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3932 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3933 int_to_threadref (&id
, tp
->ptid
.lwp ());
3934 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3935 if (threadinfo
.active
)
3937 if (*threadinfo
.shortname
)
3938 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
3939 if (*threadinfo
.display
)
3941 if (!extra
.empty ())
3943 string_appendf (extra
, " State: %s", threadinfo
.display
);
3945 if (*threadinfo
.more_display
)
3947 if (!extra
.empty ())
3949 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
3951 return extra
.c_str ();
3958 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
3959 struct static_tracepoint_marker
*marker
)
3961 struct remote_state
*rs
= get_remote_state ();
3962 char *p
= rs
->buf
.data ();
3964 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3966 p
+= hexnumstr (p
, addr
);
3968 getpkt (&rs
->buf
, 0);
3969 p
= rs
->buf
.data ();
3972 error (_("Remote failure reply: %s"), p
);
3976 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
3983 std::vector
<static_tracepoint_marker
>
3984 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
3986 struct remote_state
*rs
= get_remote_state ();
3987 std::vector
<static_tracepoint_marker
> markers
;
3989 static_tracepoint_marker marker
;
3991 /* Ask for a first packet of static tracepoint marker
3994 getpkt (&rs
->buf
, 0);
3995 p
= rs
->buf
.data ();
3997 error (_("Remote failure reply: %s"), p
);
4003 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
4005 if (strid
== NULL
|| marker
.str_id
== strid
)
4006 markers
.push_back (std::move (marker
));
4008 while (*p
++ == ','); /* comma-separated list */
4009 /* Ask for another packet of static tracepoint definition. */
4011 getpkt (&rs
->buf
, 0);
4012 p
= rs
->buf
.data ();
4019 /* Implement the to_get_ada_task_ptid function for the remote targets. */
4022 remote_target::get_ada_task_ptid (long lwp
, long thread
)
4024 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
4028 /* Restart the remote side; this is an extended protocol operation. */
4031 remote_target::extended_remote_restart ()
4033 struct remote_state
*rs
= get_remote_state ();
4035 /* Send the restart command; for reasons I don't understand the
4036 remote side really expects a number after the "R". */
4037 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
4040 remote_fileio_reset ();
4043 /* Clean up connection to a remote debugger. */
4046 remote_target::close ()
4048 /* Make sure we leave stdin registered in the event loop. */
4051 trace_reset_local_state ();
4056 remote_target::~remote_target ()
4058 struct remote_state
*rs
= get_remote_state ();
4060 /* Check for NULL because we may get here with a partially
4061 constructed target/connection. */
4062 if (rs
->remote_desc
== nullptr)
4065 serial_close (rs
->remote_desc
);
4067 /* We are destroying the remote target, so we should discard
4068 everything of this target. */
4069 discard_pending_stop_replies_in_queue ();
4071 if (rs
->remote_async_inferior_event_token
)
4072 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4074 delete rs
->notif_state
;
4077 /* Query the remote side for the text, data and bss offsets. */
4080 remote_target::get_offsets ()
4082 struct remote_state
*rs
= get_remote_state ();
4085 int lose
, num_segments
= 0, do_sections
, do_segments
;
4086 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4087 struct symfile_segment_data
*data
;
4089 if (symfile_objfile
== NULL
)
4092 putpkt ("qOffsets");
4093 getpkt (&rs
->buf
, 0);
4094 buf
= rs
->buf
.data ();
4096 if (buf
[0] == '\000')
4097 return; /* Return silently. Stub doesn't support
4101 warning (_("Remote failure reply: %s"), buf
);
4105 /* Pick up each field in turn. This used to be done with scanf, but
4106 scanf will make trouble if CORE_ADDR size doesn't match
4107 conversion directives correctly. The following code will work
4108 with any size of CORE_ADDR. */
4109 text_addr
= data_addr
= bss_addr
= 0;
4113 if (startswith (ptr
, "Text="))
4116 /* Don't use strtol, could lose on big values. */
4117 while (*ptr
&& *ptr
!= ';')
4118 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4120 if (startswith (ptr
, ";Data="))
4123 while (*ptr
&& *ptr
!= ';')
4124 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4129 if (!lose
&& startswith (ptr
, ";Bss="))
4132 while (*ptr
&& *ptr
!= ';')
4133 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4135 if (bss_addr
!= data_addr
)
4136 warning (_("Target reported unsupported offsets: %s"), buf
);
4141 else if (startswith (ptr
, "TextSeg="))
4144 /* Don't use strtol, could lose on big values. */
4145 while (*ptr
&& *ptr
!= ';')
4146 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4149 if (startswith (ptr
, ";DataSeg="))
4152 while (*ptr
&& *ptr
!= ';')
4153 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4161 error (_("Malformed response to offset query, %s"), buf
);
4162 else if (*ptr
!= '\0')
4163 warning (_("Target reported unsupported offsets: %s"), buf
);
4165 section_offsets offs
= symfile_objfile
->section_offsets
;
4167 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
4168 do_segments
= (data
!= NULL
);
4169 do_sections
= num_segments
== 0;
4171 if (num_segments
> 0)
4173 segments
[0] = text_addr
;
4174 segments
[1] = data_addr
;
4176 /* If we have two segments, we can still try to relocate everything
4177 by assuming that the .text and .data offsets apply to the whole
4178 text and data segments. Convert the offsets given in the packet
4179 to base addresses for symfile_map_offsets_to_segments. */
4180 else if (data
&& data
->num_segments
== 2)
4182 segments
[0] = data
->segment_bases
[0] + text_addr
;
4183 segments
[1] = data
->segment_bases
[1] + data_addr
;
4186 /* If the object file has only one segment, assume that it is text
4187 rather than data; main programs with no writable data are rare,
4188 but programs with no code are useless. Of course the code might
4189 have ended up in the data segment... to detect that we would need
4190 the permissions here. */
4191 else if (data
&& data
->num_segments
== 1)
4193 segments
[0] = data
->segment_bases
[0] + text_addr
;
4196 /* There's no way to relocate by segment. */
4202 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
4203 offs
, num_segments
, segments
);
4205 if (ret
== 0 && !do_sections
)
4206 error (_("Can not handle qOffsets TextSeg "
4207 "response with this symbol file"));
4214 free_symfile_segment_data (data
);
4218 offs
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
4220 /* This is a temporary kludge to force data and bss to use the
4221 same offsets because that's what nlmconv does now. The real
4222 solution requires changes to the stub and remote.c that I
4223 don't have time to do right now. */
4225 offs
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
4226 offs
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
4229 objfile_relocate (symfile_objfile
, offs
);
4232 /* Send interrupt_sequence to remote target. */
4235 remote_target::send_interrupt_sequence ()
4237 struct remote_state
*rs
= get_remote_state ();
4239 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4240 remote_serial_write ("\x03", 1);
4241 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4242 serial_send_break (rs
->remote_desc
);
4243 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4245 serial_send_break (rs
->remote_desc
);
4246 remote_serial_write ("g", 1);
4249 internal_error (__FILE__
, __LINE__
,
4250 _("Invalid value for interrupt_sequence_mode: %s."),
4251 interrupt_sequence_mode
);
4255 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4256 and extract the PTID. Returns NULL_PTID if not found. */
4259 stop_reply_extract_thread (char *stop_reply
)
4261 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4265 /* Txx r:val ; r:val (...) */
4268 /* Look for "register" named "thread". */
4273 p1
= strchr (p
, ':');
4277 if (strncmp (p
, "thread", p1
- p
) == 0)
4278 return read_ptid (++p1
, &p
);
4280 p1
= strchr (p
, ';');
4292 /* Determine the remote side's current thread. If we have a stop
4293 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4294 "thread" register we can extract the current thread from. If not,
4295 ask the remote which is the current thread with qC. The former
4296 method avoids a roundtrip. */
4299 remote_target::get_current_thread (char *wait_status
)
4301 ptid_t ptid
= null_ptid
;
4303 /* Note we don't use remote_parse_stop_reply as that makes use of
4304 the target architecture, which we haven't yet fully determined at
4306 if (wait_status
!= NULL
)
4307 ptid
= stop_reply_extract_thread (wait_status
);
4308 if (ptid
== null_ptid
)
4309 ptid
= remote_current_thread (inferior_ptid
);
4314 /* Query the remote target for which is the current thread/process,
4315 add it to our tables, and update INFERIOR_PTID. The caller is
4316 responsible for setting the state such that the remote end is ready
4317 to return the current thread.
4319 This function is called after handling the '?' or 'vRun' packets,
4320 whose response is a stop reply from which we can also try
4321 extracting the thread. If the target doesn't support the explicit
4322 qC query, we infer the current thread from that stop reply, passed
4323 in in WAIT_STATUS, which may be NULL. */
4326 remote_target::add_current_inferior_and_thread (char *wait_status
)
4328 struct remote_state
*rs
= get_remote_state ();
4329 bool fake_pid_p
= false;
4331 inferior_ptid
= null_ptid
;
4333 /* Now, if we have thread information, update inferior_ptid. */
4334 ptid_t curr_ptid
= get_current_thread (wait_status
);
4336 if (curr_ptid
!= null_ptid
)
4338 if (!remote_multi_process_p (rs
))
4343 /* Without this, some commands which require an active target
4344 (such as kill) won't work. This variable serves (at least)
4345 double duty as both the pid of the target process (if it has
4346 such), and as a flag indicating that a target is active. */
4347 curr_ptid
= magic_null_ptid
;
4351 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4353 /* Add the main thread and switch to it. Don't try reading
4354 registers yet, since we haven't fetched the target description
4356 thread_info
*tp
= add_thread_silent (this, curr_ptid
);
4357 switch_to_thread_no_regs (tp
);
4360 /* Print info about a thread that was found already stopped on
4364 print_one_stopped_thread (struct thread_info
*thread
)
4366 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4368 switch_to_thread (thread
);
4369 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4370 set_current_sal_from_frame (get_current_frame ());
4372 thread
->suspend
.waitstatus_pending_p
= 0;
4374 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4376 enum gdb_signal sig
= ws
->value
.sig
;
4378 if (signal_print_state (sig
))
4379 gdb::observers::signal_received
.notify (sig
);
4381 gdb::observers::normal_stop
.notify (NULL
, 1);
4384 /* Process all initial stop replies the remote side sent in response
4385 to the ? packet. These indicate threads that were already stopped
4386 on initial connection. We mark these threads as stopped and print
4387 their current frame before giving the user the prompt. */
4390 remote_target::process_initial_stop_replies (int from_tty
)
4392 int pending_stop_replies
= stop_reply_queue_length ();
4393 struct thread_info
*selected
= NULL
;
4394 struct thread_info
*lowest_stopped
= NULL
;
4395 struct thread_info
*first
= NULL
;
4397 /* Consume the initial pending events. */
4398 while (pending_stop_replies
-- > 0)
4400 ptid_t waiton_ptid
= minus_one_ptid
;
4402 struct target_waitstatus ws
;
4403 int ignore_event
= 0;
4405 memset (&ws
, 0, sizeof (ws
));
4406 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4408 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4412 case TARGET_WAITKIND_IGNORE
:
4413 case TARGET_WAITKIND_NO_RESUMED
:
4414 case TARGET_WAITKIND_SIGNALLED
:
4415 case TARGET_WAITKIND_EXITED
:
4416 /* We shouldn't see these, but if we do, just ignore. */
4418 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
4422 case TARGET_WAITKIND_EXECD
:
4423 xfree (ws
.value
.execd_pathname
);
4432 thread_info
*evthread
= find_thread_ptid (this, event_ptid
);
4434 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4436 enum gdb_signal sig
= ws
.value
.sig
;
4438 /* Stubs traditionally report SIGTRAP as initial signal,
4439 instead of signal 0. Suppress it. */
4440 if (sig
== GDB_SIGNAL_TRAP
)
4442 evthread
->suspend
.stop_signal
= sig
;
4446 evthread
->suspend
.waitstatus
= ws
;
4448 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4449 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4450 evthread
->suspend
.waitstatus_pending_p
= 1;
4452 set_executing (this, event_ptid
, false);
4453 set_running (this, event_ptid
, false);
4454 get_remote_thread_info (evthread
)->vcont_resumed
= 0;
4457 /* "Notice" the new inferiors before anything related to
4458 registers/memory. */
4459 for (inferior
*inf
: all_non_exited_inferiors (this))
4461 inf
->needs_setup
= 1;
4465 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4466 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4471 /* If all-stop on top of non-stop, pause all threads. Note this
4472 records the threads' stop pc, so must be done after "noticing"
4476 stop_all_threads ();
4478 /* If all threads of an inferior were already stopped, we
4479 haven't setup the inferior yet. */
4480 for (inferior
*inf
: all_non_exited_inferiors (this))
4482 if (inf
->needs_setup
)
4484 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4485 switch_to_thread_no_regs (thread
);
4491 /* Now go over all threads that are stopped, and print their current
4492 frame. If all-stop, then if there's a signalled thread, pick
4494 for (thread_info
*thread
: all_non_exited_threads (this))
4500 thread
->set_running (false);
4501 else if (thread
->state
!= THREAD_STOPPED
)
4504 if (selected
== NULL
4505 && thread
->suspend
.waitstatus_pending_p
)
4508 if (lowest_stopped
== NULL
4509 || thread
->inf
->num
< lowest_stopped
->inf
->num
4510 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4511 lowest_stopped
= thread
;
4514 print_one_stopped_thread (thread
);
4517 /* In all-stop, we only print the status of one thread, and leave
4518 others with their status pending. */
4521 thread_info
*thread
= selected
;
4523 thread
= lowest_stopped
;
4527 print_one_stopped_thread (thread
);
4530 /* For "info program". */
4531 thread_info
*thread
= inferior_thread ();
4532 if (thread
->state
== THREAD_STOPPED
)
4533 set_last_target_status (this, inferior_ptid
, thread
->suspend
.waitstatus
);
4536 /* Start the remote connection and sync state. */
4539 remote_target::start_remote (int from_tty
, int extended_p
)
4541 struct remote_state
*rs
= get_remote_state ();
4542 struct packet_config
*noack_config
;
4543 char *wait_status
= NULL
;
4545 /* Signal other parts that we're going through the initial setup,
4546 and so things may not be stable yet. E.g., we don't try to
4547 install tracepoints until we've relocated symbols. Also, a
4548 Ctrl-C before we're connected and synced up can't interrupt the
4549 target. Instead, it offers to drop the (potentially wedged)
4551 rs
->starting_up
= 1;
4555 if (interrupt_on_connect
)
4556 send_interrupt_sequence ();
4558 /* Ack any packet which the remote side has already sent. */
4559 remote_serial_write ("+", 1);
4561 /* The first packet we send to the target is the optional "supported
4562 packets" request. If the target can answer this, it will tell us
4563 which later probes to skip. */
4564 remote_query_supported ();
4566 /* If the stub wants to get a QAllow, compose one and send it. */
4567 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4570 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4571 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4572 as a reply to known packet. For packet "vFile:setfs:" it is an
4573 invalid reply and GDB would return error in
4574 remote_hostio_set_filesystem, making remote files access impossible.
4575 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4576 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4578 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4580 putpkt (v_mustreplyempty
);
4581 getpkt (&rs
->buf
, 0);
4582 if (strcmp (rs
->buf
.data (), "OK") == 0)
4583 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4584 else if (strcmp (rs
->buf
.data (), "") != 0)
4585 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4589 /* Next, we possibly activate noack mode.
4591 If the QStartNoAckMode packet configuration is set to AUTO,
4592 enable noack mode if the stub reported a wish for it with
4595 If set to TRUE, then enable noack mode even if the stub didn't
4596 report it in qSupported. If the stub doesn't reply OK, the
4597 session ends with an error.
4599 If FALSE, then don't activate noack mode, regardless of what the
4600 stub claimed should be the default with qSupported. */
4602 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4603 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4605 putpkt ("QStartNoAckMode");
4606 getpkt (&rs
->buf
, 0);
4607 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4613 /* Tell the remote that we are using the extended protocol. */
4615 getpkt (&rs
->buf
, 0);
4618 /* Let the target know which signals it is allowed to pass down to
4620 update_signals_program_target ();
4622 /* Next, if the target can specify a description, read it. We do
4623 this before anything involving memory or registers. */
4624 target_find_description ();
4626 /* Next, now that we know something about the target, update the
4627 address spaces in the program spaces. */
4628 update_address_spaces ();
4630 /* On OSs where the list of libraries is global to all
4631 processes, we fetch them early. */
4632 if (gdbarch_has_global_solist (target_gdbarch ()))
4633 solib_add (NULL
, from_tty
, auto_solib_add
);
4635 if (target_is_non_stop_p ())
4637 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4638 error (_("Non-stop mode requested, but remote "
4639 "does not support non-stop"));
4641 putpkt ("QNonStop:1");
4642 getpkt (&rs
->buf
, 0);
4644 if (strcmp (rs
->buf
.data (), "OK") != 0)
4645 error (_("Remote refused setting non-stop mode with: %s"),
4648 /* Find about threads and processes the stub is already
4649 controlling. We default to adding them in the running state.
4650 The '?' query below will then tell us about which threads are
4652 this->update_thread_list ();
4654 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4656 /* Don't assume that the stub can operate in all-stop mode.
4657 Request it explicitly. */
4658 putpkt ("QNonStop:0");
4659 getpkt (&rs
->buf
, 0);
4661 if (strcmp (rs
->buf
.data (), "OK") != 0)
4662 error (_("Remote refused setting all-stop mode with: %s"),
4666 /* Upload TSVs regardless of whether the target is running or not. The
4667 remote stub, such as GDBserver, may have some predefined or builtin
4668 TSVs, even if the target is not running. */
4669 if (get_trace_status (current_trace_status ()) != -1)
4671 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4673 upload_trace_state_variables (&uploaded_tsvs
);
4674 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4677 /* Check whether the target is running now. */
4679 getpkt (&rs
->buf
, 0);
4681 if (!target_is_non_stop_p ())
4683 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4686 error (_("The target is not running (try extended-remote?)"));
4688 /* We're connected, but not running. Drop out before we
4689 call start_remote. */
4690 rs
->starting_up
= 0;
4695 /* Save the reply for later. */
4696 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4697 strcpy (wait_status
, rs
->buf
.data ());
4700 /* Fetch thread list. */
4701 target_update_thread_list ();
4703 /* Let the stub know that we want it to return the thread. */
4704 set_continue_thread (minus_one_ptid
);
4706 if (thread_count (this) == 0)
4708 /* Target has no concept of threads at all. GDB treats
4709 non-threaded target as single-threaded; add a main
4711 add_current_inferior_and_thread (wait_status
);
4715 /* We have thread information; select the thread the target
4716 says should be current. If we're reconnecting to a
4717 multi-threaded program, this will ideally be the thread
4718 that last reported an event before GDB disconnected. */
4719 ptid_t curr_thread
= get_current_thread (wait_status
);
4720 if (curr_thread
== null_ptid
)
4722 /* Odd... The target was able to list threads, but not
4723 tell us which thread was current (no "thread"
4724 register in T stop reply?). Just pick the first
4725 thread in the thread list then. */
4728 fprintf_unfiltered (gdb_stdlog
,
4729 "warning: couldn't determine remote "
4730 "current thread; picking first in list.\n");
4732 for (thread_info
*tp
: all_non_exited_threads (this,
4735 switch_to_thread (tp
);
4740 switch_to_thread (find_thread_ptid (this, curr_thread
));
4743 /* init_wait_for_inferior should be called before get_offsets in order
4744 to manage `inserted' flag in bp loc in a correct state.
4745 breakpoint_init_inferior, called from init_wait_for_inferior, set
4746 `inserted' flag to 0, while before breakpoint_re_set, called from
4747 start_remote, set `inserted' flag to 1. In the initialization of
4748 inferior, breakpoint_init_inferior should be called first, and then
4749 breakpoint_re_set can be called. If this order is broken, state of
4750 `inserted' flag is wrong, and cause some problems on breakpoint
4752 init_wait_for_inferior ();
4754 get_offsets (); /* Get text, data & bss offsets. */
4756 /* If we could not find a description using qXfer, and we know
4757 how to do it some other way, try again. This is not
4758 supported for non-stop; it could be, but it is tricky if
4759 there are no stopped threads when we connect. */
4760 if (remote_read_description_p (this)
4761 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4763 target_clear_description ();
4764 target_find_description ();
4767 /* Use the previously fetched status. */
4768 gdb_assert (wait_status
!= NULL
);
4769 strcpy (rs
->buf
.data (), wait_status
);
4770 rs
->cached_wait_status
= 1;
4772 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4776 /* Clear WFI global state. Do this before finding about new
4777 threads and inferiors, and setting the current inferior.
4778 Otherwise we would clear the proceed status of the current
4779 inferior when we want its stop_soon state to be preserved
4780 (see notice_new_inferior). */
4781 init_wait_for_inferior ();
4783 /* In non-stop, we will either get an "OK", meaning that there
4784 are no stopped threads at this time; or, a regular stop
4785 reply. In the latter case, there may be more than one thread
4786 stopped --- we pull them all out using the vStopped
4788 if (strcmp (rs
->buf
.data (), "OK") != 0)
4790 struct notif_client
*notif
= ¬if_client_stop
;
4792 /* remote_notif_get_pending_replies acks this one, and gets
4794 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4795 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4796 remote_notif_get_pending_events (notif
);
4799 if (thread_count (this) == 0)
4802 error (_("The target is not running (try extended-remote?)"));
4804 /* We're connected, but not running. Drop out before we
4805 call start_remote. */
4806 rs
->starting_up
= 0;
4810 /* In non-stop mode, any cached wait status will be stored in
4811 the stop reply queue. */
4812 gdb_assert (wait_status
== NULL
);
4814 /* Report all signals during attach/startup. */
4817 /* If there are already stopped threads, mark them stopped and
4818 report their stops before giving the prompt to the user. */
4819 process_initial_stop_replies (from_tty
);
4821 if (target_can_async_p ())
4825 /* If we connected to a live target, do some additional setup. */
4826 if (target_has_execution
)
4828 if (symfile_objfile
) /* No use without a symbol-file. */
4829 remote_check_symbols ();
4832 /* Possibly the target has been engaged in a trace run started
4833 previously; find out where things are at. */
4834 if (get_trace_status (current_trace_status ()) != -1)
4836 struct uploaded_tp
*uploaded_tps
= NULL
;
4838 if (current_trace_status ()->running
)
4839 printf_filtered (_("Trace is already running on the target.\n"));
4841 upload_tracepoints (&uploaded_tps
);
4843 merge_uploaded_tracepoints (&uploaded_tps
);
4846 /* Possibly the target has been engaged in a btrace record started
4847 previously; find out where things are at. */
4848 remote_btrace_maybe_reopen ();
4850 /* The thread and inferior lists are now synchronized with the
4851 target, our symbols have been relocated, and we're merged the
4852 target's tracepoints with ours. We're done with basic start
4854 rs
->starting_up
= 0;
4856 /* Maybe breakpoints are global and need to be inserted now. */
4857 if (breakpoints_should_be_inserted_now ())
4858 insert_breakpoints ();
4862 remote_target::connection_string ()
4864 remote_state
*rs
= get_remote_state ();
4866 if (rs
->remote_desc
->name
!= NULL
)
4867 return rs
->remote_desc
->name
;
4872 /* Open a connection to a remote debugger.
4873 NAME is the filename used for communication. */
4876 remote_target::open (const char *name
, int from_tty
)
4878 open_1 (name
, from_tty
, 0);
4881 /* Open a connection to a remote debugger using the extended
4882 remote gdb protocol. NAME is the filename used for communication. */
4885 extended_remote_target::open (const char *name
, int from_tty
)
4887 open_1 (name
, from_tty
, 1 /*extended_p */);
4890 /* Reset all packets back to "unknown support". Called when opening a
4891 new connection to a remote target. */
4894 reset_all_packet_configs_support (void)
4898 for (i
= 0; i
< PACKET_MAX
; i
++)
4899 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4902 /* Initialize all packet configs. */
4905 init_all_packet_configs (void)
4909 for (i
= 0; i
< PACKET_MAX
; i
++)
4911 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4912 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4916 /* Symbol look-up. */
4919 remote_target::remote_check_symbols ()
4924 /* The remote side has no concept of inferiors that aren't running
4925 yet, it only knows about running processes. If we're connected
4926 but our current inferior is not running, we should not invite the
4927 remote target to request symbol lookups related to its
4928 (unrelated) current process. */
4929 if (!target_has_execution
)
4932 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4935 /* Make sure the remote is pointing at the right process. Note
4936 there's no way to select "no process". */
4937 set_general_process ();
4939 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4940 because we need both at the same time. */
4941 gdb::char_vector
msg (get_remote_packet_size ());
4942 gdb::char_vector
reply (get_remote_packet_size ());
4944 /* Invite target to request symbol lookups. */
4946 putpkt ("qSymbol::");
4948 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4950 while (startswith (reply
.data (), "qSymbol:"))
4952 struct bound_minimal_symbol sym
;
4955 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
4958 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
4959 if (sym
.minsym
== NULL
)
4960 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
4964 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4965 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4967 /* If this is a function address, return the start of code
4968 instead of any data function descriptor. */
4969 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4971 current_top_target ());
4973 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4974 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4977 putpkt (msg
.data ());
4982 static struct serial
*
4983 remote_serial_open (const char *name
)
4985 static int udp_warning
= 0;
4987 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4988 of in ser-tcp.c, because it is the remote protocol assuming that the
4989 serial connection is reliable and not the serial connection promising
4991 if (!udp_warning
&& startswith (name
, "udp:"))
4993 warning (_("The remote protocol may be unreliable over UDP.\n"
4994 "Some events may be lost, rendering further debugging "
4999 return serial_open (name
);
5002 /* Inform the target of our permission settings. The permission flags
5003 work without this, but if the target knows the settings, it can do
5004 a couple things. First, it can add its own check, to catch cases
5005 that somehow manage to get by the permissions checks in target
5006 methods. Second, if the target is wired to disallow particular
5007 settings (for instance, a system in the field that is not set up to
5008 be able to stop at a breakpoint), it can object to any unavailable
5012 remote_target::set_permissions ()
5014 struct remote_state
*rs
= get_remote_state ();
5016 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
5017 "WriteReg:%x;WriteMem:%x;"
5018 "InsertBreak:%x;InsertTrace:%x;"
5019 "InsertFastTrace:%x;Stop:%x",
5020 may_write_registers
, may_write_memory
,
5021 may_insert_breakpoints
, may_insert_tracepoints
,
5022 may_insert_fast_tracepoints
, may_stop
);
5024 getpkt (&rs
->buf
, 0);
5026 /* If the target didn't like the packet, warn the user. Do not try
5027 to undo the user's settings, that would just be maddening. */
5028 if (strcmp (rs
->buf
.data (), "OK") != 0)
5029 warning (_("Remote refused setting permissions with: %s"),
5033 /* This type describes each known response to the qSupported
5035 struct protocol_feature
5037 /* The name of this protocol feature. */
5040 /* The default for this protocol feature. */
5041 enum packet_support default_support
;
5043 /* The function to call when this feature is reported, or after
5044 qSupported processing if the feature is not supported.
5045 The first argument points to this structure. The second
5046 argument indicates whether the packet requested support be
5047 enabled, disabled, or probed (or the default, if this function
5048 is being called at the end of processing and this feature was
5049 not reported). The third argument may be NULL; if not NULL, it
5050 is a NUL-terminated string taken from the packet following
5051 this feature's name and an equals sign. */
5052 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5053 enum packet_support
, const char *);
5055 /* The corresponding packet for this feature. Only used if
5056 FUNC is remote_supported_packet. */
5061 remote_supported_packet (remote_target
*remote
,
5062 const struct protocol_feature
*feature
,
5063 enum packet_support support
,
5064 const char *argument
)
5068 warning (_("Remote qSupported response supplied an unexpected value for"
5069 " \"%s\"."), feature
->name
);
5073 remote_protocol_packets
[feature
->packet
].support
= support
;
5077 remote_target::remote_packet_size (const protocol_feature
*feature
,
5078 enum packet_support support
, const char *value
)
5080 struct remote_state
*rs
= get_remote_state ();
5085 if (support
!= PACKET_ENABLE
)
5088 if (value
== NULL
|| *value
== '\0')
5090 warning (_("Remote target reported \"%s\" without a size."),
5096 packet_size
= strtol (value
, &value_end
, 16);
5097 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5099 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5100 feature
->name
, value
);
5104 /* Record the new maximum packet size. */
5105 rs
->explicit_packet_size
= packet_size
;
5109 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5110 enum packet_support support
, const char *value
)
5112 remote
->remote_packet_size (feature
, support
, value
);
5115 static const struct protocol_feature remote_protocol_features
[] = {
5116 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5117 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5118 PACKET_qXfer_auxv
},
5119 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5120 PACKET_qXfer_exec_file
},
5121 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5122 PACKET_qXfer_features
},
5123 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5124 PACKET_qXfer_libraries
},
5125 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5126 PACKET_qXfer_libraries_svr4
},
5127 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5128 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5129 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5130 PACKET_qXfer_memory_map
},
5131 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5132 PACKET_qXfer_osdata
},
5133 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5134 PACKET_qXfer_threads
},
5135 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5136 PACKET_qXfer_traceframe_info
},
5137 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5138 PACKET_QPassSignals
},
5139 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5140 PACKET_QCatchSyscalls
},
5141 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5142 PACKET_QProgramSignals
},
5143 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5144 PACKET_QSetWorkingDir
},
5145 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5146 PACKET_QStartupWithShell
},
5147 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5148 PACKET_QEnvironmentHexEncoded
},
5149 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5150 PACKET_QEnvironmentReset
},
5151 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5152 PACKET_QEnvironmentUnset
},
5153 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5154 PACKET_QStartNoAckMode
},
5155 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5156 PACKET_multiprocess_feature
},
5157 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5158 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5159 PACKET_qXfer_siginfo_read
},
5160 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5161 PACKET_qXfer_siginfo_write
},
5162 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5163 PACKET_ConditionalTracepoints
},
5164 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5165 PACKET_ConditionalBreakpoints
},
5166 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5167 PACKET_BreakpointCommands
},
5168 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5169 PACKET_FastTracepoints
},
5170 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5171 PACKET_StaticTracepoints
},
5172 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5173 PACKET_InstallInTrace
},
5174 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5175 PACKET_DisconnectedTracing_feature
},
5176 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5178 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5180 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5181 PACKET_TracepointSource
},
5182 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5184 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5185 PACKET_EnableDisableTracepoints_feature
},
5186 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5187 PACKET_qXfer_fdpic
},
5188 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5190 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5191 PACKET_QDisableRandomization
},
5192 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5193 { "QTBuffer:size", PACKET_DISABLE
,
5194 remote_supported_packet
, PACKET_QTBuffer_size
},
5195 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5196 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5197 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5198 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5199 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5200 PACKET_qXfer_btrace
},
5201 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5202 PACKET_qXfer_btrace_conf
},
5203 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5204 PACKET_Qbtrace_conf_bts_size
},
5205 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5206 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5207 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5208 PACKET_fork_event_feature
},
5209 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5210 PACKET_vfork_event_feature
},
5211 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5212 PACKET_exec_event_feature
},
5213 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5214 PACKET_Qbtrace_conf_pt_size
},
5215 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5216 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5217 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5220 static char *remote_support_xml
;
5222 /* Register string appended to "xmlRegisters=" in qSupported query. */
5225 register_remote_support_xml (const char *xml
)
5227 #if defined(HAVE_LIBEXPAT)
5228 if (remote_support_xml
== NULL
)
5229 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5232 char *copy
= xstrdup (remote_support_xml
+ 13);
5234 char *p
= strtok_r (copy
, ",", &saveptr
);
5238 if (strcmp (p
, xml
) == 0)
5245 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5248 remote_support_xml
= reconcat (remote_support_xml
,
5249 remote_support_xml
, ",", xml
,
5256 remote_query_supported_append (std::string
*msg
, const char *append
)
5260 msg
->append (append
);
5264 remote_target::remote_query_supported ()
5266 struct remote_state
*rs
= get_remote_state ();
5269 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5271 /* The packet support flags are handled differently for this packet
5272 than for most others. We treat an error, a disabled packet, and
5273 an empty response identically: any features which must be reported
5274 to be used will be automatically disabled. An empty buffer
5275 accomplishes this, since that is also the representation for a list
5276 containing no features. */
5279 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5283 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5284 remote_query_supported_append (&q
, "multiprocess+");
5286 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5287 remote_query_supported_append (&q
, "swbreak+");
5288 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5289 remote_query_supported_append (&q
, "hwbreak+");
5291 remote_query_supported_append (&q
, "qRelocInsn+");
5293 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5294 != AUTO_BOOLEAN_FALSE
)
5295 remote_query_supported_append (&q
, "fork-events+");
5296 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5297 != AUTO_BOOLEAN_FALSE
)
5298 remote_query_supported_append (&q
, "vfork-events+");
5299 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5300 != AUTO_BOOLEAN_FALSE
)
5301 remote_query_supported_append (&q
, "exec-events+");
5303 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5304 remote_query_supported_append (&q
, "vContSupported+");
5306 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5307 remote_query_supported_append (&q
, "QThreadEvents+");
5309 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5310 remote_query_supported_append (&q
, "no-resumed+");
5312 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5313 the qSupported:xmlRegisters=i386 handling. */
5314 if (remote_support_xml
!= NULL
5315 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5316 remote_query_supported_append (&q
, remote_support_xml
);
5318 q
= "qSupported:" + q
;
5319 putpkt (q
.c_str ());
5321 getpkt (&rs
->buf
, 0);
5323 /* If an error occured, warn, but do not return - just reset the
5324 buffer to empty and go on to disable features. */
5325 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5328 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5333 memset (seen
, 0, sizeof (seen
));
5335 next
= rs
->buf
.data ();
5338 enum packet_support is_supported
;
5339 char *p
, *end
, *name_end
, *value
;
5341 /* First separate out this item from the rest of the packet. If
5342 there's another item after this, we overwrite the separator
5343 (terminated strings are much easier to work with). */
5345 end
= strchr (p
, ';');
5348 end
= p
+ strlen (p
);
5358 warning (_("empty item in \"qSupported\" response"));
5363 name_end
= strchr (p
, '=');
5366 /* This is a name=value entry. */
5367 is_supported
= PACKET_ENABLE
;
5368 value
= name_end
+ 1;
5377 is_supported
= PACKET_ENABLE
;
5381 is_supported
= PACKET_DISABLE
;
5385 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5389 warning (_("unrecognized item \"%s\" "
5390 "in \"qSupported\" response"), p
);
5396 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5397 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5399 const struct protocol_feature
*feature
;
5402 feature
= &remote_protocol_features
[i
];
5403 feature
->func (this, feature
, is_supported
, value
);
5408 /* If we increased the packet size, make sure to increase the global
5409 buffer size also. We delay this until after parsing the entire
5410 qSupported packet, because this is the same buffer we were
5412 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5413 rs
->buf
.resize (rs
->explicit_packet_size
);
5415 /* Handle the defaults for unmentioned features. */
5416 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5419 const struct protocol_feature
*feature
;
5421 feature
= &remote_protocol_features
[i
];
5422 feature
->func (this, feature
, feature
->default_support
, NULL
);
5426 /* Serial QUIT handler for the remote serial descriptor.
5428 Defers handling a Ctrl-C until we're done with the current
5429 command/response packet sequence, unless:
5431 - We're setting up the connection. Don't send a remote interrupt
5432 request, as we're not fully synced yet. Quit immediately
5435 - The target has been resumed in the foreground
5436 (target_terminal::is_ours is false) with a synchronous resume
5437 packet, and we're blocked waiting for the stop reply, thus a
5438 Ctrl-C should be immediately sent to the target.
5440 - We get a second Ctrl-C while still within the same serial read or
5441 write. In that case the serial is seemingly wedged --- offer to
5444 - We see a second Ctrl-C without target response, after having
5445 previously interrupted the target. In that case the target/stub
5446 is probably wedged --- offer to quit/disconnect.
5450 remote_target::remote_serial_quit_handler ()
5452 struct remote_state
*rs
= get_remote_state ();
5454 if (check_quit_flag ())
5456 /* If we're starting up, we're not fully synced yet. Quit
5458 if (rs
->starting_up
)
5460 else if (rs
->got_ctrlc_during_io
)
5462 if (query (_("The target is not responding to GDB commands.\n"
5463 "Stop debugging it? ")))
5464 remote_unpush_and_throw (this);
5466 /* If ^C has already been sent once, offer to disconnect. */
5467 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5469 /* All-stop protocol, and blocked waiting for stop reply. Send
5470 an interrupt request. */
5471 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5472 target_interrupt ();
5474 rs
->got_ctrlc_during_io
= 1;
5478 /* The remote_target that is current while the quit handler is
5479 overridden with remote_serial_quit_handler. */
5480 static remote_target
*curr_quit_handler_target
;
5483 remote_serial_quit_handler ()
5485 curr_quit_handler_target
->remote_serial_quit_handler ();
5488 /* Remove the remote target from the target stack of each inferior
5489 that is using it. Upper targets depend on it so remove them
5493 remote_unpush_target (remote_target
*target
)
5495 /* We have to unpush the target from all inferiors, even those that
5497 scoped_restore_current_inferior restore_current_inferior
;
5499 for (inferior
*inf
: all_inferiors (target
))
5501 switch_to_inferior_no_thread (inf
);
5502 pop_all_targets_at_and_above (process_stratum
);
5503 generic_mourn_inferior ();
5508 remote_unpush_and_throw (remote_target
*target
)
5510 remote_unpush_target (target
);
5511 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5515 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5517 remote_target
*curr_remote
= get_current_remote_target ();
5520 error (_("To open a remote debug connection, you need to specify what\n"
5521 "serial device is attached to the remote system\n"
5522 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5524 /* If we're connected to a running target, target_preopen will kill it.
5525 Ask this question first, before target_preopen has a chance to kill
5527 if (curr_remote
!= NULL
&& !target_has_execution
)
5530 && !query (_("Already connected to a remote target. Disconnect? ")))
5531 error (_("Still connected."));
5534 /* Here the possibly existing remote target gets unpushed. */
5535 target_preopen (from_tty
);
5537 remote_fileio_reset ();
5538 reopen_exec_file ();
5541 remote_target
*remote
5542 = (extended_p
? new extended_remote_target () : new remote_target ());
5543 target_ops_up
target_holder (remote
);
5545 remote_state
*rs
= remote
->get_remote_state ();
5547 /* See FIXME above. */
5548 if (!target_async_permitted
)
5549 rs
->wait_forever_enabled_p
= 1;
5551 rs
->remote_desc
= remote_serial_open (name
);
5552 if (!rs
->remote_desc
)
5553 perror_with_name (name
);
5555 if (baud_rate
!= -1)
5557 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5559 /* The requested speed could not be set. Error out to
5560 top level after closing remote_desc. Take care to
5561 set remote_desc to NULL to avoid closing remote_desc
5563 serial_close (rs
->remote_desc
);
5564 rs
->remote_desc
= NULL
;
5565 perror_with_name (name
);
5569 serial_setparity (rs
->remote_desc
, serial_parity
);
5570 serial_raw (rs
->remote_desc
);
5572 /* If there is something sitting in the buffer we might take it as a
5573 response to a command, which would be bad. */
5574 serial_flush_input (rs
->remote_desc
);
5578 puts_filtered ("Remote debugging using ");
5579 puts_filtered (name
);
5580 puts_filtered ("\n");
5583 /* Switch to using the remote target now. */
5584 push_target (std::move (target_holder
));
5586 /* Register extra event sources in the event loop. */
5587 rs
->remote_async_inferior_event_token
5588 = create_async_event_handler (remote_async_inferior_event_handler
,
5590 rs
->notif_state
= remote_notif_state_allocate (remote
);
5592 /* Reset the target state; these things will be queried either by
5593 remote_query_supported or as they are needed. */
5594 reset_all_packet_configs_support ();
5595 rs
->cached_wait_status
= 0;
5596 rs
->explicit_packet_size
= 0;
5598 rs
->extended
= extended_p
;
5599 rs
->waiting_for_stop_reply
= 0;
5600 rs
->ctrlc_pending_p
= 0;
5601 rs
->got_ctrlc_during_io
= 0;
5603 rs
->general_thread
= not_sent_ptid
;
5604 rs
->continue_thread
= not_sent_ptid
;
5605 rs
->remote_traceframe_number
= -1;
5607 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5609 /* Probe for ability to use "ThreadInfo" query, as required. */
5610 rs
->use_threadinfo_query
= 1;
5611 rs
->use_threadextra_query
= 1;
5613 rs
->readahead_cache
.invalidate ();
5615 if (target_async_permitted
)
5617 /* FIXME: cagney/1999-09-23: During the initial connection it is
5618 assumed that the target is already ready and able to respond to
5619 requests. Unfortunately remote_start_remote() eventually calls
5620 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5621 around this. Eventually a mechanism that allows
5622 wait_for_inferior() to expect/get timeouts will be
5624 rs
->wait_forever_enabled_p
= 0;
5627 /* First delete any symbols previously loaded from shared libraries. */
5628 no_shared_libraries (NULL
, 0);
5630 /* Start the remote connection. If error() or QUIT, discard this
5631 target (we'd otherwise be in an inconsistent state) and then
5632 propogate the error on up the exception chain. This ensures that
5633 the caller doesn't stumble along blindly assuming that the
5634 function succeeded. The CLI doesn't have this problem but other
5635 UI's, such as MI do.
5637 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5638 this function should return an error indication letting the
5639 caller restore the previous state. Unfortunately the command
5640 ``target remote'' is directly wired to this function making that
5641 impossible. On a positive note, the CLI side of this problem has
5642 been fixed - the function set_cmd_context() makes it possible for
5643 all the ``target ....'' commands to share a common callback
5644 function. See cli-dump.c. */
5649 remote
->start_remote (from_tty
, extended_p
);
5651 catch (const gdb_exception
&ex
)
5653 /* Pop the partially set up target - unless something else did
5654 already before throwing the exception. */
5655 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5656 remote_unpush_target (remote
);
5661 remote_btrace_reset (rs
);
5663 if (target_async_permitted
)
5664 rs
->wait_forever_enabled_p
= 1;
5667 /* Detach the specified process. */
5670 remote_target::remote_detach_pid (int pid
)
5672 struct remote_state
*rs
= get_remote_state ();
5674 /* This should not be necessary, but the handling for D;PID in
5675 GDBserver versions prior to 8.2 incorrectly assumes that the
5676 selected process points to the same process we're detaching,
5677 leading to misbehavior (and possibly GDBserver crashing) when it
5678 does not. Since it's easy and cheap, work around it by forcing
5679 GDBserver to select GDB's current process. */
5680 set_general_process ();
5682 if (remote_multi_process_p (rs
))
5683 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5685 strcpy (rs
->buf
.data (), "D");
5688 getpkt (&rs
->buf
, 0);
5690 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5692 else if (rs
->buf
[0] == '\0')
5693 error (_("Remote doesn't know how to detach"));
5695 error (_("Can't detach process."));
5698 /* This detaches a program to which we previously attached, using
5699 inferior_ptid to identify the process. After this is done, GDB
5700 can be used to debug some other program. We better not have left
5701 any breakpoints in the target program or it'll die when it hits
5705 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5707 int pid
= inferior_ptid
.pid ();
5708 struct remote_state
*rs
= get_remote_state ();
5711 if (!target_has_execution
)
5712 error (_("No process to detach from."));
5714 target_announce_detach (from_tty
);
5716 /* Tell the remote target to detach. */
5717 remote_detach_pid (pid
);
5719 /* Exit only if this is the only active inferior. */
5720 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors (this) == 1)
5721 puts_filtered (_("Ending remote debugging.\n"));
5723 thread_info
*tp
= find_thread_ptid (this, inferior_ptid
);
5725 /* Check to see if we are detaching a fork parent. Note that if we
5726 are detaching a fork child, tp == NULL. */
5727 is_fork_parent
= (tp
!= NULL
5728 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5730 /* If doing detach-on-fork, we don't mourn, because that will delete
5731 breakpoints that should be available for the followed inferior. */
5732 if (!is_fork_parent
)
5734 /* Save the pid as a string before mourning, since that will
5735 unpush the remote target, and we need the string after. */
5736 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5738 target_mourn_inferior (inferior_ptid
);
5739 if (print_inferior_events
)
5740 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5741 inf
->num
, infpid
.c_str ());
5745 inferior_ptid
= null_ptid
;
5746 detach_inferior (current_inferior ());
5751 remote_target::detach (inferior
*inf
, int from_tty
)
5753 remote_detach_1 (inf
, from_tty
);
5757 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5759 remote_detach_1 (inf
, from_tty
);
5762 /* Target follow-fork function for remote targets. On entry, and
5763 at return, the current inferior is the fork parent.
5765 Note that although this is currently only used for extended-remote,
5766 it is named remote_follow_fork in anticipation of using it for the
5767 remote target as well. */
5770 remote_target::follow_fork (int follow_child
, int detach_fork
)
5772 struct remote_state
*rs
= get_remote_state ();
5773 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5775 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5776 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5778 /* When following the parent and detaching the child, we detach
5779 the child here. For the case of following the child and
5780 detaching the parent, the detach is done in the target-
5781 independent follow fork code in infrun.c. We can't use
5782 target_detach when detaching an unfollowed child because
5783 the client side doesn't know anything about the child. */
5784 if (detach_fork
&& !follow_child
)
5786 /* Detach the fork child. */
5790 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5791 child_pid
= child_ptid
.pid ();
5793 remote_detach_pid (child_pid
);
5799 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5800 in the program space of the new inferior. On entry and at return the
5801 current inferior is the exec'ing inferior. INF is the new exec'd
5802 inferior, which may be the same as the exec'ing inferior unless
5803 follow-exec-mode is "new". */
5806 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5808 /* We know that this is a target file name, so if it has the "target:"
5809 prefix we strip it off before saving it in the program space. */
5810 if (is_target_filename (execd_pathname
))
5811 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5813 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5816 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5819 remote_target::disconnect (const char *args
, int from_tty
)
5822 error (_("Argument given to \"disconnect\" when remotely debugging."));
5824 /* Make sure we unpush even the extended remote targets. Calling
5825 target_mourn_inferior won't unpush, and
5826 remote_target::mourn_inferior won't unpush if there is more than
5827 one inferior left. */
5828 remote_unpush_target (this);
5831 puts_filtered ("Ending remote debugging.\n");
5834 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5835 be chatty about it. */
5838 extended_remote_target::attach (const char *args
, int from_tty
)
5840 struct remote_state
*rs
= get_remote_state ();
5842 char *wait_status
= NULL
;
5844 pid
= parse_pid_to_attach (args
);
5846 /* Remote PID can be freely equal to getpid, do not check it here the same
5847 way as in other targets. */
5849 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5850 error (_("This target does not support attaching to a process"));
5854 const char *exec_file
= get_exec_file (0);
5857 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5858 target_pid_to_str (ptid_t (pid
)).c_str ());
5860 printf_unfiltered (_("Attaching to %s\n"),
5861 target_pid_to_str (ptid_t (pid
)).c_str ());
5864 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5866 getpkt (&rs
->buf
, 0);
5868 switch (packet_ok (rs
->buf
,
5869 &remote_protocol_packets
[PACKET_vAttach
]))
5872 if (!target_is_non_stop_p ())
5874 /* Save the reply for later. */
5875 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5876 strcpy (wait_status
, rs
->buf
.data ());
5878 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5879 error (_("Attaching to %s failed with: %s"),
5880 target_pid_to_str (ptid_t (pid
)).c_str (),
5883 case PACKET_UNKNOWN
:
5884 error (_("This target does not support attaching to a process"));
5886 error (_("Attaching to %s failed"),
5887 target_pid_to_str (ptid_t (pid
)).c_str ());
5890 set_current_inferior (remote_add_inferior (false, pid
, 1, 0));
5892 inferior_ptid
= ptid_t (pid
);
5894 if (target_is_non_stop_p ())
5896 struct thread_info
*thread
;
5898 /* Get list of threads. */
5899 update_thread_list ();
5901 thread
= first_thread_of_inferior (current_inferior ());
5903 inferior_ptid
= thread
->ptid
;
5905 inferior_ptid
= ptid_t (pid
);
5907 /* Invalidate our notion of the remote current thread. */
5908 record_currthread (rs
, minus_one_ptid
);
5912 /* Now, if we have thread information, update inferior_ptid. */
5913 inferior_ptid
= remote_current_thread (inferior_ptid
);
5915 /* Add the main thread to the thread list. */
5916 thread_info
*thr
= add_thread_silent (this, inferior_ptid
);
5917 /* Don't consider the thread stopped until we've processed the
5918 saved stop reply. */
5919 set_executing (this, thr
->ptid
, true);
5922 /* Next, if the target can specify a description, read it. We do
5923 this before anything involving memory or registers. */
5924 target_find_description ();
5926 if (!target_is_non_stop_p ())
5928 /* Use the previously fetched status. */
5929 gdb_assert (wait_status
!= NULL
);
5931 if (target_can_async_p ())
5933 struct notif_event
*reply
5934 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
5936 push_stop_reply ((struct stop_reply
*) reply
);
5942 gdb_assert (wait_status
!= NULL
);
5943 strcpy (rs
->buf
.data (), wait_status
);
5944 rs
->cached_wait_status
= 1;
5948 gdb_assert (wait_status
== NULL
);
5951 /* Implementation of the to_post_attach method. */
5954 extended_remote_target::post_attach (int pid
)
5956 /* Get text, data & bss offsets. */
5959 /* In certain cases GDB might not have had the chance to start
5960 symbol lookup up until now. This could happen if the debugged
5961 binary is not using shared libraries, the vsyscall page is not
5962 present (on Linux) and the binary itself hadn't changed since the
5963 debugging process was started. */
5964 if (symfile_objfile
!= NULL
)
5965 remote_check_symbols();
5969 /* Check for the availability of vCont. This function should also check
5973 remote_target::remote_vcont_probe ()
5975 remote_state
*rs
= get_remote_state ();
5978 strcpy (rs
->buf
.data (), "vCont?");
5980 getpkt (&rs
->buf
, 0);
5981 buf
= rs
->buf
.data ();
5983 /* Make sure that the features we assume are supported. */
5984 if (startswith (buf
, "vCont"))
5987 int support_c
, support_C
;
5989 rs
->supports_vCont
.s
= 0;
5990 rs
->supports_vCont
.S
= 0;
5993 rs
->supports_vCont
.t
= 0;
5994 rs
->supports_vCont
.r
= 0;
5995 while (p
&& *p
== ';')
5998 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5999 rs
->supports_vCont
.s
= 1;
6000 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6001 rs
->supports_vCont
.S
= 1;
6002 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6004 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6006 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6007 rs
->supports_vCont
.t
= 1;
6008 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6009 rs
->supports_vCont
.r
= 1;
6011 p
= strchr (p
, ';');
6014 /* If c, and C are not all supported, we can't use vCont. Clearing
6015 BUF will make packet_ok disable the packet. */
6016 if (!support_c
|| !support_C
)
6020 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
6021 rs
->supports_vCont_probed
= true;
6024 /* Helper function for building "vCont" resumptions. Write a
6025 resumption to P. ENDP points to one-passed-the-end of the buffer
6026 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
6027 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
6028 resumed thread should be single-stepped and/or signalled. If PTID
6029 equals minus_one_ptid, then all threads are resumed; if PTID
6030 represents a process, then all threads of the process are resumed;
6031 the thread to be stepped and/or signalled is given in the global
6035 remote_target::append_resumption (char *p
, char *endp
,
6036 ptid_t ptid
, int step
, gdb_signal siggnal
)
6038 struct remote_state
*rs
= get_remote_state ();
6040 if (step
&& siggnal
!= GDB_SIGNAL_0
)
6041 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
6043 /* GDB is willing to range step. */
6044 && use_range_stepping
6045 /* Target supports range stepping. */
6046 && rs
->supports_vCont
.r
6047 /* We don't currently support range stepping multiple
6048 threads with a wildcard (though the protocol allows it,
6049 so stubs shouldn't make an active effort to forbid
6051 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6053 struct thread_info
*tp
;
6055 if (ptid
== minus_one_ptid
)
6057 /* If we don't know about the target thread's tid, then
6058 we're resuming magic_null_ptid (see caller). */
6059 tp
= find_thread_ptid (this, magic_null_ptid
);
6062 tp
= find_thread_ptid (this, ptid
);
6063 gdb_assert (tp
!= NULL
);
6065 if (tp
->control
.may_range_step
)
6067 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6069 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6070 phex_nz (tp
->control
.step_range_start
,
6072 phex_nz (tp
->control
.step_range_end
,
6076 p
+= xsnprintf (p
, endp
- p
, ";s");
6079 p
+= xsnprintf (p
, endp
- p
, ";s");
6080 else if (siggnal
!= GDB_SIGNAL_0
)
6081 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6083 p
+= xsnprintf (p
, endp
- p
, ";c");
6085 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6089 /* All (-1) threads of process. */
6090 nptid
= ptid_t (ptid
.pid (), -1, 0);
6092 p
+= xsnprintf (p
, endp
- p
, ":");
6093 p
= write_ptid (p
, endp
, nptid
);
6095 else if (ptid
!= minus_one_ptid
)
6097 p
+= xsnprintf (p
, endp
- p
, ":");
6098 p
= write_ptid (p
, endp
, ptid
);
6104 /* Clear the thread's private info on resume. */
6107 resume_clear_thread_private_info (struct thread_info
*thread
)
6109 if (thread
->priv
!= NULL
)
6111 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6113 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6114 priv
->watch_data_address
= 0;
6118 /* Append a vCont continue-with-signal action for threads that have a
6119 non-zero stop signal. */
6122 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6125 for (thread_info
*thread
: all_non_exited_threads (this, ptid
))
6126 if (inferior_ptid
!= thread
->ptid
6127 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6129 p
= append_resumption (p
, endp
, thread
->ptid
,
6130 0, thread
->suspend
.stop_signal
);
6131 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6132 resume_clear_thread_private_info (thread
);
6138 /* Set the target running, using the packets that use Hc
6142 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6145 struct remote_state
*rs
= get_remote_state ();
6148 rs
->last_sent_signal
= siggnal
;
6149 rs
->last_sent_step
= step
;
6151 /* The c/s/C/S resume packets use Hc, so set the continue
6153 if (ptid
== minus_one_ptid
)
6154 set_continue_thread (any_thread_ptid
);
6156 set_continue_thread (ptid
);
6158 for (thread_info
*thread
: all_non_exited_threads (this))
6159 resume_clear_thread_private_info (thread
);
6161 buf
= rs
->buf
.data ();
6162 if (::execution_direction
== EXEC_REVERSE
)
6164 /* We don't pass signals to the target in reverse exec mode. */
6165 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6166 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6169 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6170 error (_("Remote reverse-step not supported."));
6171 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6172 error (_("Remote reverse-continue not supported."));
6174 strcpy (buf
, step
? "bs" : "bc");
6176 else if (siggnal
!= GDB_SIGNAL_0
)
6178 buf
[0] = step
? 'S' : 'C';
6179 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6180 buf
[2] = tohex (((int) siggnal
) & 0xf);
6184 strcpy (buf
, step
? "s" : "c");
6189 /* Resume the remote inferior by using a "vCont" packet. The thread
6190 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6191 resumed thread should be single-stepped and/or signalled. If PTID
6192 equals minus_one_ptid, then all threads are resumed; the thread to
6193 be stepped and/or signalled is given in the global INFERIOR_PTID.
6194 This function returns non-zero iff it resumes the inferior.
6196 This function issues a strict subset of all possible vCont commands
6200 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6201 enum gdb_signal siggnal
)
6203 struct remote_state
*rs
= get_remote_state ();
6207 /* No reverse execution actions defined for vCont. */
6208 if (::execution_direction
== EXEC_REVERSE
)
6211 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6212 remote_vcont_probe ();
6214 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6217 p
= rs
->buf
.data ();
6218 endp
= p
+ get_remote_packet_size ();
6220 /* If we could generate a wider range of packets, we'd have to worry
6221 about overflowing BUF. Should there be a generic
6222 "multi-part-packet" packet? */
6224 p
+= xsnprintf (p
, endp
- p
, "vCont");
6226 if (ptid
== magic_null_ptid
)
6228 /* MAGIC_NULL_PTID means that we don't have any active threads,
6229 so we don't have any TID numbers the inferior will
6230 understand. Make sure to only send forms that do not specify
6232 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6234 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6236 /* Resume all threads (of all processes, or of a single
6237 process), with preference for INFERIOR_PTID. This assumes
6238 inferior_ptid belongs to the set of all threads we are about
6240 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6242 /* Step inferior_ptid, with or without signal. */
6243 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6246 /* Also pass down any pending signaled resumption for other
6247 threads not the current. */
6248 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6250 /* And continue others without a signal. */
6251 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6255 /* Scheduler locking; resume only PTID. */
6256 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6259 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6262 if (target_is_non_stop_p ())
6264 /* In non-stop, the stub replies to vCont with "OK". The stop
6265 reply will be reported asynchronously by means of a `%Stop'
6267 getpkt (&rs
->buf
, 0);
6268 if (strcmp (rs
->buf
.data (), "OK") != 0)
6269 error (_("Unexpected vCont reply in non-stop mode: %s"),
6276 /* Tell the remote machine to resume. */
6279 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6281 struct remote_state
*rs
= get_remote_state ();
6283 /* When connected in non-stop mode, the core resumes threads
6284 individually. Resuming remote threads directly in target_resume
6285 would thus result in sending one packet per thread. Instead, to
6286 minimize roundtrip latency, here we just store the resume
6287 request; the actual remote resumption will be done in
6288 target_commit_resume / remote_commit_resume, where we'll be able
6289 to do vCont action coalescing. */
6290 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6292 remote_thread_info
*remote_thr
;
6294 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6295 remote_thr
= get_remote_thread_info (this, inferior_ptid
);
6297 remote_thr
= get_remote_thread_info (this, ptid
);
6299 remote_thr
->last_resume_step
= step
;
6300 remote_thr
->last_resume_sig
= siggnal
;
6304 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6305 (explained in remote-notif.c:handle_notification) so
6306 remote_notif_process is not called. We need find a place where
6307 it is safe to start a 'vNotif' sequence. It is good to do it
6308 before resuming inferior, because inferior was stopped and no RSP
6309 traffic at that moment. */
6310 if (!target_is_non_stop_p ())
6311 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6313 rs
->last_resume_exec_dir
= ::execution_direction
;
6315 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6316 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6317 remote_resume_with_hc (ptid
, step
, siggnal
);
6319 /* We are about to start executing the inferior, let's register it
6320 with the event loop. NOTE: this is the one place where all the
6321 execution commands end up. We could alternatively do this in each
6322 of the execution commands in infcmd.c. */
6323 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6324 into infcmd.c in order to allow inferior function calls to work
6325 NOT asynchronously. */
6326 if (target_can_async_p ())
6329 /* We've just told the target to resume. The remote server will
6330 wait for the inferior to stop, and then send a stop reply. In
6331 the mean time, we can't start another command/query ourselves
6332 because the stub wouldn't be ready to process it. This applies
6333 only to the base all-stop protocol, however. In non-stop (which
6334 only supports vCont), the stub replies with an "OK", and is
6335 immediate able to process further serial input. */
6336 if (!target_is_non_stop_p ())
6337 rs
->waiting_for_stop_reply
= 1;
6340 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6342 /* Private per-inferior info for target remote processes. */
6344 struct remote_inferior
: public private_inferior
6346 /* Whether we can send a wildcard vCont for this process. */
6347 bool may_wildcard_vcont
= true;
6350 /* Get the remote private inferior data associated to INF. */
6352 static remote_inferior
*
6353 get_remote_inferior (inferior
*inf
)
6355 if (inf
->priv
== NULL
)
6356 inf
->priv
.reset (new remote_inferior
);
6358 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6361 /* Class used to track the construction of a vCont packet in the
6362 outgoing packet buffer. This is used to send multiple vCont
6363 packets if we have more actions than would fit a single packet. */
6368 explicit vcont_builder (remote_target
*remote
)
6375 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6380 /* The remote target. */
6381 remote_target
*m_remote
;
6383 /* Pointer to the first action. P points here if no action has been
6385 char *m_first_action
;
6387 /* Where the next action will be appended. */
6390 /* The end of the buffer. Must never write past this. */
6394 /* Prepare the outgoing buffer for a new vCont packet. */
6397 vcont_builder::restart ()
6399 struct remote_state
*rs
= m_remote
->get_remote_state ();
6401 m_p
= rs
->buf
.data ();
6402 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6403 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6404 m_first_action
= m_p
;
6407 /* If the vCont packet being built has any action, send it to the
6411 vcont_builder::flush ()
6413 struct remote_state
*rs
;
6415 if (m_p
== m_first_action
)
6418 rs
= m_remote
->get_remote_state ();
6419 m_remote
->putpkt (rs
->buf
);
6420 m_remote
->getpkt (&rs
->buf
, 0);
6421 if (strcmp (rs
->buf
.data (), "OK") != 0)
6422 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6425 /* The largest action is range-stepping, with its two addresses. This
6426 is more than sufficient. If a new, bigger action is created, it'll
6427 quickly trigger a failed assertion in append_resumption (and we'll
6429 #define MAX_ACTION_SIZE 200
6431 /* Append a new vCont action in the outgoing packet being built. If
6432 the action doesn't fit the packet along with previous actions, push
6433 what we've got so far to the remote end and start over a new vCont
6434 packet (with the new action). */
6437 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6439 char buf
[MAX_ACTION_SIZE
+ 1];
6441 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6442 ptid
, step
, siggnal
);
6444 /* Check whether this new action would fit in the vCont packet along
6445 with previous actions. If not, send what we've got so far and
6446 start a new vCont packet. */
6447 size_t rsize
= endp
- buf
;
6448 if (rsize
> m_endp
- m_p
)
6453 /* Should now fit. */
6454 gdb_assert (rsize
<= m_endp
- m_p
);
6457 memcpy (m_p
, buf
, rsize
);
6462 /* to_commit_resume implementation. */
6465 remote_target::commit_resume ()
6467 int any_process_wildcard
;
6468 int may_global_wildcard_vcont
;
6470 /* If connected in all-stop mode, we'd send the remote resume
6471 request directly from remote_resume. Likewise if
6472 reverse-debugging, as there are no defined vCont actions for
6473 reverse execution. */
6474 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6477 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6478 instead of resuming all threads of each process individually.
6479 However, if any thread of a process must remain halted, we can't
6480 send wildcard resumes and must send one action per thread.
6482 Care must be taken to not resume threads/processes the server
6483 side already told us are stopped, but the core doesn't know about
6484 yet, because the events are still in the vStopped notification
6487 #1 => vCont s:p1.1;c
6489 #3 <= %Stopped T05 p1.1
6494 #8 (infrun handles the stop for p1.1 and continues stepping)
6495 #9 => vCont s:p1.1;c
6497 The last vCont above would resume thread p1.2 by mistake, because
6498 the server has no idea that the event for p1.2 had not been
6501 The server side must similarly ignore resume actions for the
6502 thread that has a pending %Stopped notification (and any other
6503 threads with events pending), until GDB acks the notification
6504 with vStopped. Otherwise, e.g., the following case is
6507 #1 => g (or any other packet)
6509 #3 <= %Stopped T05 p1.2
6510 #4 => vCont s:p1.1;c
6513 Above, the server must not resume thread p1.2. GDB can't know
6514 that p1.2 stopped until it acks the %Stopped notification, and
6515 since from GDB's perspective all threads should be running, it
6518 Finally, special care must also be given to handling fork/vfork
6519 events. A (v)fork event actually tells us that two processes
6520 stopped -- the parent and the child. Until we follow the fork,
6521 we must not resume the child. Therefore, if we have a pending
6522 fork follow, we must not send a global wildcard resume action
6523 (vCont;c). We can still send process-wide wildcards though. */
6525 /* Start by assuming a global wildcard (vCont;c) is possible. */
6526 may_global_wildcard_vcont
= 1;
6528 /* And assume every process is individually wildcard-able too. */
6529 for (inferior
*inf
: all_non_exited_inferiors (this))
6531 remote_inferior
*priv
= get_remote_inferior (inf
);
6533 priv
->may_wildcard_vcont
= true;
6536 /* Check for any pending events (not reported or processed yet) and
6537 disable process and global wildcard resumes appropriately. */
6538 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6540 for (thread_info
*tp
: all_non_exited_threads (this))
6542 /* If a thread of a process is not meant to be resumed, then we
6543 can't wildcard that process. */
6546 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6548 /* And if we can't wildcard a process, we can't wildcard
6549 everything either. */
6550 may_global_wildcard_vcont
= 0;
6554 /* If a thread is the parent of an unfollowed fork, then we
6555 can't do a global wildcard, as that would resume the fork
6557 if (is_pending_fork_parent_thread (tp
))
6558 may_global_wildcard_vcont
= 0;
6561 /* Now let's build the vCont packet(s). Actions must be appended
6562 from narrower to wider scopes (thread -> process -> global). If
6563 we end up with too many actions for a single packet vcont_builder
6564 flushes the current vCont packet to the remote side and starts a
6566 struct vcont_builder
vcont_builder (this);
6568 /* Threads first. */
6569 for (thread_info
*tp
: all_non_exited_threads (this))
6571 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6573 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6576 gdb_assert (!thread_is_in_step_over_chain (tp
));
6578 if (!remote_thr
->last_resume_step
6579 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6580 && get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6582 /* We'll send a wildcard resume instead. */
6583 remote_thr
->vcont_resumed
= 1;
6587 vcont_builder
.push_action (tp
->ptid
,
6588 remote_thr
->last_resume_step
,
6589 remote_thr
->last_resume_sig
);
6590 remote_thr
->vcont_resumed
= 1;
6593 /* Now check whether we can send any process-wide wildcard. This is
6594 to avoid sending a global wildcard in the case nothing is
6595 supposed to be resumed. */
6596 any_process_wildcard
= 0;
6598 for (inferior
*inf
: all_non_exited_inferiors (this))
6600 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6602 any_process_wildcard
= 1;
6607 if (any_process_wildcard
)
6609 /* If all processes are wildcard-able, then send a single "c"
6610 action, otherwise, send an "all (-1) threads of process"
6611 continue action for each running process, if any. */
6612 if (may_global_wildcard_vcont
)
6614 vcont_builder
.push_action (minus_one_ptid
,
6615 false, GDB_SIGNAL_0
);
6619 for (inferior
*inf
: all_non_exited_inferiors (this))
6621 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6623 vcont_builder
.push_action (ptid_t (inf
->pid
),
6624 false, GDB_SIGNAL_0
);
6630 vcont_builder
.flush ();
6635 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6636 thread, all threads of a remote process, or all threads of all
6640 remote_target::remote_stop_ns (ptid_t ptid
)
6642 struct remote_state
*rs
= get_remote_state ();
6643 char *p
= rs
->buf
.data ();
6644 char *endp
= p
+ get_remote_packet_size ();
6646 /* FIXME: This supports_vCont_probed check is a workaround until
6647 packet_support is per-connection. */
6648 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
6649 || !rs
->supports_vCont_probed
)
6650 remote_vcont_probe ();
6652 if (!rs
->supports_vCont
.t
)
6653 error (_("Remote server does not support stopping threads"));
6655 if (ptid
== minus_one_ptid
6656 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6657 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6662 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6665 /* All (-1) threads of process. */
6666 nptid
= ptid_t (ptid
.pid (), -1, 0);
6669 /* Small optimization: if we already have a stop reply for
6670 this thread, no use in telling the stub we want this
6672 if (peek_stop_reply (ptid
))
6678 write_ptid (p
, endp
, nptid
);
6681 /* In non-stop, we get an immediate OK reply. The stop reply will
6682 come in asynchronously by notification. */
6684 getpkt (&rs
->buf
, 0);
6685 if (strcmp (rs
->buf
.data (), "OK") != 0)
6686 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6690 /* All-stop version of target_interrupt. Sends a break or a ^C to
6691 interrupt the remote target. It is undefined which thread of which
6692 process reports the interrupt. */
6695 remote_target::remote_interrupt_as ()
6697 struct remote_state
*rs
= get_remote_state ();
6699 rs
->ctrlc_pending_p
= 1;
6701 /* If the inferior is stopped already, but the core didn't know
6702 about it yet, just ignore the request. The cached wait status
6703 will be collected in remote_wait. */
6704 if (rs
->cached_wait_status
)
6707 /* Send interrupt_sequence to remote target. */
6708 send_interrupt_sequence ();
6711 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6712 the remote target. It is undefined which thread of which process
6713 reports the interrupt. Throws an error if the packet is not
6714 supported by the server. */
6717 remote_target::remote_interrupt_ns ()
6719 struct remote_state
*rs
= get_remote_state ();
6720 char *p
= rs
->buf
.data ();
6721 char *endp
= p
+ get_remote_packet_size ();
6723 xsnprintf (p
, endp
- p
, "vCtrlC");
6725 /* In non-stop, we get an immediate OK reply. The stop reply will
6726 come in asynchronously by notification. */
6728 getpkt (&rs
->buf
, 0);
6730 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6734 case PACKET_UNKNOWN
:
6735 error (_("No support for interrupting the remote target."));
6737 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6741 /* Implement the to_stop function for the remote targets. */
6744 remote_target::stop (ptid_t ptid
)
6747 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6749 if (target_is_non_stop_p ())
6750 remote_stop_ns (ptid
);
6753 /* We don't currently have a way to transparently pause the
6754 remote target in all-stop mode. Interrupt it instead. */
6755 remote_interrupt_as ();
6759 /* Implement the to_interrupt function for the remote targets. */
6762 remote_target::interrupt ()
6765 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6767 if (target_is_non_stop_p ())
6768 remote_interrupt_ns ();
6770 remote_interrupt_as ();
6773 /* Implement the to_pass_ctrlc function for the remote targets. */
6776 remote_target::pass_ctrlc ()
6778 struct remote_state
*rs
= get_remote_state ();
6781 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6783 /* If we're starting up, we're not fully synced yet. Quit
6785 if (rs
->starting_up
)
6787 /* If ^C has already been sent once, offer to disconnect. */
6788 else if (rs
->ctrlc_pending_p
)
6791 target_interrupt ();
6794 /* Ask the user what to do when an interrupt is received. */
6797 remote_target::interrupt_query ()
6799 struct remote_state
*rs
= get_remote_state ();
6801 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6803 if (query (_("The target is not responding to interrupt requests.\n"
6804 "Stop debugging it? ")))
6806 remote_unpush_target (this);
6807 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6812 if (query (_("Interrupted while waiting for the program.\n"
6813 "Give up waiting? ")))
6818 /* Enable/disable target terminal ownership. Most targets can use
6819 terminal groups to control terminal ownership. Remote targets are
6820 different in that explicit transfer of ownership to/from GDB/target
6824 remote_target::terminal_inferior ()
6826 /* NOTE: At this point we could also register our selves as the
6827 recipient of all input. Any characters typed could then be
6828 passed on down to the target. */
6832 remote_target::terminal_ours ()
6837 remote_console_output (const char *msg
)
6841 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6844 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6848 gdb_stdtarg
->puts (tb
);
6850 gdb_stdtarg
->flush ();
6853 struct stop_reply
: public notif_event
6857 /* The identifier of the thread about this event */
6860 /* The remote state this event is associated with. When the remote
6861 connection, represented by a remote_state object, is closed,
6862 all the associated stop_reply events should be released. */
6863 struct remote_state
*rs
;
6865 struct target_waitstatus ws
;
6867 /* The architecture associated with the expedited registers. */
6870 /* Expedited registers. This makes remote debugging a bit more
6871 efficient for those targets that provide critical registers as
6872 part of their normal status mechanism (as another roundtrip to
6873 fetch them is avoided). */
6874 std::vector
<cached_reg_t
> regcache
;
6876 enum target_stop_reason stop_reason
;
6878 CORE_ADDR watch_data_address
;
6883 /* Return the length of the stop reply queue. */
6886 remote_target::stop_reply_queue_length ()
6888 remote_state
*rs
= get_remote_state ();
6889 return rs
->stop_reply_queue
.size ();
6893 remote_notif_stop_parse (remote_target
*remote
,
6894 struct notif_client
*self
, const char *buf
,
6895 struct notif_event
*event
)
6897 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6901 remote_notif_stop_ack (remote_target
*remote
,
6902 struct notif_client
*self
, const char *buf
,
6903 struct notif_event
*event
)
6905 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6908 putpkt (remote
, self
->ack_command
);
6910 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6912 /* We got an unknown stop reply. */
6913 error (_("Unknown stop reply"));
6916 remote
->push_stop_reply (stop_reply
);
6920 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
6921 struct notif_client
*self
)
6923 /* We can't get pending events in remote_notif_process for
6924 notification stop, and we have to do this in remote_wait_ns
6925 instead. If we fetch all queued events from stub, remote stub
6926 may exit and we have no chance to process them back in
6928 remote_state
*rs
= remote
->get_remote_state ();
6929 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
6933 stop_reply::~stop_reply ()
6935 for (cached_reg_t
®
: regcache
)
6939 static notif_event_up
6940 remote_notif_stop_alloc_reply ()
6942 return notif_event_up (new struct stop_reply ());
6945 /* A client of notification Stop. */
6947 struct notif_client notif_client_stop
=
6951 remote_notif_stop_parse
,
6952 remote_notif_stop_ack
,
6953 remote_notif_stop_can_get_pending_events
,
6954 remote_notif_stop_alloc_reply
,
6958 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6959 the pid of the process that owns the threads we want to check, or
6960 -1 if we want to check all threads. */
6963 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6966 if (ws
->kind
== TARGET_WAITKIND_FORKED
6967 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6969 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
6976 /* Return the thread's pending status used to determine whether the
6977 thread is a fork parent stopped at a fork event. */
6979 static struct target_waitstatus
*
6980 thread_pending_fork_status (struct thread_info
*thread
)
6982 if (thread
->suspend
.waitstatus_pending_p
)
6983 return &thread
->suspend
.waitstatus
;
6985 return &thread
->pending_follow
;
6988 /* Determine if THREAD is a pending fork parent thread. */
6991 is_pending_fork_parent_thread (struct thread_info
*thread
)
6993 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6996 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6999 /* If CONTEXT contains any fork child threads that have not been
7000 reported yet, remove them from the CONTEXT list. If such a
7001 thread exists it is because we are stopped at a fork catchpoint
7002 and have not yet called follow_fork, which will set up the
7003 host-side data structures for the new process. */
7006 remote_target::remove_new_fork_children (threads_listing_context
*context
)
7009 struct notif_client
*notif
= ¬if_client_stop
;
7011 /* For any threads stopped at a fork event, remove the corresponding
7012 fork child threads from the CONTEXT list. */
7013 for (thread_info
*thread
: all_non_exited_threads (this))
7015 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
7017 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
7018 context
->remove_thread (ws
->value
.related_pid
);
7021 /* Check for any pending fork events (not reported or processed yet)
7022 in process PID and remove those fork child threads from the
7023 CONTEXT list as well. */
7024 remote_notif_get_pending_events (notif
);
7025 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7026 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7027 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
7028 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
7029 context
->remove_thread (event
->ws
.value
.related_pid
);
7032 /* Check whether any event pending in the vStopped queue would prevent
7033 a global or process wildcard vCont action. Clear
7034 *may_global_wildcard if we can't do a global wildcard (vCont;c),
7035 and clear the event inferior's may_wildcard_vcont flag if we can't
7036 do a process-wide wildcard resume (vCont;c:pPID.-1). */
7039 remote_target::check_pending_events_prevent_wildcard_vcont
7040 (int *may_global_wildcard
)
7042 struct notif_client
*notif
= ¬if_client_stop
;
7044 remote_notif_get_pending_events (notif
);
7045 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7047 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
7048 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
7051 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7052 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
7053 *may_global_wildcard
= 0;
7055 struct inferior
*inf
= find_inferior_ptid (this, event
->ptid
);
7057 /* This may be the first time we heard about this process.
7058 Regardless, we must not do a global wildcard resume, otherwise
7059 we'd resume this process too. */
7060 *may_global_wildcard
= 0;
7062 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7066 /* Discard all pending stop replies of inferior INF. */
7069 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7071 struct stop_reply
*reply
;
7072 struct remote_state
*rs
= get_remote_state ();
7073 struct remote_notif_state
*rns
= rs
->notif_state
;
7075 /* This function can be notified when an inferior exists. When the
7076 target is not remote, the notification state is NULL. */
7077 if (rs
->remote_desc
== NULL
)
7080 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7082 /* Discard the in-flight notification. */
7083 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7086 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7089 /* Discard the stop replies we have already pulled with
7091 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7092 rs
->stop_reply_queue
.end (),
7093 [=] (const stop_reply_up
&event
)
7095 return event
->ptid
.pid () == inf
->pid
;
7097 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7100 /* Discard the stop replies for RS in stop_reply_queue. */
7103 remote_target::discard_pending_stop_replies_in_queue ()
7105 remote_state
*rs
= get_remote_state ();
7107 /* Discard the stop replies we have already pulled with
7109 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7110 rs
->stop_reply_queue
.end (),
7111 [=] (const stop_reply_up
&event
)
7113 return event
->rs
== rs
;
7115 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7118 /* Remove the first reply in 'stop_reply_queue' which matches
7122 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7124 remote_state
*rs
= get_remote_state ();
7126 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7127 rs
->stop_reply_queue
.end (),
7128 [=] (const stop_reply_up
&event
)
7130 return event
->ptid
.matches (ptid
);
7132 struct stop_reply
*result
;
7133 if (iter
== rs
->stop_reply_queue
.end ())
7137 result
= iter
->release ();
7138 rs
->stop_reply_queue
.erase (iter
);
7142 fprintf_unfiltered (gdb_stdlog
,
7143 "notif: discard queued event: 'Stop' in %s\n",
7144 target_pid_to_str (ptid
).c_str ());
7149 /* Look for a queued stop reply belonging to PTID. If one is found,
7150 remove it from the queue, and return it. Returns NULL if none is
7151 found. If there are still queued events left to process, tell the
7152 event loop to get back to target_wait soon. */
7155 remote_target::queued_stop_reply (ptid_t ptid
)
7157 remote_state
*rs
= get_remote_state ();
7158 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7160 if (!rs
->stop_reply_queue
.empty ())
7162 /* There's still at least an event left. */
7163 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7169 /* Push a fully parsed stop reply in the stop reply queue. Since we
7170 know that we now have at least one queued event left to pass to the
7171 core side, tell the event loop to get back to target_wait soon. */
7174 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7176 remote_state
*rs
= get_remote_state ();
7177 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7180 fprintf_unfiltered (gdb_stdlog
,
7181 "notif: push 'Stop' %s to queue %d\n",
7182 target_pid_to_str (new_event
->ptid
).c_str (),
7183 int (rs
->stop_reply_queue
.size ()));
7185 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7188 /* Returns true if we have a stop reply for PTID. */
7191 remote_target::peek_stop_reply (ptid_t ptid
)
7193 remote_state
*rs
= get_remote_state ();
7194 for (auto &event
: rs
->stop_reply_queue
)
7195 if (ptid
== event
->ptid
7196 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7201 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7202 starting with P and ending with PEND matches PREFIX. */
7205 strprefix (const char *p
, const char *pend
, const char *prefix
)
7207 for ( ; p
< pend
; p
++, prefix
++)
7210 return *prefix
== '\0';
7213 /* Parse the stop reply in BUF. Either the function succeeds, and the
7214 result is stored in EVENT, or throws an error. */
7217 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7219 remote_arch_state
*rsa
= NULL
;
7224 event
->ptid
= null_ptid
;
7225 event
->rs
= get_remote_state ();
7226 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7227 event
->ws
.value
.integer
= 0;
7228 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7229 event
->regcache
.clear ();
7234 case 'T': /* Status with PC, SP, FP, ... */
7235 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7236 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7238 n... = register number
7239 r... = register contents
7242 p
= &buf
[3]; /* after Txx */
7248 p1
= strchr (p
, ':');
7250 error (_("Malformed packet(a) (missing colon): %s\n\
7254 error (_("Malformed packet(a) (missing register number): %s\n\
7258 /* Some "registers" are actually extended stop information.
7259 Note if you're adding a new entry here: GDB 7.9 and
7260 earlier assume that all register "numbers" that start
7261 with an hex digit are real register numbers. Make sure
7262 the server only sends such a packet if it knows the
7263 client understands it. */
7265 if (strprefix (p
, p1
, "thread"))
7266 event
->ptid
= read_ptid (++p1
, &p
);
7267 else if (strprefix (p
, p1
, "syscall_entry"))
7271 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7272 p
= unpack_varlen_hex (++p1
, &sysno
);
7273 event
->ws
.value
.syscall_number
= (int) sysno
;
7275 else if (strprefix (p
, p1
, "syscall_return"))
7279 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7280 p
= unpack_varlen_hex (++p1
, &sysno
);
7281 event
->ws
.value
.syscall_number
= (int) sysno
;
7283 else if (strprefix (p
, p1
, "watch")
7284 || strprefix (p
, p1
, "rwatch")
7285 || strprefix (p
, p1
, "awatch"))
7287 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7288 p
= unpack_varlen_hex (++p1
, &addr
);
7289 event
->watch_data_address
= (CORE_ADDR
) addr
;
7291 else if (strprefix (p
, p1
, "swbreak"))
7293 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7295 /* Make sure the stub doesn't forget to indicate support
7297 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7298 error (_("Unexpected swbreak stop reason"));
7300 /* The value part is documented as "must be empty",
7301 though we ignore it, in case we ever decide to make
7302 use of it in a backward compatible way. */
7303 p
= strchrnul (p1
+ 1, ';');
7305 else if (strprefix (p
, p1
, "hwbreak"))
7307 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7309 /* Make sure the stub doesn't forget to indicate support
7311 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7312 error (_("Unexpected hwbreak stop reason"));
7315 p
= strchrnul (p1
+ 1, ';');
7317 else if (strprefix (p
, p1
, "library"))
7319 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7320 p
= strchrnul (p1
+ 1, ';');
7322 else if (strprefix (p
, p1
, "replaylog"))
7324 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7325 /* p1 will indicate "begin" or "end", but it makes
7326 no difference for now, so ignore it. */
7327 p
= strchrnul (p1
+ 1, ';');
7329 else if (strprefix (p
, p1
, "core"))
7333 p
= unpack_varlen_hex (++p1
, &c
);
7336 else if (strprefix (p
, p1
, "fork"))
7338 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7339 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7341 else if (strprefix (p
, p1
, "vfork"))
7343 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7344 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7346 else if (strprefix (p
, p1
, "vforkdone"))
7348 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7349 p
= strchrnul (p1
+ 1, ';');
7351 else if (strprefix (p
, p1
, "exec"))
7356 /* Determine the length of the execd pathname. */
7357 p
= unpack_varlen_hex (++p1
, &ignored
);
7358 pathlen
= (p
- p1
) / 2;
7360 /* Save the pathname for event reporting and for
7361 the next run command. */
7362 gdb::unique_xmalloc_ptr
<char[]> pathname
7363 ((char *) xmalloc (pathlen
+ 1));
7364 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7365 pathname
[pathlen
] = '\0';
7367 /* This is freed during event handling. */
7368 event
->ws
.value
.execd_pathname
= pathname
.release ();
7369 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7371 /* Skip the registers included in this packet, since
7372 they may be for an architecture different from the
7373 one used by the original program. */
7376 else if (strprefix (p
, p1
, "create"))
7378 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7379 p
= strchrnul (p1
+ 1, ';');
7388 p
= strchrnul (p1
+ 1, ';');
7393 /* Maybe a real ``P'' register number. */
7394 p_temp
= unpack_varlen_hex (p
, &pnum
);
7395 /* If the first invalid character is the colon, we got a
7396 register number. Otherwise, it's an unknown stop
7400 /* If we haven't parsed the event's thread yet, find
7401 it now, in order to find the architecture of the
7402 reported expedited registers. */
7403 if (event
->ptid
== null_ptid
)
7405 /* If there is no thread-id information then leave
7406 the event->ptid as null_ptid. Later in
7407 process_stop_reply we will pick a suitable
7409 const char *thr
= strstr (p1
+ 1, ";thread:");
7411 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7418 = (event
->ptid
== null_ptid
7420 : find_inferior_ptid (this, event
->ptid
));
7421 /* If this is the first time we learn anything
7422 about this process, skip the registers
7423 included in this packet, since we don't yet
7424 know which architecture to use to parse them.
7425 We'll determine the architecture later when
7426 we process the stop reply and retrieve the
7427 target description, via
7428 remote_notice_new_inferior ->
7429 post_create_inferior. */
7432 p
= strchrnul (p1
+ 1, ';');
7437 event
->arch
= inf
->gdbarch
;
7438 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7442 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7443 cached_reg_t cached_reg
;
7446 error (_("Remote sent bad register number %s: %s\n\
7448 hex_string (pnum
), p
, buf
);
7450 cached_reg
.num
= reg
->regnum
;
7451 cached_reg
.data
= (gdb_byte
*)
7452 xmalloc (register_size (event
->arch
, reg
->regnum
));
7455 fieldsize
= hex2bin (p
, cached_reg
.data
,
7456 register_size (event
->arch
, reg
->regnum
));
7458 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7459 warning (_("Remote reply is too short: %s"), buf
);
7461 event
->regcache
.push_back (cached_reg
);
7465 /* Not a number. Silently skip unknown optional
7467 p
= strchrnul (p1
+ 1, ';');
7472 error (_("Remote register badly formatted: %s\nhere: %s"),
7477 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7481 case 'S': /* Old style status, just signal only. */
7485 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7486 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7487 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7488 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7490 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7493 case 'w': /* Thread exited. */
7497 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7498 p
= unpack_varlen_hex (&buf
[1], &value
);
7499 event
->ws
.value
.integer
= value
;
7501 error (_("stop reply packet badly formatted: %s"), buf
);
7502 event
->ptid
= read_ptid (++p
, NULL
);
7505 case 'W': /* Target exited. */
7510 /* GDB used to accept only 2 hex chars here. Stubs should
7511 only send more if they detect GDB supports multi-process
7513 p
= unpack_varlen_hex (&buf
[1], &value
);
7517 /* The remote process exited. */
7518 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7519 event
->ws
.value
.integer
= value
;
7523 /* The remote process exited with a signal. */
7524 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7525 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7526 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7528 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7531 /* If no process is specified, return null_ptid, and let the
7532 caller figure out the right process to use. */
7542 else if (startswith (p
, "process:"))
7546 p
+= sizeof ("process:") - 1;
7547 unpack_varlen_hex (p
, &upid
);
7551 error (_("unknown stop reply packet: %s"), buf
);
7554 error (_("unknown stop reply packet: %s"), buf
);
7555 event
->ptid
= ptid_t (pid
);
7559 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7560 event
->ptid
= minus_one_ptid
;
7564 if (target_is_non_stop_p () && event
->ptid
== null_ptid
)
7565 error (_("No process or thread specified in stop reply: %s"), buf
);
7568 /* When the stub wants to tell GDB about a new notification reply, it
7569 sends a notification (%Stop, for example). Those can come it at
7570 any time, hence, we have to make sure that any pending
7571 putpkt/getpkt sequence we're making is finished, before querying
7572 the stub for more events with the corresponding ack command
7573 (vStopped, for example). E.g., if we started a vStopped sequence
7574 immediately upon receiving the notification, something like this
7582 1.6) <-- (registers reply to step #1.3)
7584 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7587 To solve this, whenever we parse a %Stop notification successfully,
7588 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7589 doing whatever we were doing:
7595 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7596 2.5) <-- (registers reply to step #2.3)
7598 Eventually after step #2.5, we return to the event loop, which
7599 notices there's an event on the
7600 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7601 associated callback --- the function below. At this point, we're
7602 always safe to start a vStopped sequence. :
7605 2.7) <-- T05 thread:2
7611 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7613 struct remote_state
*rs
= get_remote_state ();
7615 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7618 fprintf_unfiltered (gdb_stdlog
,
7619 "notif: process: '%s' ack pending event\n",
7623 nc
->ack (this, nc
, rs
->buf
.data (),
7624 rs
->notif_state
->pending_event
[nc
->id
]);
7625 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7629 getpkt (&rs
->buf
, 0);
7630 if (strcmp (rs
->buf
.data (), "OK") == 0)
7633 remote_notif_ack (this, nc
, rs
->buf
.data ());
7639 fprintf_unfiltered (gdb_stdlog
,
7640 "notif: process: '%s' no pending reply\n",
7645 /* Wrapper around remote_target::remote_notif_get_pending_events to
7646 avoid having to export the whole remote_target class. */
7649 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7651 remote
->remote_notif_get_pending_events (nc
);
7654 /* Called when it is decided that STOP_REPLY holds the info of the
7655 event that is to be returned to the core. This function always
7656 destroys STOP_REPLY. */
7659 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7660 struct target_waitstatus
*status
)
7664 *status
= stop_reply
->ws
;
7665 ptid
= stop_reply
->ptid
;
7667 /* If no thread/process was reported by the stub then use the first
7668 non-exited thread in the current target. */
7669 if (ptid
== null_ptid
)
7671 /* Some stop events apply to all threads in an inferior, while others
7672 only apply to a single thread. */
7673 bool is_stop_for_all_threads
7674 = (status
->kind
== TARGET_WAITKIND_EXITED
7675 || status
->kind
== TARGET_WAITKIND_SIGNALLED
);
7677 for (thread_info
*thr
: all_non_exited_threads (this))
7679 if (ptid
!= null_ptid
7680 && (!is_stop_for_all_threads
7681 || ptid
.pid () != thr
->ptid
.pid ()))
7683 static bool warned
= false;
7687 /* If you are seeing this warning then the remote target
7688 has stopped without specifying a thread-id, but the
7689 target does have multiple threads (or inferiors), and
7690 so GDB is having to guess which thread stopped.
7692 Examples of what might cause this are the target
7693 sending and 'S' stop packet, or a 'T' stop packet and
7694 not including a thread-id.
7696 Additionally, the target might send a 'W' or 'X
7697 packet without including a process-id, when the target
7698 has multiple running inferiors. */
7699 if (is_stop_for_all_threads
)
7700 warning (_("multi-inferior target stopped without "
7701 "sending a process-id, using first "
7702 "non-exited inferior"));
7704 warning (_("multi-threaded target stopped without "
7705 "sending a thread-id, using first "
7706 "non-exited thread"));
7712 /* If this is a stop for all threads then don't use a particular
7713 threads ptid, instead create a new ptid where only the pid
7715 if (is_stop_for_all_threads
)
7716 ptid
= ptid_t (thr
->ptid
.pid ());
7720 gdb_assert (ptid
!= null_ptid
);
7723 if (status
->kind
!= TARGET_WAITKIND_EXITED
7724 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7725 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7727 /* Expedited registers. */
7728 if (!stop_reply
->regcache
.empty ())
7730 struct regcache
*regcache
7731 = get_thread_arch_regcache (this, ptid
, stop_reply
->arch
);
7733 for (cached_reg_t
®
: stop_reply
->regcache
)
7735 regcache
->raw_supply (reg
.num
, reg
.data
);
7739 stop_reply
->regcache
.clear ();
7742 remote_notice_new_inferior (ptid
, 0);
7743 remote_thread_info
*remote_thr
= get_remote_thread_info (this, ptid
);
7744 remote_thr
->core
= stop_reply
->core
;
7745 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7746 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7747 remote_thr
->vcont_resumed
= 0;
7754 /* The non-stop mode version of target_wait. */
7757 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7759 struct remote_state
*rs
= get_remote_state ();
7760 struct stop_reply
*stop_reply
;
7764 /* If in non-stop mode, get out of getpkt even if a
7765 notification is received. */
7767 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7770 if (ret
!= -1 && !is_notif
)
7773 case 'E': /* Error of some sort. */
7774 /* We're out of sync with the target now. Did it continue
7775 or not? We can't tell which thread it was in non-stop,
7776 so just ignore this. */
7777 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7779 case 'O': /* Console output. */
7780 remote_console_output (&rs
->buf
[1]);
7783 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7787 /* Acknowledge a pending stop reply that may have arrived in the
7789 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7790 remote_notif_get_pending_events (¬if_client_stop
);
7792 /* If indeed we noticed a stop reply, we're done. */
7793 stop_reply
= queued_stop_reply (ptid
);
7794 if (stop_reply
!= NULL
)
7795 return process_stop_reply (stop_reply
, status
);
7797 /* Still no event. If we're just polling for an event, then
7798 return to the event loop. */
7799 if (options
& TARGET_WNOHANG
)
7801 status
->kind
= TARGET_WAITKIND_IGNORE
;
7802 return minus_one_ptid
;
7805 /* Otherwise do a blocking wait. */
7806 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7810 /* Return the first resumed thread. */
7813 first_remote_resumed_thread (remote_target
*target
)
7815 for (thread_info
*tp
: all_non_exited_threads (target
, minus_one_ptid
))
7821 /* Wait until the remote machine stops, then return, storing status in
7822 STATUS just as `wait' would. */
7825 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
, int options
)
7827 struct remote_state
*rs
= get_remote_state ();
7828 ptid_t event_ptid
= null_ptid
;
7830 struct stop_reply
*stop_reply
;
7834 status
->kind
= TARGET_WAITKIND_IGNORE
;
7835 status
->value
.integer
= 0;
7837 stop_reply
= queued_stop_reply (ptid
);
7838 if (stop_reply
!= NULL
)
7839 return process_stop_reply (stop_reply
, status
);
7841 if (rs
->cached_wait_status
)
7842 /* Use the cached wait status, but only once. */
7843 rs
->cached_wait_status
= 0;
7848 int forever
= ((options
& TARGET_WNOHANG
) == 0
7849 && rs
->wait_forever_enabled_p
);
7851 if (!rs
->waiting_for_stop_reply
)
7853 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7854 return minus_one_ptid
;
7857 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7858 _never_ wait for ever -> test on target_is_async_p().
7859 However, before we do that we need to ensure that the caller
7860 knows how to take the target into/out of async mode. */
7861 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
7863 /* GDB gets a notification. Return to core as this event is
7865 if (ret
!= -1 && is_notif
)
7866 return minus_one_ptid
;
7868 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7869 return minus_one_ptid
;
7872 buf
= rs
->buf
.data ();
7874 /* Assume that the target has acknowledged Ctrl-C unless we receive
7875 an 'F' or 'O' packet. */
7876 if (buf
[0] != 'F' && buf
[0] != 'O')
7877 rs
->ctrlc_pending_p
= 0;
7881 case 'E': /* Error of some sort. */
7882 /* We're out of sync with the target now. Did it continue or
7883 not? Not is more likely, so report a stop. */
7884 rs
->waiting_for_stop_reply
= 0;
7886 warning (_("Remote failure reply: %s"), buf
);
7887 status
->kind
= TARGET_WAITKIND_STOPPED
;
7888 status
->value
.sig
= GDB_SIGNAL_0
;
7890 case 'F': /* File-I/O request. */
7891 /* GDB may access the inferior memory while handling the File-I/O
7892 request, but we don't want GDB accessing memory while waiting
7893 for a stop reply. See the comments in putpkt_binary. Set
7894 waiting_for_stop_reply to 0 temporarily. */
7895 rs
->waiting_for_stop_reply
= 0;
7896 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
7897 rs
->ctrlc_pending_p
= 0;
7898 /* GDB handled the File-I/O request, and the target is running
7899 again. Keep waiting for events. */
7900 rs
->waiting_for_stop_reply
= 1;
7902 case 'N': case 'T': case 'S': case 'X': case 'W':
7904 /* There is a stop reply to handle. */
7905 rs
->waiting_for_stop_reply
= 0;
7908 = (struct stop_reply
*) remote_notif_parse (this,
7912 event_ptid
= process_stop_reply (stop_reply
, status
);
7915 case 'O': /* Console output. */
7916 remote_console_output (buf
+ 1);
7919 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7921 /* Zero length reply means that we tried 'S' or 'C' and the
7922 remote system doesn't support it. */
7923 target_terminal::ours_for_output ();
7925 ("Can't send signals to this remote system. %s not sent.\n",
7926 gdb_signal_to_name (rs
->last_sent_signal
));
7927 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7928 target_terminal::inferior ();
7930 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7936 warning (_("Invalid remote reply: %s"), buf
);
7940 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7941 return minus_one_ptid
;
7942 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7944 /* Nothing interesting happened. If we're doing a non-blocking
7945 poll, we're done. Otherwise, go back to waiting. */
7946 if (options
& TARGET_WNOHANG
)
7947 return minus_one_ptid
;
7951 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7952 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7954 if (event_ptid
!= null_ptid
)
7955 record_currthread (rs
, event_ptid
);
7957 event_ptid
= first_remote_resumed_thread (this);
7961 /* A process exit. Invalidate our notion of current thread. */
7962 record_currthread (rs
, minus_one_ptid
);
7963 /* It's possible that the packet did not include a pid. */
7964 if (event_ptid
== null_ptid
)
7965 event_ptid
= first_remote_resumed_thread (this);
7966 /* EVENT_PTID could still be NULL_PTID. Double-check. */
7967 if (event_ptid
== null_ptid
)
7968 event_ptid
= magic_null_ptid
;
7974 /* Wait until the remote machine stops, then return, storing status in
7975 STATUS just as `wait' would. */
7978 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7982 if (target_is_non_stop_p ())
7983 event_ptid
= wait_ns (ptid
, status
, options
);
7985 event_ptid
= wait_as (ptid
, status
, options
);
7987 if (target_is_async_p ())
7989 remote_state
*rs
= get_remote_state ();
7991 /* If there are are events left in the queue tell the event loop
7993 if (!rs
->stop_reply_queue
.empty ())
7994 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
8000 /* Fetch a single register using a 'p' packet. */
8003 remote_target::fetch_register_using_p (struct regcache
*regcache
,
8006 struct gdbarch
*gdbarch
= regcache
->arch ();
8007 struct remote_state
*rs
= get_remote_state ();
8009 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8012 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
8015 if (reg
->pnum
== -1)
8018 p
= rs
->buf
.data ();
8020 p
+= hexnumstr (p
, reg
->pnum
);
8023 getpkt (&rs
->buf
, 0);
8025 buf
= rs
->buf
.data ();
8027 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
8031 case PACKET_UNKNOWN
:
8034 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
8035 gdbarch_register_name (regcache
->arch (),
8040 /* If this register is unfetchable, tell the regcache. */
8043 regcache
->raw_supply (reg
->regnum
, NULL
);
8047 /* Otherwise, parse and supply the value. */
8053 error (_("fetch_register_using_p: early buf termination"));
8055 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8058 regcache
->raw_supply (reg
->regnum
, regp
);
8062 /* Fetch the registers included in the target's 'g' packet. */
8065 remote_target::send_g_packet ()
8067 struct remote_state
*rs
= get_remote_state ();
8070 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
8072 getpkt (&rs
->buf
, 0);
8073 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8074 error (_("Could not read registers; remote failure reply '%s'"),
8077 /* We can get out of synch in various cases. If the first character
8078 in the buffer is not a hex character, assume that has happened
8079 and try to fetch another packet to read. */
8080 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
8081 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
8082 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
8083 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
8086 fprintf_unfiltered (gdb_stdlog
,
8087 "Bad register packet; fetching a new packet\n");
8088 getpkt (&rs
->buf
, 0);
8091 buf_len
= strlen (rs
->buf
.data ());
8093 /* Sanity check the received packet. */
8094 if (buf_len
% 2 != 0)
8095 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
8101 remote_target::process_g_packet (struct regcache
*regcache
)
8103 struct gdbarch
*gdbarch
= regcache
->arch ();
8104 struct remote_state
*rs
= get_remote_state ();
8105 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8110 buf_len
= strlen (rs
->buf
.data ());
8112 /* Further sanity checks, with knowledge of the architecture. */
8113 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
8114 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8116 rsa
->sizeof_g_packet
, buf_len
/ 2,
8119 /* Save the size of the packet sent to us by the target. It is used
8120 as a heuristic when determining the max size of packets that the
8121 target can safely receive. */
8122 if (rsa
->actual_register_packet_size
== 0)
8123 rsa
->actual_register_packet_size
= buf_len
;
8125 /* If this is smaller than we guessed the 'g' packet would be,
8126 update our records. A 'g' reply that doesn't include a register's
8127 value implies either that the register is not available, or that
8128 the 'p' packet must be used. */
8129 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8131 long sizeof_g_packet
= buf_len
/ 2;
8133 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8135 long offset
= rsa
->regs
[i
].offset
;
8136 long reg_size
= register_size (gdbarch
, i
);
8138 if (rsa
->regs
[i
].pnum
== -1)
8141 if (offset
>= sizeof_g_packet
)
8142 rsa
->regs
[i
].in_g_packet
= 0;
8143 else if (offset
+ reg_size
> sizeof_g_packet
)
8144 error (_("Truncated register %d in remote 'g' packet"), i
);
8146 rsa
->regs
[i
].in_g_packet
= 1;
8149 /* Looks valid enough, we can assume this is the correct length
8150 for a 'g' packet. It's important not to adjust
8151 rsa->sizeof_g_packet if we have truncated registers otherwise
8152 this "if" won't be run the next time the method is called
8153 with a packet of the same size and one of the internal errors
8154 below will trigger instead. */
8155 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8158 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8160 /* Unimplemented registers read as all bits zero. */
8161 memset (regs
, 0, rsa
->sizeof_g_packet
);
8163 /* Reply describes registers byte by byte, each byte encoded as two
8164 hex characters. Suck them all up, then supply them to the
8165 register cacheing/storage mechanism. */
8167 p
= rs
->buf
.data ();
8168 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8170 if (p
[0] == 0 || p
[1] == 0)
8171 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8172 internal_error (__FILE__
, __LINE__
,
8173 _("unexpected end of 'g' packet reply"));
8175 if (p
[0] == 'x' && p
[1] == 'x')
8176 regs
[i
] = 0; /* 'x' */
8178 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8182 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8184 struct packet_reg
*r
= &rsa
->regs
[i
];
8185 long reg_size
= register_size (gdbarch
, i
);
8189 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8190 /* This shouldn't happen - we adjusted in_g_packet above. */
8191 internal_error (__FILE__
, __LINE__
,
8192 _("unexpected end of 'g' packet reply"));
8193 else if (rs
->buf
[r
->offset
* 2] == 'x')
8195 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8196 /* The register isn't available, mark it as such (at
8197 the same time setting the value to zero). */
8198 regcache
->raw_supply (r
->regnum
, NULL
);
8201 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8207 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8210 process_g_packet (regcache
);
8213 /* Make the remote selected traceframe match GDB's selected
8217 remote_target::set_remote_traceframe ()
8220 struct remote_state
*rs
= get_remote_state ();
8222 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8225 /* Avoid recursion, remote_trace_find calls us again. */
8226 rs
->remote_traceframe_number
= get_traceframe_number ();
8228 newnum
= target_trace_find (tfind_number
,
8229 get_traceframe_number (), 0, 0, NULL
);
8231 /* Should not happen. If it does, all bets are off. */
8232 if (newnum
!= get_traceframe_number ())
8233 warning (_("could not set remote traceframe"));
8237 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8239 struct gdbarch
*gdbarch
= regcache
->arch ();
8240 struct remote_state
*rs
= get_remote_state ();
8241 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8244 set_remote_traceframe ();
8245 set_general_thread (regcache
->ptid ());
8249 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8251 gdb_assert (reg
!= NULL
);
8253 /* If this register might be in the 'g' packet, try that first -
8254 we are likely to read more than one register. If this is the
8255 first 'g' packet, we might be overly optimistic about its
8256 contents, so fall back to 'p'. */
8257 if (reg
->in_g_packet
)
8259 fetch_registers_using_g (regcache
);
8260 if (reg
->in_g_packet
)
8264 if (fetch_register_using_p (regcache
, reg
))
8267 /* This register is not available. */
8268 regcache
->raw_supply (reg
->regnum
, NULL
);
8273 fetch_registers_using_g (regcache
);
8275 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8276 if (!rsa
->regs
[i
].in_g_packet
)
8277 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8279 /* This register is not available. */
8280 regcache
->raw_supply (i
, NULL
);
8284 /* Prepare to store registers. Since we may send them all (using a
8285 'G' request), we have to read out the ones we don't want to change
8289 remote_target::prepare_to_store (struct regcache
*regcache
)
8291 struct remote_state
*rs
= get_remote_state ();
8292 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8295 /* Make sure the entire registers array is valid. */
8296 switch (packet_support (PACKET_P
))
8298 case PACKET_DISABLE
:
8299 case PACKET_SUPPORT_UNKNOWN
:
8300 /* Make sure all the necessary registers are cached. */
8301 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8302 if (rsa
->regs
[i
].in_g_packet
)
8303 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8310 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8311 packet was not recognized. */
8314 remote_target::store_register_using_P (const struct regcache
*regcache
,
8317 struct gdbarch
*gdbarch
= regcache
->arch ();
8318 struct remote_state
*rs
= get_remote_state ();
8319 /* Try storing a single register. */
8320 char *buf
= rs
->buf
.data ();
8321 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8324 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8327 if (reg
->pnum
== -1)
8330 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8331 p
= buf
+ strlen (buf
);
8332 regcache
->raw_collect (reg
->regnum
, regp
);
8333 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8335 getpkt (&rs
->buf
, 0);
8337 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8342 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8343 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8344 case PACKET_UNKNOWN
:
8347 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8351 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8352 contents of the register cache buffer. FIXME: ignores errors. */
8355 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8357 struct remote_state
*rs
= get_remote_state ();
8358 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8362 /* Extract all the registers in the regcache copying them into a
8367 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8368 memset (regs
, 0, rsa
->sizeof_g_packet
);
8369 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8371 struct packet_reg
*r
= &rsa
->regs
[i
];
8374 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8378 /* Command describes registers byte by byte,
8379 each byte encoded as two hex characters. */
8380 p
= rs
->buf
.data ();
8382 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8384 getpkt (&rs
->buf
, 0);
8385 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8386 error (_("Could not write registers; remote failure reply '%s'"),
8390 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8391 of the register cache buffer. FIXME: ignores errors. */
8394 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8396 struct gdbarch
*gdbarch
= regcache
->arch ();
8397 struct remote_state
*rs
= get_remote_state ();
8398 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8401 set_remote_traceframe ();
8402 set_general_thread (regcache
->ptid ());
8406 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8408 gdb_assert (reg
!= NULL
);
8410 /* Always prefer to store registers using the 'P' packet if
8411 possible; we often change only a small number of registers.
8412 Sometimes we change a larger number; we'd need help from a
8413 higher layer to know to use 'G'. */
8414 if (store_register_using_P (regcache
, reg
))
8417 /* For now, don't complain if we have no way to write the
8418 register. GDB loses track of unavailable registers too
8419 easily. Some day, this may be an error. We don't have
8420 any way to read the register, either... */
8421 if (!reg
->in_g_packet
)
8424 store_registers_using_G (regcache
);
8428 store_registers_using_G (regcache
);
8430 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8431 if (!rsa
->regs
[i
].in_g_packet
)
8432 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8433 /* See above for why we do not issue an error here. */
8438 /* Return the number of hex digits in num. */
8441 hexnumlen (ULONGEST num
)
8445 for (i
= 0; num
!= 0; i
++)
8448 return std::max (i
, 1);
8451 /* Set BUF to the minimum number of hex digits representing NUM. */
8454 hexnumstr (char *buf
, ULONGEST num
)
8456 int len
= hexnumlen (num
);
8458 return hexnumnstr (buf
, num
, len
);
8462 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8465 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8471 for (i
= width
- 1; i
>= 0; i
--)
8473 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8480 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8483 remote_address_masked (CORE_ADDR addr
)
8485 unsigned int address_size
= remote_address_size
;
8487 /* If "remoteaddresssize" was not set, default to target address size. */
8489 address_size
= gdbarch_addr_bit (target_gdbarch ());
8491 if (address_size
> 0
8492 && address_size
< (sizeof (ULONGEST
) * 8))
8494 /* Only create a mask when that mask can safely be constructed
8495 in a ULONGEST variable. */
8498 mask
= (mask
<< address_size
) - 1;
8504 /* Determine whether the remote target supports binary downloading.
8505 This is accomplished by sending a no-op memory write of zero length
8506 to the target at the specified address. It does not suffice to send
8507 the whole packet, since many stubs strip the eighth bit and
8508 subsequently compute a wrong checksum, which causes real havoc with
8511 NOTE: This can still lose if the serial line is not eight-bit
8512 clean. In cases like this, the user should clear "remote
8516 remote_target::check_binary_download (CORE_ADDR addr
)
8518 struct remote_state
*rs
= get_remote_state ();
8520 switch (packet_support (PACKET_X
))
8522 case PACKET_DISABLE
:
8526 case PACKET_SUPPORT_UNKNOWN
:
8530 p
= rs
->buf
.data ();
8532 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8534 p
+= hexnumstr (p
, (ULONGEST
) 0);
8538 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8539 getpkt (&rs
->buf
, 0);
8541 if (rs
->buf
[0] == '\0')
8544 fprintf_unfiltered (gdb_stdlog
,
8545 "binary downloading NOT "
8546 "supported by target\n");
8547 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8552 fprintf_unfiltered (gdb_stdlog
,
8553 "binary downloading supported by target\n");
8554 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8561 /* Helper function to resize the payload in order to try to get a good
8562 alignment. We try to write an amount of data such that the next write will
8563 start on an address aligned on REMOTE_ALIGN_WRITES. */
8566 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8568 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8571 /* Write memory data directly to the remote machine.
8572 This does not inform the data cache; the data cache uses this.
8573 HEADER is the starting part of the packet.
8574 MEMADDR is the address in the remote memory space.
8575 MYADDR is the address of the buffer in our space.
8576 LEN_UNITS is the number of addressable units to write.
8577 UNIT_SIZE is the length in bytes of an addressable unit.
8578 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8579 should send data as binary ('X'), or hex-encoded ('M').
8581 The function creates packet of the form
8582 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8584 where encoding of <DATA> is terminated by PACKET_FORMAT.
8586 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8589 Return the transferred status, error or OK (an
8590 'enum target_xfer_status' value). Save the number of addressable units
8591 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8593 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8594 exchange between gdb and the stub could look like (?? in place of the
8600 -> $M1000,3:eeeeffffeeee#??
8604 <- eeeeffffeeeedddd */
8607 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8608 const gdb_byte
*myaddr
,
8611 ULONGEST
*xfered_len_units
,
8612 char packet_format
, int use_length
)
8614 struct remote_state
*rs
= get_remote_state ();
8620 int payload_capacity_bytes
;
8621 int payload_length_bytes
;
8623 if (packet_format
!= 'X' && packet_format
!= 'M')
8624 internal_error (__FILE__
, __LINE__
,
8625 _("remote_write_bytes_aux: bad packet format"));
8628 return TARGET_XFER_EOF
;
8630 payload_capacity_bytes
= get_memory_write_packet_size ();
8632 /* The packet buffer will be large enough for the payload;
8633 get_memory_packet_size ensures this. */
8636 /* Compute the size of the actual payload by subtracting out the
8637 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8639 payload_capacity_bytes
-= strlen ("$,:#NN");
8641 /* The comma won't be used. */
8642 payload_capacity_bytes
+= 1;
8643 payload_capacity_bytes
-= strlen (header
);
8644 payload_capacity_bytes
-= hexnumlen (memaddr
);
8646 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8648 strcat (rs
->buf
.data (), header
);
8649 p
= rs
->buf
.data () + strlen (header
);
8651 /* Compute a best guess of the number of bytes actually transfered. */
8652 if (packet_format
== 'X')
8654 /* Best guess at number of bytes that will fit. */
8655 todo_units
= std::min (len_units
,
8656 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8658 payload_capacity_bytes
-= hexnumlen (todo_units
);
8659 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8663 /* Number of bytes that will fit. */
8665 = std::min (len_units
,
8666 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8668 payload_capacity_bytes
-= hexnumlen (todo_units
);
8669 todo_units
= std::min (todo_units
,
8670 (payload_capacity_bytes
/ unit_size
) / 2);
8673 if (todo_units
<= 0)
8674 internal_error (__FILE__
, __LINE__
,
8675 _("minimum packet size too small to write data"));
8677 /* If we already need another packet, then try to align the end
8678 of this packet to a useful boundary. */
8679 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8680 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8682 /* Append "<memaddr>". */
8683 memaddr
= remote_address_masked (memaddr
);
8684 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8691 /* Append the length and retain its location and size. It may need to be
8692 adjusted once the packet body has been created. */
8694 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8702 /* Append the packet body. */
8703 if (packet_format
== 'X')
8705 /* Binary mode. Send target system values byte by byte, in
8706 increasing byte addresses. Only escape certain critical
8708 payload_length_bytes
=
8709 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8710 &units_written
, payload_capacity_bytes
);
8712 /* If not all TODO units fit, then we'll need another packet. Make
8713 a second try to keep the end of the packet aligned. Don't do
8714 this if the packet is tiny. */
8715 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8719 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8721 if (new_todo_units
!= units_written
)
8722 payload_length_bytes
=
8723 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8724 (gdb_byte
*) p
, &units_written
,
8725 payload_capacity_bytes
);
8728 p
+= payload_length_bytes
;
8729 if (use_length
&& units_written
< todo_units
)
8731 /* Escape chars have filled up the buffer prematurely,
8732 and we have actually sent fewer units than planned.
8733 Fix-up the length field of the packet. Use the same
8734 number of characters as before. */
8735 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8737 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8742 /* Normal mode: Send target system values byte by byte, in
8743 increasing byte addresses. Each byte is encoded as a two hex
8745 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8746 units_written
= todo_units
;
8749 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8750 getpkt (&rs
->buf
, 0);
8752 if (rs
->buf
[0] == 'E')
8753 return TARGET_XFER_E_IO
;
8755 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8756 send fewer units than we'd planned. */
8757 *xfered_len_units
= (ULONGEST
) units_written
;
8758 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8761 /* Write memory data directly to the remote machine.
8762 This does not inform the data cache; the data cache uses this.
8763 MEMADDR is the address in the remote memory space.
8764 MYADDR is the address of the buffer in our space.
8765 LEN is the number of bytes.
8767 Return the transferred status, error or OK (an
8768 'enum target_xfer_status' value). Save the number of bytes
8769 transferred in *XFERED_LEN. Only transfer a single packet. */
8772 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8773 ULONGEST len
, int unit_size
,
8774 ULONGEST
*xfered_len
)
8776 const char *packet_format
= NULL
;
8778 /* Check whether the target supports binary download. */
8779 check_binary_download (memaddr
);
8781 switch (packet_support (PACKET_X
))
8784 packet_format
= "X";
8786 case PACKET_DISABLE
:
8787 packet_format
= "M";
8789 case PACKET_SUPPORT_UNKNOWN
:
8790 internal_error (__FILE__
, __LINE__
,
8791 _("remote_write_bytes: bad internal state"));
8793 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8796 return remote_write_bytes_aux (packet_format
,
8797 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8798 packet_format
[0], 1);
8801 /* Read memory data directly from the remote machine.
8802 This does not use the data cache; the data cache uses this.
8803 MEMADDR is the address in the remote memory space.
8804 MYADDR is the address of the buffer in our space.
8805 LEN_UNITS is the number of addressable memory units to read..
8806 UNIT_SIZE is the length in bytes of an addressable unit.
8808 Return the transferred status, error or OK (an
8809 'enum target_xfer_status' value). Save the number of bytes
8810 transferred in *XFERED_LEN_UNITS.
8812 See the comment of remote_write_bytes_aux for an example of
8813 memory read/write exchange between gdb and the stub. */
8816 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8818 int unit_size
, ULONGEST
*xfered_len_units
)
8820 struct remote_state
*rs
= get_remote_state ();
8821 int buf_size_bytes
; /* Max size of packet output buffer. */
8826 buf_size_bytes
= get_memory_read_packet_size ();
8827 /* The packet buffer will be large enough for the payload;
8828 get_memory_packet_size ensures this. */
8830 /* Number of units that will fit. */
8831 todo_units
= std::min (len_units
,
8832 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8834 /* Construct "m"<memaddr>","<len>". */
8835 memaddr
= remote_address_masked (memaddr
);
8836 p
= rs
->buf
.data ();
8838 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8840 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8843 getpkt (&rs
->buf
, 0);
8844 if (rs
->buf
[0] == 'E'
8845 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8846 && rs
->buf
[3] == '\0')
8847 return TARGET_XFER_E_IO
;
8848 /* Reply describes memory byte by byte, each byte encoded as two hex
8850 p
= rs
->buf
.data ();
8851 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8852 /* Return what we have. Let higher layers handle partial reads. */
8853 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8854 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8857 /* Using the set of read-only target sections of remote, read live
8860 For interface/parameters/return description see target.h,
8864 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
8868 ULONGEST
*xfered_len
)
8870 struct target_section
*secp
;
8871 struct target_section_table
*table
;
8873 secp
= target_section_by_addr (this, memaddr
);
8875 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
8877 struct target_section
*p
;
8878 ULONGEST memend
= memaddr
+ len
;
8880 table
= target_get_section_table (this);
8882 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8884 if (memaddr
>= p
->addr
)
8886 if (memend
<= p
->endaddr
)
8888 /* Entire transfer is within this section. */
8889 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8892 else if (memaddr
>= p
->endaddr
)
8894 /* This section ends before the transfer starts. */
8899 /* This section overlaps the transfer. Just do half. */
8900 len
= p
->endaddr
- memaddr
;
8901 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8908 return TARGET_XFER_EOF
;
8911 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8912 first if the requested memory is unavailable in traceframe.
8913 Otherwise, fall back to remote_read_bytes_1. */
8916 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
8917 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8918 ULONGEST
*xfered_len
)
8921 return TARGET_XFER_EOF
;
8923 if (get_traceframe_number () != -1)
8925 std::vector
<mem_range
> available
;
8927 /* If we fail to get the set of available memory, then the
8928 target does not support querying traceframe info, and so we
8929 attempt reading from the traceframe anyway (assuming the
8930 target implements the old QTro packet then). */
8931 if (traceframe_available_memory (&available
, memaddr
, len
))
8933 if (available
.empty () || available
[0].start
!= memaddr
)
8935 enum target_xfer_status res
;
8937 /* Don't read into the traceframe's available
8939 if (!available
.empty ())
8941 LONGEST oldlen
= len
;
8943 len
= available
[0].start
- memaddr
;
8944 gdb_assert (len
<= oldlen
);
8947 /* This goes through the topmost target again. */
8948 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
8949 len
, unit_size
, xfered_len
);
8950 if (res
== TARGET_XFER_OK
)
8951 return TARGET_XFER_OK
;
8954 /* No use trying further, we know some memory starting
8955 at MEMADDR isn't available. */
8957 return (*xfered_len
!= 0) ?
8958 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
8962 /* Don't try to read more than how much is available, in
8963 case the target implements the deprecated QTro packet to
8964 cater for older GDBs (the target's knowledge of read-only
8965 sections may be outdated by now). */
8966 len
= available
[0].length
;
8970 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8975 /* Sends a packet with content determined by the printf format string
8976 FORMAT and the remaining arguments, then gets the reply. Returns
8977 whether the packet was a success, a failure, or unknown. */
8980 remote_target::remote_send_printf (const char *format
, ...)
8982 struct remote_state
*rs
= get_remote_state ();
8983 int max_size
= get_remote_packet_size ();
8986 va_start (ap
, format
);
8989 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
8993 if (size
>= max_size
)
8994 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8996 if (putpkt (rs
->buf
) < 0)
8997 error (_("Communication problem with target."));
9000 getpkt (&rs
->buf
, 0);
9002 return packet_check_result (rs
->buf
);
9005 /* Flash writing can take quite some time. We'll set
9006 effectively infinite timeout for flash operations.
9007 In future, we'll need to decide on a better approach. */
9008 static const int remote_flash_timeout
= 1000;
9011 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
9013 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
9014 enum packet_result ret
;
9015 scoped_restore restore_timeout
9016 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9018 ret
= remote_send_printf ("vFlashErase:%s,%s",
9019 phex (address
, addr_size
),
9023 case PACKET_UNKNOWN
:
9024 error (_("Remote target does not support flash erase"));
9026 error (_("Error erasing flash with vFlashErase packet"));
9033 remote_target::remote_flash_write (ULONGEST address
,
9034 ULONGEST length
, ULONGEST
*xfered_len
,
9035 const gdb_byte
*data
)
9037 scoped_restore restore_timeout
9038 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9039 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
9044 remote_target::flash_done ()
9048 scoped_restore restore_timeout
9049 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9051 ret
= remote_send_printf ("vFlashDone");
9055 case PACKET_UNKNOWN
:
9056 error (_("Remote target does not support vFlashDone"));
9058 error (_("Error finishing flash operation"));
9065 remote_target::files_info ()
9067 puts_filtered ("Debugging a target over a serial line.\n");
9070 /* Stuff for dealing with the packets which are part of this protocol.
9071 See comment at top of file for details. */
9073 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
9074 error to higher layers. Called when a serial error is detected.
9075 The exception message is STRING, followed by a colon and a blank,
9076 the system error message for errno at function entry and final dot
9077 for output compatibility with throw_perror_with_name. */
9080 unpush_and_perror (remote_target
*target
, const char *string
)
9082 int saved_errno
= errno
;
9084 remote_unpush_target (target
);
9085 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
9086 safe_strerror (saved_errno
));
9089 /* Read a single character from the remote end. The current quit
9090 handler is overridden to avoid quitting in the middle of packet
9091 sequence, as that would break communication with the remote server.
9092 See remote_serial_quit_handler for more detail. */
9095 remote_target::readchar (int timeout
)
9098 struct remote_state
*rs
= get_remote_state ();
9101 scoped_restore restore_quit_target
9102 = make_scoped_restore (&curr_quit_handler_target
, this);
9103 scoped_restore restore_quit
9104 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9106 rs
->got_ctrlc_during_io
= 0;
9108 ch
= serial_readchar (rs
->remote_desc
, timeout
);
9110 if (rs
->got_ctrlc_during_io
)
9117 switch ((enum serial_rc
) ch
)
9120 remote_unpush_target (this);
9121 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9124 unpush_and_perror (this, _("Remote communication error. "
9125 "Target disconnected."));
9127 case SERIAL_TIMEOUT
:
9133 /* Wrapper for serial_write that closes the target and throws if
9134 writing fails. The current quit handler is overridden to avoid
9135 quitting in the middle of packet sequence, as that would break
9136 communication with the remote server. See
9137 remote_serial_quit_handler for more detail. */
9140 remote_target::remote_serial_write (const char *str
, int len
)
9142 struct remote_state
*rs
= get_remote_state ();
9144 scoped_restore restore_quit_target
9145 = make_scoped_restore (&curr_quit_handler_target
, this);
9146 scoped_restore restore_quit
9147 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9149 rs
->got_ctrlc_during_io
= 0;
9151 if (serial_write (rs
->remote_desc
, str
, len
))
9153 unpush_and_perror (this, _("Remote communication error. "
9154 "Target disconnected."));
9157 if (rs
->got_ctrlc_during_io
)
9161 /* Return a string representing an escaped version of BUF, of len N.
9162 E.g. \n is converted to \\n, \t to \\t, etc. */
9165 escape_buffer (const char *buf
, int n
)
9169 stb
.putstrn (buf
, n
, '\\');
9170 return std::move (stb
.string ());
9173 /* Display a null-terminated packet on stdout, for debugging, using C
9177 print_packet (const char *buf
)
9179 puts_filtered ("\"");
9180 fputstr_filtered (buf
, '"', gdb_stdout
);
9181 puts_filtered ("\"");
9185 remote_target::putpkt (const char *buf
)
9187 return putpkt_binary (buf
, strlen (buf
));
9190 /* Wrapper around remote_target::putpkt to avoid exporting
9194 putpkt (remote_target
*remote
, const char *buf
)
9196 return remote
->putpkt (buf
);
9199 /* Send a packet to the remote machine, with error checking. The data
9200 of the packet is in BUF. The string in BUF can be at most
9201 get_remote_packet_size () - 5 to account for the $, # and checksum,
9202 and for a possible /0 if we are debugging (remote_debug) and want
9203 to print the sent packet as a string. */
9206 remote_target::putpkt_binary (const char *buf
, int cnt
)
9208 struct remote_state
*rs
= get_remote_state ();
9210 unsigned char csum
= 0;
9211 gdb::def_vector
<char> data (cnt
+ 6);
9212 char *buf2
= data
.data ();
9218 /* Catch cases like trying to read memory or listing threads while
9219 we're waiting for a stop reply. The remote server wouldn't be
9220 ready to handle this request, so we'd hang and timeout. We don't
9221 have to worry about this in synchronous mode, because in that
9222 case it's not possible to issue a command while the target is
9223 running. This is not a problem in non-stop mode, because in that
9224 case, the stub is always ready to process serial input. */
9225 if (!target_is_non_stop_p ()
9226 && target_is_async_p ()
9227 && rs
->waiting_for_stop_reply
)
9229 error (_("Cannot execute this command while the target is running.\n"
9230 "Use the \"interrupt\" command to stop the target\n"
9231 "and then try again."));
9234 /* We're sending out a new packet. Make sure we don't look at a
9235 stale cached response. */
9236 rs
->cached_wait_status
= 0;
9238 /* Copy the packet into buffer BUF2, encapsulating it
9239 and giving it a checksum. */
9244 for (i
= 0; i
< cnt
; i
++)
9250 *p
++ = tohex ((csum
>> 4) & 0xf);
9251 *p
++ = tohex (csum
& 0xf);
9253 /* Send it over and over until we get a positive ack. */
9257 int started_error_output
= 0;
9263 int len
= (int) (p
- buf2
);
9266 if (remote_packet_max_chars
< 0)
9269 max_chars
= remote_packet_max_chars
;
9272 = escape_buffer (buf2
, std::min (len
, max_chars
));
9274 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9276 if (len
> max_chars
)
9277 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9280 fprintf_unfiltered (gdb_stdlog
, "...");
9282 gdb_flush (gdb_stdlog
);
9284 remote_serial_write (buf2
, p
- buf2
);
9286 /* If this is a no acks version of the remote protocol, send the
9287 packet and move on. */
9291 /* Read until either a timeout occurs (-2) or '+' is read.
9292 Handle any notification that arrives in the mean time. */
9295 ch
= readchar (remote_timeout
);
9303 case SERIAL_TIMEOUT
:
9306 if (started_error_output
)
9308 putchar_unfiltered ('\n');
9309 started_error_output
= 0;
9318 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9322 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9324 case SERIAL_TIMEOUT
:
9328 break; /* Retransmit buffer. */
9332 fprintf_unfiltered (gdb_stdlog
,
9333 "Packet instead of Ack, ignoring it\n");
9334 /* It's probably an old response sent because an ACK
9335 was lost. Gobble up the packet and ack it so it
9336 doesn't get retransmitted when we resend this
9339 remote_serial_write ("+", 1);
9340 continue; /* Now, go look for +. */
9347 /* If we got a notification, handle it, and go back to looking
9349 /* We've found the start of a notification. Now
9350 collect the data. */
9351 val
= read_frame (&rs
->buf
);
9356 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9358 fprintf_unfiltered (gdb_stdlog
,
9359 " Notification received: %s\n",
9362 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9363 /* We're in sync now, rewait for the ack. */
9370 if (!started_error_output
)
9372 started_error_output
= 1;
9373 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9375 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9376 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9385 if (!started_error_output
)
9387 started_error_output
= 1;
9388 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9390 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9394 break; /* Here to retransmit. */
9398 /* This is wrong. If doing a long backtrace, the user should be
9399 able to get out next time we call QUIT, without anything as
9400 violent as interrupt_query. If we want to provide a way out of
9401 here without getting to the next QUIT, it should be based on
9402 hitting ^C twice as in remote_wait. */
9414 /* Come here after finding the start of a frame when we expected an
9415 ack. Do our best to discard the rest of this packet. */
9418 remote_target::skip_frame ()
9424 c
= readchar (remote_timeout
);
9427 case SERIAL_TIMEOUT
:
9428 /* Nothing we can do. */
9431 /* Discard the two bytes of checksum and stop. */
9432 c
= readchar (remote_timeout
);
9434 c
= readchar (remote_timeout
);
9437 case '*': /* Run length encoding. */
9438 /* Discard the repeat count. */
9439 c
= readchar (remote_timeout
);
9444 /* A regular character. */
9450 /* Come here after finding the start of the frame. Collect the rest
9451 into *BUF, verifying the checksum, length, and handling run-length
9452 compression. NUL terminate the buffer. If there is not enough room,
9455 Returns -1 on error, number of characters in buffer (ignoring the
9456 trailing NULL) on success. (could be extended to return one of the
9457 SERIAL status indications). */
9460 remote_target::read_frame (gdb::char_vector
*buf_p
)
9465 char *buf
= buf_p
->data ();
9466 struct remote_state
*rs
= get_remote_state ();
9473 c
= readchar (remote_timeout
);
9476 case SERIAL_TIMEOUT
:
9478 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9482 fputs_filtered ("Saw new packet start in middle of old one\n",
9484 return -1; /* Start a new packet, count retries. */
9487 unsigned char pktcsum
;
9493 check_0
= readchar (remote_timeout
);
9495 check_1
= readchar (remote_timeout
);
9497 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9500 fputs_filtered ("Timeout in checksum, retrying\n",
9504 else if (check_0
< 0 || check_1
< 0)
9507 fputs_filtered ("Communication error in checksum\n",
9512 /* Don't recompute the checksum; with no ack packets we
9513 don't have any way to indicate a packet retransmission
9518 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9519 if (csum
== pktcsum
)
9524 std::string str
= escape_buffer (buf
, bc
);
9526 fprintf_unfiltered (gdb_stdlog
,
9527 "Bad checksum, sentsum=0x%x, "
9528 "csum=0x%x, buf=%s\n",
9529 pktcsum
, csum
, str
.c_str ());
9531 /* Number of characters in buffer ignoring trailing
9535 case '*': /* Run length encoding. */
9540 c
= readchar (remote_timeout
);
9542 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9544 /* The character before ``*'' is repeated. */
9546 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9548 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9550 /* Make some more room in the buffer. */
9551 buf_p
->resize (buf_p
->size () + repeat
);
9552 buf
= buf_p
->data ();
9555 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9561 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9565 if (bc
>= buf_p
->size () - 1)
9567 /* Make some more room in the buffer. */
9568 buf_p
->resize (buf_p
->size () * 2);
9569 buf
= buf_p
->data ();
9579 /* Set this to the maximum number of seconds to wait instead of waiting forever
9580 in target_wait(). If this timer times out, then it generates an error and
9581 the command is aborted. This replaces most of the need for timeouts in the
9582 GDB test suite, and makes it possible to distinguish between a hung target
9583 and one with slow communications. */
9585 static int watchdog
= 0;
9587 show_watchdog (struct ui_file
*file
, int from_tty
,
9588 struct cmd_list_element
*c
, const char *value
)
9590 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9593 /* Read a packet from the remote machine, with error checking, and
9594 store it in *BUF. Resize *BUF if necessary to hold the result. If
9595 FOREVER, wait forever rather than timing out; this is used (in
9596 synchronous mode) to wait for a target that is is executing user
9598 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9599 don't have to change all the calls to getpkt to deal with the
9600 return value, because at the moment I don't know what the right
9601 thing to do it for those. */
9604 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9606 getpkt_sane (buf
, forever
);
9610 /* Read a packet from the remote machine, with error checking, and
9611 store it in *BUF. Resize *BUF if necessary to hold the result. If
9612 FOREVER, wait forever rather than timing out; this is used (in
9613 synchronous mode) to wait for a target that is is executing user
9614 code to stop. If FOREVER == 0, this function is allowed to time
9615 out gracefully and return an indication of this to the caller.
9616 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9617 consider receiving a notification enough reason to return to the
9618 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9619 holds a notification or not (a regular packet). */
9622 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9623 int forever
, int expecting_notif
,
9626 struct remote_state
*rs
= get_remote_state ();
9632 /* We're reading a new response. Make sure we don't look at a
9633 previously cached response. */
9634 rs
->cached_wait_status
= 0;
9636 strcpy (buf
->data (), "timeout");
9639 timeout
= watchdog
> 0 ? watchdog
: -1;
9640 else if (expecting_notif
)
9641 timeout
= 0; /* There should already be a char in the buffer. If
9644 timeout
= remote_timeout
;
9648 /* Process any number of notifications, and then return when
9652 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9654 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9656 /* This can loop forever if the remote side sends us
9657 characters continuously, but if it pauses, we'll get
9658 SERIAL_TIMEOUT from readchar because of timeout. Then
9659 we'll count that as a retry.
9661 Note that even when forever is set, we will only wait
9662 forever prior to the start of a packet. After that, we
9663 expect characters to arrive at a brisk pace. They should
9664 show up within remote_timeout intervals. */
9666 c
= readchar (timeout
);
9667 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9669 if (c
== SERIAL_TIMEOUT
)
9671 if (expecting_notif
)
9672 return -1; /* Don't complain, it's normal to not get
9673 anything in this case. */
9675 if (forever
) /* Watchdog went off? Kill the target. */
9677 remote_unpush_target (this);
9678 throw_error (TARGET_CLOSE_ERROR
,
9679 _("Watchdog timeout has expired. "
9680 "Target detached."));
9683 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9687 /* We've found the start of a packet or notification.
9688 Now collect the data. */
9689 val
= read_frame (buf
);
9694 remote_serial_write ("-", 1);
9697 if (tries
> MAX_TRIES
)
9699 /* We have tried hard enough, and just can't receive the
9700 packet/notification. Give up. */
9701 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9703 /* Skip the ack char if we're in no-ack mode. */
9704 if (!rs
->noack_mode
)
9705 remote_serial_write ("+", 1);
9709 /* If we got an ordinary packet, return that to our caller. */
9716 if (remote_packet_max_chars
< 0)
9719 max_chars
= remote_packet_max_chars
;
9722 = escape_buffer (buf
->data (),
9723 std::min (val
, max_chars
));
9725 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9728 if (val
> max_chars
)
9729 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9732 fprintf_unfiltered (gdb_stdlog
, "\n");
9735 /* Skip the ack char if we're in no-ack mode. */
9736 if (!rs
->noack_mode
)
9737 remote_serial_write ("+", 1);
9738 if (is_notif
!= NULL
)
9743 /* If we got a notification, handle it, and go back to looking
9747 gdb_assert (c
== '%');
9751 std::string str
= escape_buffer (buf
->data (), val
);
9753 fprintf_unfiltered (gdb_stdlog
,
9754 " Notification received: %s\n",
9757 if (is_notif
!= NULL
)
9760 handle_notification (rs
->notif_state
, buf
->data ());
9762 /* Notifications require no acknowledgement. */
9764 if (expecting_notif
)
9771 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9773 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9777 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9780 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9783 /* Kill any new fork children of process PID that haven't been
9784 processed by follow_fork. */
9787 remote_target::kill_new_fork_children (int pid
)
9789 remote_state
*rs
= get_remote_state ();
9790 struct notif_client
*notif
= ¬if_client_stop
;
9792 /* Kill the fork child threads of any threads in process PID
9793 that are stopped at a fork event. */
9794 for (thread_info
*thread
: all_non_exited_threads (this))
9796 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9798 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9800 int child_pid
= ws
->value
.related_pid
.pid ();
9803 res
= remote_vkill (child_pid
);
9805 error (_("Can't kill fork child process %d"), child_pid
);
9809 /* Check for any pending fork events (not reported or processed yet)
9810 in process PID and kill those fork child threads as well. */
9811 remote_notif_get_pending_events (notif
);
9812 for (auto &event
: rs
->stop_reply_queue
)
9813 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9815 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9818 res
= remote_vkill (child_pid
);
9820 error (_("Can't kill fork child process %d"), child_pid
);
9825 /* Target hook to kill the current inferior. */
9828 remote_target::kill ()
9831 int pid
= inferior_ptid
.pid ();
9832 struct remote_state
*rs
= get_remote_state ();
9834 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9836 /* If we're stopped while forking and we haven't followed yet,
9837 kill the child task. We need to do this before killing the
9838 parent task because if this is a vfork then the parent will
9840 kill_new_fork_children (pid
);
9842 res
= remote_vkill (pid
);
9845 target_mourn_inferior (inferior_ptid
);
9850 /* If we are in 'target remote' mode and we are killing the only
9851 inferior, then we will tell gdbserver to exit and unpush the
9853 if (res
== -1 && !remote_multi_process_p (rs
)
9854 && number_of_live_inferiors (this) == 1)
9858 /* We've killed the remote end, we get to mourn it. If we are
9859 not in extended mode, mourning the inferior also unpushes
9860 remote_ops from the target stack, which closes the remote
9862 target_mourn_inferior (inferior_ptid
);
9867 error (_("Can't kill process"));
9870 /* Send a kill request to the target using the 'vKill' packet. */
9873 remote_target::remote_vkill (int pid
)
9875 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9878 remote_state
*rs
= get_remote_state ();
9880 /* Tell the remote target to detach. */
9881 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
9883 getpkt (&rs
->buf
, 0);
9885 switch (packet_ok (rs
->buf
,
9886 &remote_protocol_packets
[PACKET_vKill
]))
9892 case PACKET_UNKNOWN
:
9895 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9899 /* Send a kill request to the target using the 'k' packet. */
9902 remote_target::remote_kill_k ()
9904 /* Catch errors so the user can quit from gdb even when we
9905 aren't on speaking terms with the remote system. */
9910 catch (const gdb_exception_error
&ex
)
9912 if (ex
.error
== TARGET_CLOSE_ERROR
)
9914 /* If we got an (EOF) error that caused the target
9915 to go away, then we're done, that's what we wanted.
9916 "k" is susceptible to cause a premature EOF, given
9917 that the remote server isn't actually required to
9918 reply to "k", and it can happen that it doesn't
9919 even get to reply ACK to the "k". */
9923 /* Otherwise, something went wrong. We didn't actually kill
9924 the target. Just propagate the exception, and let the
9925 user or higher layers decide what to do. */
9931 remote_target::mourn_inferior ()
9933 struct remote_state
*rs
= get_remote_state ();
9935 /* We're no longer interested in notification events of an inferior
9936 that exited or was killed/detached. */
9937 discard_pending_stop_replies (current_inferior ());
9939 /* In 'target remote' mode with one inferior, we close the connection. */
9940 if (!rs
->extended
&& number_of_live_inferiors (this) <= 1)
9942 remote_unpush_target (this);
9946 /* In case we got here due to an error, but we're going to stay
9948 rs
->waiting_for_stop_reply
= 0;
9950 /* If the current general thread belonged to the process we just
9951 detached from or has exited, the remote side current general
9952 thread becomes undefined. Considering a case like this:
9954 - We just got here due to a detach.
9955 - The process that we're detaching from happens to immediately
9956 report a global breakpoint being hit in non-stop mode, in the
9957 same thread we had selected before.
9958 - GDB attaches to this process again.
9959 - This event happens to be the next event we handle.
9961 GDB would consider that the current general thread didn't need to
9962 be set on the stub side (with Hg), since for all it knew,
9963 GENERAL_THREAD hadn't changed.
9965 Notice that although in all-stop mode, the remote server always
9966 sets the current thread to the thread reporting the stop event,
9967 that doesn't happen in non-stop mode; in non-stop, the stub *must
9968 not* change the current thread when reporting a breakpoint hit,
9969 due to the decoupling of event reporting and event handling.
9971 To keep things simple, we always invalidate our notion of the
9973 record_currthread (rs
, minus_one_ptid
);
9975 /* Call common code to mark the inferior as not running. */
9976 generic_mourn_inferior ();
9980 extended_remote_target::supports_disable_randomization ()
9982 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9986 remote_target::extended_remote_disable_randomization (int val
)
9988 struct remote_state
*rs
= get_remote_state ();
9991 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9992 "QDisableRandomization:%x", val
);
9994 reply
= remote_get_noisy_reply ();
9996 error (_("Target does not support QDisableRandomization."));
9997 if (strcmp (reply
, "OK") != 0)
9998 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
10002 remote_target::extended_remote_run (const std::string
&args
)
10004 struct remote_state
*rs
= get_remote_state ();
10006 const char *remote_exec_file
= get_remote_exec_file ();
10008 /* If the user has disabled vRun support, or we have detected that
10009 support is not available, do not try it. */
10010 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
10013 strcpy (rs
->buf
.data (), "vRun;");
10014 len
= strlen (rs
->buf
.data ());
10016 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
10017 error (_("Remote file name too long for run packet"));
10018 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
10019 strlen (remote_exec_file
));
10021 if (!args
.empty ())
10025 gdb_argv
argv (args
.c_str ());
10026 for (i
= 0; argv
[i
] != NULL
; i
++)
10028 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
10029 error (_("Argument list too long for run packet"));
10030 rs
->buf
[len
++] = ';';
10031 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
10036 rs
->buf
[len
++] = '\0';
10039 getpkt (&rs
->buf
, 0);
10041 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
10044 /* We have a wait response. All is well. */
10046 case PACKET_UNKNOWN
:
10049 if (remote_exec_file
[0] == '\0')
10050 error (_("Running the default executable on the remote target failed; "
10051 "try \"set remote exec-file\"?"));
10053 error (_("Running \"%s\" on the remote target failed"),
10056 gdb_assert_not_reached (_("bad switch"));
10060 /* Helper function to send set/unset environment packets. ACTION is
10061 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
10062 or "QEnvironmentUnsetVariable". VALUE is the variable to be
10066 remote_target::send_environment_packet (const char *action
,
10067 const char *packet
,
10070 remote_state
*rs
= get_remote_state ();
10072 /* Convert the environment variable to an hex string, which
10073 is the best format to be transmitted over the wire. */
10074 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
10077 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10078 "%s:%s", packet
, encoded_value
.c_str ());
10081 getpkt (&rs
->buf
, 0);
10082 if (strcmp (rs
->buf
.data (), "OK") != 0)
10083 warning (_("Unable to %s environment variable '%s' on remote."),
10087 /* Helper function to handle the QEnvironment* packets. */
10090 remote_target::extended_remote_environment_support ()
10092 remote_state
*rs
= get_remote_state ();
10094 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
10096 putpkt ("QEnvironmentReset");
10097 getpkt (&rs
->buf
, 0);
10098 if (strcmp (rs
->buf
.data (), "OK") != 0)
10099 warning (_("Unable to reset environment on remote."));
10102 gdb_environ
*e
= ¤t_inferior ()->environment
;
10104 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
10105 for (const std::string
&el
: e
->user_set_env ())
10106 send_environment_packet ("set", "QEnvironmentHexEncoded",
10109 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
10110 for (const std::string
&el
: e
->user_unset_env ())
10111 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10114 /* Helper function to set the current working directory for the
10115 inferior in the remote target. */
10118 remote_target::extended_remote_set_inferior_cwd ()
10120 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10122 const char *inferior_cwd
= get_inferior_cwd ();
10123 remote_state
*rs
= get_remote_state ();
10125 if (inferior_cwd
!= NULL
)
10127 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10128 strlen (inferior_cwd
));
10130 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10131 "QSetWorkingDir:%s", hexpath
.c_str ());
10135 /* An empty inferior_cwd means that the user wants us to
10136 reset the remote server's inferior's cwd. */
10137 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10138 "QSetWorkingDir:");
10142 getpkt (&rs
->buf
, 0);
10143 if (packet_ok (rs
->buf
,
10144 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10147 Remote replied unexpectedly while setting the inferior's working\n\
10154 /* In the extended protocol we want to be able to do things like
10155 "run" and have them basically work as expected. So we need
10156 a special create_inferior function. We support changing the
10157 executable file and the command line arguments, but not the
10161 extended_remote_target::create_inferior (const char *exec_file
,
10162 const std::string
&args
,
10163 char **env
, int from_tty
)
10167 struct remote_state
*rs
= get_remote_state ();
10168 const char *remote_exec_file
= get_remote_exec_file ();
10170 /* If running asynchronously, register the target file descriptor
10171 with the event loop. */
10172 if (target_can_async_p ())
10175 /* Disable address space randomization if requested (and supported). */
10176 if (supports_disable_randomization ())
10177 extended_remote_disable_randomization (disable_randomization
);
10179 /* If startup-with-shell is on, we inform gdbserver to start the
10180 remote inferior using a shell. */
10181 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10183 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10184 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10186 getpkt (&rs
->buf
, 0);
10187 if (strcmp (rs
->buf
.data (), "OK") != 0)
10189 Remote replied unexpectedly while setting startup-with-shell: %s"),
10193 extended_remote_environment_support ();
10195 extended_remote_set_inferior_cwd ();
10197 /* Now restart the remote server. */
10198 run_worked
= extended_remote_run (args
) != -1;
10201 /* vRun was not supported. Fail if we need it to do what the
10203 if (remote_exec_file
[0])
10204 error (_("Remote target does not support \"set remote exec-file\""));
10205 if (!args
.empty ())
10206 error (_("Remote target does not support \"set args\" or run ARGS"));
10208 /* Fall back to "R". */
10209 extended_remote_restart ();
10212 /* vRun's success return is a stop reply. */
10213 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10214 add_current_inferior_and_thread (stop_reply
);
10216 /* Get updated offsets, if the stub uses qOffsets. */
10221 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10222 the list of conditions (in agent expression bytecode format), if any, the
10223 target needs to evaluate. The output is placed into the packet buffer
10224 started from BUF and ended at BUF_END. */
10227 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10228 struct bp_target_info
*bp_tgt
, char *buf
,
10231 if (bp_tgt
->conditions
.empty ())
10234 buf
+= strlen (buf
);
10235 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10238 /* Send conditions to the target. */
10239 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10241 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10242 buf
+= strlen (buf
);
10243 for (int i
= 0; i
< aexpr
->len
; ++i
)
10244 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10251 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10252 struct bp_target_info
*bp_tgt
, char *buf
)
10254 if (bp_tgt
->tcommands
.empty ())
10257 buf
+= strlen (buf
);
10259 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10260 buf
+= strlen (buf
);
10262 /* Concatenate all the agent expressions that are commands into the
10264 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10266 sprintf (buf
, "X%x,", aexpr
->len
);
10267 buf
+= strlen (buf
);
10268 for (int i
= 0; i
< aexpr
->len
; ++i
)
10269 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10274 /* Insert a breakpoint. On targets that have software breakpoint
10275 support, we ask the remote target to do the work; on targets
10276 which don't, we insert a traditional memory breakpoint. */
10279 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10280 struct bp_target_info
*bp_tgt
)
10282 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10283 If it succeeds, then set the support to PACKET_ENABLE. If it
10284 fails, and the user has explicitly requested the Z support then
10285 report an error, otherwise, mark it disabled and go on. */
10287 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10289 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10290 struct remote_state
*rs
;
10293 /* Make sure the remote is pointing at the right process, if
10295 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10296 set_general_process ();
10298 rs
= get_remote_state ();
10299 p
= rs
->buf
.data ();
10300 endbuf
= p
+ get_remote_packet_size ();
10305 addr
= (ULONGEST
) remote_address_masked (addr
);
10306 p
+= hexnumstr (p
, addr
);
10307 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10309 if (supports_evaluation_of_breakpoint_conditions ())
10310 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10312 if (can_run_breakpoint_commands ())
10313 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10316 getpkt (&rs
->buf
, 0);
10318 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10324 case PACKET_UNKNOWN
:
10329 /* If this breakpoint has target-side commands but this stub doesn't
10330 support Z0 packets, throw error. */
10331 if (!bp_tgt
->tcommands
.empty ())
10332 throw_error (NOT_SUPPORTED_ERROR
, _("\
10333 Target doesn't support breakpoints that have target side commands."));
10335 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10339 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10340 struct bp_target_info
*bp_tgt
,
10341 enum remove_bp_reason reason
)
10343 CORE_ADDR addr
= bp_tgt
->placed_address
;
10344 struct remote_state
*rs
= get_remote_state ();
10346 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10348 char *p
= rs
->buf
.data ();
10349 char *endbuf
= p
+ get_remote_packet_size ();
10351 /* Make sure the remote is pointing at the right process, if
10353 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10354 set_general_process ();
10360 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10361 p
+= hexnumstr (p
, addr
);
10362 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10365 getpkt (&rs
->buf
, 0);
10367 return (rs
->buf
[0] == 'E');
10370 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10373 static enum Z_packet_type
10374 watchpoint_to_Z_packet (int type
)
10379 return Z_PACKET_WRITE_WP
;
10382 return Z_PACKET_READ_WP
;
10385 return Z_PACKET_ACCESS_WP
;
10388 internal_error (__FILE__
, __LINE__
,
10389 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10394 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10395 enum target_hw_bp_type type
, struct expression
*cond
)
10397 struct remote_state
*rs
= get_remote_state ();
10398 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10400 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10402 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10405 /* Make sure the remote is pointing at the right process, if
10407 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10408 set_general_process ();
10410 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10411 p
= strchr (rs
->buf
.data (), '\0');
10412 addr
= remote_address_masked (addr
);
10413 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10414 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10417 getpkt (&rs
->buf
, 0);
10419 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10423 case PACKET_UNKNOWN
:
10428 internal_error (__FILE__
, __LINE__
,
10429 _("remote_insert_watchpoint: reached end of function"));
10433 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10434 CORE_ADDR start
, int length
)
10436 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10438 return diff
< length
;
10443 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10444 enum target_hw_bp_type type
, struct expression
*cond
)
10446 struct remote_state
*rs
= get_remote_state ();
10447 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10449 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10451 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10454 /* Make sure the remote is pointing at the right process, if
10456 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10457 set_general_process ();
10459 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10460 p
= strchr (rs
->buf
.data (), '\0');
10461 addr
= remote_address_masked (addr
);
10462 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10463 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10465 getpkt (&rs
->buf
, 0);
10467 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10470 case PACKET_UNKNOWN
:
10475 internal_error (__FILE__
, __LINE__
,
10476 _("remote_remove_watchpoint: reached end of function"));
10480 static int remote_hw_watchpoint_limit
= -1;
10481 static int remote_hw_watchpoint_length_limit
= -1;
10482 static int remote_hw_breakpoint_limit
= -1;
10485 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10487 if (remote_hw_watchpoint_length_limit
== 0)
10489 else if (remote_hw_watchpoint_length_limit
< 0)
10491 else if (len
<= remote_hw_watchpoint_length_limit
)
10498 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10500 if (type
== bp_hardware_breakpoint
)
10502 if (remote_hw_breakpoint_limit
== 0)
10504 else if (remote_hw_breakpoint_limit
< 0)
10506 else if (cnt
<= remote_hw_breakpoint_limit
)
10511 if (remote_hw_watchpoint_limit
== 0)
10513 else if (remote_hw_watchpoint_limit
< 0)
10517 else if (cnt
<= remote_hw_watchpoint_limit
)
10523 /* The to_stopped_by_sw_breakpoint method of target remote. */
10526 remote_target::stopped_by_sw_breakpoint ()
10528 struct thread_info
*thread
= inferior_thread ();
10530 return (thread
->priv
!= NULL
10531 && (get_remote_thread_info (thread
)->stop_reason
10532 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10535 /* The to_supports_stopped_by_sw_breakpoint method of target
10539 remote_target::supports_stopped_by_sw_breakpoint ()
10541 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10544 /* The to_stopped_by_hw_breakpoint method of target remote. */
10547 remote_target::stopped_by_hw_breakpoint ()
10549 struct thread_info
*thread
= inferior_thread ();
10551 return (thread
->priv
!= NULL
10552 && (get_remote_thread_info (thread
)->stop_reason
10553 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10556 /* The to_supports_stopped_by_hw_breakpoint method of target
10560 remote_target::supports_stopped_by_hw_breakpoint ()
10562 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10566 remote_target::stopped_by_watchpoint ()
10568 struct thread_info
*thread
= inferior_thread ();
10570 return (thread
->priv
!= NULL
10571 && (get_remote_thread_info (thread
)->stop_reason
10572 == TARGET_STOPPED_BY_WATCHPOINT
));
10576 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10578 struct thread_info
*thread
= inferior_thread ();
10580 if (thread
->priv
!= NULL
10581 && (get_remote_thread_info (thread
)->stop_reason
10582 == TARGET_STOPPED_BY_WATCHPOINT
))
10584 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10593 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10594 struct bp_target_info
*bp_tgt
)
10596 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10597 struct remote_state
*rs
;
10601 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10604 /* Make sure the remote is pointing at the right process, if
10606 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10607 set_general_process ();
10609 rs
= get_remote_state ();
10610 p
= rs
->buf
.data ();
10611 endbuf
= p
+ get_remote_packet_size ();
10617 addr
= remote_address_masked (addr
);
10618 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10619 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10621 if (supports_evaluation_of_breakpoint_conditions ())
10622 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10624 if (can_run_breakpoint_commands ())
10625 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10628 getpkt (&rs
->buf
, 0);
10630 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10633 if (rs
->buf
[1] == '.')
10635 message
= strchr (&rs
->buf
[2], '.');
10637 error (_("Remote failure reply: %s"), message
+ 1);
10640 case PACKET_UNKNOWN
:
10645 internal_error (__FILE__
, __LINE__
,
10646 _("remote_insert_hw_breakpoint: reached end of function"));
10651 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10652 struct bp_target_info
*bp_tgt
)
10655 struct remote_state
*rs
= get_remote_state ();
10656 char *p
= rs
->buf
.data ();
10657 char *endbuf
= p
+ get_remote_packet_size ();
10659 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10662 /* Make sure the remote is pointing at the right process, if
10664 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10665 set_general_process ();
10671 addr
= remote_address_masked (bp_tgt
->placed_address
);
10672 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10673 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10676 getpkt (&rs
->buf
, 0);
10678 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10681 case PACKET_UNKNOWN
:
10686 internal_error (__FILE__
, __LINE__
,
10687 _("remote_remove_hw_breakpoint: reached end of function"));
10690 /* Verify memory using the "qCRC:" request. */
10693 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10695 struct remote_state
*rs
= get_remote_state ();
10696 unsigned long host_crc
, target_crc
;
10699 /* It doesn't make sense to use qCRC if the remote target is
10700 connected but not running. */
10701 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10703 enum packet_result result
;
10705 /* Make sure the remote is pointing at the right process. */
10706 set_general_process ();
10708 /* FIXME: assumes lma can fit into long. */
10709 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10710 (long) lma
, (long) size
);
10713 /* Be clever; compute the host_crc before waiting for target
10715 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10717 getpkt (&rs
->buf
, 0);
10719 result
= packet_ok (rs
->buf
,
10720 &remote_protocol_packets
[PACKET_qCRC
]);
10721 if (result
== PACKET_ERROR
)
10723 else if (result
== PACKET_OK
)
10725 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10726 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10728 return (host_crc
== target_crc
);
10732 return simple_verify_memory (this, data
, lma
, size
);
10735 /* compare-sections command
10737 With no arguments, compares each loadable section in the exec bfd
10738 with the same memory range on the target, and reports mismatches.
10739 Useful for verifying the image on the target against the exec file. */
10742 compare_sections_command (const char *args
, int from_tty
)
10745 const char *sectname
;
10746 bfd_size_type size
;
10749 int mismatched
= 0;
10754 error (_("command cannot be used without an exec file"));
10756 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10762 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10764 if (!(s
->flags
& SEC_LOAD
))
10765 continue; /* Skip non-loadable section. */
10767 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10768 continue; /* Skip writeable sections */
10770 size
= bfd_section_size (s
);
10772 continue; /* Skip zero-length section. */
10774 sectname
= bfd_section_name (s
);
10775 if (args
&& strcmp (args
, sectname
) != 0)
10776 continue; /* Not the section selected by user. */
10778 matched
= 1; /* Do this section. */
10781 gdb::byte_vector
sectdata (size
);
10782 bfd_get_section_contents (exec_bfd
, s
, sectdata
.data (), 0, size
);
10784 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10787 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10788 paddress (target_gdbarch (), lma
),
10789 paddress (target_gdbarch (), lma
+ size
));
10791 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10792 paddress (target_gdbarch (), lma
),
10793 paddress (target_gdbarch (), lma
+ size
));
10795 printf_filtered ("matched.\n");
10798 printf_filtered ("MIS-MATCHED!\n");
10802 if (mismatched
> 0)
10803 warning (_("One or more sections of the target image does not match\n\
10804 the loaded file\n"));
10805 if (args
&& !matched
)
10806 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10809 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10810 into remote target. The number of bytes written to the remote
10811 target is returned, or -1 for error. */
10814 remote_target::remote_write_qxfer (const char *object_name
,
10815 const char *annex
, const gdb_byte
*writebuf
,
10816 ULONGEST offset
, LONGEST len
,
10817 ULONGEST
*xfered_len
,
10818 struct packet_config
*packet
)
10822 struct remote_state
*rs
= get_remote_state ();
10823 int max_size
= get_memory_write_packet_size ();
10825 if (packet_config_support (packet
) == PACKET_DISABLE
)
10826 return TARGET_XFER_E_IO
;
10828 /* Insert header. */
10829 i
= snprintf (rs
->buf
.data (), max_size
,
10830 "qXfer:%s:write:%s:%s:",
10831 object_name
, annex
? annex
: "",
10832 phex_nz (offset
, sizeof offset
));
10833 max_size
-= (i
+ 1);
10835 /* Escape as much data as fits into rs->buf. */
10836 buf_len
= remote_escape_output
10837 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10839 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10840 || getpkt_sane (&rs
->buf
, 0) < 0
10841 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10842 return TARGET_XFER_E_IO
;
10844 unpack_varlen_hex (rs
->buf
.data (), &n
);
10847 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10850 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10851 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10852 number of bytes read is returned, or 0 for EOF, or -1 for error.
10853 The number of bytes read may be less than LEN without indicating an
10854 EOF. PACKET is checked and updated to indicate whether the remote
10855 target supports this object. */
10858 remote_target::remote_read_qxfer (const char *object_name
,
10860 gdb_byte
*readbuf
, ULONGEST offset
,
10862 ULONGEST
*xfered_len
,
10863 struct packet_config
*packet
)
10865 struct remote_state
*rs
= get_remote_state ();
10866 LONGEST i
, n
, packet_len
;
10868 if (packet_config_support (packet
) == PACKET_DISABLE
)
10869 return TARGET_XFER_E_IO
;
10871 /* Check whether we've cached an end-of-object packet that matches
10873 if (rs
->finished_object
)
10875 if (strcmp (object_name
, rs
->finished_object
) == 0
10876 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10877 && offset
== rs
->finished_offset
)
10878 return TARGET_XFER_EOF
;
10881 /* Otherwise, we're now reading something different. Discard
10883 xfree (rs
->finished_object
);
10884 xfree (rs
->finished_annex
);
10885 rs
->finished_object
= NULL
;
10886 rs
->finished_annex
= NULL
;
10889 /* Request only enough to fit in a single packet. The actual data
10890 may not, since we don't know how much of it will need to be escaped;
10891 the target is free to respond with slightly less data. We subtract
10892 five to account for the response type and the protocol frame. */
10893 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10894 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
10895 "qXfer:%s:read:%s:%s,%s",
10896 object_name
, annex
? annex
: "",
10897 phex_nz (offset
, sizeof offset
),
10898 phex_nz (n
, sizeof n
));
10899 i
= putpkt (rs
->buf
);
10901 return TARGET_XFER_E_IO
;
10904 packet_len
= getpkt_sane (&rs
->buf
, 0);
10905 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10906 return TARGET_XFER_E_IO
;
10908 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10909 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
10911 /* 'm' means there is (or at least might be) more data after this
10912 batch. That does not make sense unless there's at least one byte
10913 of data in this reply. */
10914 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10915 error (_("Remote qXfer reply contained no data."));
10917 /* Got some data. */
10918 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
10919 packet_len
- 1, readbuf
, n
);
10921 /* 'l' is an EOF marker, possibly including a final block of data,
10922 or possibly empty. If we have the final block of a non-empty
10923 object, record this fact to bypass a subsequent partial read. */
10924 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10926 rs
->finished_object
= xstrdup (object_name
);
10927 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10928 rs
->finished_offset
= offset
+ i
;
10932 return TARGET_XFER_EOF
;
10936 return TARGET_XFER_OK
;
10940 enum target_xfer_status
10941 remote_target::xfer_partial (enum target_object object
,
10942 const char *annex
, gdb_byte
*readbuf
,
10943 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10944 ULONGEST
*xfered_len
)
10946 struct remote_state
*rs
;
10950 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10952 set_remote_traceframe ();
10953 set_general_thread (inferior_ptid
);
10955 rs
= get_remote_state ();
10957 /* Handle memory using the standard memory routines. */
10958 if (object
== TARGET_OBJECT_MEMORY
)
10960 /* If the remote target is connected but not running, we should
10961 pass this request down to a lower stratum (e.g. the executable
10963 if (!target_has_execution
)
10964 return TARGET_XFER_EOF
;
10966 if (writebuf
!= NULL
)
10967 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10970 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
10974 /* Handle extra signal info using qxfer packets. */
10975 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10978 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
10979 xfered_len
, &remote_protocol_packets
10980 [PACKET_qXfer_siginfo_read
]);
10982 return remote_write_qxfer ("siginfo", annex
,
10983 writebuf
, offset
, len
, xfered_len
,
10984 &remote_protocol_packets
10985 [PACKET_qXfer_siginfo_write
]);
10988 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10991 return remote_read_qxfer ("statictrace", annex
,
10992 readbuf
, offset
, len
, xfered_len
,
10993 &remote_protocol_packets
10994 [PACKET_qXfer_statictrace_read
]);
10996 return TARGET_XFER_E_IO
;
10999 /* Only handle flash writes. */
11000 if (writebuf
!= NULL
)
11004 case TARGET_OBJECT_FLASH
:
11005 return remote_flash_write (offset
, len
, xfered_len
,
11009 return TARGET_XFER_E_IO
;
11013 /* Map pre-existing objects onto letters. DO NOT do this for new
11014 objects!!! Instead specify new query packets. */
11017 case TARGET_OBJECT_AVR
:
11021 case TARGET_OBJECT_AUXV
:
11022 gdb_assert (annex
== NULL
);
11023 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
11025 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
11027 case TARGET_OBJECT_AVAILABLE_FEATURES
:
11028 return remote_read_qxfer
11029 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
11030 &remote_protocol_packets
[PACKET_qXfer_features
]);
11032 case TARGET_OBJECT_LIBRARIES
:
11033 return remote_read_qxfer
11034 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
11035 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
11037 case TARGET_OBJECT_LIBRARIES_SVR4
:
11038 return remote_read_qxfer
11039 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
11040 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
11042 case TARGET_OBJECT_MEMORY_MAP
:
11043 gdb_assert (annex
== NULL
);
11044 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
11046 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
11048 case TARGET_OBJECT_OSDATA
:
11049 /* Should only get here if we're connected. */
11050 gdb_assert (rs
->remote_desc
);
11051 return remote_read_qxfer
11052 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
11053 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
11055 case TARGET_OBJECT_THREADS
:
11056 gdb_assert (annex
== NULL
);
11057 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
11059 &remote_protocol_packets
[PACKET_qXfer_threads
]);
11061 case TARGET_OBJECT_TRACEFRAME_INFO
:
11062 gdb_assert (annex
== NULL
);
11063 return remote_read_qxfer
11064 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
11065 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
11067 case TARGET_OBJECT_FDPIC
:
11068 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
11070 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
11072 case TARGET_OBJECT_OPENVMS_UIB
:
11073 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
11075 &remote_protocol_packets
[PACKET_qXfer_uib
]);
11077 case TARGET_OBJECT_BTRACE
:
11078 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
11080 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
11082 case TARGET_OBJECT_BTRACE_CONF
:
11083 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
11085 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
11087 case TARGET_OBJECT_EXEC_FILE
:
11088 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
11090 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
11093 return TARGET_XFER_E_IO
;
11096 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
11097 large enough let the caller deal with it. */
11098 if (len
< get_remote_packet_size ())
11099 return TARGET_XFER_E_IO
;
11100 len
= get_remote_packet_size ();
11102 /* Except for querying the minimum buffer size, target must be open. */
11103 if (!rs
->remote_desc
)
11104 error (_("remote query is only available after target open"));
11106 gdb_assert (annex
!= NULL
);
11107 gdb_assert (readbuf
!= NULL
);
11109 p2
= rs
->buf
.data ();
11111 *p2
++ = query_type
;
11113 /* We used one buffer char for the remote protocol q command and
11114 another for the query type. As the remote protocol encapsulation
11115 uses 4 chars plus one extra in case we are debugging
11116 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11119 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11121 /* Bad caller may have sent forbidden characters. */
11122 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11127 gdb_assert (annex
[i
] == '\0');
11129 i
= putpkt (rs
->buf
);
11131 return TARGET_XFER_E_IO
;
11133 getpkt (&rs
->buf
, 0);
11134 strcpy ((char *) readbuf
, rs
->buf
.data ());
11136 *xfered_len
= strlen ((char *) readbuf
);
11137 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11140 /* Implementation of to_get_memory_xfer_limit. */
11143 remote_target::get_memory_xfer_limit ()
11145 return get_memory_write_packet_size ();
11149 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11150 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11151 CORE_ADDR
*found_addrp
)
11153 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11154 struct remote_state
*rs
= get_remote_state ();
11155 int max_size
= get_memory_write_packet_size ();
11156 struct packet_config
*packet
=
11157 &remote_protocol_packets
[PACKET_qSearch_memory
];
11158 /* Number of packet bytes used to encode the pattern;
11159 this could be more than PATTERN_LEN due to escape characters. */
11160 int escaped_pattern_len
;
11161 /* Amount of pattern that was encodable in the packet. */
11162 int used_pattern_len
;
11165 ULONGEST found_addr
;
11167 /* Don't go to the target if we don't have to. This is done before
11168 checking packet_config_support to avoid the possibility that a
11169 success for this edge case means the facility works in
11171 if (pattern_len
> search_space_len
)
11173 if (pattern_len
== 0)
11175 *found_addrp
= start_addr
;
11179 /* If we already know the packet isn't supported, fall back to the simple
11180 way of searching memory. */
11182 if (packet_config_support (packet
) == PACKET_DISABLE
)
11184 /* Target doesn't provided special support, fall back and use the
11185 standard support (copy memory and do the search here). */
11186 return simple_search_memory (this, start_addr
, search_space_len
,
11187 pattern
, pattern_len
, found_addrp
);
11190 /* Make sure the remote is pointing at the right process. */
11191 set_general_process ();
11193 /* Insert header. */
11194 i
= snprintf (rs
->buf
.data (), max_size
,
11195 "qSearch:memory:%s;%s;",
11196 phex_nz (start_addr
, addr_size
),
11197 phex_nz (search_space_len
, sizeof (search_space_len
)));
11198 max_size
-= (i
+ 1);
11200 /* Escape as much data as fits into rs->buf. */
11201 escaped_pattern_len
=
11202 remote_escape_output (pattern
, pattern_len
, 1,
11203 (gdb_byte
*) rs
->buf
.data () + i
,
11204 &used_pattern_len
, max_size
);
11206 /* Bail if the pattern is too large. */
11207 if (used_pattern_len
!= pattern_len
)
11208 error (_("Pattern is too large to transmit to remote target."));
11210 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11211 || getpkt_sane (&rs
->buf
, 0) < 0
11212 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11214 /* The request may not have worked because the command is not
11215 supported. If so, fall back to the simple way. */
11216 if (packet_config_support (packet
) == PACKET_DISABLE
)
11218 return simple_search_memory (this, start_addr
, search_space_len
,
11219 pattern
, pattern_len
, found_addrp
);
11224 if (rs
->buf
[0] == '0')
11226 else if (rs
->buf
[0] == '1')
11229 if (rs
->buf
[1] != ',')
11230 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11231 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11232 *found_addrp
= found_addr
;
11235 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11241 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11243 struct remote_state
*rs
= get_remote_state ();
11244 char *p
= rs
->buf
.data ();
11246 if (!rs
->remote_desc
)
11247 error (_("remote rcmd is only available after target open"));
11249 /* Send a NULL command across as an empty command. */
11250 if (command
== NULL
)
11253 /* The query prefix. */
11254 strcpy (rs
->buf
.data (), "qRcmd,");
11255 p
= strchr (rs
->buf
.data (), '\0');
11257 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11258 > get_remote_packet_size ())
11259 error (_("\"monitor\" command ``%s'' is too long."), command
);
11261 /* Encode the actual command. */
11262 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11264 if (putpkt (rs
->buf
) < 0)
11265 error (_("Communication problem with target."));
11267 /* get/display the response */
11272 /* XXX - see also remote_get_noisy_reply(). */
11273 QUIT
; /* Allow user to bail out with ^C. */
11275 if (getpkt_sane (&rs
->buf
, 0) == -1)
11277 /* Timeout. Continue to (try to) read responses.
11278 This is better than stopping with an error, assuming the stub
11279 is still executing the (long) monitor command.
11280 If needed, the user can interrupt gdb using C-c, obtaining
11281 an effect similar to stop on timeout. */
11284 buf
= rs
->buf
.data ();
11285 if (buf
[0] == '\0')
11286 error (_("Target does not support this command."));
11287 if (buf
[0] == 'O' && buf
[1] != 'K')
11289 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11292 if (strcmp (buf
, "OK") == 0)
11294 if (strlen (buf
) == 3 && buf
[0] == 'E'
11295 && isdigit (buf
[1]) && isdigit (buf
[2]))
11297 error (_("Protocol error with Rcmd"));
11299 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11301 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11303 fputc_unfiltered (c
, outbuf
);
11309 std::vector
<mem_region
>
11310 remote_target::memory_map ()
11312 std::vector
<mem_region
> result
;
11313 gdb::optional
<gdb::char_vector
> text
11314 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11317 result
= parse_memory_map (text
->data ());
11323 packet_command (const char *args
, int from_tty
)
11325 remote_target
*remote
= get_current_remote_target ();
11327 if (remote
== nullptr)
11328 error (_("command can only be used with remote target"));
11330 remote
->packet_command (args
, from_tty
);
11334 remote_target::packet_command (const char *args
, int from_tty
)
11337 error (_("remote-packet command requires packet text as argument"));
11339 puts_filtered ("sending: ");
11340 print_packet (args
);
11341 puts_filtered ("\n");
11344 remote_state
*rs
= get_remote_state ();
11346 getpkt (&rs
->buf
, 0);
11347 puts_filtered ("received: ");
11348 print_packet (rs
->buf
.data ());
11349 puts_filtered ("\n");
11353 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11355 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11357 static void threadset_test_cmd (char *cmd
, int tty
);
11359 static void threadalive_test (char *cmd
, int tty
);
11361 static void threadlist_test_cmd (char *cmd
, int tty
);
11363 int get_and_display_threadinfo (threadref
*ref
);
11365 static void threadinfo_test_cmd (char *cmd
, int tty
);
11367 static int thread_display_step (threadref
*ref
, void *context
);
11369 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11371 static void init_remote_threadtests (void);
11373 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11376 threadset_test_cmd (const char *cmd
, int tty
)
11378 int sample_thread
= SAMPLE_THREAD
;
11380 printf_filtered (_("Remote threadset test\n"));
11381 set_general_thread (sample_thread
);
11386 threadalive_test (const char *cmd
, int tty
)
11388 int sample_thread
= SAMPLE_THREAD
;
11389 int pid
= inferior_ptid
.pid ();
11390 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11392 if (remote_thread_alive (ptid
))
11393 printf_filtered ("PASS: Thread alive test\n");
11395 printf_filtered ("FAIL: Thread alive test\n");
11398 void output_threadid (char *title
, threadref
*ref
);
11401 output_threadid (char *title
, threadref
*ref
)
11405 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11407 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11411 threadlist_test_cmd (const char *cmd
, int tty
)
11414 threadref nextthread
;
11415 int done
, result_count
;
11416 threadref threadlist
[3];
11418 printf_filtered ("Remote Threadlist test\n");
11419 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11420 &result_count
, &threadlist
[0]))
11421 printf_filtered ("FAIL: threadlist test\n");
11424 threadref
*scan
= threadlist
;
11425 threadref
*limit
= scan
+ result_count
;
11427 while (scan
< limit
)
11428 output_threadid (" thread ", scan
++);
11433 display_thread_info (struct gdb_ext_thread_info
*info
)
11435 output_threadid ("Threadid: ", &info
->threadid
);
11436 printf_filtered ("Name: %s\n ", info
->shortname
);
11437 printf_filtered ("State: %s\n", info
->display
);
11438 printf_filtered ("other: %s\n\n", info
->more_display
);
11442 get_and_display_threadinfo (threadref
*ref
)
11446 struct gdb_ext_thread_info threadinfo
;
11448 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11449 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11450 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11451 display_thread_info (&threadinfo
);
11456 threadinfo_test_cmd (const char *cmd
, int tty
)
11458 int athread
= SAMPLE_THREAD
;
11462 int_to_threadref (&thread
, athread
);
11463 printf_filtered ("Remote Threadinfo test\n");
11464 if (!get_and_display_threadinfo (&thread
))
11465 printf_filtered ("FAIL cannot get thread info\n");
11469 thread_display_step (threadref
*ref
, void *context
)
11471 /* output_threadid(" threadstep ",ref); *//* simple test */
11472 return get_and_display_threadinfo (ref
);
11476 threadlist_update_test_cmd (const char *cmd
, int tty
)
11478 printf_filtered ("Remote Threadlist update test\n");
11479 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11483 init_remote_threadtests (void)
11485 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11486 _("Fetch and print the remote list of "
11487 "thread identifiers, one pkt only."));
11488 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11489 _("Fetch and display info about one thread."));
11490 add_com ("tset", class_obscure
, threadset_test_cmd
,
11491 _("Test setting to a different thread."));
11492 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11493 _("Iterate through updating all remote thread info."));
11494 add_com ("talive", class_obscure
, threadalive_test
,
11495 _("Remote thread alive test."));
11500 /* Convert a thread ID to a string. */
11503 remote_target::pid_to_str (ptid_t ptid
)
11505 struct remote_state
*rs
= get_remote_state ();
11507 if (ptid
== null_ptid
)
11508 return normal_pid_to_str (ptid
);
11509 else if (ptid
.is_pid ())
11511 /* Printing an inferior target id. */
11513 /* When multi-process extensions are off, there's no way in the
11514 remote protocol to know the remote process id, if there's any
11515 at all. There's one exception --- when we're connected with
11516 target extended-remote, and we manually attached to a process
11517 with "attach PID". We don't record anywhere a flag that
11518 allows us to distinguish that case from the case of
11519 connecting with extended-remote and the stub already being
11520 attached to a process, and reporting yes to qAttached, hence
11521 no smart special casing here. */
11522 if (!remote_multi_process_p (rs
))
11523 return "Remote target";
11525 return normal_pid_to_str (ptid
);
11529 if (magic_null_ptid
== ptid
)
11530 return "Thread <main>";
11531 else if (remote_multi_process_p (rs
))
11532 if (ptid
.lwp () == 0)
11533 return normal_pid_to_str (ptid
);
11535 return string_printf ("Thread %d.%ld",
11536 ptid
.pid (), ptid
.lwp ());
11538 return string_printf ("Thread %ld", ptid
.lwp ());
11542 /* Get the address of the thread local variable in OBJFILE which is
11543 stored at OFFSET within the thread local storage for thread PTID. */
11546 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11549 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11551 struct remote_state
*rs
= get_remote_state ();
11552 char *p
= rs
->buf
.data ();
11553 char *endp
= p
+ get_remote_packet_size ();
11554 enum packet_result result
;
11556 strcpy (p
, "qGetTLSAddr:");
11558 p
= write_ptid (p
, endp
, ptid
);
11560 p
+= hexnumstr (p
, offset
);
11562 p
+= hexnumstr (p
, lm
);
11566 getpkt (&rs
->buf
, 0);
11567 result
= packet_ok (rs
->buf
,
11568 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11569 if (result
== PACKET_OK
)
11573 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11576 else if (result
== PACKET_UNKNOWN
)
11577 throw_error (TLS_GENERIC_ERROR
,
11578 _("Remote target doesn't support qGetTLSAddr packet"));
11580 throw_error (TLS_GENERIC_ERROR
,
11581 _("Remote target failed to process qGetTLSAddr request"));
11584 throw_error (TLS_GENERIC_ERROR
,
11585 _("TLS not supported or disabled on this target"));
11590 /* Provide thread local base, i.e. Thread Information Block address.
11591 Returns 1 if ptid is found and thread_local_base is non zero. */
11594 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11596 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11598 struct remote_state
*rs
= get_remote_state ();
11599 char *p
= rs
->buf
.data ();
11600 char *endp
= p
+ get_remote_packet_size ();
11601 enum packet_result result
;
11603 strcpy (p
, "qGetTIBAddr:");
11605 p
= write_ptid (p
, endp
, ptid
);
11609 getpkt (&rs
->buf
, 0);
11610 result
= packet_ok (rs
->buf
,
11611 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11612 if (result
== PACKET_OK
)
11615 unpack_varlen_hex (rs
->buf
.data (), &val
);
11617 *addr
= (CORE_ADDR
) val
;
11620 else if (result
== PACKET_UNKNOWN
)
11621 error (_("Remote target doesn't support qGetTIBAddr packet"));
11623 error (_("Remote target failed to process qGetTIBAddr request"));
11626 error (_("qGetTIBAddr not supported or disabled on this target"));
11631 /* Support for inferring a target description based on the current
11632 architecture and the size of a 'g' packet. While the 'g' packet
11633 can have any size (since optional registers can be left off the
11634 end), some sizes are easily recognizable given knowledge of the
11635 approximate architecture. */
11637 struct remote_g_packet_guess
11639 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11646 const struct target_desc
*tdesc
;
11649 struct remote_g_packet_data
: public allocate_on_obstack
11651 std::vector
<remote_g_packet_guess
> guesses
;
11654 static struct gdbarch_data
*remote_g_packet_data_handle
;
11657 remote_g_packet_data_init (struct obstack
*obstack
)
11659 return new (obstack
) remote_g_packet_data
;
11663 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11664 const struct target_desc
*tdesc
)
11666 struct remote_g_packet_data
*data
11667 = ((struct remote_g_packet_data
*)
11668 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11670 gdb_assert (tdesc
!= NULL
);
11672 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11673 if (guess
.bytes
== bytes
)
11674 internal_error (__FILE__
, __LINE__
,
11675 _("Duplicate g packet description added for size %d"),
11678 data
->guesses
.emplace_back (bytes
, tdesc
);
11681 /* Return true if remote_read_description would do anything on this target
11682 and architecture, false otherwise. */
11685 remote_read_description_p (struct target_ops
*target
)
11687 struct remote_g_packet_data
*data
11688 = ((struct remote_g_packet_data
*)
11689 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11691 return !data
->guesses
.empty ();
11694 const struct target_desc
*
11695 remote_target::read_description ()
11697 struct remote_g_packet_data
*data
11698 = ((struct remote_g_packet_data
*)
11699 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11701 /* Do not try this during initial connection, when we do not know
11702 whether there is a running but stopped thread. */
11703 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
11704 return beneath ()->read_description ();
11706 if (!data
->guesses
.empty ())
11708 int bytes
= send_g_packet ();
11710 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11711 if (guess
.bytes
== bytes
)
11712 return guess
.tdesc
;
11714 /* We discard the g packet. A minor optimization would be to
11715 hold on to it, and fill the register cache once we have selected
11716 an architecture, but it's too tricky to do safely. */
11719 return beneath ()->read_description ();
11722 /* Remote file transfer support. This is host-initiated I/O, not
11723 target-initiated; for target-initiated, see remote-fileio.c. */
11725 /* If *LEFT is at least the length of STRING, copy STRING to
11726 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11727 decrease *LEFT. Otherwise raise an error. */
11730 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11732 int len
= strlen (string
);
11735 error (_("Packet too long for target."));
11737 memcpy (*buffer
, string
, len
);
11741 /* NUL-terminate the buffer as a convenience, if there is
11747 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11748 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11749 decrease *LEFT. Otherwise raise an error. */
11752 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11755 if (2 * len
> *left
)
11756 error (_("Packet too long for target."));
11758 bin2hex (bytes
, *buffer
, len
);
11759 *buffer
+= 2 * len
;
11762 /* NUL-terminate the buffer as a convenience, if there is
11768 /* If *LEFT is large enough, convert VALUE to hex and add it to
11769 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11770 decrease *LEFT. Otherwise raise an error. */
11773 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11775 int len
= hexnumlen (value
);
11778 error (_("Packet too long for target."));
11780 hexnumstr (*buffer
, value
);
11784 /* NUL-terminate the buffer as a convenience, if there is
11790 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11791 value, *REMOTE_ERRNO to the remote error number or zero if none
11792 was included, and *ATTACHMENT to point to the start of the annex
11793 if any. The length of the packet isn't needed here; there may
11794 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11796 Return 0 if the packet could be parsed, -1 if it could not. If
11797 -1 is returned, the other variables may not be initialized. */
11800 remote_hostio_parse_result (char *buffer
, int *retcode
,
11801 int *remote_errno
, char **attachment
)
11806 *attachment
= NULL
;
11808 if (buffer
[0] != 'F')
11812 *retcode
= strtol (&buffer
[1], &p
, 16);
11813 if (errno
!= 0 || p
== &buffer
[1])
11816 /* Check for ",errno". */
11820 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11821 if (errno
!= 0 || p
+ 1 == p2
)
11826 /* Check for ";attachment". If there is no attachment, the
11827 packet should end here. */
11830 *attachment
= p
+ 1;
11833 else if (*p
== '\0')
11839 /* Send a prepared I/O packet to the target and read its response.
11840 The prepared packet is in the global RS->BUF before this function
11841 is called, and the answer is there when we return.
11843 COMMAND_BYTES is the length of the request to send, which may include
11844 binary data. WHICH_PACKET is the packet configuration to check
11845 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11846 is set to the error number and -1 is returned. Otherwise the value
11847 returned by the function is returned.
11849 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11850 attachment is expected; an error will be reported if there's a
11851 mismatch. If one is found, *ATTACHMENT will be set to point into
11852 the packet buffer and *ATTACHMENT_LEN will be set to the
11853 attachment's length. */
11856 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11857 int *remote_errno
, char **attachment
,
11858 int *attachment_len
)
11860 struct remote_state
*rs
= get_remote_state ();
11861 int ret
, bytes_read
;
11862 char *attachment_tmp
;
11864 if (packet_support (which_packet
) == PACKET_DISABLE
)
11866 *remote_errno
= FILEIO_ENOSYS
;
11870 putpkt_binary (rs
->buf
.data (), command_bytes
);
11871 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11873 /* If it timed out, something is wrong. Don't try to parse the
11875 if (bytes_read
< 0)
11877 *remote_errno
= FILEIO_EINVAL
;
11881 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11884 *remote_errno
= FILEIO_EINVAL
;
11886 case PACKET_UNKNOWN
:
11887 *remote_errno
= FILEIO_ENOSYS
;
11893 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
11896 *remote_errno
= FILEIO_EINVAL
;
11900 /* Make sure we saw an attachment if and only if we expected one. */
11901 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11902 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11904 *remote_errno
= FILEIO_EINVAL
;
11908 /* If an attachment was found, it must point into the packet buffer;
11909 work out how many bytes there were. */
11910 if (attachment_tmp
!= NULL
)
11912 *attachment
= attachment_tmp
;
11913 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
11919 /* See declaration.h. */
11922 readahead_cache::invalidate ()
11927 /* See declaration.h. */
11930 readahead_cache::invalidate_fd (int fd
)
11932 if (this->fd
== fd
)
11936 /* Set the filesystem remote_hostio functions that take FILENAME
11937 arguments will use. Return 0 on success, or -1 if an error
11938 occurs (and set *REMOTE_ERRNO). */
11941 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
11944 struct remote_state
*rs
= get_remote_state ();
11945 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11946 char *p
= rs
->buf
.data ();
11947 int left
= get_remote_packet_size () - 1;
11951 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11954 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11957 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11959 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11960 remote_buffer_add_string (&p
, &left
, arg
);
11962 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
11963 remote_errno
, NULL
, NULL
);
11965 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11969 rs
->fs_pid
= required_pid
;
11974 /* Implementation of to_fileio_open. */
11977 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
11978 int flags
, int mode
, int warn_if_slow
,
11981 struct remote_state
*rs
= get_remote_state ();
11982 char *p
= rs
->buf
.data ();
11983 int left
= get_remote_packet_size () - 1;
11987 static int warning_issued
= 0;
11989 printf_unfiltered (_("Reading %s from remote target...\n"),
11992 if (!warning_issued
)
11994 warning (_("File transfers from remote targets can be slow."
11995 " Use \"set sysroot\" to access files locally"
11997 warning_issued
= 1;
12001 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12004 remote_buffer_add_string (&p
, &left
, "vFile:open:");
12006 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12007 strlen (filename
));
12008 remote_buffer_add_string (&p
, &left
, ",");
12010 remote_buffer_add_int (&p
, &left
, flags
);
12011 remote_buffer_add_string (&p
, &left
, ",");
12013 remote_buffer_add_int (&p
, &left
, mode
);
12015 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
12016 remote_errno
, NULL
, NULL
);
12020 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
12021 int flags
, int mode
, int warn_if_slow
,
12024 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
12028 /* Implementation of to_fileio_pwrite. */
12031 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12032 ULONGEST offset
, int *remote_errno
)
12034 struct remote_state
*rs
= get_remote_state ();
12035 char *p
= rs
->buf
.data ();
12036 int left
= get_remote_packet_size ();
12039 rs
->readahead_cache
.invalidate_fd (fd
);
12041 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
12043 remote_buffer_add_int (&p
, &left
, fd
);
12044 remote_buffer_add_string (&p
, &left
, ",");
12046 remote_buffer_add_int (&p
, &left
, offset
);
12047 remote_buffer_add_string (&p
, &left
, ",");
12049 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
12050 (get_remote_packet_size ()
12051 - (p
- rs
->buf
.data ())));
12053 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
12054 remote_errno
, NULL
, NULL
);
12058 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12059 ULONGEST offset
, int *remote_errno
)
12061 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
12064 /* Helper for the implementation of to_fileio_pread. Read the file
12065 from the remote side with vFile:pread. */
12068 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
12069 ULONGEST offset
, int *remote_errno
)
12071 struct remote_state
*rs
= get_remote_state ();
12072 char *p
= rs
->buf
.data ();
12074 int left
= get_remote_packet_size ();
12075 int ret
, attachment_len
;
12078 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
12080 remote_buffer_add_int (&p
, &left
, fd
);
12081 remote_buffer_add_string (&p
, &left
, ",");
12083 remote_buffer_add_int (&p
, &left
, len
);
12084 remote_buffer_add_string (&p
, &left
, ",");
12086 remote_buffer_add_int (&p
, &left
, offset
);
12088 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
12089 remote_errno
, &attachment
,
12095 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12097 if (read_len
!= ret
)
12098 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
12103 /* See declaration.h. */
12106 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12110 && this->offset
<= offset
12111 && offset
< this->offset
+ this->bufsize
)
12113 ULONGEST max
= this->offset
+ this->bufsize
;
12115 if (offset
+ len
> max
)
12116 len
= max
- offset
;
12118 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12125 /* Implementation of to_fileio_pread. */
12128 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12129 ULONGEST offset
, int *remote_errno
)
12132 struct remote_state
*rs
= get_remote_state ();
12133 readahead_cache
*cache
= &rs
->readahead_cache
;
12135 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12138 cache
->hit_count
++;
12141 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12142 pulongest (cache
->hit_count
));
12146 cache
->miss_count
++;
12148 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12149 pulongest (cache
->miss_count
));
12152 cache
->offset
= offset
;
12153 cache
->bufsize
= get_remote_packet_size ();
12154 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12156 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12157 cache
->offset
, remote_errno
);
12160 cache
->invalidate_fd (fd
);
12164 cache
->bufsize
= ret
;
12165 return cache
->pread (fd
, read_buf
, len
, offset
);
12169 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12170 ULONGEST offset
, int *remote_errno
)
12172 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12175 /* Implementation of to_fileio_close. */
12178 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12180 struct remote_state
*rs
= get_remote_state ();
12181 char *p
= rs
->buf
.data ();
12182 int left
= get_remote_packet_size () - 1;
12184 rs
->readahead_cache
.invalidate_fd (fd
);
12186 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12188 remote_buffer_add_int (&p
, &left
, fd
);
12190 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12191 remote_errno
, NULL
, NULL
);
12195 remote_target::fileio_close (int fd
, int *remote_errno
)
12197 return remote_hostio_close (fd
, remote_errno
);
12200 /* Implementation of to_fileio_unlink. */
12203 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12206 struct remote_state
*rs
= get_remote_state ();
12207 char *p
= rs
->buf
.data ();
12208 int left
= get_remote_packet_size () - 1;
12210 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12213 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12215 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12216 strlen (filename
));
12218 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12219 remote_errno
, NULL
, NULL
);
12223 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12226 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12229 /* Implementation of to_fileio_readlink. */
12231 gdb::optional
<std::string
>
12232 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12235 struct remote_state
*rs
= get_remote_state ();
12236 char *p
= rs
->buf
.data ();
12238 int left
= get_remote_packet_size ();
12239 int len
, attachment_len
;
12242 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12245 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12247 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12248 strlen (filename
));
12250 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12251 remote_errno
, &attachment
,
12257 std::string
ret (len
, '\0');
12259 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12260 (gdb_byte
*) &ret
[0], len
);
12261 if (read_len
!= len
)
12262 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12267 /* Implementation of to_fileio_fstat. */
12270 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12272 struct remote_state
*rs
= get_remote_state ();
12273 char *p
= rs
->buf
.data ();
12274 int left
= get_remote_packet_size ();
12275 int attachment_len
, ret
;
12277 struct fio_stat fst
;
12280 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12282 remote_buffer_add_int (&p
, &left
, fd
);
12284 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12285 remote_errno
, &attachment
,
12289 if (*remote_errno
!= FILEIO_ENOSYS
)
12292 /* Strictly we should return -1, ENOSYS here, but when
12293 "set sysroot remote:" was implemented in August 2008
12294 BFD's need for a stat function was sidestepped with
12295 this hack. This was not remedied until March 2015
12296 so we retain the previous behavior to avoid breaking
12299 Note that the memset is a March 2015 addition; older
12300 GDBs set st_size *and nothing else* so the structure
12301 would have garbage in all other fields. This might
12302 break something but retaining the previous behavior
12303 here would be just too wrong. */
12305 memset (st
, 0, sizeof (struct stat
));
12306 st
->st_size
= INT_MAX
;
12310 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12311 (gdb_byte
*) &fst
, sizeof (fst
));
12313 if (read_len
!= ret
)
12314 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12316 if (read_len
!= sizeof (fst
))
12317 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12318 read_len
, (int) sizeof (fst
));
12320 remote_fileio_to_host_stat (&fst
, st
);
12325 /* Implementation of to_filesystem_is_local. */
12328 remote_target::filesystem_is_local ()
12330 /* Valgrind GDB presents itself as a remote target but works
12331 on the local filesystem: it does not implement remote get
12332 and users are not expected to set a sysroot. To handle
12333 this case we treat the remote filesystem as local if the
12334 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12335 does not support vFile:open. */
12336 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12338 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12340 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12342 int fd
, remote_errno
;
12344 /* Try opening a file to probe support. The supplied
12345 filename is irrelevant, we only care about whether
12346 the stub recognizes the packet or not. */
12347 fd
= remote_hostio_open (NULL
, "just probing",
12348 FILEIO_O_RDONLY
, 0700, 0,
12352 remote_hostio_close (fd
, &remote_errno
);
12354 ps
= packet_support (PACKET_vFile_open
);
12357 if (ps
== PACKET_DISABLE
)
12359 static int warning_issued
= 0;
12361 if (!warning_issued
)
12363 warning (_("remote target does not support file"
12364 " transfer, attempting to access files"
12365 " from local filesystem."));
12366 warning_issued
= 1;
12377 remote_fileio_errno_to_host (int errnum
)
12383 case FILEIO_ENOENT
:
12391 case FILEIO_EACCES
:
12393 case FILEIO_EFAULT
:
12397 case FILEIO_EEXIST
:
12399 case FILEIO_ENODEV
:
12401 case FILEIO_ENOTDIR
:
12403 case FILEIO_EISDIR
:
12405 case FILEIO_EINVAL
:
12407 case FILEIO_ENFILE
:
12409 case FILEIO_EMFILE
:
12413 case FILEIO_ENOSPC
:
12415 case FILEIO_ESPIPE
:
12419 case FILEIO_ENOSYS
:
12421 case FILEIO_ENAMETOOLONG
:
12422 return ENAMETOOLONG
;
12428 remote_hostio_error (int errnum
)
12430 int host_error
= remote_fileio_errno_to_host (errnum
);
12432 if (host_error
== -1)
12433 error (_("Unknown remote I/O error %d"), errnum
);
12435 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12438 /* A RAII wrapper around a remote file descriptor. */
12440 class scoped_remote_fd
12443 scoped_remote_fd (remote_target
*remote
, int fd
)
12444 : m_remote (remote
), m_fd (fd
)
12448 ~scoped_remote_fd ()
12455 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12459 /* Swallow exception before it escapes the dtor. If
12460 something goes wrong, likely the connection is gone,
12461 and there's nothing else that can be done. */
12466 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12468 /* Release ownership of the file descriptor, and return it. */
12469 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12476 /* Return the owned file descriptor. */
12477 int get () const noexcept
12483 /* The remote target. */
12484 remote_target
*m_remote
;
12486 /* The owned remote I/O file descriptor. */
12491 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12493 remote_target
*remote
= get_current_remote_target ();
12495 if (remote
== nullptr)
12496 error (_("command can only be used with remote target"));
12498 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12502 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12505 int retcode
, remote_errno
, bytes
, io_size
;
12506 int bytes_in_buffer
;
12510 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12512 perror_with_name (local_file
);
12514 scoped_remote_fd fd
12515 (this, remote_hostio_open (NULL
,
12516 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12518 0700, 0, &remote_errno
));
12519 if (fd
.get () == -1)
12520 remote_hostio_error (remote_errno
);
12522 /* Send up to this many bytes at once. They won't all fit in the
12523 remote packet limit, so we'll transfer slightly fewer. */
12524 io_size
= get_remote_packet_size ();
12525 gdb::byte_vector
buffer (io_size
);
12527 bytes_in_buffer
= 0;
12530 while (bytes_in_buffer
|| !saw_eof
)
12534 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12535 io_size
- bytes_in_buffer
,
12539 if (ferror (file
.get ()))
12540 error (_("Error reading %s."), local_file
);
12543 /* EOF. Unless there is something still in the
12544 buffer from the last iteration, we are done. */
12546 if (bytes_in_buffer
== 0)
12554 bytes
+= bytes_in_buffer
;
12555 bytes_in_buffer
= 0;
12557 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12558 offset
, &remote_errno
);
12561 remote_hostio_error (remote_errno
);
12562 else if (retcode
== 0)
12563 error (_("Remote write of %d bytes returned 0!"), bytes
);
12564 else if (retcode
< bytes
)
12566 /* Short write. Save the rest of the read data for the next
12568 bytes_in_buffer
= bytes
- retcode
;
12569 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12575 if (remote_hostio_close (fd
.release (), &remote_errno
))
12576 remote_hostio_error (remote_errno
);
12579 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12583 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12585 remote_target
*remote
= get_current_remote_target ();
12587 if (remote
== nullptr)
12588 error (_("command can only be used with remote target"));
12590 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12594 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12597 int remote_errno
, bytes
, io_size
;
12600 scoped_remote_fd fd
12601 (this, remote_hostio_open (NULL
,
12602 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12604 if (fd
.get () == -1)
12605 remote_hostio_error (remote_errno
);
12607 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12609 perror_with_name (local_file
);
12611 /* Send up to this many bytes at once. They won't all fit in the
12612 remote packet limit, so we'll transfer slightly fewer. */
12613 io_size
= get_remote_packet_size ();
12614 gdb::byte_vector
buffer (io_size
);
12619 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12622 /* Success, but no bytes, means end-of-file. */
12625 remote_hostio_error (remote_errno
);
12629 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12631 perror_with_name (local_file
);
12634 if (remote_hostio_close (fd
.release (), &remote_errno
))
12635 remote_hostio_error (remote_errno
);
12638 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12642 remote_file_delete (const char *remote_file
, int from_tty
)
12644 remote_target
*remote
= get_current_remote_target ();
12646 if (remote
== nullptr)
12647 error (_("command can only be used with remote target"));
12649 remote
->remote_file_delete (remote_file
, from_tty
);
12653 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12655 int retcode
, remote_errno
;
12657 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12659 remote_hostio_error (remote_errno
);
12662 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12666 remote_put_command (const char *args
, int from_tty
)
12669 error_no_arg (_("file to put"));
12671 gdb_argv
argv (args
);
12672 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12673 error (_("Invalid parameters to remote put"));
12675 remote_file_put (argv
[0], argv
[1], from_tty
);
12679 remote_get_command (const char *args
, int from_tty
)
12682 error_no_arg (_("file to get"));
12684 gdb_argv
argv (args
);
12685 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12686 error (_("Invalid parameters to remote get"));
12688 remote_file_get (argv
[0], argv
[1], from_tty
);
12692 remote_delete_command (const char *args
, int from_tty
)
12695 error_no_arg (_("file to delete"));
12697 gdb_argv
argv (args
);
12698 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12699 error (_("Invalid parameters to remote delete"));
12701 remote_file_delete (argv
[0], from_tty
);
12705 remote_command (const char *args
, int from_tty
)
12707 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12711 remote_target::can_execute_reverse ()
12713 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12714 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12721 remote_target::supports_non_stop ()
12727 remote_target::supports_disable_randomization ()
12729 /* Only supported in extended mode. */
12734 remote_target::supports_multi_process ()
12736 struct remote_state
*rs
= get_remote_state ();
12738 return remote_multi_process_p (rs
);
12742 remote_supports_cond_tracepoints ()
12744 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12748 remote_target::supports_evaluation_of_breakpoint_conditions ()
12750 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12754 remote_supports_fast_tracepoints ()
12756 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12760 remote_supports_static_tracepoints ()
12762 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12766 remote_supports_install_in_trace ()
12768 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12772 remote_target::supports_enable_disable_tracepoint ()
12774 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12779 remote_target::supports_string_tracing ()
12781 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12785 remote_target::can_run_breakpoint_commands ()
12787 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12791 remote_target::trace_init ()
12793 struct remote_state
*rs
= get_remote_state ();
12796 remote_get_noisy_reply ();
12797 if (strcmp (rs
->buf
.data (), "OK") != 0)
12798 error (_("Target does not support this command."));
12801 /* Recursive routine to walk through command list including loops, and
12802 download packets for each command. */
12805 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12806 struct command_line
*cmds
)
12808 struct remote_state
*rs
= get_remote_state ();
12809 struct command_line
*cmd
;
12811 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12813 QUIT
; /* Allow user to bail out with ^C. */
12814 strcpy (rs
->buf
.data (), "QTDPsrc:");
12815 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12816 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12817 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12819 remote_get_noisy_reply ();
12820 if (strcmp (rs
->buf
.data (), "OK"))
12821 warning (_("Target does not support source download."));
12823 if (cmd
->control_type
== while_control
12824 || cmd
->control_type
== while_stepping_control
)
12826 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12828 QUIT
; /* Allow user to bail out with ^C. */
12829 strcpy (rs
->buf
.data (), "QTDPsrc:");
12830 encode_source_string (num
, addr
, "cmd", "end",
12831 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12832 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12834 remote_get_noisy_reply ();
12835 if (strcmp (rs
->buf
.data (), "OK"))
12836 warning (_("Target does not support source download."));
12842 remote_target::download_tracepoint (struct bp_location
*loc
)
12846 std::vector
<std::string
> tdp_actions
;
12847 std::vector
<std::string
> stepping_actions
;
12849 struct breakpoint
*b
= loc
->owner
;
12850 struct tracepoint
*t
= (struct tracepoint
*) b
;
12851 struct remote_state
*rs
= get_remote_state ();
12853 const char *err_msg
= _("Tracepoint packet too large for target.");
12856 /* We use a buffer other than rs->buf because we'll build strings
12857 across multiple statements, and other statements in between could
12859 gdb::char_vector
buf (get_remote_packet_size ());
12861 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12863 tpaddr
= loc
->address
;
12864 strcpy (addrbuf
, phex (tpaddr
, sizeof (CORE_ADDR
)));
12865 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12866 b
->number
, addrbuf
, /* address */
12867 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12868 t
->step_count
, t
->pass_count
);
12870 if (ret
< 0 || ret
>= buf
.size ())
12871 error ("%s", err_msg
);
12873 /* Fast tracepoints are mostly handled by the target, but we can
12874 tell the target how big of an instruction block should be moved
12876 if (b
->type
== bp_fast_tracepoint
)
12878 /* Only test for support at download time; we may not know
12879 target capabilities at definition time. */
12880 if (remote_supports_fast_tracepoints ())
12882 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12885 size_left
= buf
.size () - strlen (buf
.data ());
12886 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12888 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12890 if (ret
< 0 || ret
>= size_left
)
12891 error ("%s", err_msg
);
12894 /* If it passed validation at definition but fails now,
12895 something is very wrong. */
12896 internal_error (__FILE__
, __LINE__
,
12897 _("Fast tracepoint not "
12898 "valid during download"));
12901 /* Fast tracepoints are functionally identical to regular
12902 tracepoints, so don't take lack of support as a reason to
12903 give up on the trace run. */
12904 warning (_("Target does not support fast tracepoints, "
12905 "downloading %d as regular tracepoint"), b
->number
);
12907 else if (b
->type
== bp_static_tracepoint
)
12909 /* Only test for support at download time; we may not know
12910 target capabilities at definition time. */
12911 if (remote_supports_static_tracepoints ())
12913 struct static_tracepoint_marker marker
;
12915 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12917 size_left
= buf
.size () - strlen (buf
.data ());
12918 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12921 if (ret
< 0 || ret
>= size_left
)
12922 error ("%s", err_msg
);
12925 error (_("Static tracepoint not valid during download"));
12928 /* Fast tracepoints are functionally identical to regular
12929 tracepoints, so don't take lack of support as a reason
12930 to give up on the trace run. */
12931 error (_("Target does not support static tracepoints"));
12933 /* If the tracepoint has a conditional, make it into an agent
12934 expression and append to the definition. */
12937 /* Only test support at download time, we may not know target
12938 capabilities at definition time. */
12939 if (remote_supports_cond_tracepoints ())
12941 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
12944 size_left
= buf
.size () - strlen (buf
.data ());
12946 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12947 size_left
, ":X%x,", aexpr
->len
);
12949 if (ret
< 0 || ret
>= size_left
)
12950 error ("%s", err_msg
);
12952 size_left
= buf
.size () - strlen (buf
.data ());
12954 /* Two bytes to encode each aexpr byte, plus the terminating
12956 if (aexpr
->len
* 2 + 1 > size_left
)
12957 error ("%s", err_msg
);
12959 pkt
= buf
.data () + strlen (buf
.data ());
12961 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12962 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12966 warning (_("Target does not support conditional tracepoints, "
12967 "ignoring tp %d cond"), b
->number
);
12970 if (b
->commands
|| *default_collect
)
12972 size_left
= buf
.size () - strlen (buf
.data ());
12974 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12977 if (ret
< 0 || ret
>= size_left
)
12978 error ("%s", err_msg
);
12981 putpkt (buf
.data ());
12982 remote_get_noisy_reply ();
12983 if (strcmp (rs
->buf
.data (), "OK"))
12984 error (_("Target does not support tracepoints."));
12986 /* do_single_steps (t); */
12987 for (auto action_it
= tdp_actions
.begin ();
12988 action_it
!= tdp_actions
.end (); action_it
++)
12990 QUIT
; /* Allow user to bail out with ^C. */
12992 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
12993 || !stepping_actions
.empty ());
12995 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
12996 b
->number
, addrbuf
, /* address */
12997 action_it
->c_str (),
12998 has_more
? '-' : 0);
13000 if (ret
< 0 || ret
>= buf
.size ())
13001 error ("%s", err_msg
);
13003 putpkt (buf
.data ());
13004 remote_get_noisy_reply ();
13005 if (strcmp (rs
->buf
.data (), "OK"))
13006 error (_("Error on target while setting tracepoints."));
13009 for (auto action_it
= stepping_actions
.begin ();
13010 action_it
!= stepping_actions
.end (); action_it
++)
13012 QUIT
; /* Allow user to bail out with ^C. */
13014 bool is_first
= action_it
== stepping_actions
.begin ();
13015 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
13017 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
13018 b
->number
, addrbuf
, /* address */
13019 is_first
? "S" : "",
13020 action_it
->c_str (),
13021 has_more
? "-" : "");
13023 if (ret
< 0 || ret
>= buf
.size ())
13024 error ("%s", err_msg
);
13026 putpkt (buf
.data ());
13027 remote_get_noisy_reply ();
13028 if (strcmp (rs
->buf
.data (), "OK"))
13029 error (_("Error on target while setting tracepoints."));
13032 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
13034 if (b
->location
!= NULL
)
13036 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13038 if (ret
< 0 || ret
>= buf
.size ())
13039 error ("%s", err_msg
);
13041 encode_source_string (b
->number
, loc
->address
, "at",
13042 event_location_to_string (b
->location
.get ()),
13043 buf
.data () + strlen (buf
.data ()),
13044 buf
.size () - strlen (buf
.data ()));
13045 putpkt (buf
.data ());
13046 remote_get_noisy_reply ();
13047 if (strcmp (rs
->buf
.data (), "OK"))
13048 warning (_("Target does not support source download."));
13050 if (b
->cond_string
)
13052 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13054 if (ret
< 0 || ret
>= buf
.size ())
13055 error ("%s", err_msg
);
13057 encode_source_string (b
->number
, loc
->address
,
13058 "cond", b
->cond_string
,
13059 buf
.data () + strlen (buf
.data ()),
13060 buf
.size () - strlen (buf
.data ()));
13061 putpkt (buf
.data ());
13062 remote_get_noisy_reply ();
13063 if (strcmp (rs
->buf
.data (), "OK"))
13064 warning (_("Target does not support source download."));
13066 remote_download_command_source (b
->number
, loc
->address
,
13067 breakpoint_commands (b
));
13072 remote_target::can_download_tracepoint ()
13074 struct remote_state
*rs
= get_remote_state ();
13075 struct trace_status
*ts
;
13078 /* Don't try to install tracepoints until we've relocated our
13079 symbols, and fetched and merged the target's tracepoint list with
13081 if (rs
->starting_up
)
13084 ts
= current_trace_status ();
13085 status
= get_trace_status (ts
);
13087 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
13090 /* If we are in a tracing experiment, but remote stub doesn't support
13091 installing tracepoint in trace, we have to return. */
13092 if (!remote_supports_install_in_trace ())
13100 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
13102 struct remote_state
*rs
= get_remote_state ();
13105 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13106 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13108 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13109 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13110 >= get_remote_packet_size ())
13111 error (_("Trace state variable name too long for tsv definition packet"));
13112 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13115 remote_get_noisy_reply ();
13116 if (rs
->buf
[0] == '\0')
13117 error (_("Target does not support this command."));
13118 if (strcmp (rs
->buf
.data (), "OK") != 0)
13119 error (_("Error on target while downloading trace state variable."));
13123 remote_target::enable_tracepoint (struct bp_location
*location
)
13125 struct remote_state
*rs
= get_remote_state ();
13127 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13128 location
->owner
->number
,
13129 phex (location
->address
, sizeof (CORE_ADDR
)));
13131 remote_get_noisy_reply ();
13132 if (rs
->buf
[0] == '\0')
13133 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13134 if (strcmp (rs
->buf
.data (), "OK") != 0)
13135 error (_("Error on target while enabling tracepoint."));
13139 remote_target::disable_tracepoint (struct bp_location
*location
)
13141 struct remote_state
*rs
= get_remote_state ();
13143 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13144 location
->owner
->number
,
13145 phex (location
->address
, sizeof (CORE_ADDR
)));
13147 remote_get_noisy_reply ();
13148 if (rs
->buf
[0] == '\0')
13149 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13150 if (strcmp (rs
->buf
.data (), "OK") != 0)
13151 error (_("Error on target while disabling tracepoint."));
13155 remote_target::trace_set_readonly_regions ()
13158 bfd_size_type size
;
13164 return; /* No information to give. */
13166 struct remote_state
*rs
= get_remote_state ();
13168 strcpy (rs
->buf
.data (), "QTro");
13169 offset
= strlen (rs
->buf
.data ());
13170 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
13172 char tmp1
[40], tmp2
[40];
13175 if ((s
->flags
& SEC_LOAD
) == 0 ||
13176 /* (s->flags & SEC_CODE) == 0 || */
13177 (s
->flags
& SEC_READONLY
) == 0)
13181 vma
= bfd_section_vma (s
);
13182 size
= bfd_section_size (s
);
13183 sprintf_vma (tmp1
, vma
);
13184 sprintf_vma (tmp2
, vma
+ size
);
13185 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13186 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13188 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13190 Too many sections for read-only sections definition packet."));
13193 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13195 offset
+= sec_length
;
13200 getpkt (&rs
->buf
, 0);
13205 remote_target::trace_start ()
13207 struct remote_state
*rs
= get_remote_state ();
13209 putpkt ("QTStart");
13210 remote_get_noisy_reply ();
13211 if (rs
->buf
[0] == '\0')
13212 error (_("Target does not support this command."));
13213 if (strcmp (rs
->buf
.data (), "OK") != 0)
13214 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13218 remote_target::get_trace_status (struct trace_status
*ts
)
13220 /* Initialize it just to avoid a GCC false warning. */
13222 enum packet_result result
;
13223 struct remote_state
*rs
= get_remote_state ();
13225 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13228 /* FIXME we need to get register block size some other way. */
13229 trace_regblock_size
13230 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13232 putpkt ("qTStatus");
13236 p
= remote_get_noisy_reply ();
13238 catch (const gdb_exception_error
&ex
)
13240 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13242 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13248 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13250 /* If the remote target doesn't do tracing, flag it. */
13251 if (result
== PACKET_UNKNOWN
)
13254 /* We're working with a live target. */
13255 ts
->filename
= NULL
;
13258 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13260 /* Function 'parse_trace_status' sets default value of each field of
13261 'ts' at first, so we don't have to do it here. */
13262 parse_trace_status (p
, ts
);
13264 return ts
->running
;
13268 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13269 struct uploaded_tp
*utp
)
13271 struct remote_state
*rs
= get_remote_state ();
13273 struct bp_location
*loc
;
13274 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13275 size_t size
= get_remote_packet_size ();
13280 tp
->traceframe_usage
= 0;
13281 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13283 /* If the tracepoint was never downloaded, don't go asking for
13285 if (tp
->number_on_target
== 0)
13287 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13288 phex_nz (loc
->address
, 0));
13290 reply
= remote_get_noisy_reply ();
13291 if (reply
&& *reply
)
13294 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13300 utp
->hit_count
= 0;
13301 utp
->traceframe_usage
= 0;
13302 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13303 phex_nz (utp
->addr
, 0));
13305 reply
= remote_get_noisy_reply ();
13306 if (reply
&& *reply
)
13309 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13315 remote_target::trace_stop ()
13317 struct remote_state
*rs
= get_remote_state ();
13320 remote_get_noisy_reply ();
13321 if (rs
->buf
[0] == '\0')
13322 error (_("Target does not support this command."));
13323 if (strcmp (rs
->buf
.data (), "OK") != 0)
13324 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13328 remote_target::trace_find (enum trace_find_type type
, int num
,
13329 CORE_ADDR addr1
, CORE_ADDR addr2
,
13332 struct remote_state
*rs
= get_remote_state ();
13333 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13335 int target_frameno
= -1, target_tracept
= -1;
13337 /* Lookups other than by absolute frame number depend on the current
13338 trace selected, so make sure it is correct on the remote end
13340 if (type
!= tfind_number
)
13341 set_remote_traceframe ();
13343 p
= rs
->buf
.data ();
13344 strcpy (p
, "QTFrame:");
13345 p
= strchr (p
, '\0');
13349 xsnprintf (p
, endbuf
- p
, "%x", num
);
13352 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13355 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13358 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13359 phex_nz (addr2
, 0));
13361 case tfind_outside
:
13362 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13363 phex_nz (addr2
, 0));
13366 error (_("Unknown trace find type %d"), type
);
13370 reply
= remote_get_noisy_reply ();
13371 if (*reply
== '\0')
13372 error (_("Target does not support this command."));
13374 while (reply
&& *reply
)
13379 target_frameno
= (int) strtol (p
, &reply
, 16);
13381 error (_("Unable to parse trace frame number"));
13382 /* Don't update our remote traceframe number cache on failure
13383 to select a remote traceframe. */
13384 if (target_frameno
== -1)
13389 target_tracept
= (int) strtol (p
, &reply
, 16);
13391 error (_("Unable to parse tracepoint number"));
13393 case 'O': /* "OK"? */
13394 if (reply
[1] == 'K' && reply
[2] == '\0')
13397 error (_("Bogus reply from target: %s"), reply
);
13400 error (_("Bogus reply from target: %s"), reply
);
13403 *tpp
= target_tracept
;
13405 rs
->remote_traceframe_number
= target_frameno
;
13406 return target_frameno
;
13410 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13412 struct remote_state
*rs
= get_remote_state ();
13416 set_remote_traceframe ();
13418 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13420 reply
= remote_get_noisy_reply ();
13421 if (reply
&& *reply
)
13425 unpack_varlen_hex (reply
+ 1, &uval
);
13426 *val
= (LONGEST
) uval
;
13434 remote_target::save_trace_data (const char *filename
)
13436 struct remote_state
*rs
= get_remote_state ();
13439 p
= rs
->buf
.data ();
13440 strcpy (p
, "QTSave:");
13442 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13443 >= get_remote_packet_size ())
13444 error (_("Remote file name too long for trace save packet"));
13445 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13448 reply
= remote_get_noisy_reply ();
13449 if (*reply
== '\0')
13450 error (_("Target does not support this command."));
13451 if (strcmp (reply
, "OK") != 0)
13452 error (_("Bogus reply from target: %s"), reply
);
13456 /* This is basically a memory transfer, but needs to be its own packet
13457 because we don't know how the target actually organizes its trace
13458 memory, plus we want to be able to ask for as much as possible, but
13459 not be unhappy if we don't get as much as we ask for. */
13462 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13464 struct remote_state
*rs
= get_remote_state ();
13469 p
= rs
->buf
.data ();
13470 strcpy (p
, "qTBuffer:");
13472 p
+= hexnumstr (p
, offset
);
13474 p
+= hexnumstr (p
, len
);
13478 reply
= remote_get_noisy_reply ();
13479 if (reply
&& *reply
)
13481 /* 'l' by itself means we're at the end of the buffer and
13482 there is nothing more to get. */
13486 /* Convert the reply into binary. Limit the number of bytes to
13487 convert according to our passed-in buffer size, rather than
13488 what was returned in the packet; if the target is
13489 unexpectedly generous and gives us a bigger reply than we
13490 asked for, we don't want to crash. */
13491 rslt
= hex2bin (reply
, buf
, len
);
13495 /* Something went wrong, flag as an error. */
13500 remote_target::set_disconnected_tracing (int val
)
13502 struct remote_state
*rs
= get_remote_state ();
13504 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13508 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13509 "QTDisconnected:%x", val
);
13511 reply
= remote_get_noisy_reply ();
13512 if (*reply
== '\0')
13513 error (_("Target does not support this command."));
13514 if (strcmp (reply
, "OK") != 0)
13515 error (_("Bogus reply from target: %s"), reply
);
13518 warning (_("Target does not support disconnected tracing."));
13522 remote_target::core_of_thread (ptid_t ptid
)
13524 thread_info
*info
= find_thread_ptid (this, ptid
);
13526 if (info
!= NULL
&& info
->priv
!= NULL
)
13527 return get_remote_thread_info (info
)->core
;
13533 remote_target::set_circular_trace_buffer (int val
)
13535 struct remote_state
*rs
= get_remote_state ();
13538 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13539 "QTBuffer:circular:%x", val
);
13541 reply
= remote_get_noisy_reply ();
13542 if (*reply
== '\0')
13543 error (_("Target does not support this command."));
13544 if (strcmp (reply
, "OK") != 0)
13545 error (_("Bogus reply from target: %s"), reply
);
13549 remote_target::traceframe_info ()
13551 gdb::optional
<gdb::char_vector
> text
13552 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13555 return parse_traceframe_info (text
->data ());
13560 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13561 instruction on which a fast tracepoint may be placed. Returns -1
13562 if the packet is not supported, and 0 if the minimum instruction
13563 length is unknown. */
13566 remote_target::get_min_fast_tracepoint_insn_len ()
13568 struct remote_state
*rs
= get_remote_state ();
13571 /* If we're not debugging a process yet, the IPA can't be
13573 if (!target_has_execution
)
13576 /* Make sure the remote is pointing at the right process. */
13577 set_general_process ();
13579 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13581 reply
= remote_get_noisy_reply ();
13582 if (*reply
== '\0')
13586 ULONGEST min_insn_len
;
13588 unpack_varlen_hex (reply
, &min_insn_len
);
13590 return (int) min_insn_len
;
13595 remote_target::set_trace_buffer_size (LONGEST val
)
13597 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13599 struct remote_state
*rs
= get_remote_state ();
13600 char *buf
= rs
->buf
.data ();
13601 char *endbuf
= buf
+ get_remote_packet_size ();
13602 enum packet_result result
;
13604 gdb_assert (val
>= 0 || val
== -1);
13605 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13606 /* Send -1 as literal "-1" to avoid host size dependency. */
13610 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13613 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13616 remote_get_noisy_reply ();
13617 result
= packet_ok (rs
->buf
,
13618 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13620 if (result
!= PACKET_OK
)
13621 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13626 remote_target::set_trace_notes (const char *user
, const char *notes
,
13627 const char *stop_notes
)
13629 struct remote_state
*rs
= get_remote_state ();
13631 char *buf
= rs
->buf
.data ();
13632 char *endbuf
= buf
+ get_remote_packet_size ();
13635 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13638 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13639 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13645 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13646 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13652 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13653 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13657 /* Ensure the buffer is terminated. */
13661 reply
= remote_get_noisy_reply ();
13662 if (*reply
== '\0')
13665 if (strcmp (reply
, "OK") != 0)
13666 error (_("Bogus reply from target: %s"), reply
);
13672 remote_target::use_agent (bool use
)
13674 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13676 struct remote_state
*rs
= get_remote_state ();
13678 /* If the stub supports QAgent. */
13679 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13681 getpkt (&rs
->buf
, 0);
13683 if (strcmp (rs
->buf
.data (), "OK") == 0)
13694 remote_target::can_use_agent ()
13696 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13699 struct btrace_target_info
13701 /* The ptid of the traced thread. */
13704 /* The obtained branch trace configuration. */
13705 struct btrace_config conf
;
13708 /* Reset our idea of our target's btrace configuration. */
13711 remote_btrace_reset (remote_state
*rs
)
13713 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13716 /* Synchronize the configuration with the target. */
13719 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13721 struct packet_config
*packet
;
13722 struct remote_state
*rs
;
13723 char *buf
, *pos
, *endbuf
;
13725 rs
= get_remote_state ();
13726 buf
= rs
->buf
.data ();
13727 endbuf
= buf
+ get_remote_packet_size ();
13729 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13730 if (packet_config_support (packet
) == PACKET_ENABLE
13731 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13734 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13738 getpkt (&rs
->buf
, 0);
13740 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13742 if (buf
[0] == 'E' && buf
[1] == '.')
13743 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13745 error (_("Failed to configure the BTS buffer size."));
13748 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13751 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13752 if (packet_config_support (packet
) == PACKET_ENABLE
13753 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13756 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13760 getpkt (&rs
->buf
, 0);
13762 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13764 if (buf
[0] == 'E' && buf
[1] == '.')
13765 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13767 error (_("Failed to configure the trace buffer size."));
13770 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13774 /* Read the current thread's btrace configuration from the target and
13775 store it into CONF. */
13778 btrace_read_config (struct btrace_config
*conf
)
13780 gdb::optional
<gdb::char_vector
> xml
13781 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13783 parse_xml_btrace_conf (conf
, xml
->data ());
13786 /* Maybe reopen target btrace. */
13789 remote_target::remote_btrace_maybe_reopen ()
13791 struct remote_state
*rs
= get_remote_state ();
13792 int btrace_target_pushed
= 0;
13793 #if !defined (HAVE_LIBIPT)
13797 /* Don't bother walking the entirety of the remote thread list when
13798 we know the feature isn't supported by the remote. */
13799 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13802 scoped_restore_current_thread restore_thread
;
13804 for (thread_info
*tp
: all_non_exited_threads (this))
13806 set_general_thread (tp
->ptid
);
13808 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13809 btrace_read_config (&rs
->btrace_config
);
13811 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13814 #if !defined (HAVE_LIBIPT)
13815 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13820 warning (_("Target is recording using Intel Processor Trace "
13821 "but support was disabled at compile time."));
13826 #endif /* !defined (HAVE_LIBIPT) */
13828 /* Push target, once, but before anything else happens. This way our
13829 changes to the threads will be cleaned up by unpushing the target
13830 in case btrace_read_config () throws. */
13831 if (!btrace_target_pushed
)
13833 btrace_target_pushed
= 1;
13834 record_btrace_push_target ();
13835 printf_filtered (_("Target is recording using %s.\n"),
13836 btrace_format_string (rs
->btrace_config
.format
));
13839 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13840 tp
->btrace
.target
->ptid
= tp
->ptid
;
13841 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13845 /* Enable branch tracing. */
13847 struct btrace_target_info
*
13848 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13850 struct btrace_target_info
*tinfo
= NULL
;
13851 struct packet_config
*packet
= NULL
;
13852 struct remote_state
*rs
= get_remote_state ();
13853 char *buf
= rs
->buf
.data ();
13854 char *endbuf
= buf
+ get_remote_packet_size ();
13856 switch (conf
->format
)
13858 case BTRACE_FORMAT_BTS
:
13859 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13862 case BTRACE_FORMAT_PT
:
13863 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13867 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13868 error (_("Target does not support branch tracing."));
13870 btrace_sync_conf (conf
);
13872 set_general_thread (ptid
);
13874 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13876 getpkt (&rs
->buf
, 0);
13878 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13880 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13881 error (_("Could not enable branch tracing for %s: %s"),
13882 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
13884 error (_("Could not enable branch tracing for %s."),
13885 target_pid_to_str (ptid
).c_str ());
13888 tinfo
= XCNEW (struct btrace_target_info
);
13889 tinfo
->ptid
= ptid
;
13891 /* If we fail to read the configuration, we lose some information, but the
13892 tracing itself is not impacted. */
13895 btrace_read_config (&tinfo
->conf
);
13897 catch (const gdb_exception_error
&err
)
13899 if (err
.message
!= NULL
)
13900 warning ("%s", err
.what ());
13906 /* Disable branch tracing. */
13909 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
13911 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13912 struct remote_state
*rs
= get_remote_state ();
13913 char *buf
= rs
->buf
.data ();
13914 char *endbuf
= buf
+ get_remote_packet_size ();
13916 if (packet_config_support (packet
) != PACKET_ENABLE
)
13917 error (_("Target does not support branch tracing."));
13919 set_general_thread (tinfo
->ptid
);
13921 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13923 getpkt (&rs
->buf
, 0);
13925 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13927 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13928 error (_("Could not disable branch tracing for %s: %s"),
13929 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
13931 error (_("Could not disable branch tracing for %s."),
13932 target_pid_to_str (tinfo
->ptid
).c_str ());
13938 /* Teardown branch tracing. */
13941 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
13943 /* We must not talk to the target during teardown. */
13947 /* Read the branch trace. */
13950 remote_target::read_btrace (struct btrace_data
*btrace
,
13951 struct btrace_target_info
*tinfo
,
13952 enum btrace_read_type type
)
13954 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13957 if (packet_config_support (packet
) != PACKET_ENABLE
)
13958 error (_("Target does not support branch tracing."));
13960 #if !defined(HAVE_LIBEXPAT)
13961 error (_("Cannot process branch tracing result. XML parsing not supported."));
13966 case BTRACE_READ_ALL
:
13969 case BTRACE_READ_NEW
:
13972 case BTRACE_READ_DELTA
:
13976 internal_error (__FILE__
, __LINE__
,
13977 _("Bad branch tracing read type: %u."),
13978 (unsigned int) type
);
13981 gdb::optional
<gdb::char_vector
> xml
13982 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
13984 return BTRACE_ERR_UNKNOWN
;
13986 parse_xml_btrace (btrace
, xml
->data ());
13988 return BTRACE_ERR_NONE
;
13991 const struct btrace_config
*
13992 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
13994 return &tinfo
->conf
;
13998 remote_target::augmented_libraries_svr4_read ()
14000 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
14004 /* Implementation of to_load. */
14007 remote_target::load (const char *name
, int from_tty
)
14009 generic_load (name
, from_tty
);
14012 /* Accepts an integer PID; returns a string representing a file that
14013 can be opened on the remote side to get the symbols for the child
14014 process. Returns NULL if the operation is not supported. */
14017 remote_target::pid_to_exec_file (int pid
)
14019 static gdb::optional
<gdb::char_vector
> filename
;
14020 char *annex
= NULL
;
14022 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
14025 inferior
*inf
= find_inferior_pid (this, pid
);
14027 internal_error (__FILE__
, __LINE__
,
14028 _("not currently attached to process %d"), pid
);
14030 if (!inf
->fake_pid_p
)
14032 const int annex_size
= 9;
14034 annex
= (char *) alloca (annex_size
);
14035 xsnprintf (annex
, annex_size
, "%x", pid
);
14038 filename
= target_read_stralloc (current_top_target (),
14039 TARGET_OBJECT_EXEC_FILE
, annex
);
14041 return filename
? filename
->data () : nullptr;
14044 /* Implement the to_can_do_single_step target_ops method. */
14047 remote_target::can_do_single_step ()
14049 /* We can only tell whether target supports single step or not by
14050 supported s and S vCont actions if the stub supports vContSupported
14051 feature. If the stub doesn't support vContSupported feature,
14052 we have conservatively to think target doesn't supports single
14054 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
14056 struct remote_state
*rs
= get_remote_state ();
14058 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14059 remote_vcont_probe ();
14061 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
14067 /* Implementation of the to_execution_direction method for the remote
14070 enum exec_direction_kind
14071 remote_target::execution_direction ()
14073 struct remote_state
*rs
= get_remote_state ();
14075 return rs
->last_resume_exec_dir
;
14078 /* Return pointer to the thread_info struct which corresponds to
14079 THREAD_HANDLE (having length HANDLE_LEN). */
14082 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
14086 for (thread_info
*tp
: all_non_exited_threads (this))
14088 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14090 if (tp
->inf
== inf
&& priv
!= NULL
)
14092 if (handle_len
!= priv
->thread_handle
.size ())
14093 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14094 handle_len
, priv
->thread_handle
.size ());
14095 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14105 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
14107 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14108 return priv
->thread_handle
;
14112 remote_target::can_async_p ()
14114 struct remote_state
*rs
= get_remote_state ();
14116 /* We don't go async if the user has explicitly prevented it with the
14117 "maint set target-async" command. */
14118 if (!target_async_permitted
)
14121 /* We're async whenever the serial device is. */
14122 return serial_can_async_p (rs
->remote_desc
);
14126 remote_target::is_async_p ()
14128 struct remote_state
*rs
= get_remote_state ();
14130 if (!target_async_permitted
)
14131 /* We only enable async when the user specifically asks for it. */
14134 /* We're async whenever the serial device is. */
14135 return serial_is_async_p (rs
->remote_desc
);
14138 /* Pass the SERIAL event on and up to the client. One day this code
14139 will be able to delay notifying the client of an event until the
14140 point where an entire packet has been received. */
14142 static serial_event_ftype remote_async_serial_handler
;
14145 remote_async_serial_handler (struct serial
*scb
, void *context
)
14147 /* Don't propogate error information up to the client. Instead let
14148 the client find out about the error by querying the target. */
14149 inferior_event_handler (INF_REG_EVENT
, NULL
);
14153 remote_async_inferior_event_handler (gdb_client_data data
)
14155 inferior_event_handler (INF_REG_EVENT
, data
);
14159 remote_target::async_wait_fd ()
14161 struct remote_state
*rs
= get_remote_state ();
14162 return rs
->remote_desc
->fd
;
14166 remote_target::async (int enable
)
14168 struct remote_state
*rs
= get_remote_state ();
14172 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14174 /* If there are pending events in the stop reply queue tell the
14175 event loop to process them. */
14176 if (!rs
->stop_reply_queue
.empty ())
14177 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14178 /* For simplicity, below we clear the pending events token
14179 without remembering whether it is marked, so here we always
14180 mark it. If there's actually no pending notification to
14181 process, this ends up being a no-op (other than a spurious
14182 event-loop wakeup). */
14183 if (target_is_non_stop_p ())
14184 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14188 serial_async (rs
->remote_desc
, NULL
, NULL
);
14189 /* If the core is disabling async, it doesn't want to be
14190 disturbed with target events. Clear all async event sources
14192 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14193 if (target_is_non_stop_p ())
14194 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14198 /* Implementation of the to_thread_events method. */
14201 remote_target::thread_events (int enable
)
14203 struct remote_state
*rs
= get_remote_state ();
14204 size_t size
= get_remote_packet_size ();
14206 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14209 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14211 getpkt (&rs
->buf
, 0);
14213 switch (packet_ok (rs
->buf
,
14214 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14217 if (strcmp (rs
->buf
.data (), "OK") != 0)
14218 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14221 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14223 case PACKET_UNKNOWN
:
14229 set_remote_cmd (const char *args
, int from_tty
)
14231 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
14235 show_remote_cmd (const char *args
, int from_tty
)
14237 /* We can't just use cmd_show_list here, because we want to skip
14238 the redundant "show remote Z-packet" and the legacy aliases. */
14239 struct cmd_list_element
*list
= remote_show_cmdlist
;
14240 struct ui_out
*uiout
= current_uiout
;
14242 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14243 for (; list
!= NULL
; list
= list
->next
)
14244 if (strcmp (list
->name
, "Z-packet") == 0)
14246 else if (list
->type
== not_set_cmd
)
14247 /* Alias commands are exactly like the original, except they
14248 don't have the normal type. */
14252 ui_out_emit_tuple
option_emitter (uiout
, "option");
14254 uiout
->field_string ("name", list
->name
);
14255 uiout
->text (": ");
14256 if (list
->type
== show_cmd
)
14257 do_show_command (NULL
, from_tty
, list
);
14259 cmd_func (list
, NULL
, from_tty
);
14264 /* Function to be called whenever a new objfile (shlib) is detected. */
14266 remote_new_objfile (struct objfile
*objfile
)
14268 remote_target
*remote
= get_current_remote_target ();
14270 if (remote
!= NULL
) /* Have a remote connection. */
14271 remote
->remote_check_symbols ();
14274 /* Pull all the tracepoints defined on the target and create local
14275 data structures representing them. We don't want to create real
14276 tracepoints yet, we don't want to mess up the user's existing
14280 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14282 struct remote_state
*rs
= get_remote_state ();
14285 /* Ask for a first packet of tracepoint definition. */
14287 getpkt (&rs
->buf
, 0);
14288 p
= rs
->buf
.data ();
14289 while (*p
&& *p
!= 'l')
14291 parse_tracepoint_definition (p
, utpp
);
14292 /* Ask for another packet of tracepoint definition. */
14294 getpkt (&rs
->buf
, 0);
14295 p
= rs
->buf
.data ();
14301 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14303 struct remote_state
*rs
= get_remote_state ();
14306 /* Ask for a first packet of variable definition. */
14308 getpkt (&rs
->buf
, 0);
14309 p
= rs
->buf
.data ();
14310 while (*p
&& *p
!= 'l')
14312 parse_tsv_definition (p
, utsvp
);
14313 /* Ask for another packet of variable definition. */
14315 getpkt (&rs
->buf
, 0);
14316 p
= rs
->buf
.data ();
14321 /* The "set/show range-stepping" show hook. */
14324 show_range_stepping (struct ui_file
*file
, int from_tty
,
14325 struct cmd_list_element
*c
,
14328 fprintf_filtered (file
,
14329 _("Debugger's willingness to use range stepping "
14330 "is %s.\n"), value
);
14333 /* Return true if the vCont;r action is supported by the remote
14337 remote_target::vcont_r_supported ()
14339 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14340 remote_vcont_probe ();
14342 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14343 && get_remote_state ()->supports_vCont
.r
);
14346 /* The "set/show range-stepping" set hook. */
14349 set_range_stepping (const char *ignore_args
, int from_tty
,
14350 struct cmd_list_element
*c
)
14352 /* When enabling, check whether range stepping is actually supported
14353 by the target, and warn if not. */
14354 if (use_range_stepping
)
14356 remote_target
*remote
= get_current_remote_target ();
14358 || !remote
->vcont_r_supported ())
14359 warning (_("Range stepping is not supported by the current target"));
14363 void _initialize_remote ();
14365 _initialize_remote ()
14367 struct cmd_list_element
*cmd
;
14368 const char *cmd_name
;
14370 /* architecture specific data */
14371 remote_g_packet_data_handle
=
14372 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14374 add_target (remote_target_info
, remote_target::open
);
14375 add_target (extended_remote_target_info
, extended_remote_target::open
);
14377 /* Hook into new objfile notification. */
14378 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14381 init_remote_threadtests ();
14384 /* set/show remote ... */
14386 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14387 Remote protocol specific variables.\n\
14388 Configure various remote-protocol specific variables such as\n\
14389 the packets being used."),
14390 &remote_set_cmdlist
, "set remote ",
14391 0 /* allow-unknown */, &setlist
);
14392 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14393 Remote protocol specific variables.\n\
14394 Configure various remote-protocol specific variables such as\n\
14395 the packets being used."),
14396 &remote_show_cmdlist
, "show remote ",
14397 0 /* allow-unknown */, &showlist
);
14399 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14400 Compare section data on target to the exec file.\n\
14401 Argument is a single section name (default: all loaded sections).\n\
14402 To compare only read-only loaded sections, specify the -r option."),
14405 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14406 Send an arbitrary packet to a remote target.\n\
14407 maintenance packet TEXT\n\
14408 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14409 this command sends the string TEXT to the inferior, and displays the\n\
14410 response packet. GDB supplies the initial `$' character, and the\n\
14411 terminating `#' character and checksum."),
14414 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14415 Set whether to send break if interrupted."), _("\
14416 Show whether to send break if interrupted."), _("\
14417 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14418 set_remotebreak
, show_remotebreak
,
14419 &setlist
, &showlist
);
14420 cmd_name
= "remotebreak";
14421 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14422 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14423 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14424 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14425 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14427 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14428 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14430 Set interrupt sequence to remote target."), _("\
14431 Show interrupt sequence to remote target."), _("\
14432 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14433 NULL
, show_interrupt_sequence
,
14434 &remote_set_cmdlist
,
14435 &remote_show_cmdlist
);
14437 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14438 &interrupt_on_connect
, _("\
14439 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14440 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14441 If set, interrupt sequence is sent to remote target."),
14443 &remote_set_cmdlist
, &remote_show_cmdlist
);
14445 /* Install commands for configuring memory read/write packets. */
14447 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14448 Set the maximum number of bytes per memory write packet (deprecated)."),
14450 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14451 Show the maximum number of bytes per memory write packet (deprecated)."),
14453 add_cmd ("memory-write-packet-size", no_class
,
14454 set_memory_write_packet_size
, _("\
14455 Set the maximum number of bytes per memory-write packet.\n\
14456 Specify the number of bytes in a packet or 0 (zero) for the\n\
14457 default packet size. The actual limit is further reduced\n\
14458 dependent on the target. Specify ``fixed'' to disable the\n\
14459 further restriction and ``limit'' to enable that restriction."),
14460 &remote_set_cmdlist
);
14461 add_cmd ("memory-read-packet-size", no_class
,
14462 set_memory_read_packet_size
, _("\
14463 Set the maximum number of bytes per memory-read packet.\n\
14464 Specify the number of bytes in a packet or 0 (zero) for the\n\
14465 default packet size. The actual limit is further reduced\n\
14466 dependent on the target. Specify ``fixed'' to disable the\n\
14467 further restriction and ``limit'' to enable that restriction."),
14468 &remote_set_cmdlist
);
14469 add_cmd ("memory-write-packet-size", no_class
,
14470 show_memory_write_packet_size
,
14471 _("Show the maximum number of bytes per memory-write packet."),
14472 &remote_show_cmdlist
);
14473 add_cmd ("memory-read-packet-size", no_class
,
14474 show_memory_read_packet_size
,
14475 _("Show the maximum number of bytes per memory-read packet."),
14476 &remote_show_cmdlist
);
14478 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14479 &remote_hw_watchpoint_limit
, _("\
14480 Set the maximum number of target hardware watchpoints."), _("\
14481 Show the maximum number of target hardware watchpoints."), _("\
14482 Specify \"unlimited\" for unlimited hardware watchpoints."),
14483 NULL
, show_hardware_watchpoint_limit
,
14484 &remote_set_cmdlist
,
14485 &remote_show_cmdlist
);
14486 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14488 &remote_hw_watchpoint_length_limit
, _("\
14489 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14490 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14491 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14492 NULL
, show_hardware_watchpoint_length_limit
,
14493 &remote_set_cmdlist
, &remote_show_cmdlist
);
14494 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14495 &remote_hw_breakpoint_limit
, _("\
14496 Set the maximum number of target hardware breakpoints."), _("\
14497 Show the maximum number of target hardware breakpoints."), _("\
14498 Specify \"unlimited\" for unlimited hardware breakpoints."),
14499 NULL
, show_hardware_breakpoint_limit
,
14500 &remote_set_cmdlist
, &remote_show_cmdlist
);
14502 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14503 &remote_address_size
, _("\
14504 Set the maximum size of the address (in bits) in a memory packet."), _("\
14505 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14507 NULL
, /* FIXME: i18n: */
14508 &setlist
, &showlist
);
14510 init_all_packet_configs ();
14512 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14513 "X", "binary-download", 1);
14515 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14516 "vCont", "verbose-resume", 0);
14518 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14519 "QPassSignals", "pass-signals", 0);
14521 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14522 "QCatchSyscalls", "catch-syscalls", 0);
14524 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14525 "QProgramSignals", "program-signals", 0);
14527 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14528 "QSetWorkingDir", "set-working-dir", 0);
14530 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14531 "QStartupWithShell", "startup-with-shell", 0);
14533 add_packet_config_cmd (&remote_protocol_packets
14534 [PACKET_QEnvironmentHexEncoded
],
14535 "QEnvironmentHexEncoded", "environment-hex-encoded",
14538 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14539 "QEnvironmentReset", "environment-reset",
14542 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14543 "QEnvironmentUnset", "environment-unset",
14546 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14547 "qSymbol", "symbol-lookup", 0);
14549 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14550 "P", "set-register", 1);
14552 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14553 "p", "fetch-register", 1);
14555 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14556 "Z0", "software-breakpoint", 0);
14558 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14559 "Z1", "hardware-breakpoint", 0);
14561 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14562 "Z2", "write-watchpoint", 0);
14564 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14565 "Z3", "read-watchpoint", 0);
14567 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14568 "Z4", "access-watchpoint", 0);
14570 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14571 "qXfer:auxv:read", "read-aux-vector", 0);
14573 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14574 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14576 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14577 "qXfer:features:read", "target-features", 0);
14579 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14580 "qXfer:libraries:read", "library-info", 0);
14582 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14583 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14585 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14586 "qXfer:memory-map:read", "memory-map", 0);
14588 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14589 "qXfer:osdata:read", "osdata", 0);
14591 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14592 "qXfer:threads:read", "threads", 0);
14594 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14595 "qXfer:siginfo:read", "read-siginfo-object", 0);
14597 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14598 "qXfer:siginfo:write", "write-siginfo-object", 0);
14600 add_packet_config_cmd
14601 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14602 "qXfer:traceframe-info:read", "traceframe-info", 0);
14604 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14605 "qXfer:uib:read", "unwind-info-block", 0);
14607 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14608 "qGetTLSAddr", "get-thread-local-storage-address",
14611 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14612 "qGetTIBAddr", "get-thread-information-block-address",
14615 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14616 "bc", "reverse-continue", 0);
14618 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14619 "bs", "reverse-step", 0);
14621 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14622 "qSupported", "supported-packets", 0);
14624 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14625 "qSearch:memory", "search-memory", 0);
14627 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14628 "qTStatus", "trace-status", 0);
14630 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14631 "vFile:setfs", "hostio-setfs", 0);
14633 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14634 "vFile:open", "hostio-open", 0);
14636 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14637 "vFile:pread", "hostio-pread", 0);
14639 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14640 "vFile:pwrite", "hostio-pwrite", 0);
14642 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14643 "vFile:close", "hostio-close", 0);
14645 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14646 "vFile:unlink", "hostio-unlink", 0);
14648 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14649 "vFile:readlink", "hostio-readlink", 0);
14651 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14652 "vFile:fstat", "hostio-fstat", 0);
14654 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14655 "vAttach", "attach", 0);
14657 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14660 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14661 "QStartNoAckMode", "noack", 0);
14663 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14664 "vKill", "kill", 0);
14666 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14667 "qAttached", "query-attached", 0);
14669 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14670 "ConditionalTracepoints",
14671 "conditional-tracepoints", 0);
14673 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14674 "ConditionalBreakpoints",
14675 "conditional-breakpoints", 0);
14677 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14678 "BreakpointCommands",
14679 "breakpoint-commands", 0);
14681 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14682 "FastTracepoints", "fast-tracepoints", 0);
14684 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14685 "TracepointSource", "TracepointSource", 0);
14687 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14688 "QAllow", "allow", 0);
14690 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14691 "StaticTracepoints", "static-tracepoints", 0);
14693 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14694 "InstallInTrace", "install-in-trace", 0);
14696 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14697 "qXfer:statictrace:read", "read-sdata-object", 0);
14699 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14700 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14702 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14703 "QDisableRandomization", "disable-randomization", 0);
14705 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14706 "QAgent", "agent", 0);
14708 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14709 "QTBuffer:size", "trace-buffer-size", 0);
14711 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14712 "Qbtrace:off", "disable-btrace", 0);
14714 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14715 "Qbtrace:bts", "enable-btrace-bts", 0);
14717 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14718 "Qbtrace:pt", "enable-btrace-pt", 0);
14720 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14721 "qXfer:btrace", "read-btrace", 0);
14723 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14724 "qXfer:btrace-conf", "read-btrace-conf", 0);
14726 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14727 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14729 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14730 "multiprocess-feature", "multiprocess-feature", 0);
14732 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14733 "swbreak-feature", "swbreak-feature", 0);
14735 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14736 "hwbreak-feature", "hwbreak-feature", 0);
14738 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14739 "fork-event-feature", "fork-event-feature", 0);
14741 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14742 "vfork-event-feature", "vfork-event-feature", 0);
14744 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14745 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14747 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14748 "vContSupported", "verbose-resume-supported", 0);
14750 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14751 "exec-event-feature", "exec-event-feature", 0);
14753 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14754 "vCtrlC", "ctrl-c", 0);
14756 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14757 "QThreadEvents", "thread-events", 0);
14759 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14760 "N stop reply", "no-resumed-stop-reply", 0);
14762 /* Assert that we've registered "set remote foo-packet" commands
14763 for all packet configs. */
14767 for (i
= 0; i
< PACKET_MAX
; i
++)
14769 /* Ideally all configs would have a command associated. Some
14770 still don't though. */
14775 case PACKET_QNonStop
:
14776 case PACKET_EnableDisableTracepoints_feature
:
14777 case PACKET_tracenz_feature
:
14778 case PACKET_DisconnectedTracing_feature
:
14779 case PACKET_augmented_libraries_svr4_read_feature
:
14781 /* Additions to this list need to be well justified:
14782 pre-existing packets are OK; new packets are not. */
14790 /* This catches both forgetting to add a config command, and
14791 forgetting to remove a packet from the exception list. */
14792 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14796 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14797 Z sub-packet has its own set and show commands, but users may
14798 have sets to this variable in their .gdbinit files (or in their
14800 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14801 &remote_Z_packet_detect
, _("\
14802 Set use of remote protocol `Z' packets."), _("\
14803 Show use of remote protocol `Z' packets."), _("\
14804 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14806 set_remote_protocol_Z_packet_cmd
,
14807 show_remote_protocol_Z_packet_cmd
,
14808 /* FIXME: i18n: Use of remote protocol
14809 `Z' packets is %s. */
14810 &remote_set_cmdlist
, &remote_show_cmdlist
);
14812 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14813 Manipulate files on the remote system.\n\
14814 Transfer files to and from the remote target system."),
14815 &remote_cmdlist
, "remote ",
14816 0 /* allow-unknown */, &cmdlist
);
14818 add_cmd ("put", class_files
, remote_put_command
,
14819 _("Copy a local file to the remote system."),
14822 add_cmd ("get", class_files
, remote_get_command
,
14823 _("Copy a remote file to the local system."),
14826 add_cmd ("delete", class_files
, remote_delete_command
,
14827 _("Delete a remote file."),
14830 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14831 &remote_exec_file_var
, _("\
14832 Set the remote pathname for \"run\"."), _("\
14833 Show the remote pathname for \"run\"."), NULL
,
14834 set_remote_exec_file
,
14835 show_remote_exec_file
,
14836 &remote_set_cmdlist
,
14837 &remote_show_cmdlist
);
14839 add_setshow_boolean_cmd ("range-stepping", class_run
,
14840 &use_range_stepping
, _("\
14841 Enable or disable range stepping."), _("\
14842 Show whether target-assisted range stepping is enabled."), _("\
14843 If on, and the target supports it, when stepping a source line, GDB\n\
14844 tells the target to step the corresponding range of addresses itself instead\n\
14845 of issuing multiple single-steps. This speeds up source level\n\
14846 stepping. If off, GDB always issues single-steps, even if range\n\
14847 stepping is supported by the target. The default is on."),
14848 set_range_stepping
,
14849 show_range_stepping
,
14853 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
14854 Set watchdog timer."), _("\
14855 Show watchdog timer."), _("\
14856 When non-zero, this timeout is used instead of waiting forever for a target\n\
14857 to finish a low-level step or continue operation. If the specified amount\n\
14858 of time passes without a response from the target, an error occurs."),
14861 &setlist
, &showlist
);
14863 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
14864 &remote_packet_max_chars
, _("\
14865 Set the maximum number of characters to display for each remote packet."), _("\
14866 Show the maximum number of characters to display for each remote packet."), _("\
14867 Specify \"unlimited\" to display all the characters."),
14868 NULL
, show_remote_packet_max_chars
,
14869 &setdebuglist
, &showdebuglist
);
14871 /* Eventually initialize fileio. See fileio.c */
14872 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);