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
;
282 /* True if the user has pressed Ctrl-C, but the target hasn't
283 responded to that. */
284 bool ctrlc_pending_p
= false;
286 /* True if we saw a Ctrl-C while reading or writing from/to the
287 remote descriptor. At that point it is not safe to send a remote
288 interrupt packet, so we instead remember we saw the Ctrl-C and
289 process it once we're done with sending/receiving the current
290 packet, which should be shortly. If however that takes too long,
291 and the user presses Ctrl-C again, we offer to disconnect. */
292 bool got_ctrlc_during_io
= false;
294 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
295 remote_open knows that we don't have a file open when the program
297 struct serial
*remote_desc
= nullptr;
299 /* These are the threads which we last sent to the remote system. The
300 TID member will be -1 for all or -2 for not sent yet. */
301 ptid_t general_thread
= null_ptid
;
302 ptid_t continue_thread
= null_ptid
;
304 /* This is the traceframe which we last selected on the remote system.
305 It will be -1 if no traceframe is selected. */
306 int remote_traceframe_number
= -1;
308 char *last_pass_packet
= nullptr;
310 /* The last QProgramSignals packet sent to the target. We bypass
311 sending a new program signals list down to the target if the new
312 packet is exactly the same as the last we sent. IOW, we only let
313 the target know about program signals list changes. */
314 char *last_program_signals_packet
= nullptr;
316 gdb_signal last_sent_signal
= GDB_SIGNAL_0
;
318 bool last_sent_step
= false;
320 /* The execution direction of the last resume we got. */
321 exec_direction_kind last_resume_exec_dir
= EXEC_FORWARD
;
323 char *finished_object
= nullptr;
324 char *finished_annex
= nullptr;
325 ULONGEST finished_offset
= 0;
327 /* Should we try the 'ThreadInfo' query packet?
329 This variable (NOT available to the user: auto-detect only!)
330 determines whether GDB will use the new, simpler "ThreadInfo"
331 query or the older, more complex syntax for thread queries.
332 This is an auto-detect variable (set to true at each connect,
333 and set to false when the target fails to recognize it). */
334 bool use_threadinfo_query
= false;
335 bool use_threadextra_query
= false;
337 threadref echo_nextthread
{};
338 threadref nextthread
{};
339 threadref resultthreadlist
[MAXTHREADLISTRESULTS
] {};
341 /* The state of remote notification. */
342 struct remote_notif_state
*notif_state
= nullptr;
344 /* The branch trace configuration. */
345 struct btrace_config btrace_config
{};
347 /* The argument to the last "vFile:setfs:" packet we sent, used
348 to avoid sending repeated unnecessary "vFile:setfs:" packets.
349 Initialized to -1 to indicate that no "vFile:setfs:" packet
350 has yet been sent. */
353 /* A readahead cache for vFile:pread. Often, reading a binary
354 involves a sequence of small reads. E.g., when parsing an ELF
355 file. A readahead cache helps mostly the case of remote
356 debugging on a connection with higher latency, due to the
357 request/reply nature of the RSP. We only cache data for a single
358 file descriptor at a time. */
359 struct readahead_cache readahead_cache
;
361 /* The list of already fetched and acknowledged stop events. This
362 queue is used for notification Stop, and other notifications
363 don't need queue for their events, because the notification
364 events of Stop can't be consumed immediately, so that events
365 should be queued first, and be consumed by remote_wait_{ns,as}
366 one per time. Other notifications can consume their events
367 immediately, so queue is not needed for them. */
368 std::vector
<stop_reply_up
> stop_reply_queue
;
370 /* Asynchronous signal handle registered as event loop source for
371 when we have pending events ready to be passed to the core. */
372 struct async_event_handler
*remote_async_inferior_event_token
= nullptr;
374 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
375 ``forever'' still use the normal timeout mechanism. This is
376 currently used by the ASYNC code to guarentee that target reads
377 during the initial connect always time-out. Once getpkt has been
378 modified to return a timeout indication and, in turn
379 remote_wait()/wait_for_inferior() have gained a timeout parameter
381 int wait_forever_enabled_p
= 1;
384 /* Mapping of remote protocol data for each gdbarch. Usually there
385 is only one entry here, though we may see more with stubs that
386 support multi-process. */
387 std::unordered_map
<struct gdbarch
*, remote_arch_state
>
391 static const target_info remote_target_info
= {
393 N_("Remote serial target in gdb-specific protocol"),
397 class remote_target
: public process_stratum_target
400 remote_target () = default;
401 ~remote_target () override
;
403 const target_info
&info () const override
404 { return remote_target_info
; }
406 thread_control_capabilities
get_thread_control_capabilities () override
407 { return tc_schedlock
; }
409 /* Open a remote connection. */
410 static void open (const char *, int);
412 void close () override
;
414 void detach (inferior
*, int) override
;
415 void disconnect (const char *, int) override
;
417 void commit_resume () override
;
418 void resume (ptid_t
, int, enum gdb_signal
) override
;
419 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
421 void fetch_registers (struct regcache
*, int) override
;
422 void store_registers (struct regcache
*, int) override
;
423 void prepare_to_store (struct regcache
*) override
;
425 void files_info () override
;
427 int insert_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
429 int remove_breakpoint (struct gdbarch
*, struct bp_target_info
*,
430 enum remove_bp_reason
) override
;
433 bool stopped_by_sw_breakpoint () override
;
434 bool supports_stopped_by_sw_breakpoint () override
;
436 bool stopped_by_hw_breakpoint () override
;
438 bool supports_stopped_by_hw_breakpoint () override
;
440 bool stopped_by_watchpoint () override
;
442 bool stopped_data_address (CORE_ADDR
*) override
;
444 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
446 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
448 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
450 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
452 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
454 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
455 struct expression
*) override
;
457 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
458 struct expression
*) override
;
460 void kill () override
;
462 void load (const char *, int) override
;
464 void mourn_inferior () override
;
466 void pass_signals (gdb::array_view
<const unsigned char>) override
;
468 int set_syscall_catchpoint (int, bool, int,
469 gdb::array_view
<const int>) override
;
471 void program_signals (gdb::array_view
<const unsigned char>) override
;
473 bool thread_alive (ptid_t ptid
) override
;
475 const char *thread_name (struct thread_info
*) override
;
477 void update_thread_list () override
;
479 std::string
pid_to_str (ptid_t
) override
;
481 const char *extra_thread_info (struct thread_info
*) override
;
483 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
485 thread_info
*thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
487 inferior
*inf
) override
;
489 gdb::byte_vector
thread_info_to_thread_handle (struct thread_info
*tp
)
492 void stop (ptid_t
) override
;
494 void interrupt () override
;
496 void pass_ctrlc () override
;
498 enum target_xfer_status
xfer_partial (enum target_object object
,
501 const gdb_byte
*writebuf
,
502 ULONGEST offset
, ULONGEST len
,
503 ULONGEST
*xfered_len
) override
;
505 ULONGEST
get_memory_xfer_limit () override
;
507 void rcmd (const char *command
, struct ui_file
*output
) override
;
509 char *pid_to_exec_file (int pid
) override
;
511 void log_command (const char *cmd
) override
513 serial_log_command (this, cmd
);
516 CORE_ADDR
get_thread_local_address (ptid_t ptid
,
517 CORE_ADDR load_module_addr
,
518 CORE_ADDR offset
) override
;
520 bool can_execute_reverse () override
;
522 std::vector
<mem_region
> memory_map () override
;
524 void flash_erase (ULONGEST address
, LONGEST length
) override
;
526 void flash_done () override
;
528 const struct target_desc
*read_description () override
;
530 int search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
531 const gdb_byte
*pattern
, ULONGEST pattern_len
,
532 CORE_ADDR
*found_addrp
) override
;
534 bool can_async_p () override
;
536 bool is_async_p () override
;
538 void async (int) override
;
540 void thread_events (int) override
;
542 int can_do_single_step () override
;
544 void terminal_inferior () override
;
546 void terminal_ours () override
;
548 bool supports_non_stop () override
;
550 bool supports_multi_process () override
;
552 bool supports_disable_randomization () override
;
554 bool filesystem_is_local () override
;
557 int fileio_open (struct inferior
*inf
, const char *filename
,
558 int flags
, int mode
, int warn_if_slow
,
559 int *target_errno
) override
;
561 int fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
562 ULONGEST offset
, int *target_errno
) override
;
564 int fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
565 ULONGEST offset
, int *target_errno
) override
;
567 int fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
) override
;
569 int fileio_close (int fd
, int *target_errno
) override
;
571 int fileio_unlink (struct inferior
*inf
,
572 const char *filename
,
573 int *target_errno
) override
;
575 gdb::optional
<std::string
>
576 fileio_readlink (struct inferior
*inf
,
577 const char *filename
,
578 int *target_errno
) override
;
580 bool supports_enable_disable_tracepoint () override
;
582 bool supports_string_tracing () override
;
584 bool supports_evaluation_of_breakpoint_conditions () override
;
586 bool can_run_breakpoint_commands () override
;
588 void trace_init () override
;
590 void download_tracepoint (struct bp_location
*location
) override
;
592 bool can_download_tracepoint () override
;
594 void download_trace_state_variable (const trace_state_variable
&tsv
) override
;
596 void enable_tracepoint (struct bp_location
*location
) override
;
598 void disable_tracepoint (struct bp_location
*location
) override
;
600 void trace_set_readonly_regions () override
;
602 void trace_start () override
;
604 int get_trace_status (struct trace_status
*ts
) override
;
606 void get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
609 void trace_stop () override
;
611 int trace_find (enum trace_find_type type
, int num
,
612 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
) override
;
614 bool get_trace_state_variable_value (int tsv
, LONGEST
*val
) override
;
616 int save_trace_data (const char *filename
) override
;
618 int upload_tracepoints (struct uploaded_tp
**utpp
) override
;
620 int upload_trace_state_variables (struct uploaded_tsv
**utsvp
) override
;
622 LONGEST
get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
) override
;
624 int get_min_fast_tracepoint_insn_len () override
;
626 void set_disconnected_tracing (int val
) override
;
628 void set_circular_trace_buffer (int val
) override
;
630 void set_trace_buffer_size (LONGEST val
) override
;
632 bool set_trace_notes (const char *user
, const char *notes
,
633 const char *stopnotes
) override
;
635 int core_of_thread (ptid_t ptid
) override
;
637 int verify_memory (const gdb_byte
*data
,
638 CORE_ADDR memaddr
, ULONGEST size
) override
;
641 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
643 void set_permissions () override
;
645 bool static_tracepoint_marker_at (CORE_ADDR
,
646 struct static_tracepoint_marker
*marker
)
649 std::vector
<static_tracepoint_marker
>
650 static_tracepoint_markers_by_strid (const char *id
) override
;
652 traceframe_info_up
traceframe_info () override
;
654 bool use_agent (bool use
) override
;
655 bool can_use_agent () override
;
657 struct btrace_target_info
*enable_btrace (ptid_t ptid
,
658 const struct btrace_config
*conf
) override
;
660 void disable_btrace (struct btrace_target_info
*tinfo
) override
;
662 void teardown_btrace (struct btrace_target_info
*tinfo
) override
;
664 enum btrace_error
read_btrace (struct btrace_data
*data
,
665 struct btrace_target_info
*btinfo
,
666 enum btrace_read_type type
) override
;
668 const struct btrace_config
*btrace_conf (const struct btrace_target_info
*) override
;
669 bool augmented_libraries_svr4_read () override
;
670 int follow_fork (int, int) override
;
671 void follow_exec (struct inferior
*, const char *) override
;
672 int insert_fork_catchpoint (int) override
;
673 int remove_fork_catchpoint (int) override
;
674 int insert_vfork_catchpoint (int) override
;
675 int remove_vfork_catchpoint (int) override
;
676 int insert_exec_catchpoint (int) override
;
677 int remove_exec_catchpoint (int) override
;
678 enum exec_direction_kind
execution_direction () override
;
680 public: /* Remote specific methods. */
682 void remote_download_command_source (int num
, ULONGEST addr
,
683 struct command_line
*cmds
);
685 void remote_file_put (const char *local_file
, const char *remote_file
,
687 void remote_file_get (const char *remote_file
, const char *local_file
,
689 void remote_file_delete (const char *remote_file
, int from_tty
);
691 int remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
692 ULONGEST offset
, int *remote_errno
);
693 int remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
694 ULONGEST offset
, int *remote_errno
);
695 int remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
696 ULONGEST offset
, int *remote_errno
);
698 int remote_hostio_send_command (int command_bytes
, int which_packet
,
699 int *remote_errno
, char **attachment
,
700 int *attachment_len
);
701 int remote_hostio_set_filesystem (struct inferior
*inf
,
703 /* We should get rid of this and use fileio_open directly. */
704 int remote_hostio_open (struct inferior
*inf
, const char *filename
,
705 int flags
, int mode
, int warn_if_slow
,
707 int remote_hostio_close (int fd
, int *remote_errno
);
709 int remote_hostio_unlink (inferior
*inf
, const char *filename
,
712 struct remote_state
*get_remote_state ();
714 long get_remote_packet_size (void);
715 long get_memory_packet_size (struct memory_packet_config
*config
);
717 long get_memory_write_packet_size ();
718 long get_memory_read_packet_size ();
720 char *append_pending_thread_resumptions (char *p
, char *endp
,
722 static void open_1 (const char *name
, int from_tty
, int extended_p
);
723 void start_remote (int from_tty
, int extended_p
);
724 void remote_detach_1 (struct inferior
*inf
, int from_tty
);
726 char *append_resumption (char *p
, char *endp
,
727 ptid_t ptid
, int step
, gdb_signal siggnal
);
728 int remote_resume_with_vcont (ptid_t ptid
, int step
,
731 void add_current_inferior_and_thread (char *wait_status
);
733 ptid_t
wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
735 ptid_t
wait_as (ptid_t ptid
, target_waitstatus
*status
,
738 ptid_t
process_stop_reply (struct stop_reply
*stop_reply
,
739 target_waitstatus
*status
);
741 void remote_notice_new_inferior (ptid_t currthread
, int executing
);
743 void process_initial_stop_replies (int from_tty
);
745 thread_info
*remote_add_thread (ptid_t ptid
, bool running
, bool executing
);
747 void btrace_sync_conf (const btrace_config
*conf
);
749 void remote_btrace_maybe_reopen ();
751 void remove_new_fork_children (threads_listing_context
*context
);
752 void kill_new_fork_children (int pid
);
753 void discard_pending_stop_replies (struct inferior
*inf
);
754 int stop_reply_queue_length ();
756 void check_pending_events_prevent_wildcard_vcont
757 (int *may_global_wildcard_vcont
);
759 void discard_pending_stop_replies_in_queue ();
760 struct stop_reply
*remote_notif_remove_queued_reply (ptid_t ptid
);
761 struct stop_reply
*queued_stop_reply (ptid_t ptid
);
762 int peek_stop_reply (ptid_t ptid
);
763 void remote_parse_stop_reply (const char *buf
, stop_reply
*event
);
765 void remote_stop_ns (ptid_t ptid
);
766 void remote_interrupt_as ();
767 void remote_interrupt_ns ();
769 char *remote_get_noisy_reply ();
770 int remote_query_attached (int pid
);
771 inferior
*remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
774 ptid_t
remote_current_thread (ptid_t oldpid
);
775 ptid_t
get_current_thread (char *wait_status
);
777 void set_thread (ptid_t ptid
, int gen
);
778 void set_general_thread (ptid_t ptid
);
779 void set_continue_thread (ptid_t ptid
);
780 void set_general_process ();
782 char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
784 int remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
785 gdb_ext_thread_info
*info
);
786 int remote_get_threadinfo (threadref
*threadid
, int fieldset
,
787 gdb_ext_thread_info
*info
);
789 int parse_threadlist_response (char *pkt
, int result_limit
,
790 threadref
*original_echo
,
791 threadref
*resultlist
,
793 int remote_get_threadlist (int startflag
, threadref
*nextthread
,
794 int result_limit
, int *done
, int *result_count
,
795 threadref
*threadlist
);
797 int remote_threadlist_iterator (rmt_thread_action stepfunction
,
798 void *context
, int looplimit
);
800 int remote_get_threads_with_ql (threads_listing_context
*context
);
801 int remote_get_threads_with_qxfer (threads_listing_context
*context
);
802 int remote_get_threads_with_qthreadinfo (threads_listing_context
*context
);
804 void extended_remote_restart ();
808 void remote_check_symbols ();
810 void remote_supported_packet (const struct protocol_feature
*feature
,
811 enum packet_support support
,
812 const char *argument
);
814 void remote_query_supported ();
816 void remote_packet_size (const protocol_feature
*feature
,
817 packet_support support
, const char *value
);
819 void remote_serial_quit_handler ();
821 void remote_detach_pid (int pid
);
823 void remote_vcont_probe ();
825 void remote_resume_with_hc (ptid_t ptid
, int step
,
828 void send_interrupt_sequence ();
829 void interrupt_query ();
831 void remote_notif_get_pending_events (notif_client
*nc
);
833 int fetch_register_using_p (struct regcache
*regcache
,
835 int send_g_packet ();
836 void process_g_packet (struct regcache
*regcache
);
837 void fetch_registers_using_g (struct regcache
*regcache
);
838 int store_register_using_P (const struct regcache
*regcache
,
840 void store_registers_using_G (const struct regcache
*regcache
);
842 void set_remote_traceframe ();
844 void check_binary_download (CORE_ADDR addr
);
846 target_xfer_status
remote_write_bytes_aux (const char *header
,
848 const gdb_byte
*myaddr
,
851 ULONGEST
*xfered_len_units
,
855 target_xfer_status
remote_write_bytes (CORE_ADDR memaddr
,
856 const gdb_byte
*myaddr
, ULONGEST len
,
857 int unit_size
, ULONGEST
*xfered_len
);
859 target_xfer_status
remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
861 int unit_size
, ULONGEST
*xfered_len_units
);
863 target_xfer_status
remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
867 ULONGEST
*xfered_len
);
869 target_xfer_status
remote_read_bytes (CORE_ADDR memaddr
,
870 gdb_byte
*myaddr
, ULONGEST len
,
872 ULONGEST
*xfered_len
);
874 packet_result
remote_send_printf (const char *format
, ...)
875 ATTRIBUTE_PRINTF (2, 3);
877 target_xfer_status
remote_flash_write (ULONGEST address
,
878 ULONGEST length
, ULONGEST
*xfered_len
,
879 const gdb_byte
*data
);
881 int readchar (int timeout
);
883 void remote_serial_write (const char *str
, int len
);
885 int putpkt (const char *buf
);
886 int putpkt_binary (const char *buf
, int cnt
);
888 int putpkt (const gdb::char_vector
&buf
)
890 return putpkt (buf
.data ());
894 long read_frame (gdb::char_vector
*buf_p
);
895 void getpkt (gdb::char_vector
*buf
, int forever
);
896 int getpkt_or_notif_sane_1 (gdb::char_vector
*buf
, int forever
,
897 int expecting_notif
, int *is_notif
);
898 int getpkt_sane (gdb::char_vector
*buf
, int forever
);
899 int getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
901 int remote_vkill (int pid
);
902 void remote_kill_k ();
904 void extended_remote_disable_randomization (int val
);
905 int extended_remote_run (const std::string
&args
);
907 void send_environment_packet (const char *action
,
911 void extended_remote_environment_support ();
912 void extended_remote_set_inferior_cwd ();
914 target_xfer_status
remote_write_qxfer (const char *object_name
,
916 const gdb_byte
*writebuf
,
917 ULONGEST offset
, LONGEST len
,
918 ULONGEST
*xfered_len
,
919 struct packet_config
*packet
);
921 target_xfer_status
remote_read_qxfer (const char *object_name
,
923 gdb_byte
*readbuf
, ULONGEST offset
,
925 ULONGEST
*xfered_len
,
926 struct packet_config
*packet
);
928 void push_stop_reply (struct stop_reply
*new_event
);
930 bool vcont_r_supported ();
932 void packet_command (const char *args
, int from_tty
);
934 private: /* data fields */
936 /* The remote state. Don't reference this directly. Use the
937 get_remote_state method instead. */
938 remote_state m_remote_state
;
941 static const target_info extended_remote_target_info
= {
943 N_("Extended remote serial target in gdb-specific protocol"),
947 /* Set up the extended remote target by extending the standard remote
948 target and adding to it. */
950 class extended_remote_target final
: public remote_target
953 const target_info
&info () const override
954 { return extended_remote_target_info
; }
956 /* Open an extended-remote connection. */
957 static void open (const char *, int);
959 bool can_create_inferior () override
{ return true; }
960 void create_inferior (const char *, const std::string
&,
961 char **, int) override
;
963 void detach (inferior
*, int) override
;
965 bool can_attach () override
{ return true; }
966 void attach (const char *, int) override
;
968 void post_attach (int) override
;
969 bool supports_disable_randomization () override
;
972 /* Per-program-space data key. */
973 static const struct program_space_key
<char, gdb::xfree_deleter
<char>>
976 /* The variable registered as the control variable used by the
977 remote exec-file commands. While the remote exec-file setting is
978 per-program-space, the set/show machinery uses this as the
979 location of the remote exec-file value. */
980 static char *remote_exec_file_var
;
982 /* The size to align memory write packets, when practical. The protocol
983 does not guarantee any alignment, and gdb will generate short
984 writes and unaligned writes, but even as a best-effort attempt this
985 can improve bulk transfers. For instance, if a write is misaligned
986 relative to the target's data bus, the stub may need to make an extra
987 round trip fetching data from the target. This doesn't make a
988 huge difference, but it's easy to do, so we try to be helpful.
990 The alignment chosen is arbitrary; usually data bus width is
991 important here, not the possibly larger cache line size. */
992 enum { REMOTE_ALIGN_WRITES
= 16 };
994 /* Prototypes for local functions. */
996 static int hexnumlen (ULONGEST num
);
998 static int stubhex (int ch
);
1000 static int hexnumstr (char *, ULONGEST
);
1002 static int hexnumnstr (char *, ULONGEST
, int);
1004 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
1006 static void print_packet (const char *);
1008 static int stub_unpack_int (char *buff
, int fieldlength
);
1010 struct packet_config
;
1012 static void show_packet_config_cmd (struct packet_config
*config
);
1014 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
1016 struct cmd_list_element
*c
,
1019 static ptid_t
read_ptid (const char *buf
, const char **obuf
);
1021 static void remote_async_inferior_event_handler (gdb_client_data
);
1023 static bool remote_read_description_p (struct target_ops
*target
);
1025 static void remote_console_output (const char *msg
);
1027 static void remote_btrace_reset (remote_state
*rs
);
1029 static void remote_unpush_and_throw (void);
1033 static struct cmd_list_element
*remote_cmdlist
;
1035 /* For "set remote" and "show remote". */
1037 static struct cmd_list_element
*remote_set_cmdlist
;
1038 static struct cmd_list_element
*remote_show_cmdlist
;
1040 /* Controls whether GDB is willing to use range stepping. */
1042 static bool use_range_stepping
= true;
1044 /* Private data that we'll store in (struct thread_info)->priv. */
1045 struct remote_thread_info
: public private_thread_info
1051 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1052 sequence of bytes. */
1053 gdb::byte_vector thread_handle
;
1055 /* Whether the target stopped for a breakpoint/watchpoint. */
1056 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1058 /* This is set to the data address of the access causing the target
1059 to stop for a watchpoint. */
1060 CORE_ADDR watch_data_address
= 0;
1062 /* Fields used by the vCont action coalescing implemented in
1063 remote_resume / remote_commit_resume. remote_resume stores each
1064 thread's last resume request in these fields, so that a later
1065 remote_commit_resume knows which is the proper action for this
1066 thread to include in the vCont packet. */
1068 /* True if the last target_resume call for this thread was a step
1069 request, false if a continue request. */
1070 int last_resume_step
= 0;
1072 /* The signal specified in the last target_resume call for this
1074 gdb_signal last_resume_sig
= GDB_SIGNAL_0
;
1076 /* Whether this thread was already vCont-resumed on the remote
1078 int vcont_resumed
= 0;
1081 remote_state::remote_state ()
1086 remote_state::~remote_state ()
1088 xfree (this->last_pass_packet
);
1089 xfree (this->last_program_signals_packet
);
1090 xfree (this->finished_object
);
1091 xfree (this->finished_annex
);
1094 /* Utility: generate error from an incoming stub packet. */
1096 trace_error (char *buf
)
1099 return; /* not an error msg */
1102 case '1': /* malformed packet error */
1103 if (*++buf
== '0') /* general case: */
1104 error (_("remote.c: error in outgoing packet."));
1106 error (_("remote.c: error in outgoing packet at field #%ld."),
1107 strtol (buf
, NULL
, 16));
1109 error (_("Target returns error code '%s'."), buf
);
1113 /* Utility: wait for reply from stub, while accepting "O" packets. */
1116 remote_target::remote_get_noisy_reply ()
1118 struct remote_state
*rs
= get_remote_state ();
1120 do /* Loop on reply from remote stub. */
1124 QUIT
; /* Allow user to bail out with ^C. */
1125 getpkt (&rs
->buf
, 0);
1126 buf
= rs
->buf
.data ();
1129 else if (startswith (buf
, "qRelocInsn:"))
1132 CORE_ADDR from
, to
, org_to
;
1134 int adjusted_size
= 0;
1137 p
= buf
+ strlen ("qRelocInsn:");
1138 pp
= unpack_varlen_hex (p
, &ul
);
1140 error (_("invalid qRelocInsn packet: %s"), buf
);
1144 unpack_varlen_hex (p
, &ul
);
1151 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1154 catch (const gdb_exception
&ex
)
1156 if (ex
.error
== MEMORY_ERROR
)
1158 /* Propagate memory errors silently back to the
1159 target. The stub may have limited the range of
1160 addresses we can write to, for example. */
1164 /* Something unexpectedly bad happened. Be verbose
1165 so we can tell what, and propagate the error back
1166 to the stub, so it doesn't get stuck waiting for
1168 exception_fprintf (gdb_stderr
, ex
,
1169 _("warning: relocating instruction: "));
1176 adjusted_size
= to
- org_to
;
1178 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1182 else if (buf
[0] == 'O' && buf
[1] != 'K')
1183 remote_console_output (buf
+ 1); /* 'O' message from stub */
1185 return buf
; /* Here's the actual reply. */
1190 struct remote_arch_state
*
1191 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1193 remote_arch_state
*rsa
;
1195 auto it
= this->m_arch_states
.find (gdbarch
);
1196 if (it
== this->m_arch_states
.end ())
1198 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1199 std::forward_as_tuple (gdbarch
),
1200 std::forward_as_tuple (gdbarch
));
1201 rsa
= &p
.first
->second
;
1203 /* Make sure that the packet buffer is plenty big enough for
1204 this architecture. */
1205 if (this->buf
.size () < rsa
->remote_packet_size
)
1206 this->buf
.resize (2 * rsa
->remote_packet_size
);
1214 /* Fetch the global remote target state. */
1217 remote_target::get_remote_state ()
1219 /* Make sure that the remote architecture state has been
1220 initialized, because doing so might reallocate rs->buf. Any
1221 function which calls getpkt also needs to be mindful of changes
1222 to rs->buf, but this call limits the number of places which run
1224 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1226 return &m_remote_state
;
1229 /* Fetch the remote exec-file from the current program space. */
1232 get_remote_exec_file (void)
1234 char *remote_exec_file
;
1236 remote_exec_file
= remote_pspace_data
.get (current_program_space
);
1237 if (remote_exec_file
== NULL
)
1240 return remote_exec_file
;
1243 /* Set the remote exec file for PSPACE. */
1246 set_pspace_remote_exec_file (struct program_space
*pspace
,
1247 const char *remote_exec_file
)
1249 char *old_file
= remote_pspace_data
.get (pspace
);
1252 remote_pspace_data
.set (pspace
, xstrdup (remote_exec_file
));
1255 /* The "set/show remote exec-file" set command hook. */
1258 set_remote_exec_file (const char *ignored
, int from_tty
,
1259 struct cmd_list_element
*c
)
1261 gdb_assert (remote_exec_file_var
!= NULL
);
1262 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
1265 /* The "set/show remote exec-file" show command hook. */
1268 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1269 struct cmd_list_element
*cmd
, const char *value
)
1271 fprintf_filtered (file
, "%s\n", get_remote_exec_file ());
1275 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1277 int regnum
, num_remote_regs
, offset
;
1278 struct packet_reg
**remote_regs
;
1280 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1282 struct packet_reg
*r
= ®s
[regnum
];
1284 if (register_size (gdbarch
, regnum
) == 0)
1285 /* Do not try to fetch zero-sized (placeholder) registers. */
1288 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1293 /* Define the g/G packet format as the contents of each register
1294 with a remote protocol number, in order of ascending protocol
1297 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1298 for (num_remote_regs
= 0, regnum
= 0;
1299 regnum
< gdbarch_num_regs (gdbarch
);
1301 if (regs
[regnum
].pnum
!= -1)
1302 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1304 std::sort (remote_regs
, remote_regs
+ num_remote_regs
,
1305 [] (const packet_reg
*a
, const packet_reg
*b
)
1306 { return a
->pnum
< b
->pnum
; });
1308 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1310 remote_regs
[regnum
]->in_g_packet
= 1;
1311 remote_regs
[regnum
]->offset
= offset
;
1312 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1318 /* Given the architecture described by GDBARCH, return the remote
1319 protocol register's number and the register's offset in the g/G
1320 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1321 If the target does not have a mapping for REGNUM, return false,
1322 otherwise, return true. */
1325 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1326 int *pnum
, int *poffset
)
1328 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1330 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1332 map_regcache_remote_table (gdbarch
, regs
.data ());
1334 *pnum
= regs
[regnum
].pnum
;
1335 *poffset
= regs
[regnum
].offset
;
1340 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1342 /* Use the architecture to build a regnum<->pnum table, which will be
1343 1:1 unless a feature set specifies otherwise. */
1344 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1346 /* Record the maximum possible size of the g packet - it may turn out
1348 this->sizeof_g_packet
1349 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1351 /* Default maximum number of characters in a packet body. Many
1352 remote stubs have a hardwired buffer size of 400 bytes
1353 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1354 as the maximum packet-size to ensure that the packet and an extra
1355 NUL character can always fit in the buffer. This stops GDB
1356 trashing stubs that try to squeeze an extra NUL into what is
1357 already a full buffer (As of 1999-12-04 that was most stubs). */
1358 this->remote_packet_size
= 400 - 1;
1360 /* This one is filled in when a ``g'' packet is received. */
1361 this->actual_register_packet_size
= 0;
1363 /* Should rsa->sizeof_g_packet needs more space than the
1364 default, adjust the size accordingly. Remember that each byte is
1365 encoded as two characters. 32 is the overhead for the packet
1366 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1367 (``$NN:G...#NN'') is a better guess, the below has been padded a
1369 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1370 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1373 /* Get a pointer to the current remote target. If not connected to a
1374 remote target, return NULL. */
1376 static remote_target
*
1377 get_current_remote_target ()
1379 target_ops
*proc_target
= find_target_at (process_stratum
);
1380 return dynamic_cast<remote_target
*> (proc_target
);
1383 /* Return the current allowed size of a remote packet. This is
1384 inferred from the current architecture, and should be used to
1385 limit the length of outgoing packets. */
1387 remote_target::get_remote_packet_size ()
1389 struct remote_state
*rs
= get_remote_state ();
1390 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1392 if (rs
->explicit_packet_size
)
1393 return rs
->explicit_packet_size
;
1395 return rsa
->remote_packet_size
;
1398 static struct packet_reg
*
1399 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1402 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1406 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1408 gdb_assert (r
->regnum
== regnum
);
1413 static struct packet_reg
*
1414 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1419 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1421 struct packet_reg
*r
= &rsa
->regs
[i
];
1423 if (r
->pnum
== pnum
)
1429 /* Allow the user to specify what sequence to send to the remote
1430 when he requests a program interruption: Although ^C is usually
1431 what remote systems expect (this is the default, here), it is
1432 sometimes preferable to send a break. On other systems such
1433 as the Linux kernel, a break followed by g, which is Magic SysRq g
1434 is required in order to interrupt the execution. */
1435 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1436 const char interrupt_sequence_break
[] = "BREAK";
1437 const char interrupt_sequence_break_g
[] = "BREAK-g";
1438 static const char *const interrupt_sequence_modes
[] =
1440 interrupt_sequence_control_c
,
1441 interrupt_sequence_break
,
1442 interrupt_sequence_break_g
,
1445 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1448 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1449 struct cmd_list_element
*c
,
1452 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1453 fprintf_filtered (file
,
1454 _("Send the ASCII ETX character (Ctrl-c) "
1455 "to the remote target to interrupt the "
1456 "execution of the program.\n"));
1457 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1458 fprintf_filtered (file
,
1459 _("send a break signal to the remote target "
1460 "to interrupt the execution of the program.\n"));
1461 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1462 fprintf_filtered (file
,
1463 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1464 "the remote target to interrupt the execution "
1465 "of Linux kernel.\n"));
1467 internal_error (__FILE__
, __LINE__
,
1468 _("Invalid value for interrupt_sequence_mode: %s."),
1469 interrupt_sequence_mode
);
1472 /* This boolean variable specifies whether interrupt_sequence is sent
1473 to the remote target when gdb connects to it.
1474 This is mostly needed when you debug the Linux kernel: The Linux kernel
1475 expects BREAK g which is Magic SysRq g for connecting gdb. */
1476 static bool interrupt_on_connect
= false;
1478 /* This variable is used to implement the "set/show remotebreak" commands.
1479 Since these commands are now deprecated in favor of "set/show remote
1480 interrupt-sequence", it no longer has any effect on the code. */
1481 static bool remote_break
;
1484 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1487 interrupt_sequence_mode
= interrupt_sequence_break
;
1489 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1493 show_remotebreak (struct ui_file
*file
, int from_tty
,
1494 struct cmd_list_element
*c
,
1499 /* This variable sets the number of bits in an address that are to be
1500 sent in a memory ("M" or "m") packet. Normally, after stripping
1501 leading zeros, the entire address would be sent. This variable
1502 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1503 initial implementation of remote.c restricted the address sent in
1504 memory packets to ``host::sizeof long'' bytes - (typically 32
1505 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1506 address was never sent. Since fixing this bug may cause a break in
1507 some remote targets this variable is principally provided to
1508 facilitate backward compatibility. */
1510 static unsigned int remote_address_size
;
1513 /* User configurable variables for the number of characters in a
1514 memory read/write packet. MIN (rsa->remote_packet_size,
1515 rsa->sizeof_g_packet) is the default. Some targets need smaller
1516 values (fifo overruns, et.al.) and some users need larger values
1517 (speed up transfers). The variables ``preferred_*'' (the user
1518 request), ``current_*'' (what was actually set) and ``forced_*''
1519 (Positive - a soft limit, negative - a hard limit). */
1521 struct memory_packet_config
1528 /* The default max memory-write-packet-size, when the setting is
1529 "fixed". The 16k is historical. (It came from older GDB's using
1530 alloca for buffers and the knowledge (folklore?) that some hosts
1531 don't cope very well with large alloca calls.) */
1532 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1534 /* The minimum remote packet size for memory transfers. Ensures we
1535 can write at least one byte. */
1536 #define MIN_MEMORY_PACKET_SIZE 20
1538 /* Get the memory packet size, assuming it is fixed. */
1541 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1543 gdb_assert (config
->fixed_p
);
1545 if (config
->size
<= 0)
1546 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1548 return config
->size
;
1551 /* Compute the current size of a read/write packet. Since this makes
1552 use of ``actual_register_packet_size'' the computation is dynamic. */
1555 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1557 struct remote_state
*rs
= get_remote_state ();
1558 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1561 if (config
->fixed_p
)
1562 what_they_get
= get_fixed_memory_packet_size (config
);
1565 what_they_get
= get_remote_packet_size ();
1566 /* Limit the packet to the size specified by the user. */
1567 if (config
->size
> 0
1568 && what_they_get
> config
->size
)
1569 what_they_get
= config
->size
;
1571 /* Limit it to the size of the targets ``g'' response unless we have
1572 permission from the stub to use a larger packet size. */
1573 if (rs
->explicit_packet_size
== 0
1574 && rsa
->actual_register_packet_size
> 0
1575 && what_they_get
> rsa
->actual_register_packet_size
)
1576 what_they_get
= rsa
->actual_register_packet_size
;
1578 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1579 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1581 /* Make sure there is room in the global buffer for this packet
1582 (including its trailing NUL byte). */
1583 if (rs
->buf
.size () < what_they_get
+ 1)
1584 rs
->buf
.resize (2 * what_they_get
);
1586 return what_they_get
;
1589 /* Update the size of a read/write packet. If they user wants
1590 something really big then do a sanity check. */
1593 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1595 int fixed_p
= config
->fixed_p
;
1596 long size
= config
->size
;
1599 error (_("Argument required (integer, `fixed' or `limited')."));
1600 else if (strcmp (args
, "hard") == 0
1601 || strcmp (args
, "fixed") == 0)
1603 else if (strcmp (args
, "soft") == 0
1604 || strcmp (args
, "limit") == 0)
1610 size
= strtoul (args
, &end
, 0);
1612 error (_("Invalid %s (bad syntax)."), config
->name
);
1614 /* Instead of explicitly capping the size of a packet to or
1615 disallowing it, the user is allowed to set the size to
1616 something arbitrarily large. */
1620 if (fixed_p
&& !config
->fixed_p
)
1622 /* So that the query shows the correct value. */
1623 long query_size
= (size
<= 0
1624 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1627 if (! query (_("The target may not be able to correctly handle a %s\n"
1628 "of %ld bytes. Change the packet size? "),
1629 config
->name
, query_size
))
1630 error (_("Packet size not changed."));
1632 /* Update the config. */
1633 config
->fixed_p
= fixed_p
;
1634 config
->size
= size
;
1638 show_memory_packet_size (struct memory_packet_config
*config
)
1640 if (config
->size
== 0)
1641 printf_filtered (_("The %s is 0 (default). "), config
->name
);
1643 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1644 if (config
->fixed_p
)
1645 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1646 get_fixed_memory_packet_size (config
));
1649 remote_target
*remote
= get_current_remote_target ();
1652 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1653 remote
->get_memory_packet_size (config
));
1655 puts_filtered ("The actual limit will be further reduced "
1656 "dependent on the target.\n");
1660 static struct memory_packet_config memory_write_packet_config
=
1662 "memory-write-packet-size",
1666 set_memory_write_packet_size (const char *args
, int from_tty
)
1668 set_memory_packet_size (args
, &memory_write_packet_config
);
1672 show_memory_write_packet_size (const char *args
, int from_tty
)
1674 show_memory_packet_size (&memory_write_packet_config
);
1677 /* Show the number of hardware watchpoints that can be used. */
1680 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1681 struct cmd_list_element
*c
,
1684 fprintf_filtered (file
, _("The maximum number of target hardware "
1685 "watchpoints is %s.\n"), value
);
1688 /* Show the length limit (in bytes) for hardware watchpoints. */
1691 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1692 struct cmd_list_element
*c
,
1695 fprintf_filtered (file
, _("The maximum length (in bytes) of a target "
1696 "hardware watchpoint is %s.\n"), value
);
1699 /* Show the number of hardware breakpoints that can be used. */
1702 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1703 struct cmd_list_element
*c
,
1706 fprintf_filtered (file
, _("The maximum number of target hardware "
1707 "breakpoints is %s.\n"), value
);
1710 /* Controls the maximum number of characters to display in the debug output
1711 for each remote packet. The remaining characters are omitted. */
1713 static int remote_packet_max_chars
= 512;
1715 /* Show the maximum number of characters to display for each remote packet
1716 when remote debugging is enabled. */
1719 show_remote_packet_max_chars (struct ui_file
*file
, int from_tty
,
1720 struct cmd_list_element
*c
,
1723 fprintf_filtered (file
, _("Number of remote packet characters to "
1724 "display is %s.\n"), value
);
1728 remote_target::get_memory_write_packet_size ()
1730 return get_memory_packet_size (&memory_write_packet_config
);
1733 static struct memory_packet_config memory_read_packet_config
=
1735 "memory-read-packet-size",
1739 set_memory_read_packet_size (const char *args
, int from_tty
)
1741 set_memory_packet_size (args
, &memory_read_packet_config
);
1745 show_memory_read_packet_size (const char *args
, int from_tty
)
1747 show_memory_packet_size (&memory_read_packet_config
);
1751 remote_target::get_memory_read_packet_size ()
1753 long size
= get_memory_packet_size (&memory_read_packet_config
);
1755 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1756 extra buffer size argument before the memory read size can be
1757 increased beyond this. */
1758 if (size
> get_remote_packet_size ())
1759 size
= get_remote_packet_size ();
1765 struct packet_config
1770 /* If auto, GDB auto-detects support for this packet or feature,
1771 either through qSupported, or by trying the packet and looking
1772 at the response. If true, GDB assumes the target supports this
1773 packet. If false, the packet is disabled. Configs that don't
1774 have an associated command always have this set to auto. */
1775 enum auto_boolean detect
;
1777 /* Does the target support this packet? */
1778 enum packet_support support
;
1781 static enum packet_support
packet_config_support (struct packet_config
*config
);
1782 static enum packet_support
packet_support (int packet
);
1785 show_packet_config_cmd (struct packet_config
*config
)
1787 const char *support
= "internal-error";
1789 switch (packet_config_support (config
))
1792 support
= "enabled";
1794 case PACKET_DISABLE
:
1795 support
= "disabled";
1797 case PACKET_SUPPORT_UNKNOWN
:
1798 support
= "unknown";
1801 switch (config
->detect
)
1803 case AUTO_BOOLEAN_AUTO
:
1804 printf_filtered (_("Support for the `%s' packet "
1805 "is auto-detected, currently %s.\n"),
1806 config
->name
, support
);
1808 case AUTO_BOOLEAN_TRUE
:
1809 case AUTO_BOOLEAN_FALSE
:
1810 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1811 config
->name
, support
);
1817 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1818 const char *title
, int legacy
)
1824 config
->name
= name
;
1825 config
->title
= title
;
1826 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1828 show_doc
= xstrprintf ("Show current use of remote "
1829 "protocol `%s' (%s) packet.",
1831 /* set/show TITLE-packet {auto,on,off} */
1832 cmd_name
= xstrprintf ("%s-packet", title
);
1833 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1834 &config
->detect
, set_doc
,
1835 show_doc
, NULL
, /* help_doc */
1837 show_remote_protocol_packet_cmd
,
1838 &remote_set_cmdlist
, &remote_show_cmdlist
);
1839 /* The command code copies the documentation strings. */
1842 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1847 legacy_name
= xstrprintf ("%s-packet", name
);
1848 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1849 &remote_set_cmdlist
);
1850 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1851 &remote_show_cmdlist
);
1855 static enum packet_result
1856 packet_check_result (const char *buf
)
1860 /* The stub recognized the packet request. Check that the
1861 operation succeeded. */
1863 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1865 /* "Enn" - definitely an error. */
1866 return PACKET_ERROR
;
1868 /* Always treat "E." as an error. This will be used for
1869 more verbose error messages, such as E.memtypes. */
1870 if (buf
[0] == 'E' && buf
[1] == '.')
1871 return PACKET_ERROR
;
1873 /* The packet may or may not be OK. Just assume it is. */
1877 /* The stub does not support the packet. */
1878 return PACKET_UNKNOWN
;
1881 static enum packet_result
1882 packet_check_result (const gdb::char_vector
&buf
)
1884 return packet_check_result (buf
.data ());
1887 static enum packet_result
1888 packet_ok (const char *buf
, struct packet_config
*config
)
1890 enum packet_result result
;
1892 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1893 && config
->support
== PACKET_DISABLE
)
1894 internal_error (__FILE__
, __LINE__
,
1895 _("packet_ok: attempt to use a disabled packet"));
1897 result
= packet_check_result (buf
);
1902 /* The stub recognized the packet request. */
1903 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1906 fprintf_unfiltered (gdb_stdlog
,
1907 "Packet %s (%s) is supported\n",
1908 config
->name
, config
->title
);
1909 config
->support
= PACKET_ENABLE
;
1912 case PACKET_UNKNOWN
:
1913 /* The stub does not support the packet. */
1914 if (config
->detect
== AUTO_BOOLEAN_AUTO
1915 && config
->support
== PACKET_ENABLE
)
1917 /* If the stub previously indicated that the packet was
1918 supported then there is a protocol error. */
1919 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1920 config
->name
, config
->title
);
1922 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
1924 /* The user set it wrong. */
1925 error (_("Enabled packet %s (%s) not recognized by stub"),
1926 config
->name
, config
->title
);
1930 fprintf_unfiltered (gdb_stdlog
,
1931 "Packet %s (%s) is NOT supported\n",
1932 config
->name
, config
->title
);
1933 config
->support
= PACKET_DISABLE
;
1940 static enum packet_result
1941 packet_ok (const gdb::char_vector
&buf
, struct packet_config
*config
)
1943 return packet_ok (buf
.data (), config
);
1960 PACKET_vFile_pwrite
,
1962 PACKET_vFile_unlink
,
1963 PACKET_vFile_readlink
,
1966 PACKET_qXfer_features
,
1967 PACKET_qXfer_exec_file
,
1968 PACKET_qXfer_libraries
,
1969 PACKET_qXfer_libraries_svr4
,
1970 PACKET_qXfer_memory_map
,
1971 PACKET_qXfer_osdata
,
1972 PACKET_qXfer_threads
,
1973 PACKET_qXfer_statictrace_read
,
1974 PACKET_qXfer_traceframe_info
,
1980 PACKET_QPassSignals
,
1981 PACKET_QCatchSyscalls
,
1982 PACKET_QProgramSignals
,
1983 PACKET_QSetWorkingDir
,
1984 PACKET_QStartupWithShell
,
1985 PACKET_QEnvironmentHexEncoded
,
1986 PACKET_QEnvironmentReset
,
1987 PACKET_QEnvironmentUnset
,
1989 PACKET_qSearch_memory
,
1992 PACKET_QStartNoAckMode
,
1994 PACKET_qXfer_siginfo_read
,
1995 PACKET_qXfer_siginfo_write
,
1998 /* Support for conditional tracepoints. */
1999 PACKET_ConditionalTracepoints
,
2001 /* Support for target-side breakpoint conditions. */
2002 PACKET_ConditionalBreakpoints
,
2004 /* Support for target-side breakpoint commands. */
2005 PACKET_BreakpointCommands
,
2007 /* Support for fast tracepoints. */
2008 PACKET_FastTracepoints
,
2010 /* Support for static tracepoints. */
2011 PACKET_StaticTracepoints
,
2013 /* Support for installing tracepoints while a trace experiment is
2015 PACKET_InstallInTrace
,
2019 PACKET_TracepointSource
,
2022 PACKET_QDisableRandomization
,
2024 PACKET_QTBuffer_size
,
2028 PACKET_qXfer_btrace
,
2030 /* Support for the QNonStop packet. */
2033 /* Support for the QThreadEvents packet. */
2034 PACKET_QThreadEvents
,
2036 /* Support for multi-process extensions. */
2037 PACKET_multiprocess_feature
,
2039 /* Support for enabling and disabling tracepoints while a trace
2040 experiment is running. */
2041 PACKET_EnableDisableTracepoints_feature
,
2043 /* Support for collecting strings using the tracenz bytecode. */
2044 PACKET_tracenz_feature
,
2046 /* Support for continuing to run a trace experiment while GDB is
2048 PACKET_DisconnectedTracing_feature
,
2050 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2051 PACKET_augmented_libraries_svr4_read_feature
,
2053 /* Support for the qXfer:btrace-conf:read packet. */
2054 PACKET_qXfer_btrace_conf
,
2056 /* Support for the Qbtrace-conf:bts:size packet. */
2057 PACKET_Qbtrace_conf_bts_size
,
2059 /* Support for swbreak+ feature. */
2060 PACKET_swbreak_feature
,
2062 /* Support for hwbreak+ feature. */
2063 PACKET_hwbreak_feature
,
2065 /* Support for fork events. */
2066 PACKET_fork_event_feature
,
2068 /* Support for vfork events. */
2069 PACKET_vfork_event_feature
,
2071 /* Support for the Qbtrace-conf:pt:size packet. */
2072 PACKET_Qbtrace_conf_pt_size
,
2074 /* Support for exec events. */
2075 PACKET_exec_event_feature
,
2077 /* Support for query supported vCont actions. */
2078 PACKET_vContSupported
,
2080 /* Support remote CTRL-C. */
2083 /* Support TARGET_WAITKIND_NO_RESUMED. */
2089 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
2091 /* Returns the packet's corresponding "set remote foo-packet" command
2092 state. See struct packet_config for more details. */
2094 static enum auto_boolean
2095 packet_set_cmd_state (int packet
)
2097 return remote_protocol_packets
[packet
].detect
;
2100 /* Returns whether a given packet or feature is supported. This takes
2101 into account the state of the corresponding "set remote foo-packet"
2102 command, which may be used to bypass auto-detection. */
2104 static enum packet_support
2105 packet_config_support (struct packet_config
*config
)
2107 switch (config
->detect
)
2109 case AUTO_BOOLEAN_TRUE
:
2110 return PACKET_ENABLE
;
2111 case AUTO_BOOLEAN_FALSE
:
2112 return PACKET_DISABLE
;
2113 case AUTO_BOOLEAN_AUTO
:
2114 return config
->support
;
2116 gdb_assert_not_reached (_("bad switch"));
2120 /* Same as packet_config_support, but takes the packet's enum value as
2123 static enum packet_support
2124 packet_support (int packet
)
2126 struct packet_config
*config
= &remote_protocol_packets
[packet
];
2128 return packet_config_support (config
);
2132 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
2133 struct cmd_list_element
*c
,
2136 struct packet_config
*packet
;
2138 for (packet
= remote_protocol_packets
;
2139 packet
< &remote_protocol_packets
[PACKET_MAX
];
2142 if (&packet
->detect
== c
->var
)
2144 show_packet_config_cmd (packet
);
2148 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
2152 /* Should we try one of the 'Z' requests? */
2156 Z_PACKET_SOFTWARE_BP
,
2157 Z_PACKET_HARDWARE_BP
,
2164 /* For compatibility with older distributions. Provide a ``set remote
2165 Z-packet ...'' command that updates all the Z packet types. */
2167 static enum auto_boolean remote_Z_packet_detect
;
2170 set_remote_protocol_Z_packet_cmd (const char *args
, int from_tty
,
2171 struct cmd_list_element
*c
)
2175 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2176 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
2180 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
2181 struct cmd_list_element
*c
,
2186 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2188 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
2192 /* Returns true if the multi-process extensions are in effect. */
2195 remote_multi_process_p (struct remote_state
*rs
)
2197 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
2200 /* Returns true if fork events are supported. */
2203 remote_fork_event_p (struct remote_state
*rs
)
2205 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
2208 /* Returns true if vfork events are supported. */
2211 remote_vfork_event_p (struct remote_state
*rs
)
2213 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
2216 /* Returns true if exec events are supported. */
2219 remote_exec_event_p (struct remote_state
*rs
)
2221 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
2224 /* Insert fork catchpoint target routine. If fork events are enabled
2225 then return success, nothing more to do. */
2228 remote_target::insert_fork_catchpoint (int pid
)
2230 struct remote_state
*rs
= get_remote_state ();
2232 return !remote_fork_event_p (rs
);
2235 /* Remove fork catchpoint target routine. Nothing to do, just
2239 remote_target::remove_fork_catchpoint (int pid
)
2244 /* Insert vfork catchpoint target routine. If vfork events are enabled
2245 then return success, nothing more to do. */
2248 remote_target::insert_vfork_catchpoint (int pid
)
2250 struct remote_state
*rs
= get_remote_state ();
2252 return !remote_vfork_event_p (rs
);
2255 /* Remove vfork catchpoint target routine. Nothing to do, just
2259 remote_target::remove_vfork_catchpoint (int pid
)
2264 /* Insert exec catchpoint target routine. If exec events are
2265 enabled, just return success. */
2268 remote_target::insert_exec_catchpoint (int pid
)
2270 struct remote_state
*rs
= get_remote_state ();
2272 return !remote_exec_event_p (rs
);
2275 /* Remove exec catchpoint target routine. Nothing to do, just
2279 remote_target::remove_exec_catchpoint (int pid
)
2286 /* Take advantage of the fact that the TID field is not used, to tag
2287 special ptids with it set to != 0. */
2288 static const ptid_t
magic_null_ptid (42000, -1, 1);
2289 static const ptid_t
not_sent_ptid (42000, -2, 1);
2290 static const ptid_t
any_thread_ptid (42000, 0, 1);
2292 /* Find out if the stub attached to PID (and hence GDB should offer to
2293 detach instead of killing it when bailing out). */
2296 remote_target::remote_query_attached (int pid
)
2298 struct remote_state
*rs
= get_remote_state ();
2299 size_t size
= get_remote_packet_size ();
2301 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
2304 if (remote_multi_process_p (rs
))
2305 xsnprintf (rs
->buf
.data (), size
, "qAttached:%x", pid
);
2307 xsnprintf (rs
->buf
.data (), size
, "qAttached");
2310 getpkt (&rs
->buf
, 0);
2312 switch (packet_ok (rs
->buf
,
2313 &remote_protocol_packets
[PACKET_qAttached
]))
2316 if (strcmp (rs
->buf
.data (), "1") == 0)
2320 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
2322 case PACKET_UNKNOWN
:
2329 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2330 has been invented by GDB, instead of reported by the target. Since
2331 we can be connected to a remote system before before knowing about
2332 any inferior, mark the target with execution when we find the first
2333 inferior. If ATTACHED is 1, then we had just attached to this
2334 inferior. If it is 0, then we just created this inferior. If it
2335 is -1, then try querying the remote stub to find out if it had
2336 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2337 attempt to open this inferior's executable as the main executable
2338 if no main executable is open already. */
2341 remote_target::remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
2344 struct inferior
*inf
;
2346 /* Check whether this process we're learning about is to be
2347 considered attached, or if is to be considered to have been
2348 spawned by the stub. */
2350 attached
= remote_query_attached (pid
);
2352 if (gdbarch_has_global_solist (target_gdbarch ()))
2354 /* If the target shares code across all inferiors, then every
2355 attach adds a new inferior. */
2356 inf
= add_inferior (pid
);
2358 /* ... and every inferior is bound to the same program space.
2359 However, each inferior may still have its own address
2361 inf
->aspace
= maybe_new_address_space ();
2362 inf
->pspace
= current_program_space
;
2366 /* In the traditional debugging scenario, there's a 1-1 match
2367 between program/address spaces. We simply bind the inferior
2368 to the program space's address space. */
2369 inf
= current_inferior ();
2370 inferior_appeared (inf
, pid
);
2373 inf
->attach_flag
= attached
;
2374 inf
->fake_pid_p
= fake_pid_p
;
2376 /* If no main executable is currently open then attempt to
2377 open the file that was executed to create this inferior. */
2378 if (try_open_exec
&& get_exec_file (0) == NULL
)
2379 exec_file_locate_attach (pid
, 0, 1);
2384 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2385 static remote_thread_info
*get_remote_thread_info (ptid_t ptid
);
2387 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2388 according to RUNNING. */
2391 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
)
2393 struct remote_state
*rs
= get_remote_state ();
2394 struct thread_info
*thread
;
2396 /* GDB historically didn't pull threads in the initial connection
2397 setup. If the remote target doesn't even have a concept of
2398 threads (e.g., a bare-metal target), even if internally we
2399 consider that a single-threaded target, mentioning a new thread
2400 might be confusing to the user. Be silent then, preserving the
2401 age old behavior. */
2402 if (rs
->starting_up
)
2403 thread
= add_thread_silent (ptid
);
2405 thread
= add_thread (ptid
);
2407 get_remote_thread_info (thread
)->vcont_resumed
= executing
;
2408 set_executing (ptid
, executing
);
2409 set_running (ptid
, running
);
2414 /* Come here when we learn about a thread id from the remote target.
2415 It may be the first time we hear about such thread, so take the
2416 opportunity to add it to GDB's thread list. In case this is the
2417 first time we're noticing its corresponding inferior, add it to
2418 GDB's inferior list as well. EXECUTING indicates whether the
2419 thread is (internally) executing or stopped. */
2422 remote_target::remote_notice_new_inferior (ptid_t currthread
, int executing
)
2424 /* In non-stop mode, we assume new found threads are (externally)
2425 running until proven otherwise with a stop reply. In all-stop,
2426 we can only get here if all threads are stopped. */
2427 int running
= target_is_non_stop_p () ? 1 : 0;
2429 /* If this is a new thread, add it to GDB's thread list.
2430 If we leave it up to WFI to do this, bad things will happen. */
2432 thread_info
*tp
= find_thread_ptid (currthread
);
2433 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2435 /* We're seeing an event on a thread id we knew had exited.
2436 This has to be a new thread reusing the old id. Add it. */
2437 remote_add_thread (currthread
, running
, executing
);
2441 if (!in_thread_list (currthread
))
2443 struct inferior
*inf
= NULL
;
2444 int pid
= currthread
.pid ();
2446 if (inferior_ptid
.is_pid ()
2447 && pid
== inferior_ptid
.pid ())
2449 /* inferior_ptid has no thread member yet. This can happen
2450 with the vAttach -> remote_wait,"TAAthread:" path if the
2451 stub doesn't support qC. This is the first stop reported
2452 after an attach, so this is the main thread. Update the
2453 ptid in the thread list. */
2454 if (in_thread_list (ptid_t (pid
)))
2455 thread_change_ptid (inferior_ptid
, currthread
);
2458 remote_add_thread (currthread
, running
, executing
);
2459 inferior_ptid
= currthread
;
2464 if (magic_null_ptid
== inferior_ptid
)
2466 /* inferior_ptid is not set yet. This can happen with the
2467 vRun -> remote_wait,"TAAthread:" path if the stub
2468 doesn't support qC. This is the first stop reported
2469 after an attach, so this is the main thread. Update the
2470 ptid in the thread list. */
2471 thread_change_ptid (inferior_ptid
, currthread
);
2475 /* When connecting to a target remote, or to a target
2476 extended-remote which already was debugging an inferior, we
2477 may not know about it yet. Add it before adding its child
2478 thread, so notifications are emitted in a sensible order. */
2479 if (find_inferior_pid (currthread
.pid ()) == NULL
)
2481 struct remote_state
*rs
= get_remote_state ();
2482 bool fake_pid_p
= !remote_multi_process_p (rs
);
2484 inf
= remote_add_inferior (fake_pid_p
,
2485 currthread
.pid (), -1, 1);
2488 /* This is really a new thread. Add it. */
2489 thread_info
*new_thr
2490 = remote_add_thread (currthread
, running
, executing
);
2492 /* If we found a new inferior, let the common code do whatever
2493 it needs to with it (e.g., read shared libraries, insert
2494 breakpoints), unless we're just setting up an all-stop
2498 struct remote_state
*rs
= get_remote_state ();
2500 if (!rs
->starting_up
)
2501 notice_new_inferior (new_thr
, executing
, 0);
2506 /* Return THREAD's private thread data, creating it if necessary. */
2508 static remote_thread_info
*
2509 get_remote_thread_info (thread_info
*thread
)
2511 gdb_assert (thread
!= NULL
);
2513 if (thread
->priv
== NULL
)
2514 thread
->priv
.reset (new remote_thread_info
);
2516 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2519 static remote_thread_info
*
2520 get_remote_thread_info (ptid_t ptid
)
2522 thread_info
*thr
= find_thread_ptid (ptid
);
2523 return get_remote_thread_info (thr
);
2526 /* Call this function as a result of
2527 1) A halt indication (T packet) containing a thread id
2528 2) A direct query of currthread
2529 3) Successful execution of set thread */
2532 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2534 rs
->general_thread
= currthread
;
2537 /* If 'QPassSignals' is supported, tell the remote stub what signals
2538 it can simply pass through to the inferior without reporting. */
2541 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2543 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2545 char *pass_packet
, *p
;
2547 struct remote_state
*rs
= get_remote_state ();
2549 gdb_assert (pass_signals
.size () < 256);
2550 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2552 if (pass_signals
[i
])
2555 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2556 strcpy (pass_packet
, "QPassSignals:");
2557 p
= pass_packet
+ strlen (pass_packet
);
2558 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2560 if (pass_signals
[i
])
2563 *p
++ = tohex (i
>> 4);
2564 *p
++ = tohex (i
& 15);
2573 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2575 putpkt (pass_packet
);
2576 getpkt (&rs
->buf
, 0);
2577 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2578 if (rs
->last_pass_packet
)
2579 xfree (rs
->last_pass_packet
);
2580 rs
->last_pass_packet
= pass_packet
;
2583 xfree (pass_packet
);
2587 /* If 'QCatchSyscalls' is supported, tell the remote stub
2588 to report syscalls to GDB. */
2591 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2592 gdb::array_view
<const int> syscall_counts
)
2594 const char *catch_packet
;
2595 enum packet_result result
;
2598 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2600 /* Not supported. */
2604 if (needed
&& any_count
== 0)
2606 /* Count how many syscalls are to be caught. */
2607 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2609 if (syscall_counts
[i
] != 0)
2616 fprintf_unfiltered (gdb_stdlog
,
2617 "remote_set_syscall_catchpoint "
2618 "pid %d needed %d any_count %d n_sysno %d\n",
2619 pid
, needed
, any_count
, n_sysno
);
2622 std::string built_packet
;
2625 /* Prepare a packet with the sysno list, assuming max 8+1
2626 characters for a sysno. If the resulting packet size is too
2627 big, fallback on the non-selective packet. */
2628 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2629 built_packet
.reserve (maxpktsz
);
2630 built_packet
= "QCatchSyscalls:1";
2633 /* Add in each syscall to be caught. */
2634 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2636 if (syscall_counts
[i
] != 0)
2637 string_appendf (built_packet
, ";%zx", i
);
2640 if (built_packet
.size () > get_remote_packet_size ())
2642 /* catch_packet too big. Fallback to less efficient
2643 non selective mode, with GDB doing the filtering. */
2644 catch_packet
= "QCatchSyscalls:1";
2647 catch_packet
= built_packet
.c_str ();
2650 catch_packet
= "QCatchSyscalls:0";
2652 struct remote_state
*rs
= get_remote_state ();
2654 putpkt (catch_packet
);
2655 getpkt (&rs
->buf
, 0);
2656 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2657 if (result
== PACKET_OK
)
2663 /* If 'QProgramSignals' is supported, tell the remote stub what
2664 signals it should pass through to the inferior when detaching. */
2667 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2669 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2673 struct remote_state
*rs
= get_remote_state ();
2675 gdb_assert (signals
.size () < 256);
2676 for (size_t i
= 0; i
< signals
.size (); i
++)
2681 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2682 strcpy (packet
, "QProgramSignals:");
2683 p
= packet
+ strlen (packet
);
2684 for (size_t i
= 0; i
< signals
.size (); i
++)
2686 if (signal_pass_state (i
))
2689 *p
++ = tohex (i
>> 4);
2690 *p
++ = tohex (i
& 15);
2699 if (!rs
->last_program_signals_packet
2700 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2703 getpkt (&rs
->buf
, 0);
2704 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2705 xfree (rs
->last_program_signals_packet
);
2706 rs
->last_program_signals_packet
= packet
;
2713 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2714 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2715 thread. If GEN is set, set the general thread, if not, then set
2716 the step/continue thread. */
2718 remote_target::set_thread (ptid_t ptid
, int gen
)
2720 struct remote_state
*rs
= get_remote_state ();
2721 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2722 char *buf
= rs
->buf
.data ();
2723 char *endbuf
= buf
+ get_remote_packet_size ();
2729 *buf
++ = gen
? 'g' : 'c';
2730 if (ptid
== magic_null_ptid
)
2731 xsnprintf (buf
, endbuf
- buf
, "0");
2732 else if (ptid
== any_thread_ptid
)
2733 xsnprintf (buf
, endbuf
- buf
, "0");
2734 else if (ptid
== minus_one_ptid
)
2735 xsnprintf (buf
, endbuf
- buf
, "-1");
2737 write_ptid (buf
, endbuf
, ptid
);
2739 getpkt (&rs
->buf
, 0);
2741 rs
->general_thread
= ptid
;
2743 rs
->continue_thread
= ptid
;
2747 remote_target::set_general_thread (ptid_t ptid
)
2749 set_thread (ptid
, 1);
2753 remote_target::set_continue_thread (ptid_t ptid
)
2755 set_thread (ptid
, 0);
2758 /* Change the remote current process. Which thread within the process
2759 ends up selected isn't important, as long as it is the same process
2760 as what INFERIOR_PTID points to.
2762 This comes from that fact that there is no explicit notion of
2763 "selected process" in the protocol. The selected process for
2764 general operations is the process the selected general thread
2768 remote_target::set_general_process ()
2770 struct remote_state
*rs
= get_remote_state ();
2772 /* If the remote can't handle multiple processes, don't bother. */
2773 if (!remote_multi_process_p (rs
))
2776 /* We only need to change the remote current thread if it's pointing
2777 at some other process. */
2778 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2779 set_general_thread (inferior_ptid
);
2783 /* Return nonzero if this is the main thread that we made up ourselves
2784 to model non-threaded targets as single-threaded. */
2787 remote_thread_always_alive (ptid_t ptid
)
2789 if (ptid
== magic_null_ptid
)
2790 /* The main thread is always alive. */
2793 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2794 /* The main thread is always alive. This can happen after a
2795 vAttach, if the remote side doesn't support
2802 /* Return nonzero if the thread PTID is still alive on the remote
2806 remote_target::thread_alive (ptid_t ptid
)
2808 struct remote_state
*rs
= get_remote_state ();
2811 /* Check if this is a thread that we made up ourselves to model
2812 non-threaded targets as single-threaded. */
2813 if (remote_thread_always_alive (ptid
))
2816 p
= rs
->buf
.data ();
2817 endp
= p
+ get_remote_packet_size ();
2820 write_ptid (p
, endp
, ptid
);
2823 getpkt (&rs
->buf
, 0);
2824 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2827 /* Return a pointer to a thread name if we know it and NULL otherwise.
2828 The thread_info object owns the memory for the name. */
2831 remote_target::thread_name (struct thread_info
*info
)
2833 if (info
->priv
!= NULL
)
2835 const std::string
&name
= get_remote_thread_info (info
)->name
;
2836 return !name
.empty () ? name
.c_str () : NULL
;
2842 /* About these extended threadlist and threadinfo packets. They are
2843 variable length packets but, the fields within them are often fixed
2844 length. They are redundant enough to send over UDP as is the
2845 remote protocol in general. There is a matching unit test module
2848 /* WARNING: This threadref data structure comes from the remote O.S.,
2849 libstub protocol encoding, and remote.c. It is not particularly
2852 /* Right now, the internal structure is int. We want it to be bigger.
2853 Plan to fix this. */
2855 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2857 /* gdb_ext_thread_info is an internal GDB data structure which is
2858 equivalent to the reply of the remote threadinfo packet. */
2860 struct gdb_ext_thread_info
2862 threadref threadid
; /* External form of thread reference. */
2863 int active
; /* Has state interesting to GDB?
2865 char display
[256]; /* Brief state display, name,
2866 blocked/suspended. */
2867 char shortname
[32]; /* To be used to name threads. */
2868 char more_display
[256]; /* Long info, statistics, queue depth,
2872 /* The volume of remote transfers can be limited by submitting
2873 a mask containing bits specifying the desired information.
2874 Use a union of these values as the 'selection' parameter to
2875 get_thread_info. FIXME: Make these TAG names more thread specific. */
2877 #define TAG_THREADID 1
2878 #define TAG_EXISTS 2
2879 #define TAG_DISPLAY 4
2880 #define TAG_THREADNAME 8
2881 #define TAG_MOREDISPLAY 16
2883 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2885 static char *unpack_nibble (char *buf
, int *val
);
2887 static char *unpack_byte (char *buf
, int *value
);
2889 static char *pack_int (char *buf
, int value
);
2891 static char *unpack_int (char *buf
, int *value
);
2893 static char *unpack_string (char *src
, char *dest
, int length
);
2895 static char *pack_threadid (char *pkt
, threadref
*id
);
2897 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2899 void int_to_threadref (threadref
*id
, int value
);
2901 static int threadref_to_int (threadref
*ref
);
2903 static void copy_threadref (threadref
*dest
, threadref
*src
);
2905 static int threadmatch (threadref
*dest
, threadref
*src
);
2907 static char *pack_threadinfo_request (char *pkt
, int mode
,
2910 static char *pack_threadlist_request (char *pkt
, int startflag
,
2912 threadref
*nextthread
);
2914 static int remote_newthread_step (threadref
*ref
, void *context
);
2917 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2918 buffer we're allowed to write to. Returns
2919 BUF+CHARACTERS_WRITTEN. */
2922 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2925 struct remote_state
*rs
= get_remote_state ();
2927 if (remote_multi_process_p (rs
))
2931 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2933 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2937 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2939 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2944 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2945 last parsed char. Returns null_ptid if no thread id is found, and
2946 throws an error if the thread id has an invalid format. */
2949 read_ptid (const char *buf
, const char **obuf
)
2951 const char *p
= buf
;
2953 ULONGEST pid
= 0, tid
= 0;
2957 /* Multi-process ptid. */
2958 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2960 error (_("invalid remote ptid: %s"), p
);
2963 pp
= unpack_varlen_hex (p
+ 1, &tid
);
2966 return ptid_t (pid
, tid
, 0);
2969 /* No multi-process. Just a tid. */
2970 pp
= unpack_varlen_hex (p
, &tid
);
2972 /* Return null_ptid when no thread id is found. */
2980 /* Since the stub is not sending a process id, then default to
2981 what's in inferior_ptid, unless it's null at this point. If so,
2982 then since there's no way to know the pid of the reported
2983 threads, use the magic number. */
2984 if (inferior_ptid
== null_ptid
)
2985 pid
= magic_null_ptid
.pid ();
2987 pid
= inferior_ptid
.pid ();
2991 return ptid_t (pid
, tid
, 0);
2997 if (ch
>= 'a' && ch
<= 'f')
2998 return ch
- 'a' + 10;
2999 if (ch
>= '0' && ch
<= '9')
3001 if (ch
>= 'A' && ch
<= 'F')
3002 return ch
- 'A' + 10;
3007 stub_unpack_int (char *buff
, int fieldlength
)
3014 nibble
= stubhex (*buff
++);
3018 retval
= retval
<< 4;
3024 unpack_nibble (char *buf
, int *val
)
3026 *val
= fromhex (*buf
++);
3031 unpack_byte (char *buf
, int *value
)
3033 *value
= stub_unpack_int (buf
, 2);
3038 pack_int (char *buf
, int value
)
3040 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3041 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3042 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3043 buf
= pack_hex_byte (buf
, (value
& 0xff));
3048 unpack_int (char *buf
, int *value
)
3050 *value
= stub_unpack_int (buf
, 8);
3054 #if 0 /* Currently unused, uncomment when needed. */
3055 static char *pack_string (char *pkt
, char *string
);
3058 pack_string (char *pkt
, char *string
)
3063 len
= strlen (string
);
3065 len
= 200; /* Bigger than most GDB packets, junk??? */
3066 pkt
= pack_hex_byte (pkt
, len
);
3070 if ((ch
== '\0') || (ch
== '#'))
3071 ch
= '*'; /* Protect encapsulation. */
3076 #endif /* 0 (unused) */
3079 unpack_string (char *src
, char *dest
, int length
)
3088 pack_threadid (char *pkt
, threadref
*id
)
3091 unsigned char *altid
;
3093 altid
= (unsigned char *) id
;
3094 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3096 pkt
= pack_hex_byte (pkt
, *altid
++);
3102 unpack_threadid (char *inbuf
, threadref
*id
)
3105 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3108 altref
= (char *) id
;
3110 while (inbuf
< limit
)
3112 x
= stubhex (*inbuf
++);
3113 y
= stubhex (*inbuf
++);
3114 *altref
++ = (x
<< 4) | y
;
3119 /* Externally, threadrefs are 64 bits but internally, they are still
3120 ints. This is due to a mismatch of specifications. We would like
3121 to use 64bit thread references internally. This is an adapter
3125 int_to_threadref (threadref
*id
, int value
)
3127 unsigned char *scan
;
3129 scan
= (unsigned char *) id
;
3135 *scan
++ = (value
>> 24) & 0xff;
3136 *scan
++ = (value
>> 16) & 0xff;
3137 *scan
++ = (value
>> 8) & 0xff;
3138 *scan
++ = (value
& 0xff);
3142 threadref_to_int (threadref
*ref
)
3145 unsigned char *scan
;
3151 value
= (value
<< 8) | ((*scan
++) & 0xff);
3156 copy_threadref (threadref
*dest
, threadref
*src
)
3159 unsigned char *csrc
, *cdest
;
3161 csrc
= (unsigned char *) src
;
3162 cdest
= (unsigned char *) dest
;
3169 threadmatch (threadref
*dest
, threadref
*src
)
3171 /* Things are broken right now, so just assume we got a match. */
3173 unsigned char *srcp
, *destp
;
3175 srcp
= (char *) src
;
3176 destp
= (char *) dest
;
3180 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3187 threadid:1, # always request threadid
3194 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3197 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3199 *pkt
++ = 'q'; /* Info Query */
3200 *pkt
++ = 'P'; /* process or thread info */
3201 pkt
= pack_int (pkt
, mode
); /* mode */
3202 pkt
= pack_threadid (pkt
, id
); /* threadid */
3203 *pkt
= '\0'; /* terminate */
3207 /* These values tag the fields in a thread info response packet. */
3208 /* Tagging the fields allows us to request specific fields and to
3209 add more fields as time goes by. */
3211 #define TAG_THREADID 1 /* Echo the thread identifier. */
3212 #define TAG_EXISTS 2 /* Is this process defined enough to
3213 fetch registers and its stack? */
3214 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3215 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3216 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3220 remote_target::remote_unpack_thread_info_response (char *pkt
,
3221 threadref
*expectedref
,
3222 gdb_ext_thread_info
*info
)
3224 struct remote_state
*rs
= get_remote_state ();
3228 char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3231 /* info->threadid = 0; FIXME: implement zero_threadref. */
3233 info
->display
[0] = '\0';
3234 info
->shortname
[0] = '\0';
3235 info
->more_display
[0] = '\0';
3237 /* Assume the characters indicating the packet type have been
3239 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3240 pkt
= unpack_threadid (pkt
, &ref
);
3243 warning (_("Incomplete response to threadinfo request."));
3244 if (!threadmatch (&ref
, expectedref
))
3245 { /* This is an answer to a different request. */
3246 warning (_("ERROR RMT Thread info mismatch."));
3249 copy_threadref (&info
->threadid
, &ref
);
3251 /* Loop on tagged fields , try to bail if something goes wrong. */
3253 /* Packets are terminated with nulls. */
3254 while ((pkt
< limit
) && mask
&& *pkt
)
3256 pkt
= unpack_int (pkt
, &tag
); /* tag */
3257 pkt
= unpack_byte (pkt
, &length
); /* length */
3258 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3260 warning (_("ERROR RMT: threadinfo tag mismatch."));
3264 if (tag
== TAG_THREADID
)
3268 warning (_("ERROR RMT: length of threadid is not 16."));
3272 pkt
= unpack_threadid (pkt
, &ref
);
3273 mask
= mask
& ~TAG_THREADID
;
3276 if (tag
== TAG_EXISTS
)
3278 info
->active
= stub_unpack_int (pkt
, length
);
3280 mask
= mask
& ~(TAG_EXISTS
);
3283 warning (_("ERROR RMT: 'exists' length too long."));
3289 if (tag
== TAG_THREADNAME
)
3291 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3292 mask
= mask
& ~TAG_THREADNAME
;
3295 if (tag
== TAG_DISPLAY
)
3297 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3298 mask
= mask
& ~TAG_DISPLAY
;
3301 if (tag
== TAG_MOREDISPLAY
)
3303 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3304 mask
= mask
& ~TAG_MOREDISPLAY
;
3307 warning (_("ERROR RMT: unknown thread info tag."));
3308 break; /* Not a tag we know about. */
3314 remote_target::remote_get_threadinfo (threadref
*threadid
,
3316 gdb_ext_thread_info
*info
)
3318 struct remote_state
*rs
= get_remote_state ();
3321 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3323 getpkt (&rs
->buf
, 0);
3325 if (rs
->buf
[0] == '\0')
3328 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3333 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3336 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3337 threadref
*nextthread
)
3339 *pkt
++ = 'q'; /* info query packet */
3340 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3341 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3342 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3343 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3348 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3351 remote_target::parse_threadlist_response (char *pkt
, int result_limit
,
3352 threadref
*original_echo
,
3353 threadref
*resultlist
,
3356 struct remote_state
*rs
= get_remote_state ();
3358 int count
, resultcount
, done
;
3361 /* Assume the 'q' and 'M chars have been stripped. */
3362 limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3363 /* done parse past here */
3364 pkt
= unpack_byte (pkt
, &count
); /* count field */
3365 pkt
= unpack_nibble (pkt
, &done
);
3366 /* The first threadid is the argument threadid. */
3367 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3368 while ((count
-- > 0) && (pkt
< limit
))
3370 pkt
= unpack_threadid (pkt
, resultlist
++);
3371 if (resultcount
++ >= result_limit
)
3379 /* Fetch the next batch of threads from the remote. Returns -1 if the
3380 qL packet is not supported, 0 on error and 1 on success. */
3383 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3384 int result_limit
, int *done
, int *result_count
,
3385 threadref
*threadlist
)
3387 struct remote_state
*rs
= get_remote_state ();
3390 /* Truncate result limit to be smaller than the packet size. */
3391 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3392 >= get_remote_packet_size ())
3393 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3395 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3398 getpkt (&rs
->buf
, 0);
3399 if (rs
->buf
[0] == '\0')
3401 /* Packet not supported. */
3406 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3407 &rs
->echo_nextthread
, threadlist
, done
);
3409 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3411 /* FIXME: This is a good reason to drop the packet. */
3412 /* Possibly, there is a duplicate response. */
3414 retransmit immediatly - race conditions
3415 retransmit after timeout - yes
3417 wait for packet, then exit
3419 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3420 return 0; /* I choose simply exiting. */
3422 if (*result_count
<= 0)
3426 warning (_("RMT ERROR : failed to get remote thread list."));
3429 return result
; /* break; */
3431 if (*result_count
> result_limit
)
3434 warning (_("RMT ERROR: threadlist response longer than requested."));
3440 /* Fetch the list of remote threads, with the qL packet, and call
3441 STEPFUNCTION for each thread found. Stops iterating and returns 1
3442 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3443 STEPFUNCTION returns false. If the packet is not supported,
3447 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3448 void *context
, int looplimit
)
3450 struct remote_state
*rs
= get_remote_state ();
3451 int done
, i
, result_count
;
3459 if (loopcount
++ > looplimit
)
3462 warning (_("Remote fetch threadlist -infinite loop-."));
3465 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3466 MAXTHREADLISTRESULTS
,
3467 &done
, &result_count
,
3468 rs
->resultthreadlist
);
3471 /* Clear for later iterations. */
3473 /* Setup to resume next batch of thread references, set nextthread. */
3474 if (result_count
>= 1)
3475 copy_threadref (&rs
->nextthread
,
3476 &rs
->resultthreadlist
[result_count
- 1]);
3478 while (result_count
--)
3480 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3490 /* A thread found on the remote target. */
3494 explicit thread_item (ptid_t ptid_
)
3498 thread_item (thread_item
&&other
) = default;
3499 thread_item
&operator= (thread_item
&&other
) = default;
3501 DISABLE_COPY_AND_ASSIGN (thread_item
);
3503 /* The thread's PTID. */
3506 /* The thread's extra info. */
3509 /* The thread's name. */
3512 /* The core the thread was running on. -1 if not known. */
3515 /* The thread handle associated with the thread. */
3516 gdb::byte_vector thread_handle
;
3519 /* Context passed around to the various methods listing remote
3520 threads. As new threads are found, they're added to the ITEMS
3523 struct threads_listing_context
3525 /* Return true if this object contains an entry for a thread with ptid
3528 bool contains_thread (ptid_t ptid
) const
3530 auto match_ptid
= [&] (const thread_item
&item
)
3532 return item
.ptid
== ptid
;
3535 auto it
= std::find_if (this->items
.begin (),
3539 return it
!= this->items
.end ();
3542 /* Remove the thread with ptid PTID. */
3544 void remove_thread (ptid_t ptid
)
3546 auto match_ptid
= [&] (const thread_item
&item
)
3548 return item
.ptid
== ptid
;
3551 auto it
= std::remove_if (this->items
.begin (),
3555 if (it
!= this->items
.end ())
3556 this->items
.erase (it
);
3559 /* The threads found on the remote target. */
3560 std::vector
<thread_item
> items
;
3564 remote_newthread_step (threadref
*ref
, void *data
)
3566 struct threads_listing_context
*context
3567 = (struct threads_listing_context
*) data
;
3568 int pid
= inferior_ptid
.pid ();
3569 int lwp
= threadref_to_int (ref
);
3570 ptid_t
ptid (pid
, lwp
);
3572 context
->items
.emplace_back (ptid
);
3574 return 1; /* continue iterator */
3577 #define CRAZY_MAX_THREADS 1000
3580 remote_target::remote_current_thread (ptid_t oldpid
)
3582 struct remote_state
*rs
= get_remote_state ();
3585 getpkt (&rs
->buf
, 0);
3586 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3591 result
= read_ptid (&rs
->buf
[2], &obuf
);
3592 if (*obuf
!= '\0' && remote_debug
)
3593 fprintf_unfiltered (gdb_stdlog
,
3594 "warning: garbage in qC reply\n");
3602 /* List remote threads using the deprecated qL packet. */
3605 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3607 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3608 CRAZY_MAX_THREADS
) >= 0)
3614 #if defined(HAVE_LIBEXPAT)
3617 start_thread (struct gdb_xml_parser
*parser
,
3618 const struct gdb_xml_element
*element
,
3620 std::vector
<gdb_xml_value
> &attributes
)
3622 struct threads_listing_context
*data
3623 = (struct threads_listing_context
*) user_data
;
3624 struct gdb_xml_value
*attr
;
3626 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3627 ptid_t ptid
= read_ptid (id
, NULL
);
3629 data
->items
.emplace_back (ptid
);
3630 thread_item
&item
= data
->items
.back ();
3632 attr
= xml_find_attribute (attributes
, "core");
3634 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3636 attr
= xml_find_attribute (attributes
, "name");
3638 item
.name
= (const char *) attr
->value
.get ();
3640 attr
= xml_find_attribute (attributes
, "handle");
3642 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3646 end_thread (struct gdb_xml_parser
*parser
,
3647 const struct gdb_xml_element
*element
,
3648 void *user_data
, const char *body_text
)
3650 struct threads_listing_context
*data
3651 = (struct threads_listing_context
*) user_data
;
3653 if (body_text
!= NULL
&& *body_text
!= '\0')
3654 data
->items
.back ().extra
= body_text
;
3657 const struct gdb_xml_attribute thread_attributes
[] = {
3658 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3659 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3660 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3661 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3662 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3665 const struct gdb_xml_element thread_children
[] = {
3666 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3669 const struct gdb_xml_element threads_children
[] = {
3670 { "thread", thread_attributes
, thread_children
,
3671 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3672 start_thread
, end_thread
},
3673 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3676 const struct gdb_xml_element threads_elements
[] = {
3677 { "threads", NULL
, threads_children
,
3678 GDB_XML_EF_NONE
, NULL
, NULL
},
3679 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3684 /* List remote threads using qXfer:threads:read. */
3687 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3689 #if defined(HAVE_LIBEXPAT)
3690 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3692 gdb::optional
<gdb::char_vector
> xml
3693 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3695 if (xml
&& (*xml
)[0] != '\0')
3697 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3698 threads_elements
, xml
->data (), context
);
3708 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3711 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3713 struct remote_state
*rs
= get_remote_state ();
3715 if (rs
->use_threadinfo_query
)
3719 putpkt ("qfThreadInfo");
3720 getpkt (&rs
->buf
, 0);
3721 bufp
= rs
->buf
.data ();
3722 if (bufp
[0] != '\0') /* q packet recognized */
3724 while (*bufp
++ == 'm') /* reply contains one or more TID */
3728 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3729 context
->items
.emplace_back (ptid
);
3731 while (*bufp
++ == ','); /* comma-separated list */
3732 putpkt ("qsThreadInfo");
3733 getpkt (&rs
->buf
, 0);
3734 bufp
= rs
->buf
.data ();
3740 /* Packet not recognized. */
3741 rs
->use_threadinfo_query
= 0;
3748 /* Implement the to_update_thread_list function for the remote
3752 remote_target::update_thread_list ()
3754 struct threads_listing_context context
;
3757 /* We have a few different mechanisms to fetch the thread list. Try
3758 them all, starting with the most preferred one first, falling
3759 back to older methods. */
3760 if (remote_get_threads_with_qxfer (&context
)
3761 || remote_get_threads_with_qthreadinfo (&context
)
3762 || remote_get_threads_with_ql (&context
))
3766 if (context
.items
.empty ()
3767 && remote_thread_always_alive (inferior_ptid
))
3769 /* Some targets don't really support threads, but still
3770 reply an (empty) thread list in response to the thread
3771 listing packets, instead of replying "packet not
3772 supported". Exit early so we don't delete the main
3777 /* CONTEXT now holds the current thread list on the remote
3778 target end. Delete GDB-side threads no longer found on the
3780 for (thread_info
*tp
: all_threads_safe ())
3782 if (!context
.contains_thread (tp
->ptid
))
3789 /* Remove any unreported fork child threads from CONTEXT so
3790 that we don't interfere with follow fork, which is where
3791 creation of such threads is handled. */
3792 remove_new_fork_children (&context
);
3794 /* And now add threads we don't know about yet to our list. */
3795 for (thread_item
&item
: context
.items
)
3797 if (item
.ptid
!= null_ptid
)
3799 /* In non-stop mode, we assume new found threads are
3800 executing until proven otherwise with a stop reply.
3801 In all-stop, we can only get here if all threads are
3803 int executing
= target_is_non_stop_p () ? 1 : 0;
3805 remote_notice_new_inferior (item
.ptid
, executing
);
3807 thread_info
*tp
= find_thread_ptid (item
.ptid
);
3808 remote_thread_info
*info
= get_remote_thread_info (tp
);
3809 info
->core
= item
.core
;
3810 info
->extra
= std::move (item
.extra
);
3811 info
->name
= std::move (item
.name
);
3812 info
->thread_handle
= std::move (item
.thread_handle
);
3819 /* If no thread listing method is supported, then query whether
3820 each known thread is alive, one by one, with the T packet.
3821 If the target doesn't support threads at all, then this is a
3822 no-op. See remote_thread_alive. */
3828 * Collect a descriptive string about the given thread.
3829 * The target may say anything it wants to about the thread
3830 * (typically info about its blocked / runnable state, name, etc.).
3831 * This string will appear in the info threads display.
3833 * Optional: targets are not required to implement this function.
3837 remote_target::extra_thread_info (thread_info
*tp
)
3839 struct remote_state
*rs
= get_remote_state ();
3842 struct gdb_ext_thread_info threadinfo
;
3844 if (rs
->remote_desc
== 0) /* paranoia */
3845 internal_error (__FILE__
, __LINE__
,
3846 _("remote_threads_extra_info"));
3848 if (tp
->ptid
== magic_null_ptid
3849 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
3850 /* This is the main thread which was added by GDB. The remote
3851 server doesn't know about it. */
3854 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
3856 /* If already have cached info, use it. */
3857 if (!extra
.empty ())
3858 return extra
.c_str ();
3860 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3862 /* If we're using qXfer:threads:read, then the extra info is
3863 included in the XML. So if we didn't have anything cached,
3864 it's because there's really no extra info. */
3868 if (rs
->use_threadextra_query
)
3870 char *b
= rs
->buf
.data ();
3871 char *endb
= b
+ get_remote_packet_size ();
3873 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3875 write_ptid (b
, endb
, tp
->ptid
);
3878 getpkt (&rs
->buf
, 0);
3879 if (rs
->buf
[0] != 0)
3881 extra
.resize (strlen (rs
->buf
.data ()) / 2);
3882 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
3883 return extra
.c_str ();
3887 /* If the above query fails, fall back to the old method. */
3888 rs
->use_threadextra_query
= 0;
3889 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3890 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3891 int_to_threadref (&id
, tp
->ptid
.lwp ());
3892 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3893 if (threadinfo
.active
)
3895 if (*threadinfo
.shortname
)
3896 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
3897 if (*threadinfo
.display
)
3899 if (!extra
.empty ())
3901 string_appendf (extra
, " State: %s", threadinfo
.display
);
3903 if (*threadinfo
.more_display
)
3905 if (!extra
.empty ())
3907 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
3909 return extra
.c_str ();
3916 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
3917 struct static_tracepoint_marker
*marker
)
3919 struct remote_state
*rs
= get_remote_state ();
3920 char *p
= rs
->buf
.data ();
3922 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3924 p
+= hexnumstr (p
, addr
);
3926 getpkt (&rs
->buf
, 0);
3927 p
= rs
->buf
.data ();
3930 error (_("Remote failure reply: %s"), p
);
3934 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
3941 std::vector
<static_tracepoint_marker
>
3942 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
3944 struct remote_state
*rs
= get_remote_state ();
3945 std::vector
<static_tracepoint_marker
> markers
;
3947 static_tracepoint_marker marker
;
3949 /* Ask for a first packet of static tracepoint marker
3952 getpkt (&rs
->buf
, 0);
3953 p
= rs
->buf
.data ();
3955 error (_("Remote failure reply: %s"), p
);
3961 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
3963 if (strid
== NULL
|| marker
.str_id
== strid
)
3964 markers
.push_back (std::move (marker
));
3966 while (*p
++ == ','); /* comma-separated list */
3967 /* Ask for another packet of static tracepoint definition. */
3969 getpkt (&rs
->buf
, 0);
3970 p
= rs
->buf
.data ();
3977 /* Implement the to_get_ada_task_ptid function for the remote targets. */
3980 remote_target::get_ada_task_ptid (long lwp
, long thread
)
3982 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3986 /* Restart the remote side; this is an extended protocol operation. */
3989 remote_target::extended_remote_restart ()
3991 struct remote_state
*rs
= get_remote_state ();
3993 /* Send the restart command; for reasons I don't understand the
3994 remote side really expects a number after the "R". */
3995 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
3998 remote_fileio_reset ();
4001 /* Clean up connection to a remote debugger. */
4004 remote_target::close ()
4006 /* Make sure we leave stdin registered in the event loop. */
4009 /* We don't have a connection to the remote stub anymore. Get rid
4010 of all the inferiors and their threads we were controlling.
4011 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
4012 will be unable to find the thread corresponding to (pid, 0, 0). */
4013 inferior_ptid
= null_ptid
;
4014 discard_all_inferiors ();
4016 trace_reset_local_state ();
4021 remote_target::~remote_target ()
4023 struct remote_state
*rs
= get_remote_state ();
4025 /* Check for NULL because we may get here with a partially
4026 constructed target/connection. */
4027 if (rs
->remote_desc
== nullptr)
4030 serial_close (rs
->remote_desc
);
4032 /* We are destroying the remote target, so we should discard
4033 everything of this target. */
4034 discard_pending_stop_replies_in_queue ();
4036 if (rs
->remote_async_inferior_event_token
)
4037 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4039 delete rs
->notif_state
;
4042 /* Query the remote side for the text, data and bss offsets. */
4045 remote_target::get_offsets ()
4047 struct remote_state
*rs
= get_remote_state ();
4050 int lose
, num_segments
= 0, do_sections
, do_segments
;
4051 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4052 struct symfile_segment_data
*data
;
4054 if (symfile_objfile
== NULL
)
4057 putpkt ("qOffsets");
4058 getpkt (&rs
->buf
, 0);
4059 buf
= rs
->buf
.data ();
4061 if (buf
[0] == '\000')
4062 return; /* Return silently. Stub doesn't support
4066 warning (_("Remote failure reply: %s"), buf
);
4070 /* Pick up each field in turn. This used to be done with scanf, but
4071 scanf will make trouble if CORE_ADDR size doesn't match
4072 conversion directives correctly. The following code will work
4073 with any size of CORE_ADDR. */
4074 text_addr
= data_addr
= bss_addr
= 0;
4078 if (startswith (ptr
, "Text="))
4081 /* Don't use strtol, could lose on big values. */
4082 while (*ptr
&& *ptr
!= ';')
4083 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4085 if (startswith (ptr
, ";Data="))
4088 while (*ptr
&& *ptr
!= ';')
4089 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4094 if (!lose
&& startswith (ptr
, ";Bss="))
4097 while (*ptr
&& *ptr
!= ';')
4098 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4100 if (bss_addr
!= data_addr
)
4101 warning (_("Target reported unsupported offsets: %s"), buf
);
4106 else if (startswith (ptr
, "TextSeg="))
4109 /* Don't use strtol, could lose on big values. */
4110 while (*ptr
&& *ptr
!= ';')
4111 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4114 if (startswith (ptr
, ";DataSeg="))
4117 while (*ptr
&& *ptr
!= ';')
4118 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4126 error (_("Malformed response to offset query, %s"), buf
);
4127 else if (*ptr
!= '\0')
4128 warning (_("Target reported unsupported offsets: %s"), buf
);
4130 section_offsets offs
= symfile_objfile
->section_offsets
;
4132 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
4133 do_segments
= (data
!= NULL
);
4134 do_sections
= num_segments
== 0;
4136 if (num_segments
> 0)
4138 segments
[0] = text_addr
;
4139 segments
[1] = data_addr
;
4141 /* If we have two segments, we can still try to relocate everything
4142 by assuming that the .text and .data offsets apply to the whole
4143 text and data segments. Convert the offsets given in the packet
4144 to base addresses for symfile_map_offsets_to_segments. */
4145 else if (data
&& data
->num_segments
== 2)
4147 segments
[0] = data
->segment_bases
[0] + text_addr
;
4148 segments
[1] = data
->segment_bases
[1] + data_addr
;
4151 /* If the object file has only one segment, assume that it is text
4152 rather than data; main programs with no writable data are rare,
4153 but programs with no code are useless. Of course the code might
4154 have ended up in the data segment... to detect that we would need
4155 the permissions here. */
4156 else if (data
&& data
->num_segments
== 1)
4158 segments
[0] = data
->segment_bases
[0] + text_addr
;
4161 /* There's no way to relocate by segment. */
4167 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
4168 offs
, num_segments
, segments
);
4170 if (ret
== 0 && !do_sections
)
4171 error (_("Can not handle qOffsets TextSeg "
4172 "response with this symbol file"));
4179 free_symfile_segment_data (data
);
4183 offs
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
4185 /* This is a temporary kludge to force data and bss to use the
4186 same offsets because that's what nlmconv does now. The real
4187 solution requires changes to the stub and remote.c that I
4188 don't have time to do right now. */
4190 offs
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
4191 offs
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
4194 objfile_relocate (symfile_objfile
, offs
);
4197 /* Send interrupt_sequence to remote target. */
4200 remote_target::send_interrupt_sequence ()
4202 struct remote_state
*rs
= get_remote_state ();
4204 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4205 remote_serial_write ("\x03", 1);
4206 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4207 serial_send_break (rs
->remote_desc
);
4208 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4210 serial_send_break (rs
->remote_desc
);
4211 remote_serial_write ("g", 1);
4214 internal_error (__FILE__
, __LINE__
,
4215 _("Invalid value for interrupt_sequence_mode: %s."),
4216 interrupt_sequence_mode
);
4220 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4221 and extract the PTID. Returns NULL_PTID if not found. */
4224 stop_reply_extract_thread (char *stop_reply
)
4226 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4230 /* Txx r:val ; r:val (...) */
4233 /* Look for "register" named "thread". */
4238 p1
= strchr (p
, ':');
4242 if (strncmp (p
, "thread", p1
- p
) == 0)
4243 return read_ptid (++p1
, &p
);
4245 p1
= strchr (p
, ';');
4257 /* Determine the remote side's current thread. If we have a stop
4258 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4259 "thread" register we can extract the current thread from. If not,
4260 ask the remote which is the current thread with qC. The former
4261 method avoids a roundtrip. */
4264 remote_target::get_current_thread (char *wait_status
)
4266 ptid_t ptid
= null_ptid
;
4268 /* Note we don't use remote_parse_stop_reply as that makes use of
4269 the target architecture, which we haven't yet fully determined at
4271 if (wait_status
!= NULL
)
4272 ptid
= stop_reply_extract_thread (wait_status
);
4273 if (ptid
== null_ptid
)
4274 ptid
= remote_current_thread (inferior_ptid
);
4279 /* Query the remote target for which is the current thread/process,
4280 add it to our tables, and update INFERIOR_PTID. The caller is
4281 responsible for setting the state such that the remote end is ready
4282 to return the current thread.
4284 This function is called after handling the '?' or 'vRun' packets,
4285 whose response is a stop reply from which we can also try
4286 extracting the thread. If the target doesn't support the explicit
4287 qC query, we infer the current thread from that stop reply, passed
4288 in in WAIT_STATUS, which may be NULL. */
4291 remote_target::add_current_inferior_and_thread (char *wait_status
)
4293 struct remote_state
*rs
= get_remote_state ();
4294 bool fake_pid_p
= false;
4296 inferior_ptid
= null_ptid
;
4298 /* Now, if we have thread information, update inferior_ptid. */
4299 ptid_t curr_ptid
= get_current_thread (wait_status
);
4301 if (curr_ptid
!= null_ptid
)
4303 if (!remote_multi_process_p (rs
))
4308 /* Without this, some commands which require an active target
4309 (such as kill) won't work. This variable serves (at least)
4310 double duty as both the pid of the target process (if it has
4311 such), and as a flag indicating that a target is active. */
4312 curr_ptid
= magic_null_ptid
;
4316 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4318 /* Add the main thread and switch to it. Don't try reading
4319 registers yet, since we haven't fetched the target description
4321 thread_info
*tp
= add_thread_silent (curr_ptid
);
4322 switch_to_thread_no_regs (tp
);
4325 /* Print info about a thread that was found already stopped on
4329 print_one_stopped_thread (struct thread_info
*thread
)
4331 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4333 switch_to_thread (thread
);
4334 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4335 set_current_sal_from_frame (get_current_frame ());
4337 thread
->suspend
.waitstatus_pending_p
= 0;
4339 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4341 enum gdb_signal sig
= ws
->value
.sig
;
4343 if (signal_print_state (sig
))
4344 gdb::observers::signal_received
.notify (sig
);
4346 gdb::observers::normal_stop
.notify (NULL
, 1);
4349 /* Process all initial stop replies the remote side sent in response
4350 to the ? packet. These indicate threads that were already stopped
4351 on initial connection. We mark these threads as stopped and print
4352 their current frame before giving the user the prompt. */
4355 remote_target::process_initial_stop_replies (int from_tty
)
4357 int pending_stop_replies
= stop_reply_queue_length ();
4358 struct thread_info
*selected
= NULL
;
4359 struct thread_info
*lowest_stopped
= NULL
;
4360 struct thread_info
*first
= NULL
;
4362 /* Consume the initial pending events. */
4363 while (pending_stop_replies
-- > 0)
4365 ptid_t waiton_ptid
= minus_one_ptid
;
4367 struct target_waitstatus ws
;
4368 int ignore_event
= 0;
4370 memset (&ws
, 0, sizeof (ws
));
4371 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4373 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4377 case TARGET_WAITKIND_IGNORE
:
4378 case TARGET_WAITKIND_NO_RESUMED
:
4379 case TARGET_WAITKIND_SIGNALLED
:
4380 case TARGET_WAITKIND_EXITED
:
4381 /* We shouldn't see these, but if we do, just ignore. */
4383 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
4387 case TARGET_WAITKIND_EXECD
:
4388 xfree (ws
.value
.execd_pathname
);
4397 struct thread_info
*evthread
= find_thread_ptid (event_ptid
);
4399 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4401 enum gdb_signal sig
= ws
.value
.sig
;
4403 /* Stubs traditionally report SIGTRAP as initial signal,
4404 instead of signal 0. Suppress it. */
4405 if (sig
== GDB_SIGNAL_TRAP
)
4407 evthread
->suspend
.stop_signal
= sig
;
4411 evthread
->suspend
.waitstatus
= ws
;
4413 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4414 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4415 evthread
->suspend
.waitstatus_pending_p
= 1;
4417 set_executing (event_ptid
, 0);
4418 set_running (event_ptid
, 0);
4419 get_remote_thread_info (evthread
)->vcont_resumed
= 0;
4422 /* "Notice" the new inferiors before anything related to
4423 registers/memory. */
4424 for (inferior
*inf
: all_non_exited_inferiors ())
4426 inf
->needs_setup
= 1;
4430 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4431 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4436 /* If all-stop on top of non-stop, pause all threads. Note this
4437 records the threads' stop pc, so must be done after "noticing"
4441 stop_all_threads ();
4443 /* If all threads of an inferior were already stopped, we
4444 haven't setup the inferior yet. */
4445 for (inferior
*inf
: all_non_exited_inferiors ())
4447 if (inf
->needs_setup
)
4449 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4450 switch_to_thread_no_regs (thread
);
4456 /* Now go over all threads that are stopped, and print their current
4457 frame. If all-stop, then if there's a signalled thread, pick
4459 for (thread_info
*thread
: all_non_exited_threads ())
4465 thread
->set_running (false);
4466 else if (thread
->state
!= THREAD_STOPPED
)
4469 if (selected
== NULL
4470 && thread
->suspend
.waitstatus_pending_p
)
4473 if (lowest_stopped
== NULL
4474 || thread
->inf
->num
< lowest_stopped
->inf
->num
4475 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4476 lowest_stopped
= thread
;
4479 print_one_stopped_thread (thread
);
4482 /* In all-stop, we only print the status of one thread, and leave
4483 others with their status pending. */
4486 thread_info
*thread
= selected
;
4488 thread
= lowest_stopped
;
4492 print_one_stopped_thread (thread
);
4495 /* For "info program". */
4496 thread_info
*thread
= inferior_thread ();
4497 if (thread
->state
== THREAD_STOPPED
)
4498 set_last_target_status (inferior_ptid
, thread
->suspend
.waitstatus
);
4501 /* Start the remote connection and sync state. */
4504 remote_target::start_remote (int from_tty
, int extended_p
)
4506 struct remote_state
*rs
= get_remote_state ();
4507 struct packet_config
*noack_config
;
4508 char *wait_status
= NULL
;
4510 /* Signal other parts that we're going through the initial setup,
4511 and so things may not be stable yet. E.g., we don't try to
4512 install tracepoints until we've relocated symbols. Also, a
4513 Ctrl-C before we're connected and synced up can't interrupt the
4514 target. Instead, it offers to drop the (potentially wedged)
4516 rs
->starting_up
= 1;
4520 if (interrupt_on_connect
)
4521 send_interrupt_sequence ();
4523 /* Ack any packet which the remote side has already sent. */
4524 remote_serial_write ("+", 1);
4526 /* The first packet we send to the target is the optional "supported
4527 packets" request. If the target can answer this, it will tell us
4528 which later probes to skip. */
4529 remote_query_supported ();
4531 /* If the stub wants to get a QAllow, compose one and send it. */
4532 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4535 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4536 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4537 as a reply to known packet. For packet "vFile:setfs:" it is an
4538 invalid reply and GDB would return error in
4539 remote_hostio_set_filesystem, making remote files access impossible.
4540 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4541 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4543 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4545 putpkt (v_mustreplyempty
);
4546 getpkt (&rs
->buf
, 0);
4547 if (strcmp (rs
->buf
.data (), "OK") == 0)
4548 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4549 else if (strcmp (rs
->buf
.data (), "") != 0)
4550 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4554 /* Next, we possibly activate noack mode.
4556 If the QStartNoAckMode packet configuration is set to AUTO,
4557 enable noack mode if the stub reported a wish for it with
4560 If set to TRUE, then enable noack mode even if the stub didn't
4561 report it in qSupported. If the stub doesn't reply OK, the
4562 session ends with an error.
4564 If FALSE, then don't activate noack mode, regardless of what the
4565 stub claimed should be the default with qSupported. */
4567 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4568 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4570 putpkt ("QStartNoAckMode");
4571 getpkt (&rs
->buf
, 0);
4572 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4578 /* Tell the remote that we are using the extended protocol. */
4580 getpkt (&rs
->buf
, 0);
4583 /* Let the target know which signals it is allowed to pass down to
4585 update_signals_program_target ();
4587 /* Next, if the target can specify a description, read it. We do
4588 this before anything involving memory or registers. */
4589 target_find_description ();
4591 /* Next, now that we know something about the target, update the
4592 address spaces in the program spaces. */
4593 update_address_spaces ();
4595 /* On OSs where the list of libraries is global to all
4596 processes, we fetch them early. */
4597 if (gdbarch_has_global_solist (target_gdbarch ()))
4598 solib_add (NULL
, from_tty
, auto_solib_add
);
4600 if (target_is_non_stop_p ())
4602 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4603 error (_("Non-stop mode requested, but remote "
4604 "does not support non-stop"));
4606 putpkt ("QNonStop:1");
4607 getpkt (&rs
->buf
, 0);
4609 if (strcmp (rs
->buf
.data (), "OK") != 0)
4610 error (_("Remote refused setting non-stop mode with: %s"),
4613 /* Find about threads and processes the stub is already
4614 controlling. We default to adding them in the running state.
4615 The '?' query below will then tell us about which threads are
4617 this->update_thread_list ();
4619 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4621 /* Don't assume that the stub can operate in all-stop mode.
4622 Request it explicitly. */
4623 putpkt ("QNonStop:0");
4624 getpkt (&rs
->buf
, 0);
4626 if (strcmp (rs
->buf
.data (), "OK") != 0)
4627 error (_("Remote refused setting all-stop mode with: %s"),
4631 /* Upload TSVs regardless of whether the target is running or not. The
4632 remote stub, such as GDBserver, may have some predefined or builtin
4633 TSVs, even if the target is not running. */
4634 if (get_trace_status (current_trace_status ()) != -1)
4636 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4638 upload_trace_state_variables (&uploaded_tsvs
);
4639 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4642 /* Check whether the target is running now. */
4644 getpkt (&rs
->buf
, 0);
4646 if (!target_is_non_stop_p ())
4648 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4651 error (_("The target is not running (try extended-remote?)"));
4653 /* We're connected, but not running. Drop out before we
4654 call start_remote. */
4655 rs
->starting_up
= 0;
4660 /* Save the reply for later. */
4661 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4662 strcpy (wait_status
, rs
->buf
.data ());
4665 /* Fetch thread list. */
4666 target_update_thread_list ();
4668 /* Let the stub know that we want it to return the thread. */
4669 set_continue_thread (minus_one_ptid
);
4671 if (thread_count () == 0)
4673 /* Target has no concept of threads at all. GDB treats
4674 non-threaded target as single-threaded; add a main
4676 add_current_inferior_and_thread (wait_status
);
4680 /* We have thread information; select the thread the target
4681 says should be current. If we're reconnecting to a
4682 multi-threaded program, this will ideally be the thread
4683 that last reported an event before GDB disconnected. */
4684 inferior_ptid
= get_current_thread (wait_status
);
4685 if (inferior_ptid
== null_ptid
)
4687 /* Odd... The target was able to list threads, but not
4688 tell us which thread was current (no "thread"
4689 register in T stop reply?). Just pick the first
4690 thread in the thread list then. */
4693 fprintf_unfiltered (gdb_stdlog
,
4694 "warning: couldn't determine remote "
4695 "current thread; picking first in list.\n");
4697 inferior_ptid
= inferior_list
->thread_list
->ptid
;
4701 /* init_wait_for_inferior should be called before get_offsets in order
4702 to manage `inserted' flag in bp loc in a correct state.
4703 breakpoint_init_inferior, called from init_wait_for_inferior, set
4704 `inserted' flag to 0, while before breakpoint_re_set, called from
4705 start_remote, set `inserted' flag to 1. In the initialization of
4706 inferior, breakpoint_init_inferior should be called first, and then
4707 breakpoint_re_set can be called. If this order is broken, state of
4708 `inserted' flag is wrong, and cause some problems on breakpoint
4710 init_wait_for_inferior ();
4712 get_offsets (); /* Get text, data & bss offsets. */
4714 /* If we could not find a description using qXfer, and we know
4715 how to do it some other way, try again. This is not
4716 supported for non-stop; it could be, but it is tricky if
4717 there are no stopped threads when we connect. */
4718 if (remote_read_description_p (this)
4719 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4721 target_clear_description ();
4722 target_find_description ();
4725 /* Use the previously fetched status. */
4726 gdb_assert (wait_status
!= NULL
);
4727 strcpy (rs
->buf
.data (), wait_status
);
4728 rs
->cached_wait_status
= 1;
4730 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4734 /* Clear WFI global state. Do this before finding about new
4735 threads and inferiors, and setting the current inferior.
4736 Otherwise we would clear the proceed status of the current
4737 inferior when we want its stop_soon state to be preserved
4738 (see notice_new_inferior). */
4739 init_wait_for_inferior ();
4741 /* In non-stop, we will either get an "OK", meaning that there
4742 are no stopped threads at this time; or, a regular stop
4743 reply. In the latter case, there may be more than one thread
4744 stopped --- we pull them all out using the vStopped
4746 if (strcmp (rs
->buf
.data (), "OK") != 0)
4748 struct notif_client
*notif
= ¬if_client_stop
;
4750 /* remote_notif_get_pending_replies acks this one, and gets
4752 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4753 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4754 remote_notif_get_pending_events (notif
);
4757 if (thread_count () == 0)
4760 error (_("The target is not running (try extended-remote?)"));
4762 /* We're connected, but not running. Drop out before we
4763 call start_remote. */
4764 rs
->starting_up
= 0;
4768 /* In non-stop mode, any cached wait status will be stored in
4769 the stop reply queue. */
4770 gdb_assert (wait_status
== NULL
);
4772 /* Report all signals during attach/startup. */
4775 /* If there are already stopped threads, mark them stopped and
4776 report their stops before giving the prompt to the user. */
4777 process_initial_stop_replies (from_tty
);
4779 if (target_can_async_p ())
4783 /* If we connected to a live target, do some additional setup. */
4784 if (target_has_execution
)
4786 if (symfile_objfile
) /* No use without a symbol-file. */
4787 remote_check_symbols ();
4790 /* Possibly the target has been engaged in a trace run started
4791 previously; find out where things are at. */
4792 if (get_trace_status (current_trace_status ()) != -1)
4794 struct uploaded_tp
*uploaded_tps
= NULL
;
4796 if (current_trace_status ()->running
)
4797 printf_filtered (_("Trace is already running on the target.\n"));
4799 upload_tracepoints (&uploaded_tps
);
4801 merge_uploaded_tracepoints (&uploaded_tps
);
4804 /* Possibly the target has been engaged in a btrace record started
4805 previously; find out where things are at. */
4806 remote_btrace_maybe_reopen ();
4808 /* The thread and inferior lists are now synchronized with the
4809 target, our symbols have been relocated, and we're merged the
4810 target's tracepoints with ours. We're done with basic start
4812 rs
->starting_up
= 0;
4814 /* Maybe breakpoints are global and need to be inserted now. */
4815 if (breakpoints_should_be_inserted_now ())
4816 insert_breakpoints ();
4819 /* Open a connection to a remote debugger.
4820 NAME is the filename used for communication. */
4823 remote_target::open (const char *name
, int from_tty
)
4825 open_1 (name
, from_tty
, 0);
4828 /* Open a connection to a remote debugger using the extended
4829 remote gdb protocol. NAME is the filename used for communication. */
4832 extended_remote_target::open (const char *name
, int from_tty
)
4834 open_1 (name
, from_tty
, 1 /*extended_p */);
4837 /* Reset all packets back to "unknown support". Called when opening a
4838 new connection to a remote target. */
4841 reset_all_packet_configs_support (void)
4845 for (i
= 0; i
< PACKET_MAX
; i
++)
4846 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4849 /* Initialize all packet configs. */
4852 init_all_packet_configs (void)
4856 for (i
= 0; i
< PACKET_MAX
; i
++)
4858 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4859 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4863 /* Symbol look-up. */
4866 remote_target::remote_check_symbols ()
4871 /* The remote side has no concept of inferiors that aren't running
4872 yet, it only knows about running processes. If we're connected
4873 but our current inferior is not running, we should not invite the
4874 remote target to request symbol lookups related to its
4875 (unrelated) current process. */
4876 if (!target_has_execution
)
4879 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4882 /* Make sure the remote is pointing at the right process. Note
4883 there's no way to select "no process". */
4884 set_general_process ();
4886 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4887 because we need both at the same time. */
4888 gdb::char_vector
msg (get_remote_packet_size ());
4889 gdb::char_vector
reply (get_remote_packet_size ());
4891 /* Invite target to request symbol lookups. */
4893 putpkt ("qSymbol::");
4895 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4897 while (startswith (reply
.data (), "qSymbol:"))
4899 struct bound_minimal_symbol sym
;
4902 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
4905 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
4906 if (sym
.minsym
== NULL
)
4907 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
4911 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4912 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4914 /* If this is a function address, return the start of code
4915 instead of any data function descriptor. */
4916 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4918 current_top_target ());
4920 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4921 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4924 putpkt (msg
.data ());
4929 static struct serial
*
4930 remote_serial_open (const char *name
)
4932 static int udp_warning
= 0;
4934 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4935 of in ser-tcp.c, because it is the remote protocol assuming that the
4936 serial connection is reliable and not the serial connection promising
4938 if (!udp_warning
&& startswith (name
, "udp:"))
4940 warning (_("The remote protocol may be unreliable over UDP.\n"
4941 "Some events may be lost, rendering further debugging "
4946 return serial_open (name
);
4949 /* Inform the target of our permission settings. The permission flags
4950 work without this, but if the target knows the settings, it can do
4951 a couple things. First, it can add its own check, to catch cases
4952 that somehow manage to get by the permissions checks in target
4953 methods. Second, if the target is wired to disallow particular
4954 settings (for instance, a system in the field that is not set up to
4955 be able to stop at a breakpoint), it can object to any unavailable
4959 remote_target::set_permissions ()
4961 struct remote_state
*rs
= get_remote_state ();
4963 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
4964 "WriteReg:%x;WriteMem:%x;"
4965 "InsertBreak:%x;InsertTrace:%x;"
4966 "InsertFastTrace:%x;Stop:%x",
4967 may_write_registers
, may_write_memory
,
4968 may_insert_breakpoints
, may_insert_tracepoints
,
4969 may_insert_fast_tracepoints
, may_stop
);
4971 getpkt (&rs
->buf
, 0);
4973 /* If the target didn't like the packet, warn the user. Do not try
4974 to undo the user's settings, that would just be maddening. */
4975 if (strcmp (rs
->buf
.data (), "OK") != 0)
4976 warning (_("Remote refused setting permissions with: %s"),
4980 /* This type describes each known response to the qSupported
4982 struct protocol_feature
4984 /* The name of this protocol feature. */
4987 /* The default for this protocol feature. */
4988 enum packet_support default_support
;
4990 /* The function to call when this feature is reported, or after
4991 qSupported processing if the feature is not supported.
4992 The first argument points to this structure. The second
4993 argument indicates whether the packet requested support be
4994 enabled, disabled, or probed (or the default, if this function
4995 is being called at the end of processing and this feature was
4996 not reported). The third argument may be NULL; if not NULL, it
4997 is a NUL-terminated string taken from the packet following
4998 this feature's name and an equals sign. */
4999 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5000 enum packet_support
, const char *);
5002 /* The corresponding packet for this feature. Only used if
5003 FUNC is remote_supported_packet. */
5008 remote_supported_packet (remote_target
*remote
,
5009 const struct protocol_feature
*feature
,
5010 enum packet_support support
,
5011 const char *argument
)
5015 warning (_("Remote qSupported response supplied an unexpected value for"
5016 " \"%s\"."), feature
->name
);
5020 remote_protocol_packets
[feature
->packet
].support
= support
;
5024 remote_target::remote_packet_size (const protocol_feature
*feature
,
5025 enum packet_support support
, const char *value
)
5027 struct remote_state
*rs
= get_remote_state ();
5032 if (support
!= PACKET_ENABLE
)
5035 if (value
== NULL
|| *value
== '\0')
5037 warning (_("Remote target reported \"%s\" without a size."),
5043 packet_size
= strtol (value
, &value_end
, 16);
5044 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5046 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5047 feature
->name
, value
);
5051 /* Record the new maximum packet size. */
5052 rs
->explicit_packet_size
= packet_size
;
5056 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5057 enum packet_support support
, const char *value
)
5059 remote
->remote_packet_size (feature
, support
, value
);
5062 static const struct protocol_feature remote_protocol_features
[] = {
5063 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5064 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5065 PACKET_qXfer_auxv
},
5066 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5067 PACKET_qXfer_exec_file
},
5068 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5069 PACKET_qXfer_features
},
5070 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5071 PACKET_qXfer_libraries
},
5072 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5073 PACKET_qXfer_libraries_svr4
},
5074 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5075 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5076 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5077 PACKET_qXfer_memory_map
},
5078 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5079 PACKET_qXfer_osdata
},
5080 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5081 PACKET_qXfer_threads
},
5082 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5083 PACKET_qXfer_traceframe_info
},
5084 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5085 PACKET_QPassSignals
},
5086 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5087 PACKET_QCatchSyscalls
},
5088 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5089 PACKET_QProgramSignals
},
5090 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5091 PACKET_QSetWorkingDir
},
5092 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5093 PACKET_QStartupWithShell
},
5094 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5095 PACKET_QEnvironmentHexEncoded
},
5096 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5097 PACKET_QEnvironmentReset
},
5098 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5099 PACKET_QEnvironmentUnset
},
5100 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5101 PACKET_QStartNoAckMode
},
5102 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5103 PACKET_multiprocess_feature
},
5104 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5105 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5106 PACKET_qXfer_siginfo_read
},
5107 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5108 PACKET_qXfer_siginfo_write
},
5109 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5110 PACKET_ConditionalTracepoints
},
5111 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5112 PACKET_ConditionalBreakpoints
},
5113 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5114 PACKET_BreakpointCommands
},
5115 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5116 PACKET_FastTracepoints
},
5117 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5118 PACKET_StaticTracepoints
},
5119 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5120 PACKET_InstallInTrace
},
5121 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5122 PACKET_DisconnectedTracing_feature
},
5123 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5125 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5127 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5128 PACKET_TracepointSource
},
5129 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5131 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5132 PACKET_EnableDisableTracepoints_feature
},
5133 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5134 PACKET_qXfer_fdpic
},
5135 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5137 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5138 PACKET_QDisableRandomization
},
5139 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5140 { "QTBuffer:size", PACKET_DISABLE
,
5141 remote_supported_packet
, PACKET_QTBuffer_size
},
5142 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5143 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5144 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5145 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5146 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5147 PACKET_qXfer_btrace
},
5148 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5149 PACKET_qXfer_btrace_conf
},
5150 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5151 PACKET_Qbtrace_conf_bts_size
},
5152 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5153 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5154 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5155 PACKET_fork_event_feature
},
5156 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5157 PACKET_vfork_event_feature
},
5158 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5159 PACKET_exec_event_feature
},
5160 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5161 PACKET_Qbtrace_conf_pt_size
},
5162 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5163 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5164 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5167 static char *remote_support_xml
;
5169 /* Register string appended to "xmlRegisters=" in qSupported query. */
5172 register_remote_support_xml (const char *xml
)
5174 #if defined(HAVE_LIBEXPAT)
5175 if (remote_support_xml
== NULL
)
5176 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5179 char *copy
= xstrdup (remote_support_xml
+ 13);
5181 char *p
= strtok_r (copy
, ",", &saveptr
);
5185 if (strcmp (p
, xml
) == 0)
5192 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5195 remote_support_xml
= reconcat (remote_support_xml
,
5196 remote_support_xml
, ",", xml
,
5203 remote_query_supported_append (std::string
*msg
, const char *append
)
5207 msg
->append (append
);
5211 remote_target::remote_query_supported ()
5213 struct remote_state
*rs
= get_remote_state ();
5216 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5218 /* The packet support flags are handled differently for this packet
5219 than for most others. We treat an error, a disabled packet, and
5220 an empty response identically: any features which must be reported
5221 to be used will be automatically disabled. An empty buffer
5222 accomplishes this, since that is also the representation for a list
5223 containing no features. */
5226 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5230 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5231 remote_query_supported_append (&q
, "multiprocess+");
5233 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5234 remote_query_supported_append (&q
, "swbreak+");
5235 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5236 remote_query_supported_append (&q
, "hwbreak+");
5238 remote_query_supported_append (&q
, "qRelocInsn+");
5240 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5241 != AUTO_BOOLEAN_FALSE
)
5242 remote_query_supported_append (&q
, "fork-events+");
5243 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5244 != AUTO_BOOLEAN_FALSE
)
5245 remote_query_supported_append (&q
, "vfork-events+");
5246 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5247 != AUTO_BOOLEAN_FALSE
)
5248 remote_query_supported_append (&q
, "exec-events+");
5250 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5251 remote_query_supported_append (&q
, "vContSupported+");
5253 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5254 remote_query_supported_append (&q
, "QThreadEvents+");
5256 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5257 remote_query_supported_append (&q
, "no-resumed+");
5259 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5260 the qSupported:xmlRegisters=i386 handling. */
5261 if (remote_support_xml
!= NULL
5262 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5263 remote_query_supported_append (&q
, remote_support_xml
);
5265 q
= "qSupported:" + q
;
5266 putpkt (q
.c_str ());
5268 getpkt (&rs
->buf
, 0);
5270 /* If an error occured, warn, but do not return - just reset the
5271 buffer to empty and go on to disable features. */
5272 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5275 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5280 memset (seen
, 0, sizeof (seen
));
5282 next
= rs
->buf
.data ();
5285 enum packet_support is_supported
;
5286 char *p
, *end
, *name_end
, *value
;
5288 /* First separate out this item from the rest of the packet. If
5289 there's another item after this, we overwrite the separator
5290 (terminated strings are much easier to work with). */
5292 end
= strchr (p
, ';');
5295 end
= p
+ strlen (p
);
5305 warning (_("empty item in \"qSupported\" response"));
5310 name_end
= strchr (p
, '=');
5313 /* This is a name=value entry. */
5314 is_supported
= PACKET_ENABLE
;
5315 value
= name_end
+ 1;
5324 is_supported
= PACKET_ENABLE
;
5328 is_supported
= PACKET_DISABLE
;
5332 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5336 warning (_("unrecognized item \"%s\" "
5337 "in \"qSupported\" response"), p
);
5343 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5344 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5346 const struct protocol_feature
*feature
;
5349 feature
= &remote_protocol_features
[i
];
5350 feature
->func (this, feature
, is_supported
, value
);
5355 /* If we increased the packet size, make sure to increase the global
5356 buffer size also. We delay this until after parsing the entire
5357 qSupported packet, because this is the same buffer we were
5359 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5360 rs
->buf
.resize (rs
->explicit_packet_size
);
5362 /* Handle the defaults for unmentioned features. */
5363 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5366 const struct protocol_feature
*feature
;
5368 feature
= &remote_protocol_features
[i
];
5369 feature
->func (this, feature
, feature
->default_support
, NULL
);
5373 /* Serial QUIT handler for the remote serial descriptor.
5375 Defers handling a Ctrl-C until we're done with the current
5376 command/response packet sequence, unless:
5378 - We're setting up the connection. Don't send a remote interrupt
5379 request, as we're not fully synced yet. Quit immediately
5382 - The target has been resumed in the foreground
5383 (target_terminal::is_ours is false) with a synchronous resume
5384 packet, and we're blocked waiting for the stop reply, thus a
5385 Ctrl-C should be immediately sent to the target.
5387 - We get a second Ctrl-C while still within the same serial read or
5388 write. In that case the serial is seemingly wedged --- offer to
5391 - We see a second Ctrl-C without target response, after having
5392 previously interrupted the target. In that case the target/stub
5393 is probably wedged --- offer to quit/disconnect.
5397 remote_target::remote_serial_quit_handler ()
5399 struct remote_state
*rs
= get_remote_state ();
5401 if (check_quit_flag ())
5403 /* If we're starting up, we're not fully synced yet. Quit
5405 if (rs
->starting_up
)
5407 else if (rs
->got_ctrlc_during_io
)
5409 if (query (_("The target is not responding to GDB commands.\n"
5410 "Stop debugging it? ")))
5411 remote_unpush_and_throw ();
5413 /* If ^C has already been sent once, offer to disconnect. */
5414 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5416 /* All-stop protocol, and blocked waiting for stop reply. Send
5417 an interrupt request. */
5418 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5419 target_interrupt ();
5421 rs
->got_ctrlc_during_io
= 1;
5425 /* The remote_target that is current while the quit handler is
5426 overridden with remote_serial_quit_handler. */
5427 static remote_target
*curr_quit_handler_target
;
5430 remote_serial_quit_handler ()
5432 curr_quit_handler_target
->remote_serial_quit_handler ();
5435 /* Remove any of the remote.c targets from target stack. Upper targets depend
5436 on it so remove them first. */
5439 remote_unpush_target (void)
5441 pop_all_targets_at_and_above (process_stratum
);
5445 remote_unpush_and_throw (void)
5447 remote_unpush_target ();
5448 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5452 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5454 remote_target
*curr_remote
= get_current_remote_target ();
5457 error (_("To open a remote debug connection, you need to specify what\n"
5458 "serial device is attached to the remote system\n"
5459 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5461 /* If we're connected to a running target, target_preopen will kill it.
5462 Ask this question first, before target_preopen has a chance to kill
5464 if (curr_remote
!= NULL
&& !have_inferiors ())
5467 && !query (_("Already connected to a remote target. Disconnect? ")))
5468 error (_("Still connected."));
5471 /* Here the possibly existing remote target gets unpushed. */
5472 target_preopen (from_tty
);
5474 remote_fileio_reset ();
5475 reopen_exec_file ();
5478 remote_target
*remote
5479 = (extended_p
? new extended_remote_target () : new remote_target ());
5480 target_ops_up
target_holder (remote
);
5482 remote_state
*rs
= remote
->get_remote_state ();
5484 /* See FIXME above. */
5485 if (!target_async_permitted
)
5486 rs
->wait_forever_enabled_p
= 1;
5488 rs
->remote_desc
= remote_serial_open (name
);
5489 if (!rs
->remote_desc
)
5490 perror_with_name (name
);
5492 if (baud_rate
!= -1)
5494 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5496 /* The requested speed could not be set. Error out to
5497 top level after closing remote_desc. Take care to
5498 set remote_desc to NULL to avoid closing remote_desc
5500 serial_close (rs
->remote_desc
);
5501 rs
->remote_desc
= NULL
;
5502 perror_with_name (name
);
5506 serial_setparity (rs
->remote_desc
, serial_parity
);
5507 serial_raw (rs
->remote_desc
);
5509 /* If there is something sitting in the buffer we might take it as a
5510 response to a command, which would be bad. */
5511 serial_flush_input (rs
->remote_desc
);
5515 puts_filtered ("Remote debugging using ");
5516 puts_filtered (name
);
5517 puts_filtered ("\n");
5520 /* Switch to using the remote target now. */
5521 push_target (std::move (target_holder
));
5523 /* Register extra event sources in the event loop. */
5524 rs
->remote_async_inferior_event_token
5525 = create_async_event_handler (remote_async_inferior_event_handler
,
5527 rs
->notif_state
= remote_notif_state_allocate (remote
);
5529 /* Reset the target state; these things will be queried either by
5530 remote_query_supported or as they are needed. */
5531 reset_all_packet_configs_support ();
5532 rs
->cached_wait_status
= 0;
5533 rs
->explicit_packet_size
= 0;
5535 rs
->extended
= extended_p
;
5536 rs
->waiting_for_stop_reply
= 0;
5537 rs
->ctrlc_pending_p
= 0;
5538 rs
->got_ctrlc_during_io
= 0;
5540 rs
->general_thread
= not_sent_ptid
;
5541 rs
->continue_thread
= not_sent_ptid
;
5542 rs
->remote_traceframe_number
= -1;
5544 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5546 /* Probe for ability to use "ThreadInfo" query, as required. */
5547 rs
->use_threadinfo_query
= 1;
5548 rs
->use_threadextra_query
= 1;
5550 rs
->readahead_cache
.invalidate ();
5552 if (target_async_permitted
)
5554 /* FIXME: cagney/1999-09-23: During the initial connection it is
5555 assumed that the target is already ready and able to respond to
5556 requests. Unfortunately remote_start_remote() eventually calls
5557 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5558 around this. Eventually a mechanism that allows
5559 wait_for_inferior() to expect/get timeouts will be
5561 rs
->wait_forever_enabled_p
= 0;
5564 /* First delete any symbols previously loaded from shared libraries. */
5565 no_shared_libraries (NULL
, 0);
5567 /* Start the remote connection. If error() or QUIT, discard this
5568 target (we'd otherwise be in an inconsistent state) and then
5569 propogate the error on up the exception chain. This ensures that
5570 the caller doesn't stumble along blindly assuming that the
5571 function succeeded. The CLI doesn't have this problem but other
5572 UI's, such as MI do.
5574 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5575 this function should return an error indication letting the
5576 caller restore the previous state. Unfortunately the command
5577 ``target remote'' is directly wired to this function making that
5578 impossible. On a positive note, the CLI side of this problem has
5579 been fixed - the function set_cmd_context() makes it possible for
5580 all the ``target ....'' commands to share a common callback
5581 function. See cli-dump.c. */
5586 remote
->start_remote (from_tty
, extended_p
);
5588 catch (const gdb_exception
&ex
)
5590 /* Pop the partially set up target - unless something else did
5591 already before throwing the exception. */
5592 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5593 remote_unpush_target ();
5598 remote_btrace_reset (rs
);
5600 if (target_async_permitted
)
5601 rs
->wait_forever_enabled_p
= 1;
5604 /* Detach the specified process. */
5607 remote_target::remote_detach_pid (int pid
)
5609 struct remote_state
*rs
= get_remote_state ();
5611 /* This should not be necessary, but the handling for D;PID in
5612 GDBserver versions prior to 8.2 incorrectly assumes that the
5613 selected process points to the same process we're detaching,
5614 leading to misbehavior (and possibly GDBserver crashing) when it
5615 does not. Since it's easy and cheap, work around it by forcing
5616 GDBserver to select GDB's current process. */
5617 set_general_process ();
5619 if (remote_multi_process_p (rs
))
5620 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5622 strcpy (rs
->buf
.data (), "D");
5625 getpkt (&rs
->buf
, 0);
5627 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5629 else if (rs
->buf
[0] == '\0')
5630 error (_("Remote doesn't know how to detach"));
5632 error (_("Can't detach process."));
5635 /* This detaches a program to which we previously attached, using
5636 inferior_ptid to identify the process. After this is done, GDB
5637 can be used to debug some other program. We better not have left
5638 any breakpoints in the target program or it'll die when it hits
5642 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5644 int pid
= inferior_ptid
.pid ();
5645 struct remote_state
*rs
= get_remote_state ();
5648 if (!target_has_execution
)
5649 error (_("No process to detach from."));
5651 target_announce_detach (from_tty
);
5653 /* Tell the remote target to detach. */
5654 remote_detach_pid (pid
);
5656 /* Exit only if this is the only active inferior. */
5657 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors () == 1)
5658 puts_filtered (_("Ending remote debugging.\n"));
5660 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
5662 /* Check to see if we are detaching a fork parent. Note that if we
5663 are detaching a fork child, tp == NULL. */
5664 is_fork_parent
= (tp
!= NULL
5665 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5667 /* If doing detach-on-fork, we don't mourn, because that will delete
5668 breakpoints that should be available for the followed inferior. */
5669 if (!is_fork_parent
)
5671 /* Save the pid as a string before mourning, since that will
5672 unpush the remote target, and we need the string after. */
5673 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5675 target_mourn_inferior (inferior_ptid
);
5676 if (print_inferior_events
)
5677 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5678 inf
->num
, infpid
.c_str ());
5682 inferior_ptid
= null_ptid
;
5683 detach_inferior (current_inferior ());
5688 remote_target::detach (inferior
*inf
, int from_tty
)
5690 remote_detach_1 (inf
, from_tty
);
5694 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5696 remote_detach_1 (inf
, from_tty
);
5699 /* Target follow-fork function for remote targets. On entry, and
5700 at return, the current inferior is the fork parent.
5702 Note that although this is currently only used for extended-remote,
5703 it is named remote_follow_fork in anticipation of using it for the
5704 remote target as well. */
5707 remote_target::follow_fork (int follow_child
, int detach_fork
)
5709 struct remote_state
*rs
= get_remote_state ();
5710 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5712 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5713 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5715 /* When following the parent and detaching the child, we detach
5716 the child here. For the case of following the child and
5717 detaching the parent, the detach is done in the target-
5718 independent follow fork code in infrun.c. We can't use
5719 target_detach when detaching an unfollowed child because
5720 the client side doesn't know anything about the child. */
5721 if (detach_fork
&& !follow_child
)
5723 /* Detach the fork child. */
5727 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5728 child_pid
= child_ptid
.pid ();
5730 remote_detach_pid (child_pid
);
5736 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5737 in the program space of the new inferior. On entry and at return the
5738 current inferior is the exec'ing inferior. INF is the new exec'd
5739 inferior, which may be the same as the exec'ing inferior unless
5740 follow-exec-mode is "new". */
5743 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5745 /* We know that this is a target file name, so if it has the "target:"
5746 prefix we strip it off before saving it in the program space. */
5747 if (is_target_filename (execd_pathname
))
5748 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5750 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5753 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5756 remote_target::disconnect (const char *args
, int from_tty
)
5759 error (_("Argument given to \"disconnect\" when remotely debugging."));
5761 /* Make sure we unpush even the extended remote targets. Calling
5762 target_mourn_inferior won't unpush, and remote_mourn won't
5763 unpush if there is more than one inferior left. */
5764 unpush_target (this);
5765 generic_mourn_inferior ();
5768 puts_filtered ("Ending remote debugging.\n");
5771 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5772 be chatty about it. */
5775 extended_remote_target::attach (const char *args
, int from_tty
)
5777 struct remote_state
*rs
= get_remote_state ();
5779 char *wait_status
= NULL
;
5781 pid
= parse_pid_to_attach (args
);
5783 /* Remote PID can be freely equal to getpid, do not check it here the same
5784 way as in other targets. */
5786 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5787 error (_("This target does not support attaching to a process"));
5791 const char *exec_file
= get_exec_file (0);
5794 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5795 target_pid_to_str (ptid_t (pid
)).c_str ());
5797 printf_unfiltered (_("Attaching to %s\n"),
5798 target_pid_to_str (ptid_t (pid
)).c_str ());
5801 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5803 getpkt (&rs
->buf
, 0);
5805 switch (packet_ok (rs
->buf
,
5806 &remote_protocol_packets
[PACKET_vAttach
]))
5809 if (!target_is_non_stop_p ())
5811 /* Save the reply for later. */
5812 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5813 strcpy (wait_status
, rs
->buf
.data ());
5815 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5816 error (_("Attaching to %s failed with: %s"),
5817 target_pid_to_str (ptid_t (pid
)).c_str (),
5820 case PACKET_UNKNOWN
:
5821 error (_("This target does not support attaching to a process"));
5823 error (_("Attaching to %s failed"),
5824 target_pid_to_str (ptid_t (pid
)).c_str ());
5827 set_current_inferior (remote_add_inferior (false, pid
, 1, 0));
5829 inferior_ptid
= ptid_t (pid
);
5831 if (target_is_non_stop_p ())
5833 struct thread_info
*thread
;
5835 /* Get list of threads. */
5836 update_thread_list ();
5838 thread
= first_thread_of_inferior (current_inferior ());
5840 inferior_ptid
= thread
->ptid
;
5842 inferior_ptid
= ptid_t (pid
);
5844 /* Invalidate our notion of the remote current thread. */
5845 record_currthread (rs
, minus_one_ptid
);
5849 /* Now, if we have thread information, update inferior_ptid. */
5850 inferior_ptid
= remote_current_thread (inferior_ptid
);
5852 /* Add the main thread to the thread list. */
5853 thread_info
*thr
= add_thread_silent (inferior_ptid
);
5854 /* Don't consider the thread stopped until we've processed the
5855 saved stop reply. */
5856 set_executing (thr
->ptid
, true);
5859 /* Next, if the target can specify a description, read it. We do
5860 this before anything involving memory or registers. */
5861 target_find_description ();
5863 if (!target_is_non_stop_p ())
5865 /* Use the previously fetched status. */
5866 gdb_assert (wait_status
!= NULL
);
5868 if (target_can_async_p ())
5870 struct notif_event
*reply
5871 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
5873 push_stop_reply ((struct stop_reply
*) reply
);
5879 gdb_assert (wait_status
!= NULL
);
5880 strcpy (rs
->buf
.data (), wait_status
);
5881 rs
->cached_wait_status
= 1;
5885 gdb_assert (wait_status
== NULL
);
5888 /* Implementation of the to_post_attach method. */
5891 extended_remote_target::post_attach (int pid
)
5893 /* Get text, data & bss offsets. */
5896 /* In certain cases GDB might not have had the chance to start
5897 symbol lookup up until now. This could happen if the debugged
5898 binary is not using shared libraries, the vsyscall page is not
5899 present (on Linux) and the binary itself hadn't changed since the
5900 debugging process was started. */
5901 if (symfile_objfile
!= NULL
)
5902 remote_check_symbols();
5906 /* Check for the availability of vCont. This function should also check
5910 remote_target::remote_vcont_probe ()
5912 remote_state
*rs
= get_remote_state ();
5915 strcpy (rs
->buf
.data (), "vCont?");
5917 getpkt (&rs
->buf
, 0);
5918 buf
= rs
->buf
.data ();
5920 /* Make sure that the features we assume are supported. */
5921 if (startswith (buf
, "vCont"))
5924 int support_c
, support_C
;
5926 rs
->supports_vCont
.s
= 0;
5927 rs
->supports_vCont
.S
= 0;
5930 rs
->supports_vCont
.t
= 0;
5931 rs
->supports_vCont
.r
= 0;
5932 while (p
&& *p
== ';')
5935 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5936 rs
->supports_vCont
.s
= 1;
5937 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5938 rs
->supports_vCont
.S
= 1;
5939 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5941 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5943 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5944 rs
->supports_vCont
.t
= 1;
5945 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5946 rs
->supports_vCont
.r
= 1;
5948 p
= strchr (p
, ';');
5951 /* If c, and C are not all supported, we can't use vCont. Clearing
5952 BUF will make packet_ok disable the packet. */
5953 if (!support_c
|| !support_C
)
5957 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
5960 /* Helper function for building "vCont" resumptions. Write a
5961 resumption to P. ENDP points to one-passed-the-end of the buffer
5962 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
5963 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5964 resumed thread should be single-stepped and/or signalled. If PTID
5965 equals minus_one_ptid, then all threads are resumed; if PTID
5966 represents a process, then all threads of the process are resumed;
5967 the thread to be stepped and/or signalled is given in the global
5971 remote_target::append_resumption (char *p
, char *endp
,
5972 ptid_t ptid
, int step
, gdb_signal siggnal
)
5974 struct remote_state
*rs
= get_remote_state ();
5976 if (step
&& siggnal
!= GDB_SIGNAL_0
)
5977 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
5979 /* GDB is willing to range step. */
5980 && use_range_stepping
5981 /* Target supports range stepping. */
5982 && rs
->supports_vCont
.r
5983 /* We don't currently support range stepping multiple
5984 threads with a wildcard (though the protocol allows it,
5985 so stubs shouldn't make an active effort to forbid
5987 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
5989 struct thread_info
*tp
;
5991 if (ptid
== minus_one_ptid
)
5993 /* If we don't know about the target thread's tid, then
5994 we're resuming magic_null_ptid (see caller). */
5995 tp
= find_thread_ptid (magic_null_ptid
);
5998 tp
= find_thread_ptid (ptid
);
5999 gdb_assert (tp
!= NULL
);
6001 if (tp
->control
.may_range_step
)
6003 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6005 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6006 phex_nz (tp
->control
.step_range_start
,
6008 phex_nz (tp
->control
.step_range_end
,
6012 p
+= xsnprintf (p
, endp
- p
, ";s");
6015 p
+= xsnprintf (p
, endp
- p
, ";s");
6016 else if (siggnal
!= GDB_SIGNAL_0
)
6017 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6019 p
+= xsnprintf (p
, endp
- p
, ";c");
6021 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6025 /* All (-1) threads of process. */
6026 nptid
= ptid_t (ptid
.pid (), -1, 0);
6028 p
+= xsnprintf (p
, endp
- p
, ":");
6029 p
= write_ptid (p
, endp
, nptid
);
6031 else if (ptid
!= minus_one_ptid
)
6033 p
+= xsnprintf (p
, endp
- p
, ":");
6034 p
= write_ptid (p
, endp
, ptid
);
6040 /* Clear the thread's private info on resume. */
6043 resume_clear_thread_private_info (struct thread_info
*thread
)
6045 if (thread
->priv
!= NULL
)
6047 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6049 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6050 priv
->watch_data_address
= 0;
6054 /* Append a vCont continue-with-signal action for threads that have a
6055 non-zero stop signal. */
6058 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6061 for (thread_info
*thread
: all_non_exited_threads (ptid
))
6062 if (inferior_ptid
!= thread
->ptid
6063 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6065 p
= append_resumption (p
, endp
, thread
->ptid
,
6066 0, thread
->suspend
.stop_signal
);
6067 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6068 resume_clear_thread_private_info (thread
);
6074 /* Set the target running, using the packets that use Hc
6078 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6081 struct remote_state
*rs
= get_remote_state ();
6084 rs
->last_sent_signal
= siggnal
;
6085 rs
->last_sent_step
= step
;
6087 /* The c/s/C/S resume packets use Hc, so set the continue
6089 if (ptid
== minus_one_ptid
)
6090 set_continue_thread (any_thread_ptid
);
6092 set_continue_thread (ptid
);
6094 for (thread_info
*thread
: all_non_exited_threads ())
6095 resume_clear_thread_private_info (thread
);
6097 buf
= rs
->buf
.data ();
6098 if (::execution_direction
== EXEC_REVERSE
)
6100 /* We don't pass signals to the target in reverse exec mode. */
6101 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6102 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6105 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6106 error (_("Remote reverse-step not supported."));
6107 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6108 error (_("Remote reverse-continue not supported."));
6110 strcpy (buf
, step
? "bs" : "bc");
6112 else if (siggnal
!= GDB_SIGNAL_0
)
6114 buf
[0] = step
? 'S' : 'C';
6115 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6116 buf
[2] = tohex (((int) siggnal
) & 0xf);
6120 strcpy (buf
, step
? "s" : "c");
6125 /* Resume the remote inferior by using a "vCont" packet. The thread
6126 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6127 resumed thread should be single-stepped and/or signalled. If PTID
6128 equals minus_one_ptid, then all threads are resumed; the thread to
6129 be stepped and/or signalled is given in the global INFERIOR_PTID.
6130 This function returns non-zero iff it resumes the inferior.
6132 This function issues a strict subset of all possible vCont commands
6136 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6137 enum gdb_signal siggnal
)
6139 struct remote_state
*rs
= get_remote_state ();
6143 /* No reverse execution actions defined for vCont. */
6144 if (::execution_direction
== EXEC_REVERSE
)
6147 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6148 remote_vcont_probe ();
6150 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6153 p
= rs
->buf
.data ();
6154 endp
= p
+ get_remote_packet_size ();
6156 /* If we could generate a wider range of packets, we'd have to worry
6157 about overflowing BUF. Should there be a generic
6158 "multi-part-packet" packet? */
6160 p
+= xsnprintf (p
, endp
- p
, "vCont");
6162 if (ptid
== magic_null_ptid
)
6164 /* MAGIC_NULL_PTID means that we don't have any active threads,
6165 so we don't have any TID numbers the inferior will
6166 understand. Make sure to only send forms that do not specify
6168 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6170 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6172 /* Resume all threads (of all processes, or of a single
6173 process), with preference for INFERIOR_PTID. This assumes
6174 inferior_ptid belongs to the set of all threads we are about
6176 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6178 /* Step inferior_ptid, with or without signal. */
6179 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6182 /* Also pass down any pending signaled resumption for other
6183 threads not the current. */
6184 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6186 /* And continue others without a signal. */
6187 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6191 /* Scheduler locking; resume only PTID. */
6192 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6195 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6198 if (target_is_non_stop_p ())
6200 /* In non-stop, the stub replies to vCont with "OK". The stop
6201 reply will be reported asynchronously by means of a `%Stop'
6203 getpkt (&rs
->buf
, 0);
6204 if (strcmp (rs
->buf
.data (), "OK") != 0)
6205 error (_("Unexpected vCont reply in non-stop mode: %s"),
6212 /* Tell the remote machine to resume. */
6215 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6217 struct remote_state
*rs
= get_remote_state ();
6219 /* When connected in non-stop mode, the core resumes threads
6220 individually. Resuming remote threads directly in target_resume
6221 would thus result in sending one packet per thread. Instead, to
6222 minimize roundtrip latency, here we just store the resume
6223 request; the actual remote resumption will be done in
6224 target_commit_resume / remote_commit_resume, where we'll be able
6225 to do vCont action coalescing. */
6226 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6228 remote_thread_info
*remote_thr
;
6230 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6231 remote_thr
= get_remote_thread_info (inferior_ptid
);
6233 remote_thr
= get_remote_thread_info (ptid
);
6235 remote_thr
->last_resume_step
= step
;
6236 remote_thr
->last_resume_sig
= siggnal
;
6240 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6241 (explained in remote-notif.c:handle_notification) so
6242 remote_notif_process is not called. We need find a place where
6243 it is safe to start a 'vNotif' sequence. It is good to do it
6244 before resuming inferior, because inferior was stopped and no RSP
6245 traffic at that moment. */
6246 if (!target_is_non_stop_p ())
6247 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6249 rs
->last_resume_exec_dir
= ::execution_direction
;
6251 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6252 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6253 remote_resume_with_hc (ptid
, step
, siggnal
);
6255 /* We are about to start executing the inferior, let's register it
6256 with the event loop. NOTE: this is the one place where all the
6257 execution commands end up. We could alternatively do this in each
6258 of the execution commands in infcmd.c. */
6259 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6260 into infcmd.c in order to allow inferior function calls to work
6261 NOT asynchronously. */
6262 if (target_can_async_p ())
6265 /* We've just told the target to resume. The remote server will
6266 wait for the inferior to stop, and then send a stop reply. In
6267 the mean time, we can't start another command/query ourselves
6268 because the stub wouldn't be ready to process it. This applies
6269 only to the base all-stop protocol, however. In non-stop (which
6270 only supports vCont), the stub replies with an "OK", and is
6271 immediate able to process further serial input. */
6272 if (!target_is_non_stop_p ())
6273 rs
->waiting_for_stop_reply
= 1;
6276 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6278 /* Private per-inferior info for target remote processes. */
6280 struct remote_inferior
: public private_inferior
6282 /* Whether we can send a wildcard vCont for this process. */
6283 bool may_wildcard_vcont
= true;
6286 /* Get the remote private inferior data associated to INF. */
6288 static remote_inferior
*
6289 get_remote_inferior (inferior
*inf
)
6291 if (inf
->priv
== NULL
)
6292 inf
->priv
.reset (new remote_inferior
);
6294 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6297 /* Class used to track the construction of a vCont packet in the
6298 outgoing packet buffer. This is used to send multiple vCont
6299 packets if we have more actions than would fit a single packet. */
6304 explicit vcont_builder (remote_target
*remote
)
6311 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6316 /* The remote target. */
6317 remote_target
*m_remote
;
6319 /* Pointer to the first action. P points here if no action has been
6321 char *m_first_action
;
6323 /* Where the next action will be appended. */
6326 /* The end of the buffer. Must never write past this. */
6330 /* Prepare the outgoing buffer for a new vCont packet. */
6333 vcont_builder::restart ()
6335 struct remote_state
*rs
= m_remote
->get_remote_state ();
6337 m_p
= rs
->buf
.data ();
6338 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6339 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6340 m_first_action
= m_p
;
6343 /* If the vCont packet being built has any action, send it to the
6347 vcont_builder::flush ()
6349 struct remote_state
*rs
;
6351 if (m_p
== m_first_action
)
6354 rs
= m_remote
->get_remote_state ();
6355 m_remote
->putpkt (rs
->buf
);
6356 m_remote
->getpkt (&rs
->buf
, 0);
6357 if (strcmp (rs
->buf
.data (), "OK") != 0)
6358 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6361 /* The largest action is range-stepping, with its two addresses. This
6362 is more than sufficient. If a new, bigger action is created, it'll
6363 quickly trigger a failed assertion in append_resumption (and we'll
6365 #define MAX_ACTION_SIZE 200
6367 /* Append a new vCont action in the outgoing packet being built. If
6368 the action doesn't fit the packet along with previous actions, push
6369 what we've got so far to the remote end and start over a new vCont
6370 packet (with the new action). */
6373 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6375 char buf
[MAX_ACTION_SIZE
+ 1];
6377 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6378 ptid
, step
, siggnal
);
6380 /* Check whether this new action would fit in the vCont packet along
6381 with previous actions. If not, send what we've got so far and
6382 start a new vCont packet. */
6383 size_t rsize
= endp
- buf
;
6384 if (rsize
> m_endp
- m_p
)
6389 /* Should now fit. */
6390 gdb_assert (rsize
<= m_endp
- m_p
);
6393 memcpy (m_p
, buf
, rsize
);
6398 /* to_commit_resume implementation. */
6401 remote_target::commit_resume ()
6403 int any_process_wildcard
;
6404 int may_global_wildcard_vcont
;
6406 /* If connected in all-stop mode, we'd send the remote resume
6407 request directly from remote_resume. Likewise if
6408 reverse-debugging, as there are no defined vCont actions for
6409 reverse execution. */
6410 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6413 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6414 instead of resuming all threads of each process individually.
6415 However, if any thread of a process must remain halted, we can't
6416 send wildcard resumes and must send one action per thread.
6418 Care must be taken to not resume threads/processes the server
6419 side already told us are stopped, but the core doesn't know about
6420 yet, because the events are still in the vStopped notification
6423 #1 => vCont s:p1.1;c
6425 #3 <= %Stopped T05 p1.1
6430 #8 (infrun handles the stop for p1.1 and continues stepping)
6431 #9 => vCont s:p1.1;c
6433 The last vCont above would resume thread p1.2 by mistake, because
6434 the server has no idea that the event for p1.2 had not been
6437 The server side must similarly ignore resume actions for the
6438 thread that has a pending %Stopped notification (and any other
6439 threads with events pending), until GDB acks the notification
6440 with vStopped. Otherwise, e.g., the following case is
6443 #1 => g (or any other packet)
6445 #3 <= %Stopped T05 p1.2
6446 #4 => vCont s:p1.1;c
6449 Above, the server must not resume thread p1.2. GDB can't know
6450 that p1.2 stopped until it acks the %Stopped notification, and
6451 since from GDB's perspective all threads should be running, it
6454 Finally, special care must also be given to handling fork/vfork
6455 events. A (v)fork event actually tells us that two processes
6456 stopped -- the parent and the child. Until we follow the fork,
6457 we must not resume the child. Therefore, if we have a pending
6458 fork follow, we must not send a global wildcard resume action
6459 (vCont;c). We can still send process-wide wildcards though. */
6461 /* Start by assuming a global wildcard (vCont;c) is possible. */
6462 may_global_wildcard_vcont
= 1;
6464 /* And assume every process is individually wildcard-able too. */
6465 for (inferior
*inf
: all_non_exited_inferiors ())
6467 remote_inferior
*priv
= get_remote_inferior (inf
);
6469 priv
->may_wildcard_vcont
= true;
6472 /* Check for any pending events (not reported or processed yet) and
6473 disable process and global wildcard resumes appropriately. */
6474 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6476 for (thread_info
*tp
: all_non_exited_threads ())
6478 /* If a thread of a process is not meant to be resumed, then we
6479 can't wildcard that process. */
6482 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6484 /* And if we can't wildcard a process, we can't wildcard
6485 everything either. */
6486 may_global_wildcard_vcont
= 0;
6490 /* If a thread is the parent of an unfollowed fork, then we
6491 can't do a global wildcard, as that would resume the fork
6493 if (is_pending_fork_parent_thread (tp
))
6494 may_global_wildcard_vcont
= 0;
6497 /* Now let's build the vCont packet(s). Actions must be appended
6498 from narrower to wider scopes (thread -> process -> global). If
6499 we end up with too many actions for a single packet vcont_builder
6500 flushes the current vCont packet to the remote side and starts a
6502 struct vcont_builder
vcont_builder (this);
6504 /* Threads first. */
6505 for (thread_info
*tp
: all_non_exited_threads ())
6507 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6509 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6512 gdb_assert (!thread_is_in_step_over_chain (tp
));
6514 if (!remote_thr
->last_resume_step
6515 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6516 && get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6518 /* We'll send a wildcard resume instead. */
6519 remote_thr
->vcont_resumed
= 1;
6523 vcont_builder
.push_action (tp
->ptid
,
6524 remote_thr
->last_resume_step
,
6525 remote_thr
->last_resume_sig
);
6526 remote_thr
->vcont_resumed
= 1;
6529 /* Now check whether we can send any process-wide wildcard. This is
6530 to avoid sending a global wildcard in the case nothing is
6531 supposed to be resumed. */
6532 any_process_wildcard
= 0;
6534 for (inferior
*inf
: all_non_exited_inferiors ())
6536 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6538 any_process_wildcard
= 1;
6543 if (any_process_wildcard
)
6545 /* If all processes are wildcard-able, then send a single "c"
6546 action, otherwise, send an "all (-1) threads of process"
6547 continue action for each running process, if any. */
6548 if (may_global_wildcard_vcont
)
6550 vcont_builder
.push_action (minus_one_ptid
,
6551 false, GDB_SIGNAL_0
);
6555 for (inferior
*inf
: all_non_exited_inferiors ())
6557 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6559 vcont_builder
.push_action (ptid_t (inf
->pid
),
6560 false, GDB_SIGNAL_0
);
6566 vcont_builder
.flush ();
6571 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6572 thread, all threads of a remote process, or all threads of all
6576 remote_target::remote_stop_ns (ptid_t ptid
)
6578 struct remote_state
*rs
= get_remote_state ();
6579 char *p
= rs
->buf
.data ();
6580 char *endp
= p
+ get_remote_packet_size ();
6582 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6583 remote_vcont_probe ();
6585 if (!rs
->supports_vCont
.t
)
6586 error (_("Remote server does not support stopping threads"));
6588 if (ptid
== minus_one_ptid
6589 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6590 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6595 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6598 /* All (-1) threads of process. */
6599 nptid
= ptid_t (ptid
.pid (), -1, 0);
6602 /* Small optimization: if we already have a stop reply for
6603 this thread, no use in telling the stub we want this
6605 if (peek_stop_reply (ptid
))
6611 write_ptid (p
, endp
, nptid
);
6614 /* In non-stop, we get an immediate OK reply. The stop reply will
6615 come in asynchronously by notification. */
6617 getpkt (&rs
->buf
, 0);
6618 if (strcmp (rs
->buf
.data (), "OK") != 0)
6619 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6623 /* All-stop version of target_interrupt. Sends a break or a ^C to
6624 interrupt the remote target. It is undefined which thread of which
6625 process reports the interrupt. */
6628 remote_target::remote_interrupt_as ()
6630 struct remote_state
*rs
= get_remote_state ();
6632 rs
->ctrlc_pending_p
= 1;
6634 /* If the inferior is stopped already, but the core didn't know
6635 about it yet, just ignore the request. The cached wait status
6636 will be collected in remote_wait. */
6637 if (rs
->cached_wait_status
)
6640 /* Send interrupt_sequence to remote target. */
6641 send_interrupt_sequence ();
6644 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6645 the remote target. It is undefined which thread of which process
6646 reports the interrupt. Throws an error if the packet is not
6647 supported by the server. */
6650 remote_target::remote_interrupt_ns ()
6652 struct remote_state
*rs
= get_remote_state ();
6653 char *p
= rs
->buf
.data ();
6654 char *endp
= p
+ get_remote_packet_size ();
6656 xsnprintf (p
, endp
- p
, "vCtrlC");
6658 /* In non-stop, we get an immediate OK reply. The stop reply will
6659 come in asynchronously by notification. */
6661 getpkt (&rs
->buf
, 0);
6663 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6667 case PACKET_UNKNOWN
:
6668 error (_("No support for interrupting the remote target."));
6670 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6674 /* Implement the to_stop function for the remote targets. */
6677 remote_target::stop (ptid_t ptid
)
6680 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6682 if (target_is_non_stop_p ())
6683 remote_stop_ns (ptid
);
6686 /* We don't currently have a way to transparently pause the
6687 remote target in all-stop mode. Interrupt it instead. */
6688 remote_interrupt_as ();
6692 /* Implement the to_interrupt function for the remote targets. */
6695 remote_target::interrupt ()
6698 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6700 if (target_is_non_stop_p ())
6701 remote_interrupt_ns ();
6703 remote_interrupt_as ();
6706 /* Implement the to_pass_ctrlc function for the remote targets. */
6709 remote_target::pass_ctrlc ()
6711 struct remote_state
*rs
= get_remote_state ();
6714 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6716 /* If we're starting up, we're not fully synced yet. Quit
6718 if (rs
->starting_up
)
6720 /* If ^C has already been sent once, offer to disconnect. */
6721 else if (rs
->ctrlc_pending_p
)
6724 target_interrupt ();
6727 /* Ask the user what to do when an interrupt is received. */
6730 remote_target::interrupt_query ()
6732 struct remote_state
*rs
= get_remote_state ();
6734 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6736 if (query (_("The target is not responding to interrupt requests.\n"
6737 "Stop debugging it? ")))
6739 remote_unpush_target ();
6740 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6745 if (query (_("Interrupted while waiting for the program.\n"
6746 "Give up waiting? ")))
6751 /* Enable/disable target terminal ownership. Most targets can use
6752 terminal groups to control terminal ownership. Remote targets are
6753 different in that explicit transfer of ownership to/from GDB/target
6757 remote_target::terminal_inferior ()
6759 /* NOTE: At this point we could also register our selves as the
6760 recipient of all input. Any characters typed could then be
6761 passed on down to the target. */
6765 remote_target::terminal_ours ()
6770 remote_console_output (const char *msg
)
6774 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6777 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6781 fputs_unfiltered (tb
, gdb_stdtarg
);
6783 gdb_flush (gdb_stdtarg
);
6786 struct stop_reply
: public notif_event
6790 /* The identifier of the thread about this event */
6793 /* The remote state this event is associated with. When the remote
6794 connection, represented by a remote_state object, is closed,
6795 all the associated stop_reply events should be released. */
6796 struct remote_state
*rs
;
6798 struct target_waitstatus ws
;
6800 /* The architecture associated with the expedited registers. */
6803 /* Expedited registers. This makes remote debugging a bit more
6804 efficient for those targets that provide critical registers as
6805 part of their normal status mechanism (as another roundtrip to
6806 fetch them is avoided). */
6807 std::vector
<cached_reg_t
> regcache
;
6809 enum target_stop_reason stop_reason
;
6811 CORE_ADDR watch_data_address
;
6816 /* Return the length of the stop reply queue. */
6819 remote_target::stop_reply_queue_length ()
6821 remote_state
*rs
= get_remote_state ();
6822 return rs
->stop_reply_queue
.size ();
6826 remote_notif_stop_parse (remote_target
*remote
,
6827 struct notif_client
*self
, const char *buf
,
6828 struct notif_event
*event
)
6830 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6834 remote_notif_stop_ack (remote_target
*remote
,
6835 struct notif_client
*self
, const char *buf
,
6836 struct notif_event
*event
)
6838 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6841 putpkt (remote
, self
->ack_command
);
6843 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6845 /* We got an unknown stop reply. */
6846 error (_("Unknown stop reply"));
6849 remote
->push_stop_reply (stop_reply
);
6853 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
6854 struct notif_client
*self
)
6856 /* We can't get pending events in remote_notif_process for
6857 notification stop, and we have to do this in remote_wait_ns
6858 instead. If we fetch all queued events from stub, remote stub
6859 may exit and we have no chance to process them back in
6861 remote_state
*rs
= remote
->get_remote_state ();
6862 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
6866 stop_reply::~stop_reply ()
6868 for (cached_reg_t
®
: regcache
)
6872 static notif_event_up
6873 remote_notif_stop_alloc_reply ()
6875 return notif_event_up (new struct stop_reply ());
6878 /* A client of notification Stop. */
6880 struct notif_client notif_client_stop
=
6884 remote_notif_stop_parse
,
6885 remote_notif_stop_ack
,
6886 remote_notif_stop_can_get_pending_events
,
6887 remote_notif_stop_alloc_reply
,
6891 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6892 the pid of the process that owns the threads we want to check, or
6893 -1 if we want to check all threads. */
6896 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6899 if (ws
->kind
== TARGET_WAITKIND_FORKED
6900 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6902 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
6909 /* Return the thread's pending status used to determine whether the
6910 thread is a fork parent stopped at a fork event. */
6912 static struct target_waitstatus
*
6913 thread_pending_fork_status (struct thread_info
*thread
)
6915 if (thread
->suspend
.waitstatus_pending_p
)
6916 return &thread
->suspend
.waitstatus
;
6918 return &thread
->pending_follow
;
6921 /* Determine if THREAD is a pending fork parent thread. */
6924 is_pending_fork_parent_thread (struct thread_info
*thread
)
6926 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6929 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6932 /* If CONTEXT contains any fork child threads that have not been
6933 reported yet, remove them from the CONTEXT list. If such a
6934 thread exists it is because we are stopped at a fork catchpoint
6935 and have not yet called follow_fork, which will set up the
6936 host-side data structures for the new process. */
6939 remote_target::remove_new_fork_children (threads_listing_context
*context
)
6942 struct notif_client
*notif
= ¬if_client_stop
;
6944 /* For any threads stopped at a fork event, remove the corresponding
6945 fork child threads from the CONTEXT list. */
6946 for (thread_info
*thread
: all_non_exited_threads ())
6948 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6950 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
6951 context
->remove_thread (ws
->value
.related_pid
);
6954 /* Check for any pending fork events (not reported or processed yet)
6955 in process PID and remove those fork child threads from the
6956 CONTEXT list as well. */
6957 remote_notif_get_pending_events (notif
);
6958 for (auto &event
: get_remote_state ()->stop_reply_queue
)
6959 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6960 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
6961 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
6962 context
->remove_thread (event
->ws
.value
.related_pid
);
6965 /* Check whether any event pending in the vStopped queue would prevent
6966 a global or process wildcard vCont action. Clear
6967 *may_global_wildcard if we can't do a global wildcard (vCont;c),
6968 and clear the event inferior's may_wildcard_vcont flag if we can't
6969 do a process-wide wildcard resume (vCont;c:pPID.-1). */
6972 remote_target::check_pending_events_prevent_wildcard_vcont
6973 (int *may_global_wildcard
)
6975 struct notif_client
*notif
= ¬if_client_stop
;
6977 remote_notif_get_pending_events (notif
);
6978 for (auto &event
: get_remote_state ()->stop_reply_queue
)
6980 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
6981 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
6984 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6985 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
6986 *may_global_wildcard
= 0;
6988 struct inferior
*inf
= find_inferior_ptid (event
->ptid
);
6990 /* This may be the first time we heard about this process.
6991 Regardless, we must not do a global wildcard resume, otherwise
6992 we'd resume this process too. */
6993 *may_global_wildcard
= 0;
6995 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
6999 /* Discard all pending stop replies of inferior INF. */
7002 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7004 struct stop_reply
*reply
;
7005 struct remote_state
*rs
= get_remote_state ();
7006 struct remote_notif_state
*rns
= rs
->notif_state
;
7008 /* This function can be notified when an inferior exists. When the
7009 target is not remote, the notification state is NULL. */
7010 if (rs
->remote_desc
== NULL
)
7013 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7015 /* Discard the in-flight notification. */
7016 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7019 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7022 /* Discard the stop replies we have already pulled with
7024 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7025 rs
->stop_reply_queue
.end (),
7026 [=] (const stop_reply_up
&event
)
7028 return event
->ptid
.pid () == inf
->pid
;
7030 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7033 /* Discard the stop replies for RS in stop_reply_queue. */
7036 remote_target::discard_pending_stop_replies_in_queue ()
7038 remote_state
*rs
= get_remote_state ();
7040 /* Discard the stop replies we have already pulled with
7042 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7043 rs
->stop_reply_queue
.end (),
7044 [=] (const stop_reply_up
&event
)
7046 return event
->rs
== rs
;
7048 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7051 /* Remove the first reply in 'stop_reply_queue' which matches
7055 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7057 remote_state
*rs
= get_remote_state ();
7059 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7060 rs
->stop_reply_queue
.end (),
7061 [=] (const stop_reply_up
&event
)
7063 return event
->ptid
.matches (ptid
);
7065 struct stop_reply
*result
;
7066 if (iter
== rs
->stop_reply_queue
.end ())
7070 result
= iter
->release ();
7071 rs
->stop_reply_queue
.erase (iter
);
7075 fprintf_unfiltered (gdb_stdlog
,
7076 "notif: discard queued event: 'Stop' in %s\n",
7077 target_pid_to_str (ptid
).c_str ());
7082 /* Look for a queued stop reply belonging to PTID. If one is found,
7083 remove it from the queue, and return it. Returns NULL if none is
7084 found. If there are still queued events left to process, tell the
7085 event loop to get back to target_wait soon. */
7088 remote_target::queued_stop_reply (ptid_t ptid
)
7090 remote_state
*rs
= get_remote_state ();
7091 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7093 if (!rs
->stop_reply_queue
.empty ())
7095 /* There's still at least an event left. */
7096 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7102 /* Push a fully parsed stop reply in the stop reply queue. Since we
7103 know that we now have at least one queued event left to pass to the
7104 core side, tell the event loop to get back to target_wait soon. */
7107 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7109 remote_state
*rs
= get_remote_state ();
7110 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7113 fprintf_unfiltered (gdb_stdlog
,
7114 "notif: push 'Stop' %s to queue %d\n",
7115 target_pid_to_str (new_event
->ptid
).c_str (),
7116 int (rs
->stop_reply_queue
.size ()));
7118 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7121 /* Returns true if we have a stop reply for PTID. */
7124 remote_target::peek_stop_reply (ptid_t ptid
)
7126 remote_state
*rs
= get_remote_state ();
7127 for (auto &event
: rs
->stop_reply_queue
)
7128 if (ptid
== event
->ptid
7129 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7134 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7135 starting with P and ending with PEND matches PREFIX. */
7138 strprefix (const char *p
, const char *pend
, const char *prefix
)
7140 for ( ; p
< pend
; p
++, prefix
++)
7143 return *prefix
== '\0';
7146 /* Parse the stop reply in BUF. Either the function succeeds, and the
7147 result is stored in EVENT, or throws an error. */
7150 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7152 remote_arch_state
*rsa
= NULL
;
7157 event
->ptid
= null_ptid
;
7158 event
->rs
= get_remote_state ();
7159 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7160 event
->ws
.value
.integer
= 0;
7161 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7162 event
->regcache
.clear ();
7167 case 'T': /* Status with PC, SP, FP, ... */
7168 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7169 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7171 n... = register number
7172 r... = register contents
7175 p
= &buf
[3]; /* after Txx */
7181 p1
= strchr (p
, ':');
7183 error (_("Malformed packet(a) (missing colon): %s\n\
7187 error (_("Malformed packet(a) (missing register number): %s\n\
7191 /* Some "registers" are actually extended stop information.
7192 Note if you're adding a new entry here: GDB 7.9 and
7193 earlier assume that all register "numbers" that start
7194 with an hex digit are real register numbers. Make sure
7195 the server only sends such a packet if it knows the
7196 client understands it. */
7198 if (strprefix (p
, p1
, "thread"))
7199 event
->ptid
= read_ptid (++p1
, &p
);
7200 else if (strprefix (p
, p1
, "syscall_entry"))
7204 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7205 p
= unpack_varlen_hex (++p1
, &sysno
);
7206 event
->ws
.value
.syscall_number
= (int) sysno
;
7208 else if (strprefix (p
, p1
, "syscall_return"))
7212 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7213 p
= unpack_varlen_hex (++p1
, &sysno
);
7214 event
->ws
.value
.syscall_number
= (int) sysno
;
7216 else if (strprefix (p
, p1
, "watch")
7217 || strprefix (p
, p1
, "rwatch")
7218 || strprefix (p
, p1
, "awatch"))
7220 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7221 p
= unpack_varlen_hex (++p1
, &addr
);
7222 event
->watch_data_address
= (CORE_ADDR
) addr
;
7224 else if (strprefix (p
, p1
, "swbreak"))
7226 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7228 /* Make sure the stub doesn't forget to indicate support
7230 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7231 error (_("Unexpected swbreak stop reason"));
7233 /* The value part is documented as "must be empty",
7234 though we ignore it, in case we ever decide to make
7235 use of it in a backward compatible way. */
7236 p
= strchrnul (p1
+ 1, ';');
7238 else if (strprefix (p
, p1
, "hwbreak"))
7240 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7242 /* Make sure the stub doesn't forget to indicate support
7244 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7245 error (_("Unexpected hwbreak stop reason"));
7248 p
= strchrnul (p1
+ 1, ';');
7250 else if (strprefix (p
, p1
, "library"))
7252 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7253 p
= strchrnul (p1
+ 1, ';');
7255 else if (strprefix (p
, p1
, "replaylog"))
7257 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7258 /* p1 will indicate "begin" or "end", but it makes
7259 no difference for now, so ignore it. */
7260 p
= strchrnul (p1
+ 1, ';');
7262 else if (strprefix (p
, p1
, "core"))
7266 p
= unpack_varlen_hex (++p1
, &c
);
7269 else if (strprefix (p
, p1
, "fork"))
7271 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7272 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7274 else if (strprefix (p
, p1
, "vfork"))
7276 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7277 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7279 else if (strprefix (p
, p1
, "vforkdone"))
7281 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7282 p
= strchrnul (p1
+ 1, ';');
7284 else if (strprefix (p
, p1
, "exec"))
7289 /* Determine the length of the execd pathname. */
7290 p
= unpack_varlen_hex (++p1
, &ignored
);
7291 pathlen
= (p
- p1
) / 2;
7293 /* Save the pathname for event reporting and for
7294 the next run command. */
7295 gdb::unique_xmalloc_ptr
<char[]> pathname
7296 ((char *) xmalloc (pathlen
+ 1));
7297 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7298 pathname
[pathlen
] = '\0';
7300 /* This is freed during event handling. */
7301 event
->ws
.value
.execd_pathname
= pathname
.release ();
7302 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7304 /* Skip the registers included in this packet, since
7305 they may be for an architecture different from the
7306 one used by the original program. */
7309 else if (strprefix (p
, p1
, "create"))
7311 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7312 p
= strchrnul (p1
+ 1, ';');
7321 p
= strchrnul (p1
+ 1, ';');
7326 /* Maybe a real ``P'' register number. */
7327 p_temp
= unpack_varlen_hex (p
, &pnum
);
7328 /* If the first invalid character is the colon, we got a
7329 register number. Otherwise, it's an unknown stop
7333 /* If we haven't parsed the event's thread yet, find
7334 it now, in order to find the architecture of the
7335 reported expedited registers. */
7336 if (event
->ptid
== null_ptid
)
7338 const char *thr
= strstr (p1
+ 1, ";thread:");
7340 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7344 /* Either the current thread hasn't changed,
7345 or the inferior is not multi-threaded.
7346 The event must be for the thread we last
7347 set as (or learned as being) current. */
7348 event
->ptid
= event
->rs
->general_thread
;
7354 inferior
*inf
= (event
->ptid
== null_ptid
7356 : find_inferior_ptid (event
->ptid
));
7357 /* If this is the first time we learn anything
7358 about this process, skip the registers
7359 included in this packet, since we don't yet
7360 know which architecture to use to parse them.
7361 We'll determine the architecture later when
7362 we process the stop reply and retrieve the
7363 target description, via
7364 remote_notice_new_inferior ->
7365 post_create_inferior. */
7368 p
= strchrnul (p1
+ 1, ';');
7373 event
->arch
= inf
->gdbarch
;
7374 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7378 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7379 cached_reg_t cached_reg
;
7382 error (_("Remote sent bad register number %s: %s\n\
7384 hex_string (pnum
), p
, buf
);
7386 cached_reg
.num
= reg
->regnum
;
7387 cached_reg
.data
= (gdb_byte
*)
7388 xmalloc (register_size (event
->arch
, reg
->regnum
));
7391 fieldsize
= hex2bin (p
, cached_reg
.data
,
7392 register_size (event
->arch
, reg
->regnum
));
7394 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7395 warning (_("Remote reply is too short: %s"), buf
);
7397 event
->regcache
.push_back (cached_reg
);
7401 /* Not a number. Silently skip unknown optional
7403 p
= strchrnul (p1
+ 1, ';');
7408 error (_("Remote register badly formatted: %s\nhere: %s"),
7413 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7417 case 'S': /* Old style status, just signal only. */
7421 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7422 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7423 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7424 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7426 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7429 case 'w': /* Thread exited. */
7433 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7434 p
= unpack_varlen_hex (&buf
[1], &value
);
7435 event
->ws
.value
.integer
= value
;
7437 error (_("stop reply packet badly formatted: %s"), buf
);
7438 event
->ptid
= read_ptid (++p
, NULL
);
7441 case 'W': /* Target exited. */
7447 /* GDB used to accept only 2 hex chars here. Stubs should
7448 only send more if they detect GDB supports multi-process
7450 p
= unpack_varlen_hex (&buf
[1], &value
);
7454 /* The remote process exited. */
7455 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7456 event
->ws
.value
.integer
= value
;
7460 /* The remote process exited with a signal. */
7461 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7462 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7463 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7465 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7468 /* If no process is specified, assume inferior_ptid. */
7469 pid
= inferior_ptid
.pid ();
7478 else if (startswith (p
, "process:"))
7482 p
+= sizeof ("process:") - 1;
7483 unpack_varlen_hex (p
, &upid
);
7487 error (_("unknown stop reply packet: %s"), buf
);
7490 error (_("unknown stop reply packet: %s"), buf
);
7491 event
->ptid
= ptid_t (pid
);
7495 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7496 event
->ptid
= minus_one_ptid
;
7500 if (target_is_non_stop_p () && event
->ptid
== null_ptid
)
7501 error (_("No process or thread specified in stop reply: %s"), buf
);
7504 /* When the stub wants to tell GDB about a new notification reply, it
7505 sends a notification (%Stop, for example). Those can come it at
7506 any time, hence, we have to make sure that any pending
7507 putpkt/getpkt sequence we're making is finished, before querying
7508 the stub for more events with the corresponding ack command
7509 (vStopped, for example). E.g., if we started a vStopped sequence
7510 immediately upon receiving the notification, something like this
7518 1.6) <-- (registers reply to step #1.3)
7520 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7523 To solve this, whenever we parse a %Stop notification successfully,
7524 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7525 doing whatever we were doing:
7531 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7532 2.5) <-- (registers reply to step #2.3)
7534 Eventually after step #2.5, we return to the event loop, which
7535 notices there's an event on the
7536 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7537 associated callback --- the function below. At this point, we're
7538 always safe to start a vStopped sequence. :
7541 2.7) <-- T05 thread:2
7547 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7549 struct remote_state
*rs
= get_remote_state ();
7551 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7554 fprintf_unfiltered (gdb_stdlog
,
7555 "notif: process: '%s' ack pending event\n",
7559 nc
->ack (this, nc
, rs
->buf
.data (),
7560 rs
->notif_state
->pending_event
[nc
->id
]);
7561 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7565 getpkt (&rs
->buf
, 0);
7566 if (strcmp (rs
->buf
.data (), "OK") == 0)
7569 remote_notif_ack (this, nc
, rs
->buf
.data ());
7575 fprintf_unfiltered (gdb_stdlog
,
7576 "notif: process: '%s' no pending reply\n",
7581 /* Wrapper around remote_target::remote_notif_get_pending_events to
7582 avoid having to export the whole remote_target class. */
7585 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7587 remote
->remote_notif_get_pending_events (nc
);
7590 /* Called when it is decided that STOP_REPLY holds the info of the
7591 event that is to be returned to the core. This function always
7592 destroys STOP_REPLY. */
7595 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7596 struct target_waitstatus
*status
)
7600 *status
= stop_reply
->ws
;
7601 ptid
= stop_reply
->ptid
;
7603 /* If no thread/process was reported by the stub, assume the current
7605 if (ptid
== null_ptid
)
7606 ptid
= inferior_ptid
;
7608 if (status
->kind
!= TARGET_WAITKIND_EXITED
7609 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7610 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7612 /* Expedited registers. */
7613 if (!stop_reply
->regcache
.empty ())
7615 struct regcache
*regcache
7616 = get_thread_arch_regcache (ptid
, stop_reply
->arch
);
7618 for (cached_reg_t
®
: stop_reply
->regcache
)
7620 regcache
->raw_supply (reg
.num
, reg
.data
);
7624 stop_reply
->regcache
.clear ();
7627 remote_notice_new_inferior (ptid
, 0);
7628 remote_thread_info
*remote_thr
= get_remote_thread_info (ptid
);
7629 remote_thr
->core
= stop_reply
->core
;
7630 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7631 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7632 remote_thr
->vcont_resumed
= 0;
7639 /* The non-stop mode version of target_wait. */
7642 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7644 struct remote_state
*rs
= get_remote_state ();
7645 struct stop_reply
*stop_reply
;
7649 /* If in non-stop mode, get out of getpkt even if a
7650 notification is received. */
7652 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7655 if (ret
!= -1 && !is_notif
)
7658 case 'E': /* Error of some sort. */
7659 /* We're out of sync with the target now. Did it continue
7660 or not? We can't tell which thread it was in non-stop,
7661 so just ignore this. */
7662 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7664 case 'O': /* Console output. */
7665 remote_console_output (&rs
->buf
[1]);
7668 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7672 /* Acknowledge a pending stop reply that may have arrived in the
7674 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7675 remote_notif_get_pending_events (¬if_client_stop
);
7677 /* If indeed we noticed a stop reply, we're done. */
7678 stop_reply
= queued_stop_reply (ptid
);
7679 if (stop_reply
!= NULL
)
7680 return process_stop_reply (stop_reply
, status
);
7682 /* Still no event. If we're just polling for an event, then
7683 return to the event loop. */
7684 if (options
& TARGET_WNOHANG
)
7686 status
->kind
= TARGET_WAITKIND_IGNORE
;
7687 return minus_one_ptid
;
7690 /* Otherwise do a blocking wait. */
7691 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7695 /* Wait until the remote machine stops, then return, storing status in
7696 STATUS just as `wait' would. */
7699 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
, int options
)
7701 struct remote_state
*rs
= get_remote_state ();
7702 ptid_t event_ptid
= null_ptid
;
7704 struct stop_reply
*stop_reply
;
7708 status
->kind
= TARGET_WAITKIND_IGNORE
;
7709 status
->value
.integer
= 0;
7711 stop_reply
= queued_stop_reply (ptid
);
7712 if (stop_reply
!= NULL
)
7713 return process_stop_reply (stop_reply
, status
);
7715 if (rs
->cached_wait_status
)
7716 /* Use the cached wait status, but only once. */
7717 rs
->cached_wait_status
= 0;
7722 int forever
= ((options
& TARGET_WNOHANG
) == 0
7723 && rs
->wait_forever_enabled_p
);
7725 if (!rs
->waiting_for_stop_reply
)
7727 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7728 return minus_one_ptid
;
7731 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7732 _never_ wait for ever -> test on target_is_async_p().
7733 However, before we do that we need to ensure that the caller
7734 knows how to take the target into/out of async mode. */
7735 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
7737 /* GDB gets a notification. Return to core as this event is
7739 if (ret
!= -1 && is_notif
)
7740 return minus_one_ptid
;
7742 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7743 return minus_one_ptid
;
7746 buf
= rs
->buf
.data ();
7748 /* Assume that the target has acknowledged Ctrl-C unless we receive
7749 an 'F' or 'O' packet. */
7750 if (buf
[0] != 'F' && buf
[0] != 'O')
7751 rs
->ctrlc_pending_p
= 0;
7755 case 'E': /* Error of some sort. */
7756 /* We're out of sync with the target now. Did it continue or
7757 not? Not is more likely, so report a stop. */
7758 rs
->waiting_for_stop_reply
= 0;
7760 warning (_("Remote failure reply: %s"), buf
);
7761 status
->kind
= TARGET_WAITKIND_STOPPED
;
7762 status
->value
.sig
= GDB_SIGNAL_0
;
7764 case 'F': /* File-I/O request. */
7765 /* GDB may access the inferior memory while handling the File-I/O
7766 request, but we don't want GDB accessing memory while waiting
7767 for a stop reply. See the comments in putpkt_binary. Set
7768 waiting_for_stop_reply to 0 temporarily. */
7769 rs
->waiting_for_stop_reply
= 0;
7770 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
7771 rs
->ctrlc_pending_p
= 0;
7772 /* GDB handled the File-I/O request, and the target is running
7773 again. Keep waiting for events. */
7774 rs
->waiting_for_stop_reply
= 1;
7776 case 'N': case 'T': case 'S': case 'X': case 'W':
7778 /* There is a stop reply to handle. */
7779 rs
->waiting_for_stop_reply
= 0;
7782 = (struct stop_reply
*) remote_notif_parse (this,
7786 event_ptid
= process_stop_reply (stop_reply
, status
);
7789 case 'O': /* Console output. */
7790 remote_console_output (buf
+ 1);
7793 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7795 /* Zero length reply means that we tried 'S' or 'C' and the
7796 remote system doesn't support it. */
7797 target_terminal::ours_for_output ();
7799 ("Can't send signals to this remote system. %s not sent.\n",
7800 gdb_signal_to_name (rs
->last_sent_signal
));
7801 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7802 target_terminal::inferior ();
7804 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7810 warning (_("Invalid remote reply: %s"), buf
);
7814 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7815 return minus_one_ptid
;
7816 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7818 /* Nothing interesting happened. If we're doing a non-blocking
7819 poll, we're done. Otherwise, go back to waiting. */
7820 if (options
& TARGET_WNOHANG
)
7821 return minus_one_ptid
;
7825 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7826 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7828 if (event_ptid
!= null_ptid
)
7829 record_currthread (rs
, event_ptid
);
7831 event_ptid
= inferior_ptid
;
7834 /* A process exit. Invalidate our notion of current thread. */
7835 record_currthread (rs
, minus_one_ptid
);
7840 /* Wait until the remote machine stops, then return, storing status in
7841 STATUS just as `wait' would. */
7844 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7848 if (target_is_non_stop_p ())
7849 event_ptid
= wait_ns (ptid
, status
, options
);
7851 event_ptid
= wait_as (ptid
, status
, options
);
7853 if (target_is_async_p ())
7855 remote_state
*rs
= get_remote_state ();
7857 /* If there are are events left in the queue tell the event loop
7859 if (!rs
->stop_reply_queue
.empty ())
7860 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7866 /* Fetch a single register using a 'p' packet. */
7869 remote_target::fetch_register_using_p (struct regcache
*regcache
,
7872 struct gdbarch
*gdbarch
= regcache
->arch ();
7873 struct remote_state
*rs
= get_remote_state ();
7875 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7878 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7881 if (reg
->pnum
== -1)
7884 p
= rs
->buf
.data ();
7886 p
+= hexnumstr (p
, reg
->pnum
);
7889 getpkt (&rs
->buf
, 0);
7891 buf
= rs
->buf
.data ();
7893 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
7897 case PACKET_UNKNOWN
:
7900 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7901 gdbarch_register_name (regcache
->arch (),
7906 /* If this register is unfetchable, tell the regcache. */
7909 regcache
->raw_supply (reg
->regnum
, NULL
);
7913 /* Otherwise, parse and supply the value. */
7919 error (_("fetch_register_using_p: early buf termination"));
7921 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7924 regcache
->raw_supply (reg
->regnum
, regp
);
7928 /* Fetch the registers included in the target's 'g' packet. */
7931 remote_target::send_g_packet ()
7933 struct remote_state
*rs
= get_remote_state ();
7936 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
7938 getpkt (&rs
->buf
, 0);
7939 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
7940 error (_("Could not read registers; remote failure reply '%s'"),
7943 /* We can get out of synch in various cases. If the first character
7944 in the buffer is not a hex character, assume that has happened
7945 and try to fetch another packet to read. */
7946 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
7947 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
7948 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
7949 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
7952 fprintf_unfiltered (gdb_stdlog
,
7953 "Bad register packet; fetching a new packet\n");
7954 getpkt (&rs
->buf
, 0);
7957 buf_len
= strlen (rs
->buf
.data ());
7959 /* Sanity check the received packet. */
7960 if (buf_len
% 2 != 0)
7961 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
7967 remote_target::process_g_packet (struct regcache
*regcache
)
7969 struct gdbarch
*gdbarch
= regcache
->arch ();
7970 struct remote_state
*rs
= get_remote_state ();
7971 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
7976 buf_len
= strlen (rs
->buf
.data ());
7978 /* Further sanity checks, with knowledge of the architecture. */
7979 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
7980 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
7982 rsa
->sizeof_g_packet
, buf_len
/ 2,
7985 /* Save the size of the packet sent to us by the target. It is used
7986 as a heuristic when determining the max size of packets that the
7987 target can safely receive. */
7988 if (rsa
->actual_register_packet_size
== 0)
7989 rsa
->actual_register_packet_size
= buf_len
;
7991 /* If this is smaller than we guessed the 'g' packet would be,
7992 update our records. A 'g' reply that doesn't include a register's
7993 value implies either that the register is not available, or that
7994 the 'p' packet must be used. */
7995 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
7997 long sizeof_g_packet
= buf_len
/ 2;
7999 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8001 long offset
= rsa
->regs
[i
].offset
;
8002 long reg_size
= register_size (gdbarch
, i
);
8004 if (rsa
->regs
[i
].pnum
== -1)
8007 if (offset
>= sizeof_g_packet
)
8008 rsa
->regs
[i
].in_g_packet
= 0;
8009 else if (offset
+ reg_size
> sizeof_g_packet
)
8010 error (_("Truncated register %d in remote 'g' packet"), i
);
8012 rsa
->regs
[i
].in_g_packet
= 1;
8015 /* Looks valid enough, we can assume this is the correct length
8016 for a 'g' packet. It's important not to adjust
8017 rsa->sizeof_g_packet if we have truncated registers otherwise
8018 this "if" won't be run the next time the method is called
8019 with a packet of the same size and one of the internal errors
8020 below will trigger instead. */
8021 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8024 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8026 /* Unimplemented registers read as all bits zero. */
8027 memset (regs
, 0, rsa
->sizeof_g_packet
);
8029 /* Reply describes registers byte by byte, each byte encoded as two
8030 hex characters. Suck them all up, then supply them to the
8031 register cacheing/storage mechanism. */
8033 p
= rs
->buf
.data ();
8034 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8036 if (p
[0] == 0 || p
[1] == 0)
8037 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8038 internal_error (__FILE__
, __LINE__
,
8039 _("unexpected end of 'g' packet reply"));
8041 if (p
[0] == 'x' && p
[1] == 'x')
8042 regs
[i
] = 0; /* 'x' */
8044 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8048 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8050 struct packet_reg
*r
= &rsa
->regs
[i
];
8051 long reg_size
= register_size (gdbarch
, i
);
8055 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8056 /* This shouldn't happen - we adjusted in_g_packet above. */
8057 internal_error (__FILE__
, __LINE__
,
8058 _("unexpected end of 'g' packet reply"));
8059 else if (rs
->buf
[r
->offset
* 2] == 'x')
8061 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8062 /* The register isn't available, mark it as such (at
8063 the same time setting the value to zero). */
8064 regcache
->raw_supply (r
->regnum
, NULL
);
8067 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8073 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8076 process_g_packet (regcache
);
8079 /* Make the remote selected traceframe match GDB's selected
8083 remote_target::set_remote_traceframe ()
8086 struct remote_state
*rs
= get_remote_state ();
8088 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8091 /* Avoid recursion, remote_trace_find calls us again. */
8092 rs
->remote_traceframe_number
= get_traceframe_number ();
8094 newnum
= target_trace_find (tfind_number
,
8095 get_traceframe_number (), 0, 0, NULL
);
8097 /* Should not happen. If it does, all bets are off. */
8098 if (newnum
!= get_traceframe_number ())
8099 warning (_("could not set remote traceframe"));
8103 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8105 struct gdbarch
*gdbarch
= regcache
->arch ();
8106 struct remote_state
*rs
= get_remote_state ();
8107 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8110 set_remote_traceframe ();
8111 set_general_thread (regcache
->ptid ());
8115 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8117 gdb_assert (reg
!= NULL
);
8119 /* If this register might be in the 'g' packet, try that first -
8120 we are likely to read more than one register. If this is the
8121 first 'g' packet, we might be overly optimistic about its
8122 contents, so fall back to 'p'. */
8123 if (reg
->in_g_packet
)
8125 fetch_registers_using_g (regcache
);
8126 if (reg
->in_g_packet
)
8130 if (fetch_register_using_p (regcache
, reg
))
8133 /* This register is not available. */
8134 regcache
->raw_supply (reg
->regnum
, NULL
);
8139 fetch_registers_using_g (regcache
);
8141 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8142 if (!rsa
->regs
[i
].in_g_packet
)
8143 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8145 /* This register is not available. */
8146 regcache
->raw_supply (i
, NULL
);
8150 /* Prepare to store registers. Since we may send them all (using a
8151 'G' request), we have to read out the ones we don't want to change
8155 remote_target::prepare_to_store (struct regcache
*regcache
)
8157 struct remote_state
*rs
= get_remote_state ();
8158 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8161 /* Make sure the entire registers array is valid. */
8162 switch (packet_support (PACKET_P
))
8164 case PACKET_DISABLE
:
8165 case PACKET_SUPPORT_UNKNOWN
:
8166 /* Make sure all the necessary registers are cached. */
8167 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8168 if (rsa
->regs
[i
].in_g_packet
)
8169 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8176 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8177 packet was not recognized. */
8180 remote_target::store_register_using_P (const struct regcache
*regcache
,
8183 struct gdbarch
*gdbarch
= regcache
->arch ();
8184 struct remote_state
*rs
= get_remote_state ();
8185 /* Try storing a single register. */
8186 char *buf
= rs
->buf
.data ();
8187 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8190 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8193 if (reg
->pnum
== -1)
8196 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8197 p
= buf
+ strlen (buf
);
8198 regcache
->raw_collect (reg
->regnum
, regp
);
8199 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8201 getpkt (&rs
->buf
, 0);
8203 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8208 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8209 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8210 case PACKET_UNKNOWN
:
8213 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8217 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8218 contents of the register cache buffer. FIXME: ignores errors. */
8221 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8223 struct remote_state
*rs
= get_remote_state ();
8224 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8228 /* Extract all the registers in the regcache copying them into a
8233 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8234 memset (regs
, 0, rsa
->sizeof_g_packet
);
8235 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8237 struct packet_reg
*r
= &rsa
->regs
[i
];
8240 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8244 /* Command describes registers byte by byte,
8245 each byte encoded as two hex characters. */
8246 p
= rs
->buf
.data ();
8248 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8250 getpkt (&rs
->buf
, 0);
8251 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8252 error (_("Could not write registers; remote failure reply '%s'"),
8256 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8257 of the register cache buffer. FIXME: ignores errors. */
8260 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8262 struct gdbarch
*gdbarch
= regcache
->arch ();
8263 struct remote_state
*rs
= get_remote_state ();
8264 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8267 set_remote_traceframe ();
8268 set_general_thread (regcache
->ptid ());
8272 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8274 gdb_assert (reg
!= NULL
);
8276 /* Always prefer to store registers using the 'P' packet if
8277 possible; we often change only a small number of registers.
8278 Sometimes we change a larger number; we'd need help from a
8279 higher layer to know to use 'G'. */
8280 if (store_register_using_P (regcache
, reg
))
8283 /* For now, don't complain if we have no way to write the
8284 register. GDB loses track of unavailable registers too
8285 easily. Some day, this may be an error. We don't have
8286 any way to read the register, either... */
8287 if (!reg
->in_g_packet
)
8290 store_registers_using_G (regcache
);
8294 store_registers_using_G (regcache
);
8296 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8297 if (!rsa
->regs
[i
].in_g_packet
)
8298 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8299 /* See above for why we do not issue an error here. */
8304 /* Return the number of hex digits in num. */
8307 hexnumlen (ULONGEST num
)
8311 for (i
= 0; num
!= 0; i
++)
8314 return std::max (i
, 1);
8317 /* Set BUF to the minimum number of hex digits representing NUM. */
8320 hexnumstr (char *buf
, ULONGEST num
)
8322 int len
= hexnumlen (num
);
8324 return hexnumnstr (buf
, num
, len
);
8328 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8331 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8337 for (i
= width
- 1; i
>= 0; i
--)
8339 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8346 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8349 remote_address_masked (CORE_ADDR addr
)
8351 unsigned int address_size
= remote_address_size
;
8353 /* If "remoteaddresssize" was not set, default to target address size. */
8355 address_size
= gdbarch_addr_bit (target_gdbarch ());
8357 if (address_size
> 0
8358 && address_size
< (sizeof (ULONGEST
) * 8))
8360 /* Only create a mask when that mask can safely be constructed
8361 in a ULONGEST variable. */
8364 mask
= (mask
<< address_size
) - 1;
8370 /* Determine whether the remote target supports binary downloading.
8371 This is accomplished by sending a no-op memory write of zero length
8372 to the target at the specified address. It does not suffice to send
8373 the whole packet, since many stubs strip the eighth bit and
8374 subsequently compute a wrong checksum, which causes real havoc with
8377 NOTE: This can still lose if the serial line is not eight-bit
8378 clean. In cases like this, the user should clear "remote
8382 remote_target::check_binary_download (CORE_ADDR addr
)
8384 struct remote_state
*rs
= get_remote_state ();
8386 switch (packet_support (PACKET_X
))
8388 case PACKET_DISABLE
:
8392 case PACKET_SUPPORT_UNKNOWN
:
8396 p
= rs
->buf
.data ();
8398 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8400 p
+= hexnumstr (p
, (ULONGEST
) 0);
8404 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8405 getpkt (&rs
->buf
, 0);
8407 if (rs
->buf
[0] == '\0')
8410 fprintf_unfiltered (gdb_stdlog
,
8411 "binary downloading NOT "
8412 "supported by target\n");
8413 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8418 fprintf_unfiltered (gdb_stdlog
,
8419 "binary downloading supported by target\n");
8420 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8427 /* Helper function to resize the payload in order to try to get a good
8428 alignment. We try to write an amount of data such that the next write will
8429 start on an address aligned on REMOTE_ALIGN_WRITES. */
8432 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8434 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8437 /* Write memory data directly to the remote machine.
8438 This does not inform the data cache; the data cache uses this.
8439 HEADER is the starting part of the packet.
8440 MEMADDR is the address in the remote memory space.
8441 MYADDR is the address of the buffer in our space.
8442 LEN_UNITS is the number of addressable units to write.
8443 UNIT_SIZE is the length in bytes of an addressable unit.
8444 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8445 should send data as binary ('X'), or hex-encoded ('M').
8447 The function creates packet of the form
8448 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8450 where encoding of <DATA> is terminated by PACKET_FORMAT.
8452 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8455 Return the transferred status, error or OK (an
8456 'enum target_xfer_status' value). Save the number of addressable units
8457 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8459 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8460 exchange between gdb and the stub could look like (?? in place of the
8466 -> $M1000,3:eeeeffffeeee#??
8470 <- eeeeffffeeeedddd */
8473 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8474 const gdb_byte
*myaddr
,
8477 ULONGEST
*xfered_len_units
,
8478 char packet_format
, int use_length
)
8480 struct remote_state
*rs
= get_remote_state ();
8486 int payload_capacity_bytes
;
8487 int payload_length_bytes
;
8489 if (packet_format
!= 'X' && packet_format
!= 'M')
8490 internal_error (__FILE__
, __LINE__
,
8491 _("remote_write_bytes_aux: bad packet format"));
8494 return TARGET_XFER_EOF
;
8496 payload_capacity_bytes
= get_memory_write_packet_size ();
8498 /* The packet buffer will be large enough for the payload;
8499 get_memory_packet_size ensures this. */
8502 /* Compute the size of the actual payload by subtracting out the
8503 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8505 payload_capacity_bytes
-= strlen ("$,:#NN");
8507 /* The comma won't be used. */
8508 payload_capacity_bytes
+= 1;
8509 payload_capacity_bytes
-= strlen (header
);
8510 payload_capacity_bytes
-= hexnumlen (memaddr
);
8512 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8514 strcat (rs
->buf
.data (), header
);
8515 p
= rs
->buf
.data () + strlen (header
);
8517 /* Compute a best guess of the number of bytes actually transfered. */
8518 if (packet_format
== 'X')
8520 /* Best guess at number of bytes that will fit. */
8521 todo_units
= std::min (len_units
,
8522 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8524 payload_capacity_bytes
-= hexnumlen (todo_units
);
8525 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8529 /* Number of bytes that will fit. */
8531 = std::min (len_units
,
8532 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8534 payload_capacity_bytes
-= hexnumlen (todo_units
);
8535 todo_units
= std::min (todo_units
,
8536 (payload_capacity_bytes
/ unit_size
) / 2);
8539 if (todo_units
<= 0)
8540 internal_error (__FILE__
, __LINE__
,
8541 _("minimum packet size too small to write data"));
8543 /* If we already need another packet, then try to align the end
8544 of this packet to a useful boundary. */
8545 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8546 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8548 /* Append "<memaddr>". */
8549 memaddr
= remote_address_masked (memaddr
);
8550 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8557 /* Append the length and retain its location and size. It may need to be
8558 adjusted once the packet body has been created. */
8560 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8568 /* Append the packet body. */
8569 if (packet_format
== 'X')
8571 /* Binary mode. Send target system values byte by byte, in
8572 increasing byte addresses. Only escape certain critical
8574 payload_length_bytes
=
8575 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8576 &units_written
, payload_capacity_bytes
);
8578 /* If not all TODO units fit, then we'll need another packet. Make
8579 a second try to keep the end of the packet aligned. Don't do
8580 this if the packet is tiny. */
8581 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8585 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8587 if (new_todo_units
!= units_written
)
8588 payload_length_bytes
=
8589 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8590 (gdb_byte
*) p
, &units_written
,
8591 payload_capacity_bytes
);
8594 p
+= payload_length_bytes
;
8595 if (use_length
&& units_written
< todo_units
)
8597 /* Escape chars have filled up the buffer prematurely,
8598 and we have actually sent fewer units than planned.
8599 Fix-up the length field of the packet. Use the same
8600 number of characters as before. */
8601 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8603 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8608 /* Normal mode: Send target system values byte by byte, in
8609 increasing byte addresses. Each byte is encoded as a two hex
8611 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8612 units_written
= todo_units
;
8615 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8616 getpkt (&rs
->buf
, 0);
8618 if (rs
->buf
[0] == 'E')
8619 return TARGET_XFER_E_IO
;
8621 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8622 send fewer units than we'd planned. */
8623 *xfered_len_units
= (ULONGEST
) units_written
;
8624 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8627 /* Write memory data directly to the remote machine.
8628 This does not inform the data cache; the data cache uses this.
8629 MEMADDR is the address in the remote memory space.
8630 MYADDR is the address of the buffer in our space.
8631 LEN is the number of bytes.
8633 Return the transferred status, error or OK (an
8634 'enum target_xfer_status' value). Save the number of bytes
8635 transferred in *XFERED_LEN. Only transfer a single packet. */
8638 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8639 ULONGEST len
, int unit_size
,
8640 ULONGEST
*xfered_len
)
8642 const char *packet_format
= NULL
;
8644 /* Check whether the target supports binary download. */
8645 check_binary_download (memaddr
);
8647 switch (packet_support (PACKET_X
))
8650 packet_format
= "X";
8652 case PACKET_DISABLE
:
8653 packet_format
= "M";
8655 case PACKET_SUPPORT_UNKNOWN
:
8656 internal_error (__FILE__
, __LINE__
,
8657 _("remote_write_bytes: bad internal state"));
8659 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8662 return remote_write_bytes_aux (packet_format
,
8663 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8664 packet_format
[0], 1);
8667 /* Read memory data directly from the remote machine.
8668 This does not use the data cache; the data cache uses this.
8669 MEMADDR is the address in the remote memory space.
8670 MYADDR is the address of the buffer in our space.
8671 LEN_UNITS is the number of addressable memory units to read..
8672 UNIT_SIZE is the length in bytes of an addressable unit.
8674 Return the transferred status, error or OK (an
8675 'enum target_xfer_status' value). Save the number of bytes
8676 transferred in *XFERED_LEN_UNITS.
8678 See the comment of remote_write_bytes_aux for an example of
8679 memory read/write exchange between gdb and the stub. */
8682 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8684 int unit_size
, ULONGEST
*xfered_len_units
)
8686 struct remote_state
*rs
= get_remote_state ();
8687 int buf_size_bytes
; /* Max size of packet output buffer. */
8692 buf_size_bytes
= get_memory_read_packet_size ();
8693 /* The packet buffer will be large enough for the payload;
8694 get_memory_packet_size ensures this. */
8696 /* Number of units that will fit. */
8697 todo_units
= std::min (len_units
,
8698 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8700 /* Construct "m"<memaddr>","<len>". */
8701 memaddr
= remote_address_masked (memaddr
);
8702 p
= rs
->buf
.data ();
8704 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8706 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8709 getpkt (&rs
->buf
, 0);
8710 if (rs
->buf
[0] == 'E'
8711 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8712 && rs
->buf
[3] == '\0')
8713 return TARGET_XFER_E_IO
;
8714 /* Reply describes memory byte by byte, each byte encoded as two hex
8716 p
= rs
->buf
.data ();
8717 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8718 /* Return what we have. Let higher layers handle partial reads. */
8719 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8720 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8723 /* Using the set of read-only target sections of remote, read live
8726 For interface/parameters/return description see target.h,
8730 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
8734 ULONGEST
*xfered_len
)
8736 struct target_section
*secp
;
8737 struct target_section_table
*table
;
8739 secp
= target_section_by_addr (this, memaddr
);
8741 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
8743 struct target_section
*p
;
8744 ULONGEST memend
= memaddr
+ len
;
8746 table
= target_get_section_table (this);
8748 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8750 if (memaddr
>= p
->addr
)
8752 if (memend
<= p
->endaddr
)
8754 /* Entire transfer is within this section. */
8755 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8758 else if (memaddr
>= p
->endaddr
)
8760 /* This section ends before the transfer starts. */
8765 /* This section overlaps the transfer. Just do half. */
8766 len
= p
->endaddr
- memaddr
;
8767 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8774 return TARGET_XFER_EOF
;
8777 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8778 first if the requested memory is unavailable in traceframe.
8779 Otherwise, fall back to remote_read_bytes_1. */
8782 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
8783 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8784 ULONGEST
*xfered_len
)
8787 return TARGET_XFER_EOF
;
8789 if (get_traceframe_number () != -1)
8791 std::vector
<mem_range
> available
;
8793 /* If we fail to get the set of available memory, then the
8794 target does not support querying traceframe info, and so we
8795 attempt reading from the traceframe anyway (assuming the
8796 target implements the old QTro packet then). */
8797 if (traceframe_available_memory (&available
, memaddr
, len
))
8799 if (available
.empty () || available
[0].start
!= memaddr
)
8801 enum target_xfer_status res
;
8803 /* Don't read into the traceframe's available
8805 if (!available
.empty ())
8807 LONGEST oldlen
= len
;
8809 len
= available
[0].start
- memaddr
;
8810 gdb_assert (len
<= oldlen
);
8813 /* This goes through the topmost target again. */
8814 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
8815 len
, unit_size
, xfered_len
);
8816 if (res
== TARGET_XFER_OK
)
8817 return TARGET_XFER_OK
;
8820 /* No use trying further, we know some memory starting
8821 at MEMADDR isn't available. */
8823 return (*xfered_len
!= 0) ?
8824 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
8828 /* Don't try to read more than how much is available, in
8829 case the target implements the deprecated QTro packet to
8830 cater for older GDBs (the target's knowledge of read-only
8831 sections may be outdated by now). */
8832 len
= available
[0].length
;
8836 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8841 /* Sends a packet with content determined by the printf format string
8842 FORMAT and the remaining arguments, then gets the reply. Returns
8843 whether the packet was a success, a failure, or unknown. */
8846 remote_target::remote_send_printf (const char *format
, ...)
8848 struct remote_state
*rs
= get_remote_state ();
8849 int max_size
= get_remote_packet_size ();
8852 va_start (ap
, format
);
8855 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
8859 if (size
>= max_size
)
8860 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8862 if (putpkt (rs
->buf
) < 0)
8863 error (_("Communication problem with target."));
8866 getpkt (&rs
->buf
, 0);
8868 return packet_check_result (rs
->buf
);
8871 /* Flash writing can take quite some time. We'll set
8872 effectively infinite timeout for flash operations.
8873 In future, we'll need to decide on a better approach. */
8874 static const int remote_flash_timeout
= 1000;
8877 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
8879 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8880 enum packet_result ret
;
8881 scoped_restore restore_timeout
8882 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8884 ret
= remote_send_printf ("vFlashErase:%s,%s",
8885 phex (address
, addr_size
),
8889 case PACKET_UNKNOWN
:
8890 error (_("Remote target does not support flash erase"));
8892 error (_("Error erasing flash with vFlashErase packet"));
8899 remote_target::remote_flash_write (ULONGEST address
,
8900 ULONGEST length
, ULONGEST
*xfered_len
,
8901 const gdb_byte
*data
)
8903 scoped_restore restore_timeout
8904 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8905 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8910 remote_target::flash_done ()
8914 scoped_restore restore_timeout
8915 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8917 ret
= remote_send_printf ("vFlashDone");
8921 case PACKET_UNKNOWN
:
8922 error (_("Remote target does not support vFlashDone"));
8924 error (_("Error finishing flash operation"));
8931 remote_target::files_info ()
8933 puts_filtered ("Debugging a target over a serial line.\n");
8936 /* Stuff for dealing with the packets which are part of this protocol.
8937 See comment at top of file for details. */
8939 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8940 error to higher layers. Called when a serial error is detected.
8941 The exception message is STRING, followed by a colon and a blank,
8942 the system error message for errno at function entry and final dot
8943 for output compatibility with throw_perror_with_name. */
8946 unpush_and_perror (const char *string
)
8948 int saved_errno
= errno
;
8950 remote_unpush_target ();
8951 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
8952 safe_strerror (saved_errno
));
8955 /* Read a single character from the remote end. The current quit
8956 handler is overridden to avoid quitting in the middle of packet
8957 sequence, as that would break communication with the remote server.
8958 See remote_serial_quit_handler for more detail. */
8961 remote_target::readchar (int timeout
)
8964 struct remote_state
*rs
= get_remote_state ();
8967 scoped_restore restore_quit_target
8968 = make_scoped_restore (&curr_quit_handler_target
, this);
8969 scoped_restore restore_quit
8970 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
8972 rs
->got_ctrlc_during_io
= 0;
8974 ch
= serial_readchar (rs
->remote_desc
, timeout
);
8976 if (rs
->got_ctrlc_during_io
)
8983 switch ((enum serial_rc
) ch
)
8986 remote_unpush_target ();
8987 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
8990 unpush_and_perror (_("Remote communication error. "
8991 "Target disconnected."));
8993 case SERIAL_TIMEOUT
:
8999 /* Wrapper for serial_write that closes the target and throws if
9000 writing fails. The current quit handler is overridden to avoid
9001 quitting in the middle of packet sequence, as that would break
9002 communication with the remote server. See
9003 remote_serial_quit_handler for more detail. */
9006 remote_target::remote_serial_write (const char *str
, int len
)
9008 struct remote_state
*rs
= get_remote_state ();
9010 scoped_restore restore_quit_target
9011 = make_scoped_restore (&curr_quit_handler_target
, this);
9012 scoped_restore restore_quit
9013 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9015 rs
->got_ctrlc_during_io
= 0;
9017 if (serial_write (rs
->remote_desc
, str
, len
))
9019 unpush_and_perror (_("Remote communication error. "
9020 "Target disconnected."));
9023 if (rs
->got_ctrlc_during_io
)
9027 /* Return a string representing an escaped version of BUF, of len N.
9028 E.g. \n is converted to \\n, \t to \\t, etc. */
9031 escape_buffer (const char *buf
, int n
)
9035 stb
.putstrn (buf
, n
, '\\');
9036 return std::move (stb
.string ());
9039 /* Display a null-terminated packet on stdout, for debugging, using C
9043 print_packet (const char *buf
)
9045 puts_filtered ("\"");
9046 fputstr_filtered (buf
, '"', gdb_stdout
);
9047 puts_filtered ("\"");
9051 remote_target::putpkt (const char *buf
)
9053 return putpkt_binary (buf
, strlen (buf
));
9056 /* Wrapper around remote_target::putpkt to avoid exporting
9060 putpkt (remote_target
*remote
, const char *buf
)
9062 return remote
->putpkt (buf
);
9065 /* Send a packet to the remote machine, with error checking. The data
9066 of the packet is in BUF. The string in BUF can be at most
9067 get_remote_packet_size () - 5 to account for the $, # and checksum,
9068 and for a possible /0 if we are debugging (remote_debug) and want
9069 to print the sent packet as a string. */
9072 remote_target::putpkt_binary (const char *buf
, int cnt
)
9074 struct remote_state
*rs
= get_remote_state ();
9076 unsigned char csum
= 0;
9077 gdb::def_vector
<char> data (cnt
+ 6);
9078 char *buf2
= data
.data ();
9084 /* Catch cases like trying to read memory or listing threads while
9085 we're waiting for a stop reply. The remote server wouldn't be
9086 ready to handle this request, so we'd hang and timeout. We don't
9087 have to worry about this in synchronous mode, because in that
9088 case it's not possible to issue a command while the target is
9089 running. This is not a problem in non-stop mode, because in that
9090 case, the stub is always ready to process serial input. */
9091 if (!target_is_non_stop_p ()
9092 && target_is_async_p ()
9093 && rs
->waiting_for_stop_reply
)
9095 error (_("Cannot execute this command while the target is running.\n"
9096 "Use the \"interrupt\" command to stop the target\n"
9097 "and then try again."));
9100 /* We're sending out a new packet. Make sure we don't look at a
9101 stale cached response. */
9102 rs
->cached_wait_status
= 0;
9104 /* Copy the packet into buffer BUF2, encapsulating it
9105 and giving it a checksum. */
9110 for (i
= 0; i
< cnt
; i
++)
9116 *p
++ = tohex ((csum
>> 4) & 0xf);
9117 *p
++ = tohex (csum
& 0xf);
9119 /* Send it over and over until we get a positive ack. */
9123 int started_error_output
= 0;
9129 int len
= (int) (p
- buf2
);
9132 if (remote_packet_max_chars
< 0)
9135 max_chars
= remote_packet_max_chars
;
9138 = escape_buffer (buf2
, std::min (len
, max_chars
));
9140 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9142 if (len
> max_chars
)
9143 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9146 fprintf_unfiltered (gdb_stdlog
, "...");
9148 gdb_flush (gdb_stdlog
);
9150 remote_serial_write (buf2
, p
- buf2
);
9152 /* If this is a no acks version of the remote protocol, send the
9153 packet and move on. */
9157 /* Read until either a timeout occurs (-2) or '+' is read.
9158 Handle any notification that arrives in the mean time. */
9161 ch
= readchar (remote_timeout
);
9169 case SERIAL_TIMEOUT
:
9172 if (started_error_output
)
9174 putchar_unfiltered ('\n');
9175 started_error_output
= 0;
9184 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9188 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9190 case SERIAL_TIMEOUT
:
9194 break; /* Retransmit buffer. */
9198 fprintf_unfiltered (gdb_stdlog
,
9199 "Packet instead of Ack, ignoring it\n");
9200 /* It's probably an old response sent because an ACK
9201 was lost. Gobble up the packet and ack it so it
9202 doesn't get retransmitted when we resend this
9205 remote_serial_write ("+", 1);
9206 continue; /* Now, go look for +. */
9213 /* If we got a notification, handle it, and go back to looking
9215 /* We've found the start of a notification. Now
9216 collect the data. */
9217 val
= read_frame (&rs
->buf
);
9222 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9224 fprintf_unfiltered (gdb_stdlog
,
9225 " Notification received: %s\n",
9228 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9229 /* We're in sync now, rewait for the ack. */
9236 if (!started_error_output
)
9238 started_error_output
= 1;
9239 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9241 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9242 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9251 if (!started_error_output
)
9253 started_error_output
= 1;
9254 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9256 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9260 break; /* Here to retransmit. */
9264 /* This is wrong. If doing a long backtrace, the user should be
9265 able to get out next time we call QUIT, without anything as
9266 violent as interrupt_query. If we want to provide a way out of
9267 here without getting to the next QUIT, it should be based on
9268 hitting ^C twice as in remote_wait. */
9280 /* Come here after finding the start of a frame when we expected an
9281 ack. Do our best to discard the rest of this packet. */
9284 remote_target::skip_frame ()
9290 c
= readchar (remote_timeout
);
9293 case SERIAL_TIMEOUT
:
9294 /* Nothing we can do. */
9297 /* Discard the two bytes of checksum and stop. */
9298 c
= readchar (remote_timeout
);
9300 c
= readchar (remote_timeout
);
9303 case '*': /* Run length encoding. */
9304 /* Discard the repeat count. */
9305 c
= readchar (remote_timeout
);
9310 /* A regular character. */
9316 /* Come here after finding the start of the frame. Collect the rest
9317 into *BUF, verifying the checksum, length, and handling run-length
9318 compression. NUL terminate the buffer. If there is not enough room,
9321 Returns -1 on error, number of characters in buffer (ignoring the
9322 trailing NULL) on success. (could be extended to return one of the
9323 SERIAL status indications). */
9326 remote_target::read_frame (gdb::char_vector
*buf_p
)
9331 char *buf
= buf_p
->data ();
9332 struct remote_state
*rs
= get_remote_state ();
9339 c
= readchar (remote_timeout
);
9342 case SERIAL_TIMEOUT
:
9344 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9348 fputs_filtered ("Saw new packet start in middle of old one\n",
9350 return -1; /* Start a new packet, count retries. */
9353 unsigned char pktcsum
;
9359 check_0
= readchar (remote_timeout
);
9361 check_1
= readchar (remote_timeout
);
9363 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9366 fputs_filtered ("Timeout in checksum, retrying\n",
9370 else if (check_0
< 0 || check_1
< 0)
9373 fputs_filtered ("Communication error in checksum\n",
9378 /* Don't recompute the checksum; with no ack packets we
9379 don't have any way to indicate a packet retransmission
9384 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9385 if (csum
== pktcsum
)
9390 std::string str
= escape_buffer (buf
, bc
);
9392 fprintf_unfiltered (gdb_stdlog
,
9393 "Bad checksum, sentsum=0x%x, "
9394 "csum=0x%x, buf=%s\n",
9395 pktcsum
, csum
, str
.c_str ());
9397 /* Number of characters in buffer ignoring trailing
9401 case '*': /* Run length encoding. */
9406 c
= readchar (remote_timeout
);
9408 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9410 /* The character before ``*'' is repeated. */
9412 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9414 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9416 /* Make some more room in the buffer. */
9417 buf_p
->resize (buf_p
->size () + repeat
);
9418 buf
= buf_p
->data ();
9421 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9427 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9431 if (bc
>= buf_p
->size () - 1)
9433 /* Make some more room in the buffer. */
9434 buf_p
->resize (buf_p
->size () * 2);
9435 buf
= buf_p
->data ();
9445 /* Set this to the maximum number of seconds to wait instead of waiting forever
9446 in target_wait(). If this timer times out, then it generates an error and
9447 the command is aborted. This replaces most of the need for timeouts in the
9448 GDB test suite, and makes it possible to distinguish between a hung target
9449 and one with slow communications. */
9451 static int watchdog
= 0;
9453 show_watchdog (struct ui_file
*file
, int from_tty
,
9454 struct cmd_list_element
*c
, const char *value
)
9456 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9459 /* Read a packet from the remote machine, with error checking, and
9460 store it in *BUF. Resize *BUF if necessary to hold the result. If
9461 FOREVER, wait forever rather than timing out; this is used (in
9462 synchronous mode) to wait for a target that is is executing user
9464 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9465 don't have to change all the calls to getpkt to deal with the
9466 return value, because at the moment I don't know what the right
9467 thing to do it for those. */
9470 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9472 getpkt_sane (buf
, forever
);
9476 /* Read a packet from the remote machine, with error checking, and
9477 store it in *BUF. Resize *BUF if necessary to hold the result. If
9478 FOREVER, wait forever rather than timing out; this is used (in
9479 synchronous mode) to wait for a target that is is executing user
9480 code to stop. If FOREVER == 0, this function is allowed to time
9481 out gracefully and return an indication of this to the caller.
9482 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9483 consider receiving a notification enough reason to return to the
9484 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9485 holds a notification or not (a regular packet). */
9488 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9489 int forever
, int expecting_notif
,
9492 struct remote_state
*rs
= get_remote_state ();
9498 /* We're reading a new response. Make sure we don't look at a
9499 previously cached response. */
9500 rs
->cached_wait_status
= 0;
9502 strcpy (buf
->data (), "timeout");
9505 timeout
= watchdog
> 0 ? watchdog
: -1;
9506 else if (expecting_notif
)
9507 timeout
= 0; /* There should already be a char in the buffer. If
9510 timeout
= remote_timeout
;
9514 /* Process any number of notifications, and then return when
9518 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9520 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9522 /* This can loop forever if the remote side sends us
9523 characters continuously, but if it pauses, we'll get
9524 SERIAL_TIMEOUT from readchar because of timeout. Then
9525 we'll count that as a retry.
9527 Note that even when forever is set, we will only wait
9528 forever prior to the start of a packet. After that, we
9529 expect characters to arrive at a brisk pace. They should
9530 show up within remote_timeout intervals. */
9532 c
= readchar (timeout
);
9533 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9535 if (c
== SERIAL_TIMEOUT
)
9537 if (expecting_notif
)
9538 return -1; /* Don't complain, it's normal to not get
9539 anything in this case. */
9541 if (forever
) /* Watchdog went off? Kill the target. */
9543 remote_unpush_target ();
9544 throw_error (TARGET_CLOSE_ERROR
,
9545 _("Watchdog timeout has expired. "
9546 "Target detached."));
9549 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9553 /* We've found the start of a packet or notification.
9554 Now collect the data. */
9555 val
= read_frame (buf
);
9560 remote_serial_write ("-", 1);
9563 if (tries
> MAX_TRIES
)
9565 /* We have tried hard enough, and just can't receive the
9566 packet/notification. Give up. */
9567 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9569 /* Skip the ack char if we're in no-ack mode. */
9570 if (!rs
->noack_mode
)
9571 remote_serial_write ("+", 1);
9575 /* If we got an ordinary packet, return that to our caller. */
9582 if (remote_packet_max_chars
< 0)
9585 max_chars
= remote_packet_max_chars
;
9588 = escape_buffer (buf
->data (),
9589 std::min (val
, max_chars
));
9591 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9594 if (val
> max_chars
)
9595 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9598 fprintf_unfiltered (gdb_stdlog
, "\n");
9601 /* Skip the ack char if we're in no-ack mode. */
9602 if (!rs
->noack_mode
)
9603 remote_serial_write ("+", 1);
9604 if (is_notif
!= NULL
)
9609 /* If we got a notification, handle it, and go back to looking
9613 gdb_assert (c
== '%');
9617 std::string str
= escape_buffer (buf
->data (), val
);
9619 fprintf_unfiltered (gdb_stdlog
,
9620 " Notification received: %s\n",
9623 if (is_notif
!= NULL
)
9626 handle_notification (rs
->notif_state
, buf
->data ());
9628 /* Notifications require no acknowledgement. */
9630 if (expecting_notif
)
9637 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9639 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9643 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9646 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9649 /* Kill any new fork children of process PID that haven't been
9650 processed by follow_fork. */
9653 remote_target::kill_new_fork_children (int pid
)
9655 remote_state
*rs
= get_remote_state ();
9656 struct notif_client
*notif
= ¬if_client_stop
;
9658 /* Kill the fork child threads of any threads in process PID
9659 that are stopped at a fork event. */
9660 for (thread_info
*thread
: all_non_exited_threads ())
9662 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9664 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9666 int child_pid
= ws
->value
.related_pid
.pid ();
9669 res
= remote_vkill (child_pid
);
9671 error (_("Can't kill fork child process %d"), child_pid
);
9675 /* Check for any pending fork events (not reported or processed yet)
9676 in process PID and kill those fork child threads as well. */
9677 remote_notif_get_pending_events (notif
);
9678 for (auto &event
: rs
->stop_reply_queue
)
9679 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9681 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9684 res
= remote_vkill (child_pid
);
9686 error (_("Can't kill fork child process %d"), child_pid
);
9691 /* Target hook to kill the current inferior. */
9694 remote_target::kill ()
9697 int pid
= inferior_ptid
.pid ();
9698 struct remote_state
*rs
= get_remote_state ();
9700 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9702 /* If we're stopped while forking and we haven't followed yet,
9703 kill the child task. We need to do this before killing the
9704 parent task because if this is a vfork then the parent will
9706 kill_new_fork_children (pid
);
9708 res
= remote_vkill (pid
);
9711 target_mourn_inferior (inferior_ptid
);
9716 /* If we are in 'target remote' mode and we are killing the only
9717 inferior, then we will tell gdbserver to exit and unpush the
9719 if (res
== -1 && !remote_multi_process_p (rs
)
9720 && number_of_live_inferiors () == 1)
9724 /* We've killed the remote end, we get to mourn it. If we are
9725 not in extended mode, mourning the inferior also unpushes
9726 remote_ops from the target stack, which closes the remote
9728 target_mourn_inferior (inferior_ptid
);
9733 error (_("Can't kill process"));
9736 /* Send a kill request to the target using the 'vKill' packet. */
9739 remote_target::remote_vkill (int pid
)
9741 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9744 remote_state
*rs
= get_remote_state ();
9746 /* Tell the remote target to detach. */
9747 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
9749 getpkt (&rs
->buf
, 0);
9751 switch (packet_ok (rs
->buf
,
9752 &remote_protocol_packets
[PACKET_vKill
]))
9758 case PACKET_UNKNOWN
:
9761 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9765 /* Send a kill request to the target using the 'k' packet. */
9768 remote_target::remote_kill_k ()
9770 /* Catch errors so the user can quit from gdb even when we
9771 aren't on speaking terms with the remote system. */
9776 catch (const gdb_exception_error
&ex
)
9778 if (ex
.error
== TARGET_CLOSE_ERROR
)
9780 /* If we got an (EOF) error that caused the target
9781 to go away, then we're done, that's what we wanted.
9782 "k" is susceptible to cause a premature EOF, given
9783 that the remote server isn't actually required to
9784 reply to "k", and it can happen that it doesn't
9785 even get to reply ACK to the "k". */
9789 /* Otherwise, something went wrong. We didn't actually kill
9790 the target. Just propagate the exception, and let the
9791 user or higher layers decide what to do. */
9797 remote_target::mourn_inferior ()
9799 struct remote_state
*rs
= get_remote_state ();
9801 /* We're no longer interested in notification events of an inferior
9802 that exited or was killed/detached. */
9803 discard_pending_stop_replies (current_inferior ());
9805 /* In 'target remote' mode with one inferior, we close the connection. */
9806 if (!rs
->extended
&& number_of_live_inferiors () <= 1)
9808 unpush_target (this);
9810 /* remote_close takes care of doing most of the clean up. */
9811 generic_mourn_inferior ();
9815 /* In case we got here due to an error, but we're going to stay
9817 rs
->waiting_for_stop_reply
= 0;
9819 /* If the current general thread belonged to the process we just
9820 detached from or has exited, the remote side current general
9821 thread becomes undefined. Considering a case like this:
9823 - We just got here due to a detach.
9824 - The process that we're detaching from happens to immediately
9825 report a global breakpoint being hit in non-stop mode, in the
9826 same thread we had selected before.
9827 - GDB attaches to this process again.
9828 - This event happens to be the next event we handle.
9830 GDB would consider that the current general thread didn't need to
9831 be set on the stub side (with Hg), since for all it knew,
9832 GENERAL_THREAD hadn't changed.
9834 Notice that although in all-stop mode, the remote server always
9835 sets the current thread to the thread reporting the stop event,
9836 that doesn't happen in non-stop mode; in non-stop, the stub *must
9837 not* change the current thread when reporting a breakpoint hit,
9838 due to the decoupling of event reporting and event handling.
9840 To keep things simple, we always invalidate our notion of the
9842 record_currthread (rs
, minus_one_ptid
);
9844 /* Call common code to mark the inferior as not running. */
9845 generic_mourn_inferior ();
9849 extended_remote_target::supports_disable_randomization ()
9851 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9855 remote_target::extended_remote_disable_randomization (int val
)
9857 struct remote_state
*rs
= get_remote_state ();
9860 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9861 "QDisableRandomization:%x", val
);
9863 reply
= remote_get_noisy_reply ();
9865 error (_("Target does not support QDisableRandomization."));
9866 if (strcmp (reply
, "OK") != 0)
9867 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9871 remote_target::extended_remote_run (const std::string
&args
)
9873 struct remote_state
*rs
= get_remote_state ();
9875 const char *remote_exec_file
= get_remote_exec_file ();
9877 /* If the user has disabled vRun support, or we have detected that
9878 support is not available, do not try it. */
9879 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9882 strcpy (rs
->buf
.data (), "vRun;");
9883 len
= strlen (rs
->buf
.data ());
9885 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9886 error (_("Remote file name too long for run packet"));
9887 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
9888 strlen (remote_exec_file
));
9894 gdb_argv
argv (args
.c_str ());
9895 for (i
= 0; argv
[i
] != NULL
; i
++)
9897 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9898 error (_("Argument list too long for run packet"));
9899 rs
->buf
[len
++] = ';';
9900 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
9905 rs
->buf
[len
++] = '\0';
9908 getpkt (&rs
->buf
, 0);
9910 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9913 /* We have a wait response. All is well. */
9915 case PACKET_UNKNOWN
:
9918 if (remote_exec_file
[0] == '\0')
9919 error (_("Running the default executable on the remote target failed; "
9920 "try \"set remote exec-file\"?"));
9922 error (_("Running \"%s\" on the remote target failed"),
9925 gdb_assert_not_reached (_("bad switch"));
9929 /* Helper function to send set/unset environment packets. ACTION is
9930 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
9931 or "QEnvironmentUnsetVariable". VALUE is the variable to be
9935 remote_target::send_environment_packet (const char *action
,
9939 remote_state
*rs
= get_remote_state ();
9941 /* Convert the environment variable to an hex string, which
9942 is the best format to be transmitted over the wire. */
9943 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
9946 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9947 "%s:%s", packet
, encoded_value
.c_str ());
9950 getpkt (&rs
->buf
, 0);
9951 if (strcmp (rs
->buf
.data (), "OK") != 0)
9952 warning (_("Unable to %s environment variable '%s' on remote."),
9956 /* Helper function to handle the QEnvironment* packets. */
9959 remote_target::extended_remote_environment_support ()
9961 remote_state
*rs
= get_remote_state ();
9963 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
9965 putpkt ("QEnvironmentReset");
9966 getpkt (&rs
->buf
, 0);
9967 if (strcmp (rs
->buf
.data (), "OK") != 0)
9968 warning (_("Unable to reset environment on remote."));
9971 gdb_environ
*e
= ¤t_inferior ()->environment
;
9973 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
9974 for (const std::string
&el
: e
->user_set_env ())
9975 send_environment_packet ("set", "QEnvironmentHexEncoded",
9978 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
9979 for (const std::string
&el
: e
->user_unset_env ())
9980 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
9983 /* Helper function to set the current working directory for the
9984 inferior in the remote target. */
9987 remote_target::extended_remote_set_inferior_cwd ()
9989 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
9991 const char *inferior_cwd
= get_inferior_cwd ();
9992 remote_state
*rs
= get_remote_state ();
9994 if (inferior_cwd
!= NULL
)
9996 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
9997 strlen (inferior_cwd
));
9999 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10000 "QSetWorkingDir:%s", hexpath
.c_str ());
10004 /* An empty inferior_cwd means that the user wants us to
10005 reset the remote server's inferior's cwd. */
10006 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10007 "QSetWorkingDir:");
10011 getpkt (&rs
->buf
, 0);
10012 if (packet_ok (rs
->buf
,
10013 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10016 Remote replied unexpectedly while setting the inferior's working\n\
10023 /* In the extended protocol we want to be able to do things like
10024 "run" and have them basically work as expected. So we need
10025 a special create_inferior function. We support changing the
10026 executable file and the command line arguments, but not the
10030 extended_remote_target::create_inferior (const char *exec_file
,
10031 const std::string
&args
,
10032 char **env
, int from_tty
)
10036 struct remote_state
*rs
= get_remote_state ();
10037 const char *remote_exec_file
= get_remote_exec_file ();
10039 /* If running asynchronously, register the target file descriptor
10040 with the event loop. */
10041 if (target_can_async_p ())
10044 /* Disable address space randomization if requested (and supported). */
10045 if (supports_disable_randomization ())
10046 extended_remote_disable_randomization (disable_randomization
);
10048 /* If startup-with-shell is on, we inform gdbserver to start the
10049 remote inferior using a shell. */
10050 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10052 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10053 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10055 getpkt (&rs
->buf
, 0);
10056 if (strcmp (rs
->buf
.data (), "OK") != 0)
10058 Remote replied unexpectedly while setting startup-with-shell: %s"),
10062 extended_remote_environment_support ();
10064 extended_remote_set_inferior_cwd ();
10066 /* Now restart the remote server. */
10067 run_worked
= extended_remote_run (args
) != -1;
10070 /* vRun was not supported. Fail if we need it to do what the
10072 if (remote_exec_file
[0])
10073 error (_("Remote target does not support \"set remote exec-file\""));
10074 if (!args
.empty ())
10075 error (_("Remote target does not support \"set args\" or run ARGS"));
10077 /* Fall back to "R". */
10078 extended_remote_restart ();
10081 /* vRun's success return is a stop reply. */
10082 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10083 add_current_inferior_and_thread (stop_reply
);
10085 /* Get updated offsets, if the stub uses qOffsets. */
10090 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10091 the list of conditions (in agent expression bytecode format), if any, the
10092 target needs to evaluate. The output is placed into the packet buffer
10093 started from BUF and ended at BUF_END. */
10096 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10097 struct bp_target_info
*bp_tgt
, char *buf
,
10100 if (bp_tgt
->conditions
.empty ())
10103 buf
+= strlen (buf
);
10104 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10107 /* Send conditions to the target. */
10108 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10110 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10111 buf
+= strlen (buf
);
10112 for (int i
= 0; i
< aexpr
->len
; ++i
)
10113 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10120 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10121 struct bp_target_info
*bp_tgt
, char *buf
)
10123 if (bp_tgt
->tcommands
.empty ())
10126 buf
+= strlen (buf
);
10128 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10129 buf
+= strlen (buf
);
10131 /* Concatenate all the agent expressions that are commands into the
10133 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10135 sprintf (buf
, "X%x,", aexpr
->len
);
10136 buf
+= strlen (buf
);
10137 for (int i
= 0; i
< aexpr
->len
; ++i
)
10138 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10143 /* Insert a breakpoint. On targets that have software breakpoint
10144 support, we ask the remote target to do the work; on targets
10145 which don't, we insert a traditional memory breakpoint. */
10148 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10149 struct bp_target_info
*bp_tgt
)
10151 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10152 If it succeeds, then set the support to PACKET_ENABLE. If it
10153 fails, and the user has explicitly requested the Z support then
10154 report an error, otherwise, mark it disabled and go on. */
10156 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10158 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10159 struct remote_state
*rs
;
10162 /* Make sure the remote is pointing at the right process, if
10164 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10165 set_general_process ();
10167 rs
= get_remote_state ();
10168 p
= rs
->buf
.data ();
10169 endbuf
= p
+ get_remote_packet_size ();
10174 addr
= (ULONGEST
) remote_address_masked (addr
);
10175 p
+= hexnumstr (p
, addr
);
10176 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10178 if (supports_evaluation_of_breakpoint_conditions ())
10179 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10181 if (can_run_breakpoint_commands ())
10182 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10185 getpkt (&rs
->buf
, 0);
10187 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10193 case PACKET_UNKNOWN
:
10198 /* If this breakpoint has target-side commands but this stub doesn't
10199 support Z0 packets, throw error. */
10200 if (!bp_tgt
->tcommands
.empty ())
10201 throw_error (NOT_SUPPORTED_ERROR
, _("\
10202 Target doesn't support breakpoints that have target side commands."));
10204 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10208 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10209 struct bp_target_info
*bp_tgt
,
10210 enum remove_bp_reason reason
)
10212 CORE_ADDR addr
= bp_tgt
->placed_address
;
10213 struct remote_state
*rs
= get_remote_state ();
10215 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10217 char *p
= rs
->buf
.data ();
10218 char *endbuf
= p
+ get_remote_packet_size ();
10220 /* Make sure the remote is pointing at the right process, if
10222 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10223 set_general_process ();
10229 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10230 p
+= hexnumstr (p
, addr
);
10231 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10234 getpkt (&rs
->buf
, 0);
10236 return (rs
->buf
[0] == 'E');
10239 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10242 static enum Z_packet_type
10243 watchpoint_to_Z_packet (int type
)
10248 return Z_PACKET_WRITE_WP
;
10251 return Z_PACKET_READ_WP
;
10254 return Z_PACKET_ACCESS_WP
;
10257 internal_error (__FILE__
, __LINE__
,
10258 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10263 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10264 enum target_hw_bp_type type
, struct expression
*cond
)
10266 struct remote_state
*rs
= get_remote_state ();
10267 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10269 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10271 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10274 /* Make sure the remote is pointing at the right process, if
10276 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10277 set_general_process ();
10279 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10280 p
= strchr (rs
->buf
.data (), '\0');
10281 addr
= remote_address_masked (addr
);
10282 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10283 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10286 getpkt (&rs
->buf
, 0);
10288 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10292 case PACKET_UNKNOWN
:
10297 internal_error (__FILE__
, __LINE__
,
10298 _("remote_insert_watchpoint: reached end of function"));
10302 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10303 CORE_ADDR start
, int length
)
10305 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10307 return diff
< length
;
10312 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10313 enum target_hw_bp_type type
, struct expression
*cond
)
10315 struct remote_state
*rs
= get_remote_state ();
10316 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10318 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10320 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10323 /* Make sure the remote is pointing at the right process, if
10325 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10326 set_general_process ();
10328 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10329 p
= strchr (rs
->buf
.data (), '\0');
10330 addr
= remote_address_masked (addr
);
10331 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10332 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10334 getpkt (&rs
->buf
, 0);
10336 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10339 case PACKET_UNKNOWN
:
10344 internal_error (__FILE__
, __LINE__
,
10345 _("remote_remove_watchpoint: reached end of function"));
10349 static int remote_hw_watchpoint_limit
= -1;
10350 static int remote_hw_watchpoint_length_limit
= -1;
10351 static int remote_hw_breakpoint_limit
= -1;
10354 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10356 if (remote_hw_watchpoint_length_limit
== 0)
10358 else if (remote_hw_watchpoint_length_limit
< 0)
10360 else if (len
<= remote_hw_watchpoint_length_limit
)
10367 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10369 if (type
== bp_hardware_breakpoint
)
10371 if (remote_hw_breakpoint_limit
== 0)
10373 else if (remote_hw_breakpoint_limit
< 0)
10375 else if (cnt
<= remote_hw_breakpoint_limit
)
10380 if (remote_hw_watchpoint_limit
== 0)
10382 else if (remote_hw_watchpoint_limit
< 0)
10386 else if (cnt
<= remote_hw_watchpoint_limit
)
10392 /* The to_stopped_by_sw_breakpoint method of target remote. */
10395 remote_target::stopped_by_sw_breakpoint ()
10397 struct thread_info
*thread
= inferior_thread ();
10399 return (thread
->priv
!= NULL
10400 && (get_remote_thread_info (thread
)->stop_reason
10401 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10404 /* The to_supports_stopped_by_sw_breakpoint method of target
10408 remote_target::supports_stopped_by_sw_breakpoint ()
10410 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10413 /* The to_stopped_by_hw_breakpoint method of target remote. */
10416 remote_target::stopped_by_hw_breakpoint ()
10418 struct thread_info
*thread
= inferior_thread ();
10420 return (thread
->priv
!= NULL
10421 && (get_remote_thread_info (thread
)->stop_reason
10422 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10425 /* The to_supports_stopped_by_hw_breakpoint method of target
10429 remote_target::supports_stopped_by_hw_breakpoint ()
10431 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10435 remote_target::stopped_by_watchpoint ()
10437 struct thread_info
*thread
= inferior_thread ();
10439 return (thread
->priv
!= NULL
10440 && (get_remote_thread_info (thread
)->stop_reason
10441 == TARGET_STOPPED_BY_WATCHPOINT
));
10445 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10447 struct thread_info
*thread
= inferior_thread ();
10449 if (thread
->priv
!= NULL
10450 && (get_remote_thread_info (thread
)->stop_reason
10451 == TARGET_STOPPED_BY_WATCHPOINT
))
10453 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10462 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10463 struct bp_target_info
*bp_tgt
)
10465 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10466 struct remote_state
*rs
;
10470 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10473 /* Make sure the remote is pointing at the right process, if
10475 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10476 set_general_process ();
10478 rs
= get_remote_state ();
10479 p
= rs
->buf
.data ();
10480 endbuf
= p
+ get_remote_packet_size ();
10486 addr
= remote_address_masked (addr
);
10487 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10488 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10490 if (supports_evaluation_of_breakpoint_conditions ())
10491 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10493 if (can_run_breakpoint_commands ())
10494 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10497 getpkt (&rs
->buf
, 0);
10499 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10502 if (rs
->buf
[1] == '.')
10504 message
= strchr (&rs
->buf
[2], '.');
10506 error (_("Remote failure reply: %s"), message
+ 1);
10509 case PACKET_UNKNOWN
:
10514 internal_error (__FILE__
, __LINE__
,
10515 _("remote_insert_hw_breakpoint: reached end of function"));
10520 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10521 struct bp_target_info
*bp_tgt
)
10524 struct remote_state
*rs
= get_remote_state ();
10525 char *p
= rs
->buf
.data ();
10526 char *endbuf
= p
+ get_remote_packet_size ();
10528 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10531 /* Make sure the remote is pointing at the right process, if
10533 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10534 set_general_process ();
10540 addr
= remote_address_masked (bp_tgt
->placed_address
);
10541 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10542 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10545 getpkt (&rs
->buf
, 0);
10547 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10550 case PACKET_UNKNOWN
:
10555 internal_error (__FILE__
, __LINE__
,
10556 _("remote_remove_hw_breakpoint: reached end of function"));
10559 /* Verify memory using the "qCRC:" request. */
10562 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10564 struct remote_state
*rs
= get_remote_state ();
10565 unsigned long host_crc
, target_crc
;
10568 /* It doesn't make sense to use qCRC if the remote target is
10569 connected but not running. */
10570 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10572 enum packet_result result
;
10574 /* Make sure the remote is pointing at the right process. */
10575 set_general_process ();
10577 /* FIXME: assumes lma can fit into long. */
10578 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10579 (long) lma
, (long) size
);
10582 /* Be clever; compute the host_crc before waiting for target
10584 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10586 getpkt (&rs
->buf
, 0);
10588 result
= packet_ok (rs
->buf
,
10589 &remote_protocol_packets
[PACKET_qCRC
]);
10590 if (result
== PACKET_ERROR
)
10592 else if (result
== PACKET_OK
)
10594 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10595 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10597 return (host_crc
== target_crc
);
10601 return simple_verify_memory (this, data
, lma
, size
);
10604 /* compare-sections command
10606 With no arguments, compares each loadable section in the exec bfd
10607 with the same memory range on the target, and reports mismatches.
10608 Useful for verifying the image on the target against the exec file. */
10611 compare_sections_command (const char *args
, int from_tty
)
10614 const char *sectname
;
10615 bfd_size_type size
;
10618 int mismatched
= 0;
10623 error (_("command cannot be used without an exec file"));
10625 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10631 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10633 if (!(s
->flags
& SEC_LOAD
))
10634 continue; /* Skip non-loadable section. */
10636 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10637 continue; /* Skip writeable sections */
10639 size
= bfd_section_size (s
);
10641 continue; /* Skip zero-length section. */
10643 sectname
= bfd_section_name (s
);
10644 if (args
&& strcmp (args
, sectname
) != 0)
10645 continue; /* Not the section selected by user. */
10647 matched
= 1; /* Do this section. */
10650 gdb::byte_vector
sectdata (size
);
10651 bfd_get_section_contents (exec_bfd
, s
, sectdata
.data (), 0, size
);
10653 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10656 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10657 paddress (target_gdbarch (), lma
),
10658 paddress (target_gdbarch (), lma
+ size
));
10660 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10661 paddress (target_gdbarch (), lma
),
10662 paddress (target_gdbarch (), lma
+ size
));
10664 printf_filtered ("matched.\n");
10667 printf_filtered ("MIS-MATCHED!\n");
10671 if (mismatched
> 0)
10672 warning (_("One or more sections of the target image does not match\n\
10673 the loaded file\n"));
10674 if (args
&& !matched
)
10675 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10678 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10679 into remote target. The number of bytes written to the remote
10680 target is returned, or -1 for error. */
10683 remote_target::remote_write_qxfer (const char *object_name
,
10684 const char *annex
, const gdb_byte
*writebuf
,
10685 ULONGEST offset
, LONGEST len
,
10686 ULONGEST
*xfered_len
,
10687 struct packet_config
*packet
)
10691 struct remote_state
*rs
= get_remote_state ();
10692 int max_size
= get_memory_write_packet_size ();
10694 if (packet_config_support (packet
) == PACKET_DISABLE
)
10695 return TARGET_XFER_E_IO
;
10697 /* Insert header. */
10698 i
= snprintf (rs
->buf
.data (), max_size
,
10699 "qXfer:%s:write:%s:%s:",
10700 object_name
, annex
? annex
: "",
10701 phex_nz (offset
, sizeof offset
));
10702 max_size
-= (i
+ 1);
10704 /* Escape as much data as fits into rs->buf. */
10705 buf_len
= remote_escape_output
10706 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10708 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10709 || getpkt_sane (&rs
->buf
, 0) < 0
10710 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10711 return TARGET_XFER_E_IO
;
10713 unpack_varlen_hex (rs
->buf
.data (), &n
);
10716 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10719 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10720 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10721 number of bytes read is returned, or 0 for EOF, or -1 for error.
10722 The number of bytes read may be less than LEN without indicating an
10723 EOF. PACKET is checked and updated to indicate whether the remote
10724 target supports this object. */
10727 remote_target::remote_read_qxfer (const char *object_name
,
10729 gdb_byte
*readbuf
, ULONGEST offset
,
10731 ULONGEST
*xfered_len
,
10732 struct packet_config
*packet
)
10734 struct remote_state
*rs
= get_remote_state ();
10735 LONGEST i
, n
, packet_len
;
10737 if (packet_config_support (packet
) == PACKET_DISABLE
)
10738 return TARGET_XFER_E_IO
;
10740 /* Check whether we've cached an end-of-object packet that matches
10742 if (rs
->finished_object
)
10744 if (strcmp (object_name
, rs
->finished_object
) == 0
10745 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10746 && offset
== rs
->finished_offset
)
10747 return TARGET_XFER_EOF
;
10750 /* Otherwise, we're now reading something different. Discard
10752 xfree (rs
->finished_object
);
10753 xfree (rs
->finished_annex
);
10754 rs
->finished_object
= NULL
;
10755 rs
->finished_annex
= NULL
;
10758 /* Request only enough to fit in a single packet. The actual data
10759 may not, since we don't know how much of it will need to be escaped;
10760 the target is free to respond with slightly less data. We subtract
10761 five to account for the response type and the protocol frame. */
10762 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10763 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
10764 "qXfer:%s:read:%s:%s,%s",
10765 object_name
, annex
? annex
: "",
10766 phex_nz (offset
, sizeof offset
),
10767 phex_nz (n
, sizeof n
));
10768 i
= putpkt (rs
->buf
);
10770 return TARGET_XFER_E_IO
;
10773 packet_len
= getpkt_sane (&rs
->buf
, 0);
10774 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10775 return TARGET_XFER_E_IO
;
10777 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10778 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
10780 /* 'm' means there is (or at least might be) more data after this
10781 batch. That does not make sense unless there's at least one byte
10782 of data in this reply. */
10783 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10784 error (_("Remote qXfer reply contained no data."));
10786 /* Got some data. */
10787 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
10788 packet_len
- 1, readbuf
, n
);
10790 /* 'l' is an EOF marker, possibly including a final block of data,
10791 or possibly empty. If we have the final block of a non-empty
10792 object, record this fact to bypass a subsequent partial read. */
10793 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10795 rs
->finished_object
= xstrdup (object_name
);
10796 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10797 rs
->finished_offset
= offset
+ i
;
10801 return TARGET_XFER_EOF
;
10805 return TARGET_XFER_OK
;
10809 enum target_xfer_status
10810 remote_target::xfer_partial (enum target_object object
,
10811 const char *annex
, gdb_byte
*readbuf
,
10812 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10813 ULONGEST
*xfered_len
)
10815 struct remote_state
*rs
;
10819 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10821 set_remote_traceframe ();
10822 set_general_thread (inferior_ptid
);
10824 rs
= get_remote_state ();
10826 /* Handle memory using the standard memory routines. */
10827 if (object
== TARGET_OBJECT_MEMORY
)
10829 /* If the remote target is connected but not running, we should
10830 pass this request down to a lower stratum (e.g. the executable
10832 if (!target_has_execution
)
10833 return TARGET_XFER_EOF
;
10835 if (writebuf
!= NULL
)
10836 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10839 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
10843 /* Handle extra signal info using qxfer packets. */
10844 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10847 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
10848 xfered_len
, &remote_protocol_packets
10849 [PACKET_qXfer_siginfo_read
]);
10851 return remote_write_qxfer ("siginfo", annex
,
10852 writebuf
, offset
, len
, xfered_len
,
10853 &remote_protocol_packets
10854 [PACKET_qXfer_siginfo_write
]);
10857 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10860 return remote_read_qxfer ("statictrace", annex
,
10861 readbuf
, offset
, len
, xfered_len
,
10862 &remote_protocol_packets
10863 [PACKET_qXfer_statictrace_read
]);
10865 return TARGET_XFER_E_IO
;
10868 /* Only handle flash writes. */
10869 if (writebuf
!= NULL
)
10873 case TARGET_OBJECT_FLASH
:
10874 return remote_flash_write (offset
, len
, xfered_len
,
10878 return TARGET_XFER_E_IO
;
10882 /* Map pre-existing objects onto letters. DO NOT do this for new
10883 objects!!! Instead specify new query packets. */
10886 case TARGET_OBJECT_AVR
:
10890 case TARGET_OBJECT_AUXV
:
10891 gdb_assert (annex
== NULL
);
10892 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
10894 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10896 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10897 return remote_read_qxfer
10898 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
10899 &remote_protocol_packets
[PACKET_qXfer_features
]);
10901 case TARGET_OBJECT_LIBRARIES
:
10902 return remote_read_qxfer
10903 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10904 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10906 case TARGET_OBJECT_LIBRARIES_SVR4
:
10907 return remote_read_qxfer
10908 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10909 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10911 case TARGET_OBJECT_MEMORY_MAP
:
10912 gdb_assert (annex
== NULL
);
10913 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
10915 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10917 case TARGET_OBJECT_OSDATA
:
10918 /* Should only get here if we're connected. */
10919 gdb_assert (rs
->remote_desc
);
10920 return remote_read_qxfer
10921 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
10922 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
10924 case TARGET_OBJECT_THREADS
:
10925 gdb_assert (annex
== NULL
);
10926 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
10928 &remote_protocol_packets
[PACKET_qXfer_threads
]);
10930 case TARGET_OBJECT_TRACEFRAME_INFO
:
10931 gdb_assert (annex
== NULL
);
10932 return remote_read_qxfer
10933 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
10934 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
10936 case TARGET_OBJECT_FDPIC
:
10937 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
10939 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
10941 case TARGET_OBJECT_OPENVMS_UIB
:
10942 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
10944 &remote_protocol_packets
[PACKET_qXfer_uib
]);
10946 case TARGET_OBJECT_BTRACE
:
10947 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
10949 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
10951 case TARGET_OBJECT_BTRACE_CONF
:
10952 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
10954 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
10956 case TARGET_OBJECT_EXEC_FILE
:
10957 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
10959 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
10962 return TARGET_XFER_E_IO
;
10965 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
10966 large enough let the caller deal with it. */
10967 if (len
< get_remote_packet_size ())
10968 return TARGET_XFER_E_IO
;
10969 len
= get_remote_packet_size ();
10971 /* Except for querying the minimum buffer size, target must be open. */
10972 if (!rs
->remote_desc
)
10973 error (_("remote query is only available after target open"));
10975 gdb_assert (annex
!= NULL
);
10976 gdb_assert (readbuf
!= NULL
);
10978 p2
= rs
->buf
.data ();
10980 *p2
++ = query_type
;
10982 /* We used one buffer char for the remote protocol q command and
10983 another for the query type. As the remote protocol encapsulation
10984 uses 4 chars plus one extra in case we are debugging
10985 (remote_debug), we have PBUFZIZ - 7 left to pack the query
10988 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
10990 /* Bad caller may have sent forbidden characters. */
10991 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
10996 gdb_assert (annex
[i
] == '\0');
10998 i
= putpkt (rs
->buf
);
11000 return TARGET_XFER_E_IO
;
11002 getpkt (&rs
->buf
, 0);
11003 strcpy ((char *) readbuf
, rs
->buf
.data ());
11005 *xfered_len
= strlen ((char *) readbuf
);
11006 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11009 /* Implementation of to_get_memory_xfer_limit. */
11012 remote_target::get_memory_xfer_limit ()
11014 return get_memory_write_packet_size ();
11018 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11019 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11020 CORE_ADDR
*found_addrp
)
11022 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11023 struct remote_state
*rs
= get_remote_state ();
11024 int max_size
= get_memory_write_packet_size ();
11025 struct packet_config
*packet
=
11026 &remote_protocol_packets
[PACKET_qSearch_memory
];
11027 /* Number of packet bytes used to encode the pattern;
11028 this could be more than PATTERN_LEN due to escape characters. */
11029 int escaped_pattern_len
;
11030 /* Amount of pattern that was encodable in the packet. */
11031 int used_pattern_len
;
11034 ULONGEST found_addr
;
11036 /* Don't go to the target if we don't have to. This is done before
11037 checking packet_config_support to avoid the possibility that a
11038 success for this edge case means the facility works in
11040 if (pattern_len
> search_space_len
)
11042 if (pattern_len
== 0)
11044 *found_addrp
= start_addr
;
11048 /* If we already know the packet isn't supported, fall back to the simple
11049 way of searching memory. */
11051 if (packet_config_support (packet
) == PACKET_DISABLE
)
11053 /* Target doesn't provided special support, fall back and use the
11054 standard support (copy memory and do the search here). */
11055 return simple_search_memory (this, start_addr
, search_space_len
,
11056 pattern
, pattern_len
, found_addrp
);
11059 /* Make sure the remote is pointing at the right process. */
11060 set_general_process ();
11062 /* Insert header. */
11063 i
= snprintf (rs
->buf
.data (), max_size
,
11064 "qSearch:memory:%s;%s;",
11065 phex_nz (start_addr
, addr_size
),
11066 phex_nz (search_space_len
, sizeof (search_space_len
)));
11067 max_size
-= (i
+ 1);
11069 /* Escape as much data as fits into rs->buf. */
11070 escaped_pattern_len
=
11071 remote_escape_output (pattern
, pattern_len
, 1,
11072 (gdb_byte
*) rs
->buf
.data () + i
,
11073 &used_pattern_len
, max_size
);
11075 /* Bail if the pattern is too large. */
11076 if (used_pattern_len
!= pattern_len
)
11077 error (_("Pattern is too large to transmit to remote target."));
11079 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11080 || getpkt_sane (&rs
->buf
, 0) < 0
11081 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11083 /* The request may not have worked because the command is not
11084 supported. If so, fall back to the simple way. */
11085 if (packet_config_support (packet
) == PACKET_DISABLE
)
11087 return simple_search_memory (this, start_addr
, search_space_len
,
11088 pattern
, pattern_len
, found_addrp
);
11093 if (rs
->buf
[0] == '0')
11095 else if (rs
->buf
[0] == '1')
11098 if (rs
->buf
[1] != ',')
11099 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11100 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11101 *found_addrp
= found_addr
;
11104 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11110 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11112 struct remote_state
*rs
= get_remote_state ();
11113 char *p
= rs
->buf
.data ();
11115 if (!rs
->remote_desc
)
11116 error (_("remote rcmd is only available after target open"));
11118 /* Send a NULL command across as an empty command. */
11119 if (command
== NULL
)
11122 /* The query prefix. */
11123 strcpy (rs
->buf
.data (), "qRcmd,");
11124 p
= strchr (rs
->buf
.data (), '\0');
11126 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11127 > get_remote_packet_size ())
11128 error (_("\"monitor\" command ``%s'' is too long."), command
);
11130 /* Encode the actual command. */
11131 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11133 if (putpkt (rs
->buf
) < 0)
11134 error (_("Communication problem with target."));
11136 /* get/display the response */
11141 /* XXX - see also remote_get_noisy_reply(). */
11142 QUIT
; /* Allow user to bail out with ^C. */
11144 if (getpkt_sane (&rs
->buf
, 0) == -1)
11146 /* Timeout. Continue to (try to) read responses.
11147 This is better than stopping with an error, assuming the stub
11148 is still executing the (long) monitor command.
11149 If needed, the user can interrupt gdb using C-c, obtaining
11150 an effect similar to stop on timeout. */
11153 buf
= rs
->buf
.data ();
11154 if (buf
[0] == '\0')
11155 error (_("Target does not support this command."));
11156 if (buf
[0] == 'O' && buf
[1] != 'K')
11158 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11161 if (strcmp (buf
, "OK") == 0)
11163 if (strlen (buf
) == 3 && buf
[0] == 'E'
11164 && isdigit (buf
[1]) && isdigit (buf
[2]))
11166 error (_("Protocol error with Rcmd"));
11168 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11170 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11172 fputc_unfiltered (c
, outbuf
);
11178 std::vector
<mem_region
>
11179 remote_target::memory_map ()
11181 std::vector
<mem_region
> result
;
11182 gdb::optional
<gdb::char_vector
> text
11183 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11186 result
= parse_memory_map (text
->data ());
11192 packet_command (const char *args
, int from_tty
)
11194 remote_target
*remote
= get_current_remote_target ();
11196 if (remote
== nullptr)
11197 error (_("command can only be used with remote target"));
11199 remote
->packet_command (args
, from_tty
);
11203 remote_target::packet_command (const char *args
, int from_tty
)
11206 error (_("remote-packet command requires packet text as argument"));
11208 puts_filtered ("sending: ");
11209 print_packet (args
);
11210 puts_filtered ("\n");
11213 remote_state
*rs
= get_remote_state ();
11215 getpkt (&rs
->buf
, 0);
11216 puts_filtered ("received: ");
11217 print_packet (rs
->buf
.data ());
11218 puts_filtered ("\n");
11222 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11224 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11226 static void threadset_test_cmd (char *cmd
, int tty
);
11228 static void threadalive_test (char *cmd
, int tty
);
11230 static void threadlist_test_cmd (char *cmd
, int tty
);
11232 int get_and_display_threadinfo (threadref
*ref
);
11234 static void threadinfo_test_cmd (char *cmd
, int tty
);
11236 static int thread_display_step (threadref
*ref
, void *context
);
11238 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11240 static void init_remote_threadtests (void);
11242 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11245 threadset_test_cmd (const char *cmd
, int tty
)
11247 int sample_thread
= SAMPLE_THREAD
;
11249 printf_filtered (_("Remote threadset test\n"));
11250 set_general_thread (sample_thread
);
11255 threadalive_test (const char *cmd
, int tty
)
11257 int sample_thread
= SAMPLE_THREAD
;
11258 int pid
= inferior_ptid
.pid ();
11259 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11261 if (remote_thread_alive (ptid
))
11262 printf_filtered ("PASS: Thread alive test\n");
11264 printf_filtered ("FAIL: Thread alive test\n");
11267 void output_threadid (char *title
, threadref
*ref
);
11270 output_threadid (char *title
, threadref
*ref
)
11274 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11276 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11280 threadlist_test_cmd (const char *cmd
, int tty
)
11283 threadref nextthread
;
11284 int done
, result_count
;
11285 threadref threadlist
[3];
11287 printf_filtered ("Remote Threadlist test\n");
11288 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11289 &result_count
, &threadlist
[0]))
11290 printf_filtered ("FAIL: threadlist test\n");
11293 threadref
*scan
= threadlist
;
11294 threadref
*limit
= scan
+ result_count
;
11296 while (scan
< limit
)
11297 output_threadid (" thread ", scan
++);
11302 display_thread_info (struct gdb_ext_thread_info
*info
)
11304 output_threadid ("Threadid: ", &info
->threadid
);
11305 printf_filtered ("Name: %s\n ", info
->shortname
);
11306 printf_filtered ("State: %s\n", info
->display
);
11307 printf_filtered ("other: %s\n\n", info
->more_display
);
11311 get_and_display_threadinfo (threadref
*ref
)
11315 struct gdb_ext_thread_info threadinfo
;
11317 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11318 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11319 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11320 display_thread_info (&threadinfo
);
11325 threadinfo_test_cmd (const char *cmd
, int tty
)
11327 int athread
= SAMPLE_THREAD
;
11331 int_to_threadref (&thread
, athread
);
11332 printf_filtered ("Remote Threadinfo test\n");
11333 if (!get_and_display_threadinfo (&thread
))
11334 printf_filtered ("FAIL cannot get thread info\n");
11338 thread_display_step (threadref
*ref
, void *context
)
11340 /* output_threadid(" threadstep ",ref); *//* simple test */
11341 return get_and_display_threadinfo (ref
);
11345 threadlist_update_test_cmd (const char *cmd
, int tty
)
11347 printf_filtered ("Remote Threadlist update test\n");
11348 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11352 init_remote_threadtests (void)
11354 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11355 _("Fetch and print the remote list of "
11356 "thread identifiers, one pkt only."));
11357 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11358 _("Fetch and display info about one thread."));
11359 add_com ("tset", class_obscure
, threadset_test_cmd
,
11360 _("Test setting to a different thread."));
11361 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11362 _("Iterate through updating all remote thread info."));
11363 add_com ("talive", class_obscure
, threadalive_test
,
11364 _("Remote thread alive test."));
11369 /* Convert a thread ID to a string. */
11372 remote_target::pid_to_str (ptid_t ptid
)
11374 struct remote_state
*rs
= get_remote_state ();
11376 if (ptid
== null_ptid
)
11377 return normal_pid_to_str (ptid
);
11378 else if (ptid
.is_pid ())
11380 /* Printing an inferior target id. */
11382 /* When multi-process extensions are off, there's no way in the
11383 remote protocol to know the remote process id, if there's any
11384 at all. There's one exception --- when we're connected with
11385 target extended-remote, and we manually attached to a process
11386 with "attach PID". We don't record anywhere a flag that
11387 allows us to distinguish that case from the case of
11388 connecting with extended-remote and the stub already being
11389 attached to a process, and reporting yes to qAttached, hence
11390 no smart special casing here. */
11391 if (!remote_multi_process_p (rs
))
11392 return "Remote target";
11394 return normal_pid_to_str (ptid
);
11398 if (magic_null_ptid
== ptid
)
11399 return "Thread <main>";
11400 else if (remote_multi_process_p (rs
))
11401 if (ptid
.lwp () == 0)
11402 return normal_pid_to_str (ptid
);
11404 return string_printf ("Thread %d.%ld",
11405 ptid
.pid (), ptid
.lwp ());
11407 return string_printf ("Thread %ld", ptid
.lwp ());
11411 /* Get the address of the thread local variable in OBJFILE which is
11412 stored at OFFSET within the thread local storage for thread PTID. */
11415 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11418 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11420 struct remote_state
*rs
= get_remote_state ();
11421 char *p
= rs
->buf
.data ();
11422 char *endp
= p
+ get_remote_packet_size ();
11423 enum packet_result result
;
11425 strcpy (p
, "qGetTLSAddr:");
11427 p
= write_ptid (p
, endp
, ptid
);
11429 p
+= hexnumstr (p
, offset
);
11431 p
+= hexnumstr (p
, lm
);
11435 getpkt (&rs
->buf
, 0);
11436 result
= packet_ok (rs
->buf
,
11437 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11438 if (result
== PACKET_OK
)
11442 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11445 else if (result
== PACKET_UNKNOWN
)
11446 throw_error (TLS_GENERIC_ERROR
,
11447 _("Remote target doesn't support qGetTLSAddr packet"));
11449 throw_error (TLS_GENERIC_ERROR
,
11450 _("Remote target failed to process qGetTLSAddr request"));
11453 throw_error (TLS_GENERIC_ERROR
,
11454 _("TLS not supported or disabled on this target"));
11459 /* Provide thread local base, i.e. Thread Information Block address.
11460 Returns 1 if ptid is found and thread_local_base is non zero. */
11463 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11465 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11467 struct remote_state
*rs
= get_remote_state ();
11468 char *p
= rs
->buf
.data ();
11469 char *endp
= p
+ get_remote_packet_size ();
11470 enum packet_result result
;
11472 strcpy (p
, "qGetTIBAddr:");
11474 p
= write_ptid (p
, endp
, ptid
);
11478 getpkt (&rs
->buf
, 0);
11479 result
= packet_ok (rs
->buf
,
11480 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11481 if (result
== PACKET_OK
)
11484 unpack_varlen_hex (rs
->buf
.data (), &val
);
11486 *addr
= (CORE_ADDR
) val
;
11489 else if (result
== PACKET_UNKNOWN
)
11490 error (_("Remote target doesn't support qGetTIBAddr packet"));
11492 error (_("Remote target failed to process qGetTIBAddr request"));
11495 error (_("qGetTIBAddr not supported or disabled on this target"));
11500 /* Support for inferring a target description based on the current
11501 architecture and the size of a 'g' packet. While the 'g' packet
11502 can have any size (since optional registers can be left off the
11503 end), some sizes are easily recognizable given knowledge of the
11504 approximate architecture. */
11506 struct remote_g_packet_guess
11508 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11515 const struct target_desc
*tdesc
;
11518 struct remote_g_packet_data
: public allocate_on_obstack
11520 std::vector
<remote_g_packet_guess
> guesses
;
11523 static struct gdbarch_data
*remote_g_packet_data_handle
;
11526 remote_g_packet_data_init (struct obstack
*obstack
)
11528 return new (obstack
) remote_g_packet_data
;
11532 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11533 const struct target_desc
*tdesc
)
11535 struct remote_g_packet_data
*data
11536 = ((struct remote_g_packet_data
*)
11537 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11539 gdb_assert (tdesc
!= NULL
);
11541 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11542 if (guess
.bytes
== bytes
)
11543 internal_error (__FILE__
, __LINE__
,
11544 _("Duplicate g packet description added for size %d"),
11547 data
->guesses
.emplace_back (bytes
, tdesc
);
11550 /* Return true if remote_read_description would do anything on this target
11551 and architecture, false otherwise. */
11554 remote_read_description_p (struct target_ops
*target
)
11556 struct remote_g_packet_data
*data
11557 = ((struct remote_g_packet_data
*)
11558 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11560 return !data
->guesses
.empty ();
11563 const struct target_desc
*
11564 remote_target::read_description ()
11566 struct remote_g_packet_data
*data
11567 = ((struct remote_g_packet_data
*)
11568 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11570 /* Do not try this during initial connection, when we do not know
11571 whether there is a running but stopped thread. */
11572 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
11573 return beneath ()->read_description ();
11575 if (!data
->guesses
.empty ())
11577 int bytes
= send_g_packet ();
11579 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11580 if (guess
.bytes
== bytes
)
11581 return guess
.tdesc
;
11583 /* We discard the g packet. A minor optimization would be to
11584 hold on to it, and fill the register cache once we have selected
11585 an architecture, but it's too tricky to do safely. */
11588 return beneath ()->read_description ();
11591 /* Remote file transfer support. This is host-initiated I/O, not
11592 target-initiated; for target-initiated, see remote-fileio.c. */
11594 /* If *LEFT is at least the length of STRING, copy STRING to
11595 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11596 decrease *LEFT. Otherwise raise an error. */
11599 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11601 int len
= strlen (string
);
11604 error (_("Packet too long for target."));
11606 memcpy (*buffer
, string
, len
);
11610 /* NUL-terminate the buffer as a convenience, if there is
11616 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11617 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11618 decrease *LEFT. Otherwise raise an error. */
11621 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11624 if (2 * len
> *left
)
11625 error (_("Packet too long for target."));
11627 bin2hex (bytes
, *buffer
, len
);
11628 *buffer
+= 2 * len
;
11631 /* NUL-terminate the buffer as a convenience, if there is
11637 /* If *LEFT is large enough, convert VALUE to hex and add it to
11638 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11639 decrease *LEFT. Otherwise raise an error. */
11642 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11644 int len
= hexnumlen (value
);
11647 error (_("Packet too long for target."));
11649 hexnumstr (*buffer
, value
);
11653 /* NUL-terminate the buffer as a convenience, if there is
11659 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11660 value, *REMOTE_ERRNO to the remote error number or zero if none
11661 was included, and *ATTACHMENT to point to the start of the annex
11662 if any. The length of the packet isn't needed here; there may
11663 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11665 Return 0 if the packet could be parsed, -1 if it could not. If
11666 -1 is returned, the other variables may not be initialized. */
11669 remote_hostio_parse_result (char *buffer
, int *retcode
,
11670 int *remote_errno
, char **attachment
)
11675 *attachment
= NULL
;
11677 if (buffer
[0] != 'F')
11681 *retcode
= strtol (&buffer
[1], &p
, 16);
11682 if (errno
!= 0 || p
== &buffer
[1])
11685 /* Check for ",errno". */
11689 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11690 if (errno
!= 0 || p
+ 1 == p2
)
11695 /* Check for ";attachment". If there is no attachment, the
11696 packet should end here. */
11699 *attachment
= p
+ 1;
11702 else if (*p
== '\0')
11708 /* Send a prepared I/O packet to the target and read its response.
11709 The prepared packet is in the global RS->BUF before this function
11710 is called, and the answer is there when we return.
11712 COMMAND_BYTES is the length of the request to send, which may include
11713 binary data. WHICH_PACKET is the packet configuration to check
11714 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11715 is set to the error number and -1 is returned. Otherwise the value
11716 returned by the function is returned.
11718 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11719 attachment is expected; an error will be reported if there's a
11720 mismatch. If one is found, *ATTACHMENT will be set to point into
11721 the packet buffer and *ATTACHMENT_LEN will be set to the
11722 attachment's length. */
11725 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11726 int *remote_errno
, char **attachment
,
11727 int *attachment_len
)
11729 struct remote_state
*rs
= get_remote_state ();
11730 int ret
, bytes_read
;
11731 char *attachment_tmp
;
11733 if (packet_support (which_packet
) == PACKET_DISABLE
)
11735 *remote_errno
= FILEIO_ENOSYS
;
11739 putpkt_binary (rs
->buf
.data (), command_bytes
);
11740 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11742 /* If it timed out, something is wrong. Don't try to parse the
11744 if (bytes_read
< 0)
11746 *remote_errno
= FILEIO_EINVAL
;
11750 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11753 *remote_errno
= FILEIO_EINVAL
;
11755 case PACKET_UNKNOWN
:
11756 *remote_errno
= FILEIO_ENOSYS
;
11762 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
11765 *remote_errno
= FILEIO_EINVAL
;
11769 /* Make sure we saw an attachment if and only if we expected one. */
11770 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11771 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11773 *remote_errno
= FILEIO_EINVAL
;
11777 /* If an attachment was found, it must point into the packet buffer;
11778 work out how many bytes there were. */
11779 if (attachment_tmp
!= NULL
)
11781 *attachment
= attachment_tmp
;
11782 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
11788 /* See declaration.h. */
11791 readahead_cache::invalidate ()
11796 /* See declaration.h. */
11799 readahead_cache::invalidate_fd (int fd
)
11801 if (this->fd
== fd
)
11805 /* Set the filesystem remote_hostio functions that take FILENAME
11806 arguments will use. Return 0 on success, or -1 if an error
11807 occurs (and set *REMOTE_ERRNO). */
11810 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
11813 struct remote_state
*rs
= get_remote_state ();
11814 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11815 char *p
= rs
->buf
.data ();
11816 int left
= get_remote_packet_size () - 1;
11820 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11823 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11826 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11828 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11829 remote_buffer_add_string (&p
, &left
, arg
);
11831 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
11832 remote_errno
, NULL
, NULL
);
11834 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11838 rs
->fs_pid
= required_pid
;
11843 /* Implementation of to_fileio_open. */
11846 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
11847 int flags
, int mode
, int warn_if_slow
,
11850 struct remote_state
*rs
= get_remote_state ();
11851 char *p
= rs
->buf
.data ();
11852 int left
= get_remote_packet_size () - 1;
11856 static int warning_issued
= 0;
11858 printf_unfiltered (_("Reading %s from remote target...\n"),
11861 if (!warning_issued
)
11863 warning (_("File transfers from remote targets can be slow."
11864 " Use \"set sysroot\" to access files locally"
11866 warning_issued
= 1;
11870 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11873 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11875 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11876 strlen (filename
));
11877 remote_buffer_add_string (&p
, &left
, ",");
11879 remote_buffer_add_int (&p
, &left
, flags
);
11880 remote_buffer_add_string (&p
, &left
, ",");
11882 remote_buffer_add_int (&p
, &left
, mode
);
11884 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
11885 remote_errno
, NULL
, NULL
);
11889 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
11890 int flags
, int mode
, int warn_if_slow
,
11893 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
11897 /* Implementation of to_fileio_pwrite. */
11900 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11901 ULONGEST offset
, int *remote_errno
)
11903 struct remote_state
*rs
= get_remote_state ();
11904 char *p
= rs
->buf
.data ();
11905 int left
= get_remote_packet_size ();
11908 rs
->readahead_cache
.invalidate_fd (fd
);
11910 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11912 remote_buffer_add_int (&p
, &left
, fd
);
11913 remote_buffer_add_string (&p
, &left
, ",");
11915 remote_buffer_add_int (&p
, &left
, offset
);
11916 remote_buffer_add_string (&p
, &left
, ",");
11918 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
11919 (get_remote_packet_size ()
11920 - (p
- rs
->buf
.data ())));
11922 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
11923 remote_errno
, NULL
, NULL
);
11927 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11928 ULONGEST offset
, int *remote_errno
)
11930 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
11933 /* Helper for the implementation of to_fileio_pread. Read the file
11934 from the remote side with vFile:pread. */
11937 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
11938 ULONGEST offset
, int *remote_errno
)
11940 struct remote_state
*rs
= get_remote_state ();
11941 char *p
= rs
->buf
.data ();
11943 int left
= get_remote_packet_size ();
11944 int ret
, attachment_len
;
11947 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
11949 remote_buffer_add_int (&p
, &left
, fd
);
11950 remote_buffer_add_string (&p
, &left
, ",");
11952 remote_buffer_add_int (&p
, &left
, len
);
11953 remote_buffer_add_string (&p
, &left
, ",");
11955 remote_buffer_add_int (&p
, &left
, offset
);
11957 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
11958 remote_errno
, &attachment
,
11964 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11966 if (read_len
!= ret
)
11967 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
11972 /* See declaration.h. */
11975 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
11979 && this->offset
<= offset
11980 && offset
< this->offset
+ this->bufsize
)
11982 ULONGEST max
= this->offset
+ this->bufsize
;
11984 if (offset
+ len
> max
)
11985 len
= max
- offset
;
11987 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
11994 /* Implementation of to_fileio_pread. */
11997 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
11998 ULONGEST offset
, int *remote_errno
)
12001 struct remote_state
*rs
= get_remote_state ();
12002 readahead_cache
*cache
= &rs
->readahead_cache
;
12004 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12007 cache
->hit_count
++;
12010 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12011 pulongest (cache
->hit_count
));
12015 cache
->miss_count
++;
12017 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12018 pulongest (cache
->miss_count
));
12021 cache
->offset
= offset
;
12022 cache
->bufsize
= get_remote_packet_size ();
12023 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12025 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12026 cache
->offset
, remote_errno
);
12029 cache
->invalidate_fd (fd
);
12033 cache
->bufsize
= ret
;
12034 return cache
->pread (fd
, read_buf
, len
, offset
);
12038 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12039 ULONGEST offset
, int *remote_errno
)
12041 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12044 /* Implementation of to_fileio_close. */
12047 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12049 struct remote_state
*rs
= get_remote_state ();
12050 char *p
= rs
->buf
.data ();
12051 int left
= get_remote_packet_size () - 1;
12053 rs
->readahead_cache
.invalidate_fd (fd
);
12055 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12057 remote_buffer_add_int (&p
, &left
, fd
);
12059 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12060 remote_errno
, NULL
, NULL
);
12064 remote_target::fileio_close (int fd
, int *remote_errno
)
12066 return remote_hostio_close (fd
, remote_errno
);
12069 /* Implementation of to_fileio_unlink. */
12072 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12075 struct remote_state
*rs
= get_remote_state ();
12076 char *p
= rs
->buf
.data ();
12077 int left
= get_remote_packet_size () - 1;
12079 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12082 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12084 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12085 strlen (filename
));
12087 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12088 remote_errno
, NULL
, NULL
);
12092 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12095 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12098 /* Implementation of to_fileio_readlink. */
12100 gdb::optional
<std::string
>
12101 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12104 struct remote_state
*rs
= get_remote_state ();
12105 char *p
= rs
->buf
.data ();
12107 int left
= get_remote_packet_size ();
12108 int len
, attachment_len
;
12111 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12114 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12116 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12117 strlen (filename
));
12119 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12120 remote_errno
, &attachment
,
12126 std::string
ret (len
, '\0');
12128 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12129 (gdb_byte
*) &ret
[0], len
);
12130 if (read_len
!= len
)
12131 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12136 /* Implementation of to_fileio_fstat. */
12139 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12141 struct remote_state
*rs
= get_remote_state ();
12142 char *p
= rs
->buf
.data ();
12143 int left
= get_remote_packet_size ();
12144 int attachment_len
, ret
;
12146 struct fio_stat fst
;
12149 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12151 remote_buffer_add_int (&p
, &left
, fd
);
12153 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12154 remote_errno
, &attachment
,
12158 if (*remote_errno
!= FILEIO_ENOSYS
)
12161 /* Strictly we should return -1, ENOSYS here, but when
12162 "set sysroot remote:" was implemented in August 2008
12163 BFD's need for a stat function was sidestepped with
12164 this hack. This was not remedied until March 2015
12165 so we retain the previous behavior to avoid breaking
12168 Note that the memset is a March 2015 addition; older
12169 GDBs set st_size *and nothing else* so the structure
12170 would have garbage in all other fields. This might
12171 break something but retaining the previous behavior
12172 here would be just too wrong. */
12174 memset (st
, 0, sizeof (struct stat
));
12175 st
->st_size
= INT_MAX
;
12179 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12180 (gdb_byte
*) &fst
, sizeof (fst
));
12182 if (read_len
!= ret
)
12183 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12185 if (read_len
!= sizeof (fst
))
12186 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12187 read_len
, (int) sizeof (fst
));
12189 remote_fileio_to_host_stat (&fst
, st
);
12194 /* Implementation of to_filesystem_is_local. */
12197 remote_target::filesystem_is_local ()
12199 /* Valgrind GDB presents itself as a remote target but works
12200 on the local filesystem: it does not implement remote get
12201 and users are not expected to set a sysroot. To handle
12202 this case we treat the remote filesystem as local if the
12203 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12204 does not support vFile:open. */
12205 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12207 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12209 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12211 int fd
, remote_errno
;
12213 /* Try opening a file to probe support. The supplied
12214 filename is irrelevant, we only care about whether
12215 the stub recognizes the packet or not. */
12216 fd
= remote_hostio_open (NULL
, "just probing",
12217 FILEIO_O_RDONLY
, 0700, 0,
12221 remote_hostio_close (fd
, &remote_errno
);
12223 ps
= packet_support (PACKET_vFile_open
);
12226 if (ps
== PACKET_DISABLE
)
12228 static int warning_issued
= 0;
12230 if (!warning_issued
)
12232 warning (_("remote target does not support file"
12233 " transfer, attempting to access files"
12234 " from local filesystem."));
12235 warning_issued
= 1;
12246 remote_fileio_errno_to_host (int errnum
)
12252 case FILEIO_ENOENT
:
12260 case FILEIO_EACCES
:
12262 case FILEIO_EFAULT
:
12266 case FILEIO_EEXIST
:
12268 case FILEIO_ENODEV
:
12270 case FILEIO_ENOTDIR
:
12272 case FILEIO_EISDIR
:
12274 case FILEIO_EINVAL
:
12276 case FILEIO_ENFILE
:
12278 case FILEIO_EMFILE
:
12282 case FILEIO_ENOSPC
:
12284 case FILEIO_ESPIPE
:
12288 case FILEIO_ENOSYS
:
12290 case FILEIO_ENAMETOOLONG
:
12291 return ENAMETOOLONG
;
12297 remote_hostio_error (int errnum
)
12299 int host_error
= remote_fileio_errno_to_host (errnum
);
12301 if (host_error
== -1)
12302 error (_("Unknown remote I/O error %d"), errnum
);
12304 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12307 /* A RAII wrapper around a remote file descriptor. */
12309 class scoped_remote_fd
12312 scoped_remote_fd (remote_target
*remote
, int fd
)
12313 : m_remote (remote
), m_fd (fd
)
12317 ~scoped_remote_fd ()
12324 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12328 /* Swallow exception before it escapes the dtor. If
12329 something goes wrong, likely the connection is gone,
12330 and there's nothing else that can be done. */
12335 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12337 /* Release ownership of the file descriptor, and return it. */
12338 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12345 /* Return the owned file descriptor. */
12346 int get () const noexcept
12352 /* The remote target. */
12353 remote_target
*m_remote
;
12355 /* The owned remote I/O file descriptor. */
12360 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12362 remote_target
*remote
= get_current_remote_target ();
12364 if (remote
== nullptr)
12365 error (_("command can only be used with remote target"));
12367 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12371 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12374 int retcode
, remote_errno
, bytes
, io_size
;
12375 int bytes_in_buffer
;
12379 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12381 perror_with_name (local_file
);
12383 scoped_remote_fd fd
12384 (this, remote_hostio_open (NULL
,
12385 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12387 0700, 0, &remote_errno
));
12388 if (fd
.get () == -1)
12389 remote_hostio_error (remote_errno
);
12391 /* Send up to this many bytes at once. They won't all fit in the
12392 remote packet limit, so we'll transfer slightly fewer. */
12393 io_size
= get_remote_packet_size ();
12394 gdb::byte_vector
buffer (io_size
);
12396 bytes_in_buffer
= 0;
12399 while (bytes_in_buffer
|| !saw_eof
)
12403 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12404 io_size
- bytes_in_buffer
,
12408 if (ferror (file
.get ()))
12409 error (_("Error reading %s."), local_file
);
12412 /* EOF. Unless there is something still in the
12413 buffer from the last iteration, we are done. */
12415 if (bytes_in_buffer
== 0)
12423 bytes
+= bytes_in_buffer
;
12424 bytes_in_buffer
= 0;
12426 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12427 offset
, &remote_errno
);
12430 remote_hostio_error (remote_errno
);
12431 else if (retcode
== 0)
12432 error (_("Remote write of %d bytes returned 0!"), bytes
);
12433 else if (retcode
< bytes
)
12435 /* Short write. Save the rest of the read data for the next
12437 bytes_in_buffer
= bytes
- retcode
;
12438 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12444 if (remote_hostio_close (fd
.release (), &remote_errno
))
12445 remote_hostio_error (remote_errno
);
12448 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12452 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12454 remote_target
*remote
= get_current_remote_target ();
12456 if (remote
== nullptr)
12457 error (_("command can only be used with remote target"));
12459 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12463 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12466 int remote_errno
, bytes
, io_size
;
12469 scoped_remote_fd fd
12470 (this, remote_hostio_open (NULL
,
12471 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12473 if (fd
.get () == -1)
12474 remote_hostio_error (remote_errno
);
12476 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12478 perror_with_name (local_file
);
12480 /* Send up to this many bytes at once. They won't all fit in the
12481 remote packet limit, so we'll transfer slightly fewer. */
12482 io_size
= get_remote_packet_size ();
12483 gdb::byte_vector
buffer (io_size
);
12488 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12491 /* Success, but no bytes, means end-of-file. */
12494 remote_hostio_error (remote_errno
);
12498 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12500 perror_with_name (local_file
);
12503 if (remote_hostio_close (fd
.release (), &remote_errno
))
12504 remote_hostio_error (remote_errno
);
12507 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12511 remote_file_delete (const char *remote_file
, int from_tty
)
12513 remote_target
*remote
= get_current_remote_target ();
12515 if (remote
== nullptr)
12516 error (_("command can only be used with remote target"));
12518 remote
->remote_file_delete (remote_file
, from_tty
);
12522 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12524 int retcode
, remote_errno
;
12526 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12528 remote_hostio_error (remote_errno
);
12531 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12535 remote_put_command (const char *args
, int from_tty
)
12538 error_no_arg (_("file to put"));
12540 gdb_argv
argv (args
);
12541 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12542 error (_("Invalid parameters to remote put"));
12544 remote_file_put (argv
[0], argv
[1], from_tty
);
12548 remote_get_command (const char *args
, int from_tty
)
12551 error_no_arg (_("file to get"));
12553 gdb_argv
argv (args
);
12554 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12555 error (_("Invalid parameters to remote get"));
12557 remote_file_get (argv
[0], argv
[1], from_tty
);
12561 remote_delete_command (const char *args
, int from_tty
)
12564 error_no_arg (_("file to delete"));
12566 gdb_argv
argv (args
);
12567 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12568 error (_("Invalid parameters to remote delete"));
12570 remote_file_delete (argv
[0], from_tty
);
12574 remote_command (const char *args
, int from_tty
)
12576 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12580 remote_target::can_execute_reverse ()
12582 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12583 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12590 remote_target::supports_non_stop ()
12596 remote_target::supports_disable_randomization ()
12598 /* Only supported in extended mode. */
12603 remote_target::supports_multi_process ()
12605 struct remote_state
*rs
= get_remote_state ();
12607 return remote_multi_process_p (rs
);
12611 remote_supports_cond_tracepoints ()
12613 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12617 remote_target::supports_evaluation_of_breakpoint_conditions ()
12619 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12623 remote_supports_fast_tracepoints ()
12625 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12629 remote_supports_static_tracepoints ()
12631 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12635 remote_supports_install_in_trace ()
12637 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12641 remote_target::supports_enable_disable_tracepoint ()
12643 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12648 remote_target::supports_string_tracing ()
12650 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12654 remote_target::can_run_breakpoint_commands ()
12656 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12660 remote_target::trace_init ()
12662 struct remote_state
*rs
= get_remote_state ();
12665 remote_get_noisy_reply ();
12666 if (strcmp (rs
->buf
.data (), "OK") != 0)
12667 error (_("Target does not support this command."));
12670 /* Recursive routine to walk through command list including loops, and
12671 download packets for each command. */
12674 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12675 struct command_line
*cmds
)
12677 struct remote_state
*rs
= get_remote_state ();
12678 struct command_line
*cmd
;
12680 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12682 QUIT
; /* Allow user to bail out with ^C. */
12683 strcpy (rs
->buf
.data (), "QTDPsrc:");
12684 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12685 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12686 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12688 remote_get_noisy_reply ();
12689 if (strcmp (rs
->buf
.data (), "OK"))
12690 warning (_("Target does not support source download."));
12692 if (cmd
->control_type
== while_control
12693 || cmd
->control_type
== while_stepping_control
)
12695 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12697 QUIT
; /* Allow user to bail out with ^C. */
12698 strcpy (rs
->buf
.data (), "QTDPsrc:");
12699 encode_source_string (num
, addr
, "cmd", "end",
12700 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12701 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12703 remote_get_noisy_reply ();
12704 if (strcmp (rs
->buf
.data (), "OK"))
12705 warning (_("Target does not support source download."));
12711 remote_target::download_tracepoint (struct bp_location
*loc
)
12715 std::vector
<std::string
> tdp_actions
;
12716 std::vector
<std::string
> stepping_actions
;
12718 struct breakpoint
*b
= loc
->owner
;
12719 struct tracepoint
*t
= (struct tracepoint
*) b
;
12720 struct remote_state
*rs
= get_remote_state ();
12722 const char *err_msg
= _("Tracepoint packet too large for target.");
12725 /* We use a buffer other than rs->buf because we'll build strings
12726 across multiple statements, and other statements in between could
12728 gdb::char_vector
buf (get_remote_packet_size ());
12730 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12732 tpaddr
= loc
->address
;
12733 sprintf_vma (addrbuf
, tpaddr
);
12734 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12735 b
->number
, addrbuf
, /* address */
12736 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12737 t
->step_count
, t
->pass_count
);
12739 if (ret
< 0 || ret
>= buf
.size ())
12740 error ("%s", err_msg
);
12742 /* Fast tracepoints are mostly handled by the target, but we can
12743 tell the target how big of an instruction block should be moved
12745 if (b
->type
== bp_fast_tracepoint
)
12747 /* Only test for support at download time; we may not know
12748 target capabilities at definition time. */
12749 if (remote_supports_fast_tracepoints ())
12751 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12754 size_left
= buf
.size () - strlen (buf
.data ());
12755 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12757 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12759 if (ret
< 0 || ret
>= size_left
)
12760 error ("%s", err_msg
);
12763 /* If it passed validation at definition but fails now,
12764 something is very wrong. */
12765 internal_error (__FILE__
, __LINE__
,
12766 _("Fast tracepoint not "
12767 "valid during download"));
12770 /* Fast tracepoints are functionally identical to regular
12771 tracepoints, so don't take lack of support as a reason to
12772 give up on the trace run. */
12773 warning (_("Target does not support fast tracepoints, "
12774 "downloading %d as regular tracepoint"), b
->number
);
12776 else if (b
->type
== bp_static_tracepoint
)
12778 /* Only test for support at download time; we may not know
12779 target capabilities at definition time. */
12780 if (remote_supports_static_tracepoints ())
12782 struct static_tracepoint_marker marker
;
12784 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12786 size_left
= buf
.size () - strlen (buf
.data ());
12787 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12790 if (ret
< 0 || ret
>= size_left
)
12791 error ("%s", err_msg
);
12794 error (_("Static tracepoint not valid during download"));
12797 /* Fast tracepoints are functionally identical to regular
12798 tracepoints, so don't take lack of support as a reason
12799 to give up on the trace run. */
12800 error (_("Target does not support static tracepoints"));
12802 /* If the tracepoint has a conditional, make it into an agent
12803 expression and append to the definition. */
12806 /* Only test support at download time, we may not know target
12807 capabilities at definition time. */
12808 if (remote_supports_cond_tracepoints ())
12810 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
12813 size_left
= buf
.size () - strlen (buf
.data ());
12815 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12816 size_left
, ":X%x,", aexpr
->len
);
12818 if (ret
< 0 || ret
>= size_left
)
12819 error ("%s", err_msg
);
12821 size_left
= buf
.size () - strlen (buf
.data ());
12823 /* Two bytes to encode each aexpr byte, plus the terminating
12825 if (aexpr
->len
* 2 + 1 > size_left
)
12826 error ("%s", err_msg
);
12828 pkt
= buf
.data () + strlen (buf
.data ());
12830 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12831 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12835 warning (_("Target does not support conditional tracepoints, "
12836 "ignoring tp %d cond"), b
->number
);
12839 if (b
->commands
|| *default_collect
)
12841 size_left
= buf
.size () - strlen (buf
.data ());
12843 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12846 if (ret
< 0 || ret
>= size_left
)
12847 error ("%s", err_msg
);
12850 putpkt (buf
.data ());
12851 remote_get_noisy_reply ();
12852 if (strcmp (rs
->buf
.data (), "OK"))
12853 error (_("Target does not support tracepoints."));
12855 /* do_single_steps (t); */
12856 for (auto action_it
= tdp_actions
.begin ();
12857 action_it
!= tdp_actions
.end (); action_it
++)
12859 QUIT
; /* Allow user to bail out with ^C. */
12861 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
12862 || !stepping_actions
.empty ());
12864 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
12865 b
->number
, addrbuf
, /* address */
12866 action_it
->c_str (),
12867 has_more
? '-' : 0);
12869 if (ret
< 0 || ret
>= buf
.size ())
12870 error ("%s", err_msg
);
12872 putpkt (buf
.data ());
12873 remote_get_noisy_reply ();
12874 if (strcmp (rs
->buf
.data (), "OK"))
12875 error (_("Error on target while setting tracepoints."));
12878 for (auto action_it
= stepping_actions
.begin ();
12879 action_it
!= stepping_actions
.end (); action_it
++)
12881 QUIT
; /* Allow user to bail out with ^C. */
12883 bool is_first
= action_it
== stepping_actions
.begin ();
12884 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
12886 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
12887 b
->number
, addrbuf
, /* address */
12888 is_first
? "S" : "",
12889 action_it
->c_str (),
12890 has_more
? "-" : "");
12892 if (ret
< 0 || ret
>= buf
.size ())
12893 error ("%s", err_msg
);
12895 putpkt (buf
.data ());
12896 remote_get_noisy_reply ();
12897 if (strcmp (rs
->buf
.data (), "OK"))
12898 error (_("Error on target while setting tracepoints."));
12901 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12903 if (b
->location
!= NULL
)
12905 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12907 if (ret
< 0 || ret
>= buf
.size ())
12908 error ("%s", err_msg
);
12910 encode_source_string (b
->number
, loc
->address
, "at",
12911 event_location_to_string (b
->location
.get ()),
12912 buf
.data () + strlen (buf
.data ()),
12913 buf
.size () - strlen (buf
.data ()));
12914 putpkt (buf
.data ());
12915 remote_get_noisy_reply ();
12916 if (strcmp (rs
->buf
.data (), "OK"))
12917 warning (_("Target does not support source download."));
12919 if (b
->cond_string
)
12921 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12923 if (ret
< 0 || ret
>= buf
.size ())
12924 error ("%s", err_msg
);
12926 encode_source_string (b
->number
, loc
->address
,
12927 "cond", b
->cond_string
,
12928 buf
.data () + strlen (buf
.data ()),
12929 buf
.size () - strlen (buf
.data ()));
12930 putpkt (buf
.data ());
12931 remote_get_noisy_reply ();
12932 if (strcmp (rs
->buf
.data (), "OK"))
12933 warning (_("Target does not support source download."));
12935 remote_download_command_source (b
->number
, loc
->address
,
12936 breakpoint_commands (b
));
12941 remote_target::can_download_tracepoint ()
12943 struct remote_state
*rs
= get_remote_state ();
12944 struct trace_status
*ts
;
12947 /* Don't try to install tracepoints until we've relocated our
12948 symbols, and fetched and merged the target's tracepoint list with
12950 if (rs
->starting_up
)
12953 ts
= current_trace_status ();
12954 status
= get_trace_status (ts
);
12956 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
12959 /* If we are in a tracing experiment, but remote stub doesn't support
12960 installing tracepoint in trace, we have to return. */
12961 if (!remote_supports_install_in_trace ())
12969 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
12971 struct remote_state
*rs
= get_remote_state ();
12974 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
12975 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
12977 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
12978 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
12979 >= get_remote_packet_size ())
12980 error (_("Trace state variable name too long for tsv definition packet"));
12981 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
12984 remote_get_noisy_reply ();
12985 if (rs
->buf
[0] == '\0')
12986 error (_("Target does not support this command."));
12987 if (strcmp (rs
->buf
.data (), "OK") != 0)
12988 error (_("Error on target while downloading trace state variable."));
12992 remote_target::enable_tracepoint (struct bp_location
*location
)
12994 struct remote_state
*rs
= get_remote_state ();
12997 sprintf_vma (addr_buf
, location
->address
);
12998 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
12999 location
->owner
->number
, addr_buf
);
13001 remote_get_noisy_reply ();
13002 if (rs
->buf
[0] == '\0')
13003 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13004 if (strcmp (rs
->buf
.data (), "OK") != 0)
13005 error (_("Error on target while enabling tracepoint."));
13009 remote_target::disable_tracepoint (struct bp_location
*location
)
13011 struct remote_state
*rs
= get_remote_state ();
13014 sprintf_vma (addr_buf
, location
->address
);
13015 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13016 location
->owner
->number
, addr_buf
);
13018 remote_get_noisy_reply ();
13019 if (rs
->buf
[0] == '\0')
13020 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13021 if (strcmp (rs
->buf
.data (), "OK") != 0)
13022 error (_("Error on target while disabling tracepoint."));
13026 remote_target::trace_set_readonly_regions ()
13029 bfd_size_type size
;
13035 return; /* No information to give. */
13037 struct remote_state
*rs
= get_remote_state ();
13039 strcpy (rs
->buf
.data (), "QTro");
13040 offset
= strlen (rs
->buf
.data ());
13041 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
13043 char tmp1
[40], tmp2
[40];
13046 if ((s
->flags
& SEC_LOAD
) == 0 ||
13047 /* (s->flags & SEC_CODE) == 0 || */
13048 (s
->flags
& SEC_READONLY
) == 0)
13052 vma
= bfd_section_vma (s
);
13053 size
= bfd_section_size (s
);
13054 sprintf_vma (tmp1
, vma
);
13055 sprintf_vma (tmp2
, vma
+ size
);
13056 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13057 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13059 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13061 Too many sections for read-only sections definition packet."));
13064 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13066 offset
+= sec_length
;
13071 getpkt (&rs
->buf
, 0);
13076 remote_target::trace_start ()
13078 struct remote_state
*rs
= get_remote_state ();
13080 putpkt ("QTStart");
13081 remote_get_noisy_reply ();
13082 if (rs
->buf
[0] == '\0')
13083 error (_("Target does not support this command."));
13084 if (strcmp (rs
->buf
.data (), "OK") != 0)
13085 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13089 remote_target::get_trace_status (struct trace_status
*ts
)
13091 /* Initialize it just to avoid a GCC false warning. */
13093 enum packet_result result
;
13094 struct remote_state
*rs
= get_remote_state ();
13096 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13099 /* FIXME we need to get register block size some other way. */
13100 trace_regblock_size
13101 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13103 putpkt ("qTStatus");
13107 p
= remote_get_noisy_reply ();
13109 catch (const gdb_exception_error
&ex
)
13111 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13113 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13119 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13121 /* If the remote target doesn't do tracing, flag it. */
13122 if (result
== PACKET_UNKNOWN
)
13125 /* We're working with a live target. */
13126 ts
->filename
= NULL
;
13129 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13131 /* Function 'parse_trace_status' sets default value of each field of
13132 'ts' at first, so we don't have to do it here. */
13133 parse_trace_status (p
, ts
);
13135 return ts
->running
;
13139 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13140 struct uploaded_tp
*utp
)
13142 struct remote_state
*rs
= get_remote_state ();
13144 struct bp_location
*loc
;
13145 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13146 size_t size
= get_remote_packet_size ();
13151 tp
->traceframe_usage
= 0;
13152 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13154 /* If the tracepoint was never downloaded, don't go asking for
13156 if (tp
->number_on_target
== 0)
13158 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13159 phex_nz (loc
->address
, 0));
13161 reply
= remote_get_noisy_reply ();
13162 if (reply
&& *reply
)
13165 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13171 utp
->hit_count
= 0;
13172 utp
->traceframe_usage
= 0;
13173 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13174 phex_nz (utp
->addr
, 0));
13176 reply
= remote_get_noisy_reply ();
13177 if (reply
&& *reply
)
13180 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13186 remote_target::trace_stop ()
13188 struct remote_state
*rs
= get_remote_state ();
13191 remote_get_noisy_reply ();
13192 if (rs
->buf
[0] == '\0')
13193 error (_("Target does not support this command."));
13194 if (strcmp (rs
->buf
.data (), "OK") != 0)
13195 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13199 remote_target::trace_find (enum trace_find_type type
, int num
,
13200 CORE_ADDR addr1
, CORE_ADDR addr2
,
13203 struct remote_state
*rs
= get_remote_state ();
13204 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13206 int target_frameno
= -1, target_tracept
= -1;
13208 /* Lookups other than by absolute frame number depend on the current
13209 trace selected, so make sure it is correct on the remote end
13211 if (type
!= tfind_number
)
13212 set_remote_traceframe ();
13214 p
= rs
->buf
.data ();
13215 strcpy (p
, "QTFrame:");
13216 p
= strchr (p
, '\0');
13220 xsnprintf (p
, endbuf
- p
, "%x", num
);
13223 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13226 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13229 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13230 phex_nz (addr2
, 0));
13232 case tfind_outside
:
13233 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13234 phex_nz (addr2
, 0));
13237 error (_("Unknown trace find type %d"), type
);
13241 reply
= remote_get_noisy_reply ();
13242 if (*reply
== '\0')
13243 error (_("Target does not support this command."));
13245 while (reply
&& *reply
)
13250 target_frameno
= (int) strtol (p
, &reply
, 16);
13252 error (_("Unable to parse trace frame number"));
13253 /* Don't update our remote traceframe number cache on failure
13254 to select a remote traceframe. */
13255 if (target_frameno
== -1)
13260 target_tracept
= (int) strtol (p
, &reply
, 16);
13262 error (_("Unable to parse tracepoint number"));
13264 case 'O': /* "OK"? */
13265 if (reply
[1] == 'K' && reply
[2] == '\0')
13268 error (_("Bogus reply from target: %s"), reply
);
13271 error (_("Bogus reply from target: %s"), reply
);
13274 *tpp
= target_tracept
;
13276 rs
->remote_traceframe_number
= target_frameno
;
13277 return target_frameno
;
13281 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13283 struct remote_state
*rs
= get_remote_state ();
13287 set_remote_traceframe ();
13289 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13291 reply
= remote_get_noisy_reply ();
13292 if (reply
&& *reply
)
13296 unpack_varlen_hex (reply
+ 1, &uval
);
13297 *val
= (LONGEST
) uval
;
13305 remote_target::save_trace_data (const char *filename
)
13307 struct remote_state
*rs
= get_remote_state ();
13310 p
= rs
->buf
.data ();
13311 strcpy (p
, "QTSave:");
13313 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13314 >= get_remote_packet_size ())
13315 error (_("Remote file name too long for trace save packet"));
13316 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13319 reply
= remote_get_noisy_reply ();
13320 if (*reply
== '\0')
13321 error (_("Target does not support this command."));
13322 if (strcmp (reply
, "OK") != 0)
13323 error (_("Bogus reply from target: %s"), reply
);
13327 /* This is basically a memory transfer, but needs to be its own packet
13328 because we don't know how the target actually organizes its trace
13329 memory, plus we want to be able to ask for as much as possible, but
13330 not be unhappy if we don't get as much as we ask for. */
13333 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13335 struct remote_state
*rs
= get_remote_state ();
13340 p
= rs
->buf
.data ();
13341 strcpy (p
, "qTBuffer:");
13343 p
+= hexnumstr (p
, offset
);
13345 p
+= hexnumstr (p
, len
);
13349 reply
= remote_get_noisy_reply ();
13350 if (reply
&& *reply
)
13352 /* 'l' by itself means we're at the end of the buffer and
13353 there is nothing more to get. */
13357 /* Convert the reply into binary. Limit the number of bytes to
13358 convert according to our passed-in buffer size, rather than
13359 what was returned in the packet; if the target is
13360 unexpectedly generous and gives us a bigger reply than we
13361 asked for, we don't want to crash. */
13362 rslt
= hex2bin (reply
, buf
, len
);
13366 /* Something went wrong, flag as an error. */
13371 remote_target::set_disconnected_tracing (int val
)
13373 struct remote_state
*rs
= get_remote_state ();
13375 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13379 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13380 "QTDisconnected:%x", val
);
13382 reply
= remote_get_noisy_reply ();
13383 if (*reply
== '\0')
13384 error (_("Target does not support this command."));
13385 if (strcmp (reply
, "OK") != 0)
13386 error (_("Bogus reply from target: %s"), reply
);
13389 warning (_("Target does not support disconnected tracing."));
13393 remote_target::core_of_thread (ptid_t ptid
)
13395 struct thread_info
*info
= find_thread_ptid (ptid
);
13397 if (info
!= NULL
&& info
->priv
!= NULL
)
13398 return get_remote_thread_info (info
)->core
;
13404 remote_target::set_circular_trace_buffer (int val
)
13406 struct remote_state
*rs
= get_remote_state ();
13409 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13410 "QTBuffer:circular:%x", val
);
13412 reply
= remote_get_noisy_reply ();
13413 if (*reply
== '\0')
13414 error (_("Target does not support this command."));
13415 if (strcmp (reply
, "OK") != 0)
13416 error (_("Bogus reply from target: %s"), reply
);
13420 remote_target::traceframe_info ()
13422 gdb::optional
<gdb::char_vector
> text
13423 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13426 return parse_traceframe_info (text
->data ());
13431 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13432 instruction on which a fast tracepoint may be placed. Returns -1
13433 if the packet is not supported, and 0 if the minimum instruction
13434 length is unknown. */
13437 remote_target::get_min_fast_tracepoint_insn_len ()
13439 struct remote_state
*rs
= get_remote_state ();
13442 /* If we're not debugging a process yet, the IPA can't be
13444 if (!target_has_execution
)
13447 /* Make sure the remote is pointing at the right process. */
13448 set_general_process ();
13450 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13452 reply
= remote_get_noisy_reply ();
13453 if (*reply
== '\0')
13457 ULONGEST min_insn_len
;
13459 unpack_varlen_hex (reply
, &min_insn_len
);
13461 return (int) min_insn_len
;
13466 remote_target::set_trace_buffer_size (LONGEST val
)
13468 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13470 struct remote_state
*rs
= get_remote_state ();
13471 char *buf
= rs
->buf
.data ();
13472 char *endbuf
= buf
+ get_remote_packet_size ();
13473 enum packet_result result
;
13475 gdb_assert (val
>= 0 || val
== -1);
13476 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13477 /* Send -1 as literal "-1" to avoid host size dependency. */
13481 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13484 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13487 remote_get_noisy_reply ();
13488 result
= packet_ok (rs
->buf
,
13489 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13491 if (result
!= PACKET_OK
)
13492 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13497 remote_target::set_trace_notes (const char *user
, const char *notes
,
13498 const char *stop_notes
)
13500 struct remote_state
*rs
= get_remote_state ();
13502 char *buf
= rs
->buf
.data ();
13503 char *endbuf
= buf
+ get_remote_packet_size ();
13506 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13509 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13510 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13516 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13517 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13523 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13524 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13528 /* Ensure the buffer is terminated. */
13532 reply
= remote_get_noisy_reply ();
13533 if (*reply
== '\0')
13536 if (strcmp (reply
, "OK") != 0)
13537 error (_("Bogus reply from target: %s"), reply
);
13543 remote_target::use_agent (bool use
)
13545 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13547 struct remote_state
*rs
= get_remote_state ();
13549 /* If the stub supports QAgent. */
13550 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13552 getpkt (&rs
->buf
, 0);
13554 if (strcmp (rs
->buf
.data (), "OK") == 0)
13565 remote_target::can_use_agent ()
13567 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13570 struct btrace_target_info
13572 /* The ptid of the traced thread. */
13575 /* The obtained branch trace configuration. */
13576 struct btrace_config conf
;
13579 /* Reset our idea of our target's btrace configuration. */
13582 remote_btrace_reset (remote_state
*rs
)
13584 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13587 /* Synchronize the configuration with the target. */
13590 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13592 struct packet_config
*packet
;
13593 struct remote_state
*rs
;
13594 char *buf
, *pos
, *endbuf
;
13596 rs
= get_remote_state ();
13597 buf
= rs
->buf
.data ();
13598 endbuf
= buf
+ get_remote_packet_size ();
13600 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13601 if (packet_config_support (packet
) == PACKET_ENABLE
13602 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13605 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13609 getpkt (&rs
->buf
, 0);
13611 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13613 if (buf
[0] == 'E' && buf
[1] == '.')
13614 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13616 error (_("Failed to configure the BTS buffer size."));
13619 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13622 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13623 if (packet_config_support (packet
) == PACKET_ENABLE
13624 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13627 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13631 getpkt (&rs
->buf
, 0);
13633 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13635 if (buf
[0] == 'E' && buf
[1] == '.')
13636 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13638 error (_("Failed to configure the trace buffer size."));
13641 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13645 /* Read the current thread's btrace configuration from the target and
13646 store it into CONF. */
13649 btrace_read_config (struct btrace_config
*conf
)
13651 gdb::optional
<gdb::char_vector
> xml
13652 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13654 parse_xml_btrace_conf (conf
, xml
->data ());
13657 /* Maybe reopen target btrace. */
13660 remote_target::remote_btrace_maybe_reopen ()
13662 struct remote_state
*rs
= get_remote_state ();
13663 int btrace_target_pushed
= 0;
13664 #if !defined (HAVE_LIBIPT)
13668 /* Don't bother walking the entirety of the remote thread list when
13669 we know the feature isn't supported by the remote. */
13670 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13673 scoped_restore_current_thread restore_thread
;
13675 for (thread_info
*tp
: all_non_exited_threads ())
13677 set_general_thread (tp
->ptid
);
13679 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13680 btrace_read_config (&rs
->btrace_config
);
13682 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13685 #if !defined (HAVE_LIBIPT)
13686 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13691 warning (_("Target is recording using Intel Processor Trace "
13692 "but support was disabled at compile time."));
13697 #endif /* !defined (HAVE_LIBIPT) */
13699 /* Push target, once, but before anything else happens. This way our
13700 changes to the threads will be cleaned up by unpushing the target
13701 in case btrace_read_config () throws. */
13702 if (!btrace_target_pushed
)
13704 btrace_target_pushed
= 1;
13705 record_btrace_push_target ();
13706 printf_filtered (_("Target is recording using %s.\n"),
13707 btrace_format_string (rs
->btrace_config
.format
));
13710 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13711 tp
->btrace
.target
->ptid
= tp
->ptid
;
13712 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13716 /* Enable branch tracing. */
13718 struct btrace_target_info
*
13719 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13721 struct btrace_target_info
*tinfo
= NULL
;
13722 struct packet_config
*packet
= NULL
;
13723 struct remote_state
*rs
= get_remote_state ();
13724 char *buf
= rs
->buf
.data ();
13725 char *endbuf
= buf
+ get_remote_packet_size ();
13727 switch (conf
->format
)
13729 case BTRACE_FORMAT_BTS
:
13730 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13733 case BTRACE_FORMAT_PT
:
13734 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13738 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13739 error (_("Target does not support branch tracing."));
13741 btrace_sync_conf (conf
);
13743 set_general_thread (ptid
);
13745 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13747 getpkt (&rs
->buf
, 0);
13749 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13751 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13752 error (_("Could not enable branch tracing for %s: %s"),
13753 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
13755 error (_("Could not enable branch tracing for %s."),
13756 target_pid_to_str (ptid
).c_str ());
13759 tinfo
= XCNEW (struct btrace_target_info
);
13760 tinfo
->ptid
= ptid
;
13762 /* If we fail to read the configuration, we lose some information, but the
13763 tracing itself is not impacted. */
13766 btrace_read_config (&tinfo
->conf
);
13768 catch (const gdb_exception_error
&err
)
13770 if (err
.message
!= NULL
)
13771 warning ("%s", err
.what ());
13777 /* Disable branch tracing. */
13780 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
13782 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13783 struct remote_state
*rs
= get_remote_state ();
13784 char *buf
= rs
->buf
.data ();
13785 char *endbuf
= buf
+ get_remote_packet_size ();
13787 if (packet_config_support (packet
) != PACKET_ENABLE
)
13788 error (_("Target does not support branch tracing."));
13790 set_general_thread (tinfo
->ptid
);
13792 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13794 getpkt (&rs
->buf
, 0);
13796 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13798 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13799 error (_("Could not disable branch tracing for %s: %s"),
13800 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
13802 error (_("Could not disable branch tracing for %s."),
13803 target_pid_to_str (tinfo
->ptid
).c_str ());
13809 /* Teardown branch tracing. */
13812 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
13814 /* We must not talk to the target during teardown. */
13818 /* Read the branch trace. */
13821 remote_target::read_btrace (struct btrace_data
*btrace
,
13822 struct btrace_target_info
*tinfo
,
13823 enum btrace_read_type type
)
13825 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13828 if (packet_config_support (packet
) != PACKET_ENABLE
)
13829 error (_("Target does not support branch tracing."));
13831 #if !defined(HAVE_LIBEXPAT)
13832 error (_("Cannot process branch tracing result. XML parsing not supported."));
13837 case BTRACE_READ_ALL
:
13840 case BTRACE_READ_NEW
:
13843 case BTRACE_READ_DELTA
:
13847 internal_error (__FILE__
, __LINE__
,
13848 _("Bad branch tracing read type: %u."),
13849 (unsigned int) type
);
13852 gdb::optional
<gdb::char_vector
> xml
13853 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
13855 return BTRACE_ERR_UNKNOWN
;
13857 parse_xml_btrace (btrace
, xml
->data ());
13859 return BTRACE_ERR_NONE
;
13862 const struct btrace_config
*
13863 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
13865 return &tinfo
->conf
;
13869 remote_target::augmented_libraries_svr4_read ()
13871 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13875 /* Implementation of to_load. */
13878 remote_target::load (const char *name
, int from_tty
)
13880 generic_load (name
, from_tty
);
13883 /* Accepts an integer PID; returns a string representing a file that
13884 can be opened on the remote side to get the symbols for the child
13885 process. Returns NULL if the operation is not supported. */
13888 remote_target::pid_to_exec_file (int pid
)
13890 static gdb::optional
<gdb::char_vector
> filename
;
13891 struct inferior
*inf
;
13892 char *annex
= NULL
;
13894 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13897 inf
= find_inferior_pid (pid
);
13899 internal_error (__FILE__
, __LINE__
,
13900 _("not currently attached to process %d"), pid
);
13902 if (!inf
->fake_pid_p
)
13904 const int annex_size
= 9;
13906 annex
= (char *) alloca (annex_size
);
13907 xsnprintf (annex
, annex_size
, "%x", pid
);
13910 filename
= target_read_stralloc (current_top_target (),
13911 TARGET_OBJECT_EXEC_FILE
, annex
);
13913 return filename
? filename
->data () : nullptr;
13916 /* Implement the to_can_do_single_step target_ops method. */
13919 remote_target::can_do_single_step ()
13921 /* We can only tell whether target supports single step or not by
13922 supported s and S vCont actions if the stub supports vContSupported
13923 feature. If the stub doesn't support vContSupported feature,
13924 we have conservatively to think target doesn't supports single
13926 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
13928 struct remote_state
*rs
= get_remote_state ();
13930 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13931 remote_vcont_probe ();
13933 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
13939 /* Implementation of the to_execution_direction method for the remote
13942 enum exec_direction_kind
13943 remote_target::execution_direction ()
13945 struct remote_state
*rs
= get_remote_state ();
13947 return rs
->last_resume_exec_dir
;
13950 /* Return pointer to the thread_info struct which corresponds to
13951 THREAD_HANDLE (having length HANDLE_LEN). */
13954 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
13958 for (thread_info
*tp
: all_non_exited_threads ())
13960 remote_thread_info
*priv
= get_remote_thread_info (tp
);
13962 if (tp
->inf
== inf
&& priv
!= NULL
)
13964 if (handle_len
!= priv
->thread_handle
.size ())
13965 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
13966 handle_len
, priv
->thread_handle
.size ());
13967 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
13977 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
13979 remote_thread_info
*priv
= get_remote_thread_info (tp
);
13980 return priv
->thread_handle
;
13984 remote_target::can_async_p ()
13986 struct remote_state
*rs
= get_remote_state ();
13988 /* We don't go async if the user has explicitly prevented it with the
13989 "maint set target-async" command. */
13990 if (!target_async_permitted
)
13993 /* We're async whenever the serial device is. */
13994 return serial_can_async_p (rs
->remote_desc
);
13998 remote_target::is_async_p ()
14000 struct remote_state
*rs
= get_remote_state ();
14002 if (!target_async_permitted
)
14003 /* We only enable async when the user specifically asks for it. */
14006 /* We're async whenever the serial device is. */
14007 return serial_is_async_p (rs
->remote_desc
);
14010 /* Pass the SERIAL event on and up to the client. One day this code
14011 will be able to delay notifying the client of an event until the
14012 point where an entire packet has been received. */
14014 static serial_event_ftype remote_async_serial_handler
;
14017 remote_async_serial_handler (struct serial
*scb
, void *context
)
14019 /* Don't propogate error information up to the client. Instead let
14020 the client find out about the error by querying the target. */
14021 inferior_event_handler (INF_REG_EVENT
, NULL
);
14025 remote_async_inferior_event_handler (gdb_client_data data
)
14027 inferior_event_handler (INF_REG_EVENT
, data
);
14031 remote_target::async (int enable
)
14033 struct remote_state
*rs
= get_remote_state ();
14037 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14039 /* If there are pending events in the stop reply queue tell the
14040 event loop to process them. */
14041 if (!rs
->stop_reply_queue
.empty ())
14042 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14043 /* For simplicity, below we clear the pending events token
14044 without remembering whether it is marked, so here we always
14045 mark it. If there's actually no pending notification to
14046 process, this ends up being a no-op (other than a spurious
14047 event-loop wakeup). */
14048 if (target_is_non_stop_p ())
14049 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14053 serial_async (rs
->remote_desc
, NULL
, NULL
);
14054 /* If the core is disabling async, it doesn't want to be
14055 disturbed with target events. Clear all async event sources
14057 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14058 if (target_is_non_stop_p ())
14059 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14063 /* Implementation of the to_thread_events method. */
14066 remote_target::thread_events (int enable
)
14068 struct remote_state
*rs
= get_remote_state ();
14069 size_t size
= get_remote_packet_size ();
14071 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14074 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14076 getpkt (&rs
->buf
, 0);
14078 switch (packet_ok (rs
->buf
,
14079 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14082 if (strcmp (rs
->buf
.data (), "OK") != 0)
14083 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14086 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14088 case PACKET_UNKNOWN
:
14094 set_remote_cmd (const char *args
, int from_tty
)
14096 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
14100 show_remote_cmd (const char *args
, int from_tty
)
14102 /* We can't just use cmd_show_list here, because we want to skip
14103 the redundant "show remote Z-packet" and the legacy aliases. */
14104 struct cmd_list_element
*list
= remote_show_cmdlist
;
14105 struct ui_out
*uiout
= current_uiout
;
14107 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14108 for (; list
!= NULL
; list
= list
->next
)
14109 if (strcmp (list
->name
, "Z-packet") == 0)
14111 else if (list
->type
== not_set_cmd
)
14112 /* Alias commands are exactly like the original, except they
14113 don't have the normal type. */
14117 ui_out_emit_tuple
option_emitter (uiout
, "option");
14119 uiout
->field_string ("name", list
->name
);
14120 uiout
->text (": ");
14121 if (list
->type
== show_cmd
)
14122 do_show_command (NULL
, from_tty
, list
);
14124 cmd_func (list
, NULL
, from_tty
);
14129 /* Function to be called whenever a new objfile (shlib) is detected. */
14131 remote_new_objfile (struct objfile
*objfile
)
14133 remote_target
*remote
= get_current_remote_target ();
14135 if (remote
!= NULL
) /* Have a remote connection. */
14136 remote
->remote_check_symbols ();
14139 /* Pull all the tracepoints defined on the target and create local
14140 data structures representing them. We don't want to create real
14141 tracepoints yet, we don't want to mess up the user's existing
14145 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14147 struct remote_state
*rs
= get_remote_state ();
14150 /* Ask for a first packet of tracepoint definition. */
14152 getpkt (&rs
->buf
, 0);
14153 p
= rs
->buf
.data ();
14154 while (*p
&& *p
!= 'l')
14156 parse_tracepoint_definition (p
, utpp
);
14157 /* Ask for another packet of tracepoint definition. */
14159 getpkt (&rs
->buf
, 0);
14160 p
= rs
->buf
.data ();
14166 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14168 struct remote_state
*rs
= get_remote_state ();
14171 /* Ask for a first packet of variable definition. */
14173 getpkt (&rs
->buf
, 0);
14174 p
= rs
->buf
.data ();
14175 while (*p
&& *p
!= 'l')
14177 parse_tsv_definition (p
, utsvp
);
14178 /* Ask for another packet of variable definition. */
14180 getpkt (&rs
->buf
, 0);
14181 p
= rs
->buf
.data ();
14186 /* The "set/show range-stepping" show hook. */
14189 show_range_stepping (struct ui_file
*file
, int from_tty
,
14190 struct cmd_list_element
*c
,
14193 fprintf_filtered (file
,
14194 _("Debugger's willingness to use range stepping "
14195 "is %s.\n"), value
);
14198 /* Return true if the vCont;r action is supported by the remote
14202 remote_target::vcont_r_supported ()
14204 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14205 remote_vcont_probe ();
14207 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14208 && get_remote_state ()->supports_vCont
.r
);
14211 /* The "set/show range-stepping" set hook. */
14214 set_range_stepping (const char *ignore_args
, int from_tty
,
14215 struct cmd_list_element
*c
)
14217 /* When enabling, check whether range stepping is actually supported
14218 by the target, and warn if not. */
14219 if (use_range_stepping
)
14221 remote_target
*remote
= get_current_remote_target ();
14223 || !remote
->vcont_r_supported ())
14224 warning (_("Range stepping is not supported by the current target"));
14229 _initialize_remote (void)
14231 struct cmd_list_element
*cmd
;
14232 const char *cmd_name
;
14234 /* architecture specific data */
14235 remote_g_packet_data_handle
=
14236 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14238 add_target (remote_target_info
, remote_target::open
);
14239 add_target (extended_remote_target_info
, extended_remote_target::open
);
14241 /* Hook into new objfile notification. */
14242 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14245 init_remote_threadtests ();
14248 /* set/show remote ... */
14250 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14251 Remote protocol specific variables.\n\
14252 Configure various remote-protocol specific variables such as\n\
14253 the packets being used."),
14254 &remote_set_cmdlist
, "set remote ",
14255 0 /* allow-unknown */, &setlist
);
14256 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14257 Remote protocol specific variables.\n\
14258 Configure various remote-protocol specific variables such as\n\
14259 the packets being used."),
14260 &remote_show_cmdlist
, "show remote ",
14261 0 /* allow-unknown */, &showlist
);
14263 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14264 Compare section data on target to the exec file.\n\
14265 Argument is a single section name (default: all loaded sections).\n\
14266 To compare only read-only loaded sections, specify the -r option."),
14269 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14270 Send an arbitrary packet to a remote target.\n\
14271 maintenance packet TEXT\n\
14272 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14273 this command sends the string TEXT to the inferior, and displays the\n\
14274 response packet. GDB supplies the initial `$' character, and the\n\
14275 terminating `#' character and checksum."),
14278 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14279 Set whether to send break if interrupted."), _("\
14280 Show whether to send break if interrupted."), _("\
14281 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14282 set_remotebreak
, show_remotebreak
,
14283 &setlist
, &showlist
);
14284 cmd_name
= "remotebreak";
14285 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14286 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14287 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14288 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14289 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14291 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14292 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14294 Set interrupt sequence to remote target."), _("\
14295 Show interrupt sequence to remote target."), _("\
14296 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14297 NULL
, show_interrupt_sequence
,
14298 &remote_set_cmdlist
,
14299 &remote_show_cmdlist
);
14301 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14302 &interrupt_on_connect
, _("\
14303 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14304 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14305 If set, interrupt sequence is sent to remote target."),
14307 &remote_set_cmdlist
, &remote_show_cmdlist
);
14309 /* Install commands for configuring memory read/write packets. */
14311 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14312 Set the maximum number of bytes per memory write packet (deprecated)."),
14314 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14315 Show the maximum number of bytes per memory write packet (deprecated)."),
14317 add_cmd ("memory-write-packet-size", no_class
,
14318 set_memory_write_packet_size
, _("\
14319 Set the maximum number of bytes per memory-write packet.\n\
14320 Specify the number of bytes in a packet or 0 (zero) for the\n\
14321 default packet size. The actual limit is further reduced\n\
14322 dependent on the target. Specify ``fixed'' to disable the\n\
14323 further restriction and ``limit'' to enable that restriction."),
14324 &remote_set_cmdlist
);
14325 add_cmd ("memory-read-packet-size", no_class
,
14326 set_memory_read_packet_size
, _("\
14327 Set the maximum number of bytes per memory-read packet.\n\
14328 Specify the number of bytes in a packet or 0 (zero) for the\n\
14329 default packet size. The actual limit is further reduced\n\
14330 dependent on the target. Specify ``fixed'' to disable the\n\
14331 further restriction and ``limit'' to enable that restriction."),
14332 &remote_set_cmdlist
);
14333 add_cmd ("memory-write-packet-size", no_class
,
14334 show_memory_write_packet_size
,
14335 _("Show the maximum number of bytes per memory-write packet."),
14336 &remote_show_cmdlist
);
14337 add_cmd ("memory-read-packet-size", no_class
,
14338 show_memory_read_packet_size
,
14339 _("Show the maximum number of bytes per memory-read packet."),
14340 &remote_show_cmdlist
);
14342 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14343 &remote_hw_watchpoint_limit
, _("\
14344 Set the maximum number of target hardware watchpoints."), _("\
14345 Show the maximum number of target hardware watchpoints."), _("\
14346 Specify \"unlimited\" for unlimited hardware watchpoints."),
14347 NULL
, show_hardware_watchpoint_limit
,
14348 &remote_set_cmdlist
,
14349 &remote_show_cmdlist
);
14350 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14352 &remote_hw_watchpoint_length_limit
, _("\
14353 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14354 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14355 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14356 NULL
, show_hardware_watchpoint_length_limit
,
14357 &remote_set_cmdlist
, &remote_show_cmdlist
);
14358 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14359 &remote_hw_breakpoint_limit
, _("\
14360 Set the maximum number of target hardware breakpoints."), _("\
14361 Show the maximum number of target hardware breakpoints."), _("\
14362 Specify \"unlimited\" for unlimited hardware breakpoints."),
14363 NULL
, show_hardware_breakpoint_limit
,
14364 &remote_set_cmdlist
, &remote_show_cmdlist
);
14366 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14367 &remote_address_size
, _("\
14368 Set the maximum size of the address (in bits) in a memory packet."), _("\
14369 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14371 NULL
, /* FIXME: i18n: */
14372 &setlist
, &showlist
);
14374 init_all_packet_configs ();
14376 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14377 "X", "binary-download", 1);
14379 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14380 "vCont", "verbose-resume", 0);
14382 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14383 "QPassSignals", "pass-signals", 0);
14385 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14386 "QCatchSyscalls", "catch-syscalls", 0);
14388 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14389 "QProgramSignals", "program-signals", 0);
14391 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14392 "QSetWorkingDir", "set-working-dir", 0);
14394 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14395 "QStartupWithShell", "startup-with-shell", 0);
14397 add_packet_config_cmd (&remote_protocol_packets
14398 [PACKET_QEnvironmentHexEncoded
],
14399 "QEnvironmentHexEncoded", "environment-hex-encoded",
14402 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14403 "QEnvironmentReset", "environment-reset",
14406 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14407 "QEnvironmentUnset", "environment-unset",
14410 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14411 "qSymbol", "symbol-lookup", 0);
14413 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14414 "P", "set-register", 1);
14416 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14417 "p", "fetch-register", 1);
14419 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14420 "Z0", "software-breakpoint", 0);
14422 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14423 "Z1", "hardware-breakpoint", 0);
14425 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14426 "Z2", "write-watchpoint", 0);
14428 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14429 "Z3", "read-watchpoint", 0);
14431 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14432 "Z4", "access-watchpoint", 0);
14434 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14435 "qXfer:auxv:read", "read-aux-vector", 0);
14437 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14438 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14440 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14441 "qXfer:features:read", "target-features", 0);
14443 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14444 "qXfer:libraries:read", "library-info", 0);
14446 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14447 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14449 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14450 "qXfer:memory-map:read", "memory-map", 0);
14452 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14453 "qXfer:osdata:read", "osdata", 0);
14455 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14456 "qXfer:threads:read", "threads", 0);
14458 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14459 "qXfer:siginfo:read", "read-siginfo-object", 0);
14461 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14462 "qXfer:siginfo:write", "write-siginfo-object", 0);
14464 add_packet_config_cmd
14465 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14466 "qXfer:traceframe-info:read", "traceframe-info", 0);
14468 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14469 "qXfer:uib:read", "unwind-info-block", 0);
14471 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14472 "qGetTLSAddr", "get-thread-local-storage-address",
14475 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14476 "qGetTIBAddr", "get-thread-information-block-address",
14479 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14480 "bc", "reverse-continue", 0);
14482 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14483 "bs", "reverse-step", 0);
14485 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14486 "qSupported", "supported-packets", 0);
14488 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14489 "qSearch:memory", "search-memory", 0);
14491 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14492 "qTStatus", "trace-status", 0);
14494 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14495 "vFile:setfs", "hostio-setfs", 0);
14497 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14498 "vFile:open", "hostio-open", 0);
14500 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14501 "vFile:pread", "hostio-pread", 0);
14503 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14504 "vFile:pwrite", "hostio-pwrite", 0);
14506 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14507 "vFile:close", "hostio-close", 0);
14509 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14510 "vFile:unlink", "hostio-unlink", 0);
14512 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14513 "vFile:readlink", "hostio-readlink", 0);
14515 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14516 "vFile:fstat", "hostio-fstat", 0);
14518 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14519 "vAttach", "attach", 0);
14521 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14524 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14525 "QStartNoAckMode", "noack", 0);
14527 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14528 "vKill", "kill", 0);
14530 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14531 "qAttached", "query-attached", 0);
14533 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14534 "ConditionalTracepoints",
14535 "conditional-tracepoints", 0);
14537 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14538 "ConditionalBreakpoints",
14539 "conditional-breakpoints", 0);
14541 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14542 "BreakpointCommands",
14543 "breakpoint-commands", 0);
14545 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14546 "FastTracepoints", "fast-tracepoints", 0);
14548 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14549 "TracepointSource", "TracepointSource", 0);
14551 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14552 "QAllow", "allow", 0);
14554 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14555 "StaticTracepoints", "static-tracepoints", 0);
14557 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14558 "InstallInTrace", "install-in-trace", 0);
14560 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14561 "qXfer:statictrace:read", "read-sdata-object", 0);
14563 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14564 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14566 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14567 "QDisableRandomization", "disable-randomization", 0);
14569 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14570 "QAgent", "agent", 0);
14572 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14573 "QTBuffer:size", "trace-buffer-size", 0);
14575 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14576 "Qbtrace:off", "disable-btrace", 0);
14578 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14579 "Qbtrace:bts", "enable-btrace-bts", 0);
14581 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14582 "Qbtrace:pt", "enable-btrace-pt", 0);
14584 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14585 "qXfer:btrace", "read-btrace", 0);
14587 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14588 "qXfer:btrace-conf", "read-btrace-conf", 0);
14590 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14591 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14593 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14594 "multiprocess-feature", "multiprocess-feature", 0);
14596 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14597 "swbreak-feature", "swbreak-feature", 0);
14599 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14600 "hwbreak-feature", "hwbreak-feature", 0);
14602 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14603 "fork-event-feature", "fork-event-feature", 0);
14605 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14606 "vfork-event-feature", "vfork-event-feature", 0);
14608 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14609 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14611 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14612 "vContSupported", "verbose-resume-supported", 0);
14614 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14615 "exec-event-feature", "exec-event-feature", 0);
14617 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14618 "vCtrlC", "ctrl-c", 0);
14620 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14621 "QThreadEvents", "thread-events", 0);
14623 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14624 "N stop reply", "no-resumed-stop-reply", 0);
14626 /* Assert that we've registered "set remote foo-packet" commands
14627 for all packet configs. */
14631 for (i
= 0; i
< PACKET_MAX
; i
++)
14633 /* Ideally all configs would have a command associated. Some
14634 still don't though. */
14639 case PACKET_QNonStop
:
14640 case PACKET_EnableDisableTracepoints_feature
:
14641 case PACKET_tracenz_feature
:
14642 case PACKET_DisconnectedTracing_feature
:
14643 case PACKET_augmented_libraries_svr4_read_feature
:
14645 /* Additions to this list need to be well justified:
14646 pre-existing packets are OK; new packets are not. */
14654 /* This catches both forgetting to add a config command, and
14655 forgetting to remove a packet from the exception list. */
14656 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14660 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14661 Z sub-packet has its own set and show commands, but users may
14662 have sets to this variable in their .gdbinit files (or in their
14664 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14665 &remote_Z_packet_detect
, _("\
14666 Set use of remote protocol `Z' packets."), _("\
14667 Show use of remote protocol `Z' packets."), _("\
14668 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14670 set_remote_protocol_Z_packet_cmd
,
14671 show_remote_protocol_Z_packet_cmd
,
14672 /* FIXME: i18n: Use of remote protocol
14673 `Z' packets is %s. */
14674 &remote_set_cmdlist
, &remote_show_cmdlist
);
14676 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14677 Manipulate files on the remote system.\n\
14678 Transfer files to and from the remote target system."),
14679 &remote_cmdlist
, "remote ",
14680 0 /* allow-unknown */, &cmdlist
);
14682 add_cmd ("put", class_files
, remote_put_command
,
14683 _("Copy a local file to the remote system."),
14686 add_cmd ("get", class_files
, remote_get_command
,
14687 _("Copy a remote file to the local system."),
14690 add_cmd ("delete", class_files
, remote_delete_command
,
14691 _("Delete a remote file."),
14694 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14695 &remote_exec_file_var
, _("\
14696 Set the remote pathname for \"run\"."), _("\
14697 Show the remote pathname for \"run\"."), NULL
,
14698 set_remote_exec_file
,
14699 show_remote_exec_file
,
14700 &remote_set_cmdlist
,
14701 &remote_show_cmdlist
);
14703 add_setshow_boolean_cmd ("range-stepping", class_run
,
14704 &use_range_stepping
, _("\
14705 Enable or disable range stepping."), _("\
14706 Show whether target-assisted range stepping is enabled."), _("\
14707 If on, and the target supports it, when stepping a source line, GDB\n\
14708 tells the target to step the corresponding range of addresses itself instead\n\
14709 of issuing multiple single-steps. This speeds up source level\n\
14710 stepping. If off, GDB always issues single-steps, even if range\n\
14711 stepping is supported by the target. The default is on."),
14712 set_range_stepping
,
14713 show_range_stepping
,
14717 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
14718 Set watchdog timer."), _("\
14719 Show watchdog timer."), _("\
14720 When non-zero, this timeout is used instead of waiting forever for a target\n\
14721 to finish a low-level step or continue operation. If the specified amount\n\
14722 of time passes without a response from the target, an error occurs."),
14725 &setlist
, &showlist
);
14727 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
14728 &remote_packet_max_chars
, _("\
14729 Set the maximum number of characters to display for each remote packet."), _("\
14730 Show the maximum number of characters to display for each remote packet."), _("\
14731 Specify \"unlimited\" to display all the characters."),
14732 NULL
, show_remote_packet_max_chars
,
14733 &setdebuglist
, &showdebuglist
);
14735 /* Eventually initialize fileio. See fileio.c */
14736 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);