1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2019 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 /* The max number of chars in debug output. The rest of chars are
1047 #define REMOTE_DEBUG_MAX_CHAR 512
1049 /* Private data that we'll store in (struct thread_info)->priv. */
1050 struct remote_thread_info
: public private_thread_info
1056 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1057 sequence of bytes. */
1058 gdb::byte_vector thread_handle
;
1060 /* Whether the target stopped for a breakpoint/watchpoint. */
1061 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1063 /* This is set to the data address of the access causing the target
1064 to stop for a watchpoint. */
1065 CORE_ADDR watch_data_address
= 0;
1067 /* Fields used by the vCont action coalescing implemented in
1068 remote_resume / remote_commit_resume. remote_resume stores each
1069 thread's last resume request in these fields, so that a later
1070 remote_commit_resume knows which is the proper action for this
1071 thread to include in the vCont packet. */
1073 /* True if the last target_resume call for this thread was a step
1074 request, false if a continue request. */
1075 int last_resume_step
= 0;
1077 /* The signal specified in the last target_resume call for this
1079 gdb_signal last_resume_sig
= GDB_SIGNAL_0
;
1081 /* Whether this thread was already vCont-resumed on the remote
1083 int vcont_resumed
= 0;
1086 remote_state::remote_state ()
1091 remote_state::~remote_state ()
1093 xfree (this->last_pass_packet
);
1094 xfree (this->last_program_signals_packet
);
1095 xfree (this->finished_object
);
1096 xfree (this->finished_annex
);
1099 /* Utility: generate error from an incoming stub packet. */
1101 trace_error (char *buf
)
1104 return; /* not an error msg */
1107 case '1': /* malformed packet error */
1108 if (*++buf
== '0') /* general case: */
1109 error (_("remote.c: error in outgoing packet."));
1111 error (_("remote.c: error in outgoing packet at field #%ld."),
1112 strtol (buf
, NULL
, 16));
1114 error (_("Target returns error code '%s'."), buf
);
1118 /* Utility: wait for reply from stub, while accepting "O" packets. */
1121 remote_target::remote_get_noisy_reply ()
1123 struct remote_state
*rs
= get_remote_state ();
1125 do /* Loop on reply from remote stub. */
1129 QUIT
; /* Allow user to bail out with ^C. */
1130 getpkt (&rs
->buf
, 0);
1131 buf
= rs
->buf
.data ();
1134 else if (startswith (buf
, "qRelocInsn:"))
1137 CORE_ADDR from
, to
, org_to
;
1139 int adjusted_size
= 0;
1142 p
= buf
+ strlen ("qRelocInsn:");
1143 pp
= unpack_varlen_hex (p
, &ul
);
1145 error (_("invalid qRelocInsn packet: %s"), buf
);
1149 unpack_varlen_hex (p
, &ul
);
1156 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1159 catch (const gdb_exception
&ex
)
1161 if (ex
.error
== MEMORY_ERROR
)
1163 /* Propagate memory errors silently back to the
1164 target. The stub may have limited the range of
1165 addresses we can write to, for example. */
1169 /* Something unexpectedly bad happened. Be verbose
1170 so we can tell what, and propagate the error back
1171 to the stub, so it doesn't get stuck waiting for
1173 exception_fprintf (gdb_stderr
, ex
,
1174 _("warning: relocating instruction: "));
1181 adjusted_size
= to
- org_to
;
1183 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1187 else if (buf
[0] == 'O' && buf
[1] != 'K')
1188 remote_console_output (buf
+ 1); /* 'O' message from stub */
1190 return buf
; /* Here's the actual reply. */
1195 struct remote_arch_state
*
1196 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1198 remote_arch_state
*rsa
;
1200 auto it
= this->m_arch_states
.find (gdbarch
);
1201 if (it
== this->m_arch_states
.end ())
1203 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1204 std::forward_as_tuple (gdbarch
),
1205 std::forward_as_tuple (gdbarch
));
1206 rsa
= &p
.first
->second
;
1208 /* Make sure that the packet buffer is plenty big enough for
1209 this architecture. */
1210 if (this->buf
.size () < rsa
->remote_packet_size
)
1211 this->buf
.resize (2 * rsa
->remote_packet_size
);
1219 /* Fetch the global remote target state. */
1222 remote_target::get_remote_state ()
1224 /* Make sure that the remote architecture state has been
1225 initialized, because doing so might reallocate rs->buf. Any
1226 function which calls getpkt also needs to be mindful of changes
1227 to rs->buf, but this call limits the number of places which run
1229 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1231 return &m_remote_state
;
1234 /* Fetch the remote exec-file from the current program space. */
1237 get_remote_exec_file (void)
1239 char *remote_exec_file
;
1241 remote_exec_file
= remote_pspace_data
.get (current_program_space
);
1242 if (remote_exec_file
== NULL
)
1245 return remote_exec_file
;
1248 /* Set the remote exec file for PSPACE. */
1251 set_pspace_remote_exec_file (struct program_space
*pspace
,
1252 const char *remote_exec_file
)
1254 char *old_file
= remote_pspace_data
.get (pspace
);
1257 remote_pspace_data
.set (pspace
, xstrdup (remote_exec_file
));
1260 /* The "set/show remote exec-file" set command hook. */
1263 set_remote_exec_file (const char *ignored
, int from_tty
,
1264 struct cmd_list_element
*c
)
1266 gdb_assert (remote_exec_file_var
!= NULL
);
1267 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
1270 /* The "set/show remote exec-file" show command hook. */
1273 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1274 struct cmd_list_element
*cmd
, const char *value
)
1276 fprintf_filtered (file
, "%s\n", remote_exec_file_var
);
1280 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1282 int regnum
, num_remote_regs
, offset
;
1283 struct packet_reg
**remote_regs
;
1285 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1287 struct packet_reg
*r
= ®s
[regnum
];
1289 if (register_size (gdbarch
, regnum
) == 0)
1290 /* Do not try to fetch zero-sized (placeholder) registers. */
1293 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1298 /* Define the g/G packet format as the contents of each register
1299 with a remote protocol number, in order of ascending protocol
1302 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1303 for (num_remote_regs
= 0, regnum
= 0;
1304 regnum
< gdbarch_num_regs (gdbarch
);
1306 if (regs
[regnum
].pnum
!= -1)
1307 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1309 std::sort (remote_regs
, remote_regs
+ num_remote_regs
,
1310 [] (const packet_reg
*a
, const packet_reg
*b
)
1311 { return a
->pnum
< b
->pnum
; });
1313 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1315 remote_regs
[regnum
]->in_g_packet
= 1;
1316 remote_regs
[regnum
]->offset
= offset
;
1317 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1323 /* Given the architecture described by GDBARCH, return the remote
1324 protocol register's number and the register's offset in the g/G
1325 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1326 If the target does not have a mapping for REGNUM, return false,
1327 otherwise, return true. */
1330 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1331 int *pnum
, int *poffset
)
1333 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1335 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1337 map_regcache_remote_table (gdbarch
, regs
.data ());
1339 *pnum
= regs
[regnum
].pnum
;
1340 *poffset
= regs
[regnum
].offset
;
1345 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1347 /* Use the architecture to build a regnum<->pnum table, which will be
1348 1:1 unless a feature set specifies otherwise. */
1349 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1351 /* Record the maximum possible size of the g packet - it may turn out
1353 this->sizeof_g_packet
1354 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1356 /* Default maximum number of characters in a packet body. Many
1357 remote stubs have a hardwired buffer size of 400 bytes
1358 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1359 as the maximum packet-size to ensure that the packet and an extra
1360 NUL character can always fit in the buffer. This stops GDB
1361 trashing stubs that try to squeeze an extra NUL into what is
1362 already a full buffer (As of 1999-12-04 that was most stubs). */
1363 this->remote_packet_size
= 400 - 1;
1365 /* This one is filled in when a ``g'' packet is received. */
1366 this->actual_register_packet_size
= 0;
1368 /* Should rsa->sizeof_g_packet needs more space than the
1369 default, adjust the size accordingly. Remember that each byte is
1370 encoded as two characters. 32 is the overhead for the packet
1371 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1372 (``$NN:G...#NN'') is a better guess, the below has been padded a
1374 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1375 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1378 /* Get a pointer to the current remote target. If not connected to a
1379 remote target, return NULL. */
1381 static remote_target
*
1382 get_current_remote_target ()
1384 target_ops
*proc_target
= find_target_at (process_stratum
);
1385 return dynamic_cast<remote_target
*> (proc_target
);
1388 /* Return the current allowed size of a remote packet. This is
1389 inferred from the current architecture, and should be used to
1390 limit the length of outgoing packets. */
1392 remote_target::get_remote_packet_size ()
1394 struct remote_state
*rs
= get_remote_state ();
1395 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1397 if (rs
->explicit_packet_size
)
1398 return rs
->explicit_packet_size
;
1400 return rsa
->remote_packet_size
;
1403 static struct packet_reg
*
1404 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1407 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1411 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1413 gdb_assert (r
->regnum
== regnum
);
1418 static struct packet_reg
*
1419 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1424 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1426 struct packet_reg
*r
= &rsa
->regs
[i
];
1428 if (r
->pnum
== pnum
)
1434 /* Allow the user to specify what sequence to send to the remote
1435 when he requests a program interruption: Although ^C is usually
1436 what remote systems expect (this is the default, here), it is
1437 sometimes preferable to send a break. On other systems such
1438 as the Linux kernel, a break followed by g, which is Magic SysRq g
1439 is required in order to interrupt the execution. */
1440 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1441 const char interrupt_sequence_break
[] = "BREAK";
1442 const char interrupt_sequence_break_g
[] = "BREAK-g";
1443 static const char *const interrupt_sequence_modes
[] =
1445 interrupt_sequence_control_c
,
1446 interrupt_sequence_break
,
1447 interrupt_sequence_break_g
,
1450 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1453 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1454 struct cmd_list_element
*c
,
1457 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1458 fprintf_filtered (file
,
1459 _("Send the ASCII ETX character (Ctrl-c) "
1460 "to the remote target to interrupt the "
1461 "execution of the program.\n"));
1462 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1463 fprintf_filtered (file
,
1464 _("send a break signal to the remote target "
1465 "to interrupt the execution of the program.\n"));
1466 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1467 fprintf_filtered (file
,
1468 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1469 "the remote target to interrupt the execution "
1470 "of Linux kernel.\n"));
1472 internal_error (__FILE__
, __LINE__
,
1473 _("Invalid value for interrupt_sequence_mode: %s."),
1474 interrupt_sequence_mode
);
1477 /* This boolean variable specifies whether interrupt_sequence is sent
1478 to the remote target when gdb connects to it.
1479 This is mostly needed when you debug the Linux kernel: The Linux kernel
1480 expects BREAK g which is Magic SysRq g for connecting gdb. */
1481 static bool interrupt_on_connect
= false;
1483 /* This variable is used to implement the "set/show remotebreak" commands.
1484 Since these commands are now deprecated in favor of "set/show remote
1485 interrupt-sequence", it no longer has any effect on the code. */
1486 static bool remote_break
;
1489 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1492 interrupt_sequence_mode
= interrupt_sequence_break
;
1494 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1498 show_remotebreak (struct ui_file
*file
, int from_tty
,
1499 struct cmd_list_element
*c
,
1504 /* This variable sets the number of bits in an address that are to be
1505 sent in a memory ("M" or "m") packet. Normally, after stripping
1506 leading zeros, the entire address would be sent. This variable
1507 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1508 initial implementation of remote.c restricted the address sent in
1509 memory packets to ``host::sizeof long'' bytes - (typically 32
1510 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1511 address was never sent. Since fixing this bug may cause a break in
1512 some remote targets this variable is principally provided to
1513 facilitate backward compatibility. */
1515 static unsigned int remote_address_size
;
1518 /* User configurable variables for the number of characters in a
1519 memory read/write packet. MIN (rsa->remote_packet_size,
1520 rsa->sizeof_g_packet) is the default. Some targets need smaller
1521 values (fifo overruns, et.al.) and some users need larger values
1522 (speed up transfers). The variables ``preferred_*'' (the user
1523 request), ``current_*'' (what was actually set) and ``forced_*''
1524 (Positive - a soft limit, negative - a hard limit). */
1526 struct memory_packet_config
1533 /* The default max memory-write-packet-size, when the setting is
1534 "fixed". The 16k is historical. (It came from older GDB's using
1535 alloca for buffers and the knowledge (folklore?) that some hosts
1536 don't cope very well with large alloca calls.) */
1537 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1539 /* The minimum remote packet size for memory transfers. Ensures we
1540 can write at least one byte. */
1541 #define MIN_MEMORY_PACKET_SIZE 20
1543 /* Get the memory packet size, assuming it is fixed. */
1546 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1548 gdb_assert (config
->fixed_p
);
1550 if (config
->size
<= 0)
1551 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1553 return config
->size
;
1556 /* Compute the current size of a read/write packet. Since this makes
1557 use of ``actual_register_packet_size'' the computation is dynamic. */
1560 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1562 struct remote_state
*rs
= get_remote_state ();
1563 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1566 if (config
->fixed_p
)
1567 what_they_get
= get_fixed_memory_packet_size (config
);
1570 what_they_get
= get_remote_packet_size ();
1571 /* Limit the packet to the size specified by the user. */
1572 if (config
->size
> 0
1573 && what_they_get
> config
->size
)
1574 what_they_get
= config
->size
;
1576 /* Limit it to the size of the targets ``g'' response unless we have
1577 permission from the stub to use a larger packet size. */
1578 if (rs
->explicit_packet_size
== 0
1579 && rsa
->actual_register_packet_size
> 0
1580 && what_they_get
> rsa
->actual_register_packet_size
)
1581 what_they_get
= rsa
->actual_register_packet_size
;
1583 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1584 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1586 /* Make sure there is room in the global buffer for this packet
1587 (including its trailing NUL byte). */
1588 if (rs
->buf
.size () < what_they_get
+ 1)
1589 rs
->buf
.resize (2 * what_they_get
);
1591 return what_they_get
;
1594 /* Update the size of a read/write packet. If they user wants
1595 something really big then do a sanity check. */
1598 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1600 int fixed_p
= config
->fixed_p
;
1601 long size
= config
->size
;
1604 error (_("Argument required (integer, `fixed' or `limited')."));
1605 else if (strcmp (args
, "hard") == 0
1606 || strcmp (args
, "fixed") == 0)
1608 else if (strcmp (args
, "soft") == 0
1609 || strcmp (args
, "limit") == 0)
1615 size
= strtoul (args
, &end
, 0);
1617 error (_("Invalid %s (bad syntax)."), config
->name
);
1619 /* Instead of explicitly capping the size of a packet to or
1620 disallowing it, the user is allowed to set the size to
1621 something arbitrarily large. */
1625 if (fixed_p
&& !config
->fixed_p
)
1627 /* So that the query shows the correct value. */
1628 long query_size
= (size
<= 0
1629 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1632 if (! query (_("The target may not be able to correctly handle a %s\n"
1633 "of %ld bytes. Change the packet size? "),
1634 config
->name
, query_size
))
1635 error (_("Packet size not changed."));
1637 /* Update the config. */
1638 config
->fixed_p
= fixed_p
;
1639 config
->size
= size
;
1643 show_memory_packet_size (struct memory_packet_config
*config
)
1645 if (config
->size
== 0)
1646 printf_filtered (_("The %s is 0 (default). "), config
->name
);
1648 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1649 if (config
->fixed_p
)
1650 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1651 get_fixed_memory_packet_size (config
));
1654 remote_target
*remote
= get_current_remote_target ();
1657 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1658 remote
->get_memory_packet_size (config
));
1660 puts_filtered ("The actual limit will be further reduced "
1661 "dependent on the target.\n");
1665 static struct memory_packet_config memory_write_packet_config
=
1667 "memory-write-packet-size",
1671 set_memory_write_packet_size (const char *args
, int from_tty
)
1673 set_memory_packet_size (args
, &memory_write_packet_config
);
1677 show_memory_write_packet_size (const char *args
, int from_tty
)
1679 show_memory_packet_size (&memory_write_packet_config
);
1682 /* Show the number of hardware watchpoints that can be used. */
1685 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1686 struct cmd_list_element
*c
,
1689 fprintf_filtered (file
, _("The maximum number of target hardware "
1690 "watchpoints is %s.\n"), value
);
1693 /* Show the length limit (in bytes) for hardware watchpoints. */
1696 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1697 struct cmd_list_element
*c
,
1700 fprintf_filtered (file
, _("The maximum length (in bytes) of a target "
1701 "hardware watchpoint is %s.\n"), value
);
1704 /* Show the number of hardware breakpoints that can be used. */
1707 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1708 struct cmd_list_element
*c
,
1711 fprintf_filtered (file
, _("The maximum number of target hardware "
1712 "breakpoints is %s.\n"), value
);
1716 remote_target::get_memory_write_packet_size ()
1718 return get_memory_packet_size (&memory_write_packet_config
);
1721 static struct memory_packet_config memory_read_packet_config
=
1723 "memory-read-packet-size",
1727 set_memory_read_packet_size (const char *args
, int from_tty
)
1729 set_memory_packet_size (args
, &memory_read_packet_config
);
1733 show_memory_read_packet_size (const char *args
, int from_tty
)
1735 show_memory_packet_size (&memory_read_packet_config
);
1739 remote_target::get_memory_read_packet_size ()
1741 long size
= get_memory_packet_size (&memory_read_packet_config
);
1743 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1744 extra buffer size argument before the memory read size can be
1745 increased beyond this. */
1746 if (size
> get_remote_packet_size ())
1747 size
= get_remote_packet_size ();
1753 struct packet_config
1758 /* If auto, GDB auto-detects support for this packet or feature,
1759 either through qSupported, or by trying the packet and looking
1760 at the response. If true, GDB assumes the target supports this
1761 packet. If false, the packet is disabled. Configs that don't
1762 have an associated command always have this set to auto. */
1763 enum auto_boolean detect
;
1765 /* Does the target support this packet? */
1766 enum packet_support support
;
1769 static enum packet_support
packet_config_support (struct packet_config
*config
);
1770 static enum packet_support
packet_support (int packet
);
1773 show_packet_config_cmd (struct packet_config
*config
)
1775 const char *support
= "internal-error";
1777 switch (packet_config_support (config
))
1780 support
= "enabled";
1782 case PACKET_DISABLE
:
1783 support
= "disabled";
1785 case PACKET_SUPPORT_UNKNOWN
:
1786 support
= "unknown";
1789 switch (config
->detect
)
1791 case AUTO_BOOLEAN_AUTO
:
1792 printf_filtered (_("Support for the `%s' packet "
1793 "is auto-detected, currently %s.\n"),
1794 config
->name
, support
);
1796 case AUTO_BOOLEAN_TRUE
:
1797 case AUTO_BOOLEAN_FALSE
:
1798 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1799 config
->name
, support
);
1805 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1806 const char *title
, int legacy
)
1812 config
->name
= name
;
1813 config
->title
= title
;
1814 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1816 show_doc
= xstrprintf ("Show current use of remote "
1817 "protocol `%s' (%s) packet.",
1819 /* set/show TITLE-packet {auto,on,off} */
1820 cmd_name
= xstrprintf ("%s-packet", title
);
1821 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1822 &config
->detect
, set_doc
,
1823 show_doc
, NULL
, /* help_doc */
1825 show_remote_protocol_packet_cmd
,
1826 &remote_set_cmdlist
, &remote_show_cmdlist
);
1827 /* The command code copies the documentation strings. */
1830 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1835 legacy_name
= xstrprintf ("%s-packet", name
);
1836 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1837 &remote_set_cmdlist
);
1838 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1839 &remote_show_cmdlist
);
1843 static enum packet_result
1844 packet_check_result (const char *buf
)
1848 /* The stub recognized the packet request. Check that the
1849 operation succeeded. */
1851 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1853 /* "Enn" - definitely an error. */
1854 return PACKET_ERROR
;
1856 /* Always treat "E." as an error. This will be used for
1857 more verbose error messages, such as E.memtypes. */
1858 if (buf
[0] == 'E' && buf
[1] == '.')
1859 return PACKET_ERROR
;
1861 /* The packet may or may not be OK. Just assume it is. */
1865 /* The stub does not support the packet. */
1866 return PACKET_UNKNOWN
;
1869 static enum packet_result
1870 packet_check_result (const gdb::char_vector
&buf
)
1872 return packet_check_result (buf
.data ());
1875 static enum packet_result
1876 packet_ok (const char *buf
, struct packet_config
*config
)
1878 enum packet_result result
;
1880 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1881 && config
->support
== PACKET_DISABLE
)
1882 internal_error (__FILE__
, __LINE__
,
1883 _("packet_ok: attempt to use a disabled packet"));
1885 result
= packet_check_result (buf
);
1890 /* The stub recognized the packet request. */
1891 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1894 fprintf_unfiltered (gdb_stdlog
,
1895 "Packet %s (%s) is supported\n",
1896 config
->name
, config
->title
);
1897 config
->support
= PACKET_ENABLE
;
1900 case PACKET_UNKNOWN
:
1901 /* The stub does not support the packet. */
1902 if (config
->detect
== AUTO_BOOLEAN_AUTO
1903 && config
->support
== PACKET_ENABLE
)
1905 /* If the stub previously indicated that the packet was
1906 supported then there is a protocol error. */
1907 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1908 config
->name
, config
->title
);
1910 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
1912 /* The user set it wrong. */
1913 error (_("Enabled packet %s (%s) not recognized by stub"),
1914 config
->name
, config
->title
);
1918 fprintf_unfiltered (gdb_stdlog
,
1919 "Packet %s (%s) is NOT supported\n",
1920 config
->name
, config
->title
);
1921 config
->support
= PACKET_DISABLE
;
1928 static enum packet_result
1929 packet_ok (const gdb::char_vector
&buf
, struct packet_config
*config
)
1931 return packet_ok (buf
.data (), config
);
1948 PACKET_vFile_pwrite
,
1950 PACKET_vFile_unlink
,
1951 PACKET_vFile_readlink
,
1954 PACKET_qXfer_features
,
1955 PACKET_qXfer_exec_file
,
1956 PACKET_qXfer_libraries
,
1957 PACKET_qXfer_libraries_svr4
,
1958 PACKET_qXfer_memory_map
,
1959 PACKET_qXfer_osdata
,
1960 PACKET_qXfer_threads
,
1961 PACKET_qXfer_statictrace_read
,
1962 PACKET_qXfer_traceframe_info
,
1968 PACKET_QPassSignals
,
1969 PACKET_QCatchSyscalls
,
1970 PACKET_QProgramSignals
,
1971 PACKET_QSetWorkingDir
,
1972 PACKET_QStartupWithShell
,
1973 PACKET_QEnvironmentHexEncoded
,
1974 PACKET_QEnvironmentReset
,
1975 PACKET_QEnvironmentUnset
,
1977 PACKET_qSearch_memory
,
1980 PACKET_QStartNoAckMode
,
1982 PACKET_qXfer_siginfo_read
,
1983 PACKET_qXfer_siginfo_write
,
1986 /* Support for conditional tracepoints. */
1987 PACKET_ConditionalTracepoints
,
1989 /* Support for target-side breakpoint conditions. */
1990 PACKET_ConditionalBreakpoints
,
1992 /* Support for target-side breakpoint commands. */
1993 PACKET_BreakpointCommands
,
1995 /* Support for fast tracepoints. */
1996 PACKET_FastTracepoints
,
1998 /* Support for static tracepoints. */
1999 PACKET_StaticTracepoints
,
2001 /* Support for installing tracepoints while a trace experiment is
2003 PACKET_InstallInTrace
,
2007 PACKET_TracepointSource
,
2010 PACKET_QDisableRandomization
,
2012 PACKET_QTBuffer_size
,
2016 PACKET_qXfer_btrace
,
2018 /* Support for the QNonStop packet. */
2021 /* Support for the QThreadEvents packet. */
2022 PACKET_QThreadEvents
,
2024 /* Support for multi-process extensions. */
2025 PACKET_multiprocess_feature
,
2027 /* Support for enabling and disabling tracepoints while a trace
2028 experiment is running. */
2029 PACKET_EnableDisableTracepoints_feature
,
2031 /* Support for collecting strings using the tracenz bytecode. */
2032 PACKET_tracenz_feature
,
2034 /* Support for continuing to run a trace experiment while GDB is
2036 PACKET_DisconnectedTracing_feature
,
2038 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2039 PACKET_augmented_libraries_svr4_read_feature
,
2041 /* Support for the qXfer:btrace-conf:read packet. */
2042 PACKET_qXfer_btrace_conf
,
2044 /* Support for the Qbtrace-conf:bts:size packet. */
2045 PACKET_Qbtrace_conf_bts_size
,
2047 /* Support for swbreak+ feature. */
2048 PACKET_swbreak_feature
,
2050 /* Support for hwbreak+ feature. */
2051 PACKET_hwbreak_feature
,
2053 /* Support for fork events. */
2054 PACKET_fork_event_feature
,
2056 /* Support for vfork events. */
2057 PACKET_vfork_event_feature
,
2059 /* Support for the Qbtrace-conf:pt:size packet. */
2060 PACKET_Qbtrace_conf_pt_size
,
2062 /* Support for exec events. */
2063 PACKET_exec_event_feature
,
2065 /* Support for query supported vCont actions. */
2066 PACKET_vContSupported
,
2068 /* Support remote CTRL-C. */
2071 /* Support TARGET_WAITKIND_NO_RESUMED. */
2077 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
2079 /* Returns the packet's corresponding "set remote foo-packet" command
2080 state. See struct packet_config for more details. */
2082 static enum auto_boolean
2083 packet_set_cmd_state (int packet
)
2085 return remote_protocol_packets
[packet
].detect
;
2088 /* Returns whether a given packet or feature is supported. This takes
2089 into account the state of the corresponding "set remote foo-packet"
2090 command, which may be used to bypass auto-detection. */
2092 static enum packet_support
2093 packet_config_support (struct packet_config
*config
)
2095 switch (config
->detect
)
2097 case AUTO_BOOLEAN_TRUE
:
2098 return PACKET_ENABLE
;
2099 case AUTO_BOOLEAN_FALSE
:
2100 return PACKET_DISABLE
;
2101 case AUTO_BOOLEAN_AUTO
:
2102 return config
->support
;
2104 gdb_assert_not_reached (_("bad switch"));
2108 /* Same as packet_config_support, but takes the packet's enum value as
2111 static enum packet_support
2112 packet_support (int packet
)
2114 struct packet_config
*config
= &remote_protocol_packets
[packet
];
2116 return packet_config_support (config
);
2120 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
2121 struct cmd_list_element
*c
,
2124 struct packet_config
*packet
;
2126 for (packet
= remote_protocol_packets
;
2127 packet
< &remote_protocol_packets
[PACKET_MAX
];
2130 if (&packet
->detect
== c
->var
)
2132 show_packet_config_cmd (packet
);
2136 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
2140 /* Should we try one of the 'Z' requests? */
2144 Z_PACKET_SOFTWARE_BP
,
2145 Z_PACKET_HARDWARE_BP
,
2152 /* For compatibility with older distributions. Provide a ``set remote
2153 Z-packet ...'' command that updates all the Z packet types. */
2155 static enum auto_boolean remote_Z_packet_detect
;
2158 set_remote_protocol_Z_packet_cmd (const char *args
, int from_tty
,
2159 struct cmd_list_element
*c
)
2163 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2164 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
2168 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
2169 struct cmd_list_element
*c
,
2174 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2176 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
2180 /* Returns true if the multi-process extensions are in effect. */
2183 remote_multi_process_p (struct remote_state
*rs
)
2185 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
2188 /* Returns true if fork events are supported. */
2191 remote_fork_event_p (struct remote_state
*rs
)
2193 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
2196 /* Returns true if vfork events are supported. */
2199 remote_vfork_event_p (struct remote_state
*rs
)
2201 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
2204 /* Returns true if exec events are supported. */
2207 remote_exec_event_p (struct remote_state
*rs
)
2209 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
2212 /* Insert fork catchpoint target routine. If fork events are enabled
2213 then return success, nothing more to do. */
2216 remote_target::insert_fork_catchpoint (int pid
)
2218 struct remote_state
*rs
= get_remote_state ();
2220 return !remote_fork_event_p (rs
);
2223 /* Remove fork catchpoint target routine. Nothing to do, just
2227 remote_target::remove_fork_catchpoint (int pid
)
2232 /* Insert vfork catchpoint target routine. If vfork events are enabled
2233 then return success, nothing more to do. */
2236 remote_target::insert_vfork_catchpoint (int pid
)
2238 struct remote_state
*rs
= get_remote_state ();
2240 return !remote_vfork_event_p (rs
);
2243 /* Remove vfork catchpoint target routine. Nothing to do, just
2247 remote_target::remove_vfork_catchpoint (int pid
)
2252 /* Insert exec catchpoint target routine. If exec events are
2253 enabled, just return success. */
2256 remote_target::insert_exec_catchpoint (int pid
)
2258 struct remote_state
*rs
= get_remote_state ();
2260 return !remote_exec_event_p (rs
);
2263 /* Remove exec catchpoint target routine. Nothing to do, just
2267 remote_target::remove_exec_catchpoint (int pid
)
2274 /* Take advantage of the fact that the TID field is not used, to tag
2275 special ptids with it set to != 0. */
2276 static const ptid_t
magic_null_ptid (42000, -1, 1);
2277 static const ptid_t
not_sent_ptid (42000, -2, 1);
2278 static const ptid_t
any_thread_ptid (42000, 0, 1);
2280 /* Find out if the stub attached to PID (and hence GDB should offer to
2281 detach instead of killing it when bailing out). */
2284 remote_target::remote_query_attached (int pid
)
2286 struct remote_state
*rs
= get_remote_state ();
2287 size_t size
= get_remote_packet_size ();
2289 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
2292 if (remote_multi_process_p (rs
))
2293 xsnprintf (rs
->buf
.data (), size
, "qAttached:%x", pid
);
2295 xsnprintf (rs
->buf
.data (), size
, "qAttached");
2298 getpkt (&rs
->buf
, 0);
2300 switch (packet_ok (rs
->buf
,
2301 &remote_protocol_packets
[PACKET_qAttached
]))
2304 if (strcmp (rs
->buf
.data (), "1") == 0)
2308 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
2310 case PACKET_UNKNOWN
:
2317 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2318 has been invented by GDB, instead of reported by the target. Since
2319 we can be connected to a remote system before before knowing about
2320 any inferior, mark the target with execution when we find the first
2321 inferior. If ATTACHED is 1, then we had just attached to this
2322 inferior. If it is 0, then we just created this inferior. If it
2323 is -1, then try querying the remote stub to find out if it had
2324 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2325 attempt to open this inferior's executable as the main executable
2326 if no main executable is open already. */
2329 remote_target::remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
2332 struct inferior
*inf
;
2334 /* Check whether this process we're learning about is to be
2335 considered attached, or if is to be considered to have been
2336 spawned by the stub. */
2338 attached
= remote_query_attached (pid
);
2340 if (gdbarch_has_global_solist (target_gdbarch ()))
2342 /* If the target shares code across all inferiors, then every
2343 attach adds a new inferior. */
2344 inf
= add_inferior (pid
);
2346 /* ... and every inferior is bound to the same program space.
2347 However, each inferior may still have its own address
2349 inf
->aspace
= maybe_new_address_space ();
2350 inf
->pspace
= current_program_space
;
2354 /* In the traditional debugging scenario, there's a 1-1 match
2355 between program/address spaces. We simply bind the inferior
2356 to the program space's address space. */
2357 inf
= current_inferior ();
2358 inferior_appeared (inf
, pid
);
2361 inf
->attach_flag
= attached
;
2362 inf
->fake_pid_p
= fake_pid_p
;
2364 /* If no main executable is currently open then attempt to
2365 open the file that was executed to create this inferior. */
2366 if (try_open_exec
&& get_exec_file (0) == NULL
)
2367 exec_file_locate_attach (pid
, 0, 1);
2372 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2373 static remote_thread_info
*get_remote_thread_info (ptid_t ptid
);
2375 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2376 according to RUNNING. */
2379 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
)
2381 struct remote_state
*rs
= get_remote_state ();
2382 struct thread_info
*thread
;
2384 /* GDB historically didn't pull threads in the initial connection
2385 setup. If the remote target doesn't even have a concept of
2386 threads (e.g., a bare-metal target), even if internally we
2387 consider that a single-threaded target, mentioning a new thread
2388 might be confusing to the user. Be silent then, preserving the
2389 age old behavior. */
2390 if (rs
->starting_up
)
2391 thread
= add_thread_silent (ptid
);
2393 thread
= add_thread (ptid
);
2395 get_remote_thread_info (thread
)->vcont_resumed
= executing
;
2396 set_executing (ptid
, executing
);
2397 set_running (ptid
, running
);
2402 /* Come here when we learn about a thread id from the remote target.
2403 It may be the first time we hear about such thread, so take the
2404 opportunity to add it to GDB's thread list. In case this is the
2405 first time we're noticing its corresponding inferior, add it to
2406 GDB's inferior list as well. EXECUTING indicates whether the
2407 thread is (internally) executing or stopped. */
2410 remote_target::remote_notice_new_inferior (ptid_t currthread
, int executing
)
2412 /* In non-stop mode, we assume new found threads are (externally)
2413 running until proven otherwise with a stop reply. In all-stop,
2414 we can only get here if all threads are stopped. */
2415 int running
= target_is_non_stop_p () ? 1 : 0;
2417 /* If this is a new thread, add it to GDB's thread list.
2418 If we leave it up to WFI to do this, bad things will happen. */
2420 thread_info
*tp
= find_thread_ptid (currthread
);
2421 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2423 /* We're seeing an event on a thread id we knew had exited.
2424 This has to be a new thread reusing the old id. Add it. */
2425 remote_add_thread (currthread
, running
, executing
);
2429 if (!in_thread_list (currthread
))
2431 struct inferior
*inf
= NULL
;
2432 int pid
= currthread
.pid ();
2434 if (inferior_ptid
.is_pid ()
2435 && pid
== inferior_ptid
.pid ())
2437 /* inferior_ptid has no thread member yet. This can happen
2438 with the vAttach -> remote_wait,"TAAthread:" path if the
2439 stub doesn't support qC. This is the first stop reported
2440 after an attach, so this is the main thread. Update the
2441 ptid in the thread list. */
2442 if (in_thread_list (ptid_t (pid
)))
2443 thread_change_ptid (inferior_ptid
, currthread
);
2446 remote_add_thread (currthread
, running
, executing
);
2447 inferior_ptid
= currthread
;
2452 if (magic_null_ptid
== inferior_ptid
)
2454 /* inferior_ptid is not set yet. This can happen with the
2455 vRun -> remote_wait,"TAAthread:" path if the stub
2456 doesn't support qC. This is the first stop reported
2457 after an attach, so this is the main thread. Update the
2458 ptid in the thread list. */
2459 thread_change_ptid (inferior_ptid
, currthread
);
2463 /* When connecting to a target remote, or to a target
2464 extended-remote which already was debugging an inferior, we
2465 may not know about it yet. Add it before adding its child
2466 thread, so notifications are emitted in a sensible order. */
2467 if (find_inferior_pid (currthread
.pid ()) == NULL
)
2469 struct remote_state
*rs
= get_remote_state ();
2470 bool fake_pid_p
= !remote_multi_process_p (rs
);
2472 inf
= remote_add_inferior (fake_pid_p
,
2473 currthread
.pid (), -1, 1);
2476 /* This is really a new thread. Add it. */
2477 thread_info
*new_thr
2478 = remote_add_thread (currthread
, running
, executing
);
2480 /* If we found a new inferior, let the common code do whatever
2481 it needs to with it (e.g., read shared libraries, insert
2482 breakpoints), unless we're just setting up an all-stop
2486 struct remote_state
*rs
= get_remote_state ();
2488 if (!rs
->starting_up
)
2489 notice_new_inferior (new_thr
, executing
, 0);
2494 /* Return THREAD's private thread data, creating it if necessary. */
2496 static remote_thread_info
*
2497 get_remote_thread_info (thread_info
*thread
)
2499 gdb_assert (thread
!= NULL
);
2501 if (thread
->priv
== NULL
)
2502 thread
->priv
.reset (new remote_thread_info
);
2504 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2507 static remote_thread_info
*
2508 get_remote_thread_info (ptid_t ptid
)
2510 thread_info
*thr
= find_thread_ptid (ptid
);
2511 return get_remote_thread_info (thr
);
2514 /* Call this function as a result of
2515 1) A halt indication (T packet) containing a thread id
2516 2) A direct query of currthread
2517 3) Successful execution of set thread */
2520 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2522 rs
->general_thread
= currthread
;
2525 /* If 'QPassSignals' is supported, tell the remote stub what signals
2526 it can simply pass through to the inferior without reporting. */
2529 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2531 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2533 char *pass_packet
, *p
;
2535 struct remote_state
*rs
= get_remote_state ();
2537 gdb_assert (pass_signals
.size () < 256);
2538 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2540 if (pass_signals
[i
])
2543 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2544 strcpy (pass_packet
, "QPassSignals:");
2545 p
= pass_packet
+ strlen (pass_packet
);
2546 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2548 if (pass_signals
[i
])
2551 *p
++ = tohex (i
>> 4);
2552 *p
++ = tohex (i
& 15);
2561 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2563 putpkt (pass_packet
);
2564 getpkt (&rs
->buf
, 0);
2565 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2566 if (rs
->last_pass_packet
)
2567 xfree (rs
->last_pass_packet
);
2568 rs
->last_pass_packet
= pass_packet
;
2571 xfree (pass_packet
);
2575 /* If 'QCatchSyscalls' is supported, tell the remote stub
2576 to report syscalls to GDB. */
2579 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2580 gdb::array_view
<const int> syscall_counts
)
2582 const char *catch_packet
;
2583 enum packet_result result
;
2586 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2588 /* Not supported. */
2592 if (needed
&& any_count
== 0)
2594 /* Count how many syscalls are to be caught. */
2595 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2597 if (syscall_counts
[i
] != 0)
2604 fprintf_unfiltered (gdb_stdlog
,
2605 "remote_set_syscall_catchpoint "
2606 "pid %d needed %d any_count %d n_sysno %d\n",
2607 pid
, needed
, any_count
, n_sysno
);
2610 std::string built_packet
;
2613 /* Prepare a packet with the sysno list, assuming max 8+1
2614 characters for a sysno. If the resulting packet size is too
2615 big, fallback on the non-selective packet. */
2616 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2617 built_packet
.reserve (maxpktsz
);
2618 built_packet
= "QCatchSyscalls:1";
2621 /* Add in each syscall to be caught. */
2622 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2624 if (syscall_counts
[i
] != 0)
2625 string_appendf (built_packet
, ";%zx", i
);
2628 if (built_packet
.size () > get_remote_packet_size ())
2630 /* catch_packet too big. Fallback to less efficient
2631 non selective mode, with GDB doing the filtering. */
2632 catch_packet
= "QCatchSyscalls:1";
2635 catch_packet
= built_packet
.c_str ();
2638 catch_packet
= "QCatchSyscalls:0";
2640 struct remote_state
*rs
= get_remote_state ();
2642 putpkt (catch_packet
);
2643 getpkt (&rs
->buf
, 0);
2644 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2645 if (result
== PACKET_OK
)
2651 /* If 'QProgramSignals' is supported, tell the remote stub what
2652 signals it should pass through to the inferior when detaching. */
2655 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2657 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2661 struct remote_state
*rs
= get_remote_state ();
2663 gdb_assert (signals
.size () < 256);
2664 for (size_t i
= 0; i
< signals
.size (); i
++)
2669 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2670 strcpy (packet
, "QProgramSignals:");
2671 p
= packet
+ strlen (packet
);
2672 for (size_t i
= 0; i
< signals
.size (); i
++)
2674 if (signal_pass_state (i
))
2677 *p
++ = tohex (i
>> 4);
2678 *p
++ = tohex (i
& 15);
2687 if (!rs
->last_program_signals_packet
2688 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2691 getpkt (&rs
->buf
, 0);
2692 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2693 xfree (rs
->last_program_signals_packet
);
2694 rs
->last_program_signals_packet
= packet
;
2701 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2702 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2703 thread. If GEN is set, set the general thread, if not, then set
2704 the step/continue thread. */
2706 remote_target::set_thread (ptid_t ptid
, int gen
)
2708 struct remote_state
*rs
= get_remote_state ();
2709 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2710 char *buf
= rs
->buf
.data ();
2711 char *endbuf
= buf
+ get_remote_packet_size ();
2717 *buf
++ = gen
? 'g' : 'c';
2718 if (ptid
== magic_null_ptid
)
2719 xsnprintf (buf
, endbuf
- buf
, "0");
2720 else if (ptid
== any_thread_ptid
)
2721 xsnprintf (buf
, endbuf
- buf
, "0");
2722 else if (ptid
== minus_one_ptid
)
2723 xsnprintf (buf
, endbuf
- buf
, "-1");
2725 write_ptid (buf
, endbuf
, ptid
);
2727 getpkt (&rs
->buf
, 0);
2729 rs
->general_thread
= ptid
;
2731 rs
->continue_thread
= ptid
;
2735 remote_target::set_general_thread (ptid_t ptid
)
2737 set_thread (ptid
, 1);
2741 remote_target::set_continue_thread (ptid_t ptid
)
2743 set_thread (ptid
, 0);
2746 /* Change the remote current process. Which thread within the process
2747 ends up selected isn't important, as long as it is the same process
2748 as what INFERIOR_PTID points to.
2750 This comes from that fact that there is no explicit notion of
2751 "selected process" in the protocol. The selected process for
2752 general operations is the process the selected general thread
2756 remote_target::set_general_process ()
2758 struct remote_state
*rs
= get_remote_state ();
2760 /* If the remote can't handle multiple processes, don't bother. */
2761 if (!remote_multi_process_p (rs
))
2764 /* We only need to change the remote current thread if it's pointing
2765 at some other process. */
2766 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2767 set_general_thread (inferior_ptid
);
2771 /* Return nonzero if this is the main thread that we made up ourselves
2772 to model non-threaded targets as single-threaded. */
2775 remote_thread_always_alive (ptid_t ptid
)
2777 if (ptid
== magic_null_ptid
)
2778 /* The main thread is always alive. */
2781 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2782 /* The main thread is always alive. This can happen after a
2783 vAttach, if the remote side doesn't support
2790 /* Return nonzero if the thread PTID is still alive on the remote
2794 remote_target::thread_alive (ptid_t ptid
)
2796 struct remote_state
*rs
= get_remote_state ();
2799 /* Check if this is a thread that we made up ourselves to model
2800 non-threaded targets as single-threaded. */
2801 if (remote_thread_always_alive (ptid
))
2804 p
= rs
->buf
.data ();
2805 endp
= p
+ get_remote_packet_size ();
2808 write_ptid (p
, endp
, ptid
);
2811 getpkt (&rs
->buf
, 0);
2812 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2815 /* Return a pointer to a thread name if we know it and NULL otherwise.
2816 The thread_info object owns the memory for the name. */
2819 remote_target::thread_name (struct thread_info
*info
)
2821 if (info
->priv
!= NULL
)
2823 const std::string
&name
= get_remote_thread_info (info
)->name
;
2824 return !name
.empty () ? name
.c_str () : NULL
;
2830 /* About these extended threadlist and threadinfo packets. They are
2831 variable length packets but, the fields within them are often fixed
2832 length. They are redundant enough to send over UDP as is the
2833 remote protocol in general. There is a matching unit test module
2836 /* WARNING: This threadref data structure comes from the remote O.S.,
2837 libstub protocol encoding, and remote.c. It is not particularly
2840 /* Right now, the internal structure is int. We want it to be bigger.
2841 Plan to fix this. */
2843 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2845 /* gdb_ext_thread_info is an internal GDB data structure which is
2846 equivalent to the reply of the remote threadinfo packet. */
2848 struct gdb_ext_thread_info
2850 threadref threadid
; /* External form of thread reference. */
2851 int active
; /* Has state interesting to GDB?
2853 char display
[256]; /* Brief state display, name,
2854 blocked/suspended. */
2855 char shortname
[32]; /* To be used to name threads. */
2856 char more_display
[256]; /* Long info, statistics, queue depth,
2860 /* The volume of remote transfers can be limited by submitting
2861 a mask containing bits specifying the desired information.
2862 Use a union of these values as the 'selection' parameter to
2863 get_thread_info. FIXME: Make these TAG names more thread specific. */
2865 #define TAG_THREADID 1
2866 #define TAG_EXISTS 2
2867 #define TAG_DISPLAY 4
2868 #define TAG_THREADNAME 8
2869 #define TAG_MOREDISPLAY 16
2871 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2873 static char *unpack_nibble (char *buf
, int *val
);
2875 static char *unpack_byte (char *buf
, int *value
);
2877 static char *pack_int (char *buf
, int value
);
2879 static char *unpack_int (char *buf
, int *value
);
2881 static char *unpack_string (char *src
, char *dest
, int length
);
2883 static char *pack_threadid (char *pkt
, threadref
*id
);
2885 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2887 void int_to_threadref (threadref
*id
, int value
);
2889 static int threadref_to_int (threadref
*ref
);
2891 static void copy_threadref (threadref
*dest
, threadref
*src
);
2893 static int threadmatch (threadref
*dest
, threadref
*src
);
2895 static char *pack_threadinfo_request (char *pkt
, int mode
,
2898 static char *pack_threadlist_request (char *pkt
, int startflag
,
2900 threadref
*nextthread
);
2902 static int remote_newthread_step (threadref
*ref
, void *context
);
2905 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2906 buffer we're allowed to write to. Returns
2907 BUF+CHARACTERS_WRITTEN. */
2910 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2913 struct remote_state
*rs
= get_remote_state ();
2915 if (remote_multi_process_p (rs
))
2919 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2921 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2925 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2927 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2932 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2933 last parsed char. Returns null_ptid if no thread id is found, and
2934 throws an error if the thread id has an invalid format. */
2937 read_ptid (const char *buf
, const char **obuf
)
2939 const char *p
= buf
;
2941 ULONGEST pid
= 0, tid
= 0;
2945 /* Multi-process ptid. */
2946 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2948 error (_("invalid remote ptid: %s"), p
);
2951 pp
= unpack_varlen_hex (p
+ 1, &tid
);
2954 return ptid_t (pid
, tid
, 0);
2957 /* No multi-process. Just a tid. */
2958 pp
= unpack_varlen_hex (p
, &tid
);
2960 /* Return null_ptid when no thread id is found. */
2968 /* Since the stub is not sending a process id, then default to
2969 what's in inferior_ptid, unless it's null at this point. If so,
2970 then since there's no way to know the pid of the reported
2971 threads, use the magic number. */
2972 if (inferior_ptid
== null_ptid
)
2973 pid
= magic_null_ptid
.pid ();
2975 pid
= inferior_ptid
.pid ();
2979 return ptid_t (pid
, tid
, 0);
2985 if (ch
>= 'a' && ch
<= 'f')
2986 return ch
- 'a' + 10;
2987 if (ch
>= '0' && ch
<= '9')
2989 if (ch
>= 'A' && ch
<= 'F')
2990 return ch
- 'A' + 10;
2995 stub_unpack_int (char *buff
, int fieldlength
)
3002 nibble
= stubhex (*buff
++);
3006 retval
= retval
<< 4;
3012 unpack_nibble (char *buf
, int *val
)
3014 *val
= fromhex (*buf
++);
3019 unpack_byte (char *buf
, int *value
)
3021 *value
= stub_unpack_int (buf
, 2);
3026 pack_int (char *buf
, int value
)
3028 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3029 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3030 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3031 buf
= pack_hex_byte (buf
, (value
& 0xff));
3036 unpack_int (char *buf
, int *value
)
3038 *value
= stub_unpack_int (buf
, 8);
3042 #if 0 /* Currently unused, uncomment when needed. */
3043 static char *pack_string (char *pkt
, char *string
);
3046 pack_string (char *pkt
, char *string
)
3051 len
= strlen (string
);
3053 len
= 200; /* Bigger than most GDB packets, junk??? */
3054 pkt
= pack_hex_byte (pkt
, len
);
3058 if ((ch
== '\0') || (ch
== '#'))
3059 ch
= '*'; /* Protect encapsulation. */
3064 #endif /* 0 (unused) */
3067 unpack_string (char *src
, char *dest
, int length
)
3076 pack_threadid (char *pkt
, threadref
*id
)
3079 unsigned char *altid
;
3081 altid
= (unsigned char *) id
;
3082 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3084 pkt
= pack_hex_byte (pkt
, *altid
++);
3090 unpack_threadid (char *inbuf
, threadref
*id
)
3093 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3096 altref
= (char *) id
;
3098 while (inbuf
< limit
)
3100 x
= stubhex (*inbuf
++);
3101 y
= stubhex (*inbuf
++);
3102 *altref
++ = (x
<< 4) | y
;
3107 /* Externally, threadrefs are 64 bits but internally, they are still
3108 ints. This is due to a mismatch of specifications. We would like
3109 to use 64bit thread references internally. This is an adapter
3113 int_to_threadref (threadref
*id
, int value
)
3115 unsigned char *scan
;
3117 scan
= (unsigned char *) id
;
3123 *scan
++ = (value
>> 24) & 0xff;
3124 *scan
++ = (value
>> 16) & 0xff;
3125 *scan
++ = (value
>> 8) & 0xff;
3126 *scan
++ = (value
& 0xff);
3130 threadref_to_int (threadref
*ref
)
3133 unsigned char *scan
;
3139 value
= (value
<< 8) | ((*scan
++) & 0xff);
3144 copy_threadref (threadref
*dest
, threadref
*src
)
3147 unsigned char *csrc
, *cdest
;
3149 csrc
= (unsigned char *) src
;
3150 cdest
= (unsigned char *) dest
;
3157 threadmatch (threadref
*dest
, threadref
*src
)
3159 /* Things are broken right now, so just assume we got a match. */
3161 unsigned char *srcp
, *destp
;
3163 srcp
= (char *) src
;
3164 destp
= (char *) dest
;
3168 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3175 threadid:1, # always request threadid
3182 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3185 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3187 *pkt
++ = 'q'; /* Info Query */
3188 *pkt
++ = 'P'; /* process or thread info */
3189 pkt
= pack_int (pkt
, mode
); /* mode */
3190 pkt
= pack_threadid (pkt
, id
); /* threadid */
3191 *pkt
= '\0'; /* terminate */
3195 /* These values tag the fields in a thread info response packet. */
3196 /* Tagging the fields allows us to request specific fields and to
3197 add more fields as time goes by. */
3199 #define TAG_THREADID 1 /* Echo the thread identifier. */
3200 #define TAG_EXISTS 2 /* Is this process defined enough to
3201 fetch registers and its stack? */
3202 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3203 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3204 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3208 remote_target::remote_unpack_thread_info_response (char *pkt
,
3209 threadref
*expectedref
,
3210 gdb_ext_thread_info
*info
)
3212 struct remote_state
*rs
= get_remote_state ();
3216 char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3219 /* info->threadid = 0; FIXME: implement zero_threadref. */
3221 info
->display
[0] = '\0';
3222 info
->shortname
[0] = '\0';
3223 info
->more_display
[0] = '\0';
3225 /* Assume the characters indicating the packet type have been
3227 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3228 pkt
= unpack_threadid (pkt
, &ref
);
3231 warning (_("Incomplete response to threadinfo request."));
3232 if (!threadmatch (&ref
, expectedref
))
3233 { /* This is an answer to a different request. */
3234 warning (_("ERROR RMT Thread info mismatch."));
3237 copy_threadref (&info
->threadid
, &ref
);
3239 /* Loop on tagged fields , try to bail if something goes wrong. */
3241 /* Packets are terminated with nulls. */
3242 while ((pkt
< limit
) && mask
&& *pkt
)
3244 pkt
= unpack_int (pkt
, &tag
); /* tag */
3245 pkt
= unpack_byte (pkt
, &length
); /* length */
3246 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3248 warning (_("ERROR RMT: threadinfo tag mismatch."));
3252 if (tag
== TAG_THREADID
)
3256 warning (_("ERROR RMT: length of threadid is not 16."));
3260 pkt
= unpack_threadid (pkt
, &ref
);
3261 mask
= mask
& ~TAG_THREADID
;
3264 if (tag
== TAG_EXISTS
)
3266 info
->active
= stub_unpack_int (pkt
, length
);
3268 mask
= mask
& ~(TAG_EXISTS
);
3271 warning (_("ERROR RMT: 'exists' length too long."));
3277 if (tag
== TAG_THREADNAME
)
3279 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3280 mask
= mask
& ~TAG_THREADNAME
;
3283 if (tag
== TAG_DISPLAY
)
3285 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3286 mask
= mask
& ~TAG_DISPLAY
;
3289 if (tag
== TAG_MOREDISPLAY
)
3291 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3292 mask
= mask
& ~TAG_MOREDISPLAY
;
3295 warning (_("ERROR RMT: unknown thread info tag."));
3296 break; /* Not a tag we know about. */
3302 remote_target::remote_get_threadinfo (threadref
*threadid
,
3304 gdb_ext_thread_info
*info
)
3306 struct remote_state
*rs
= get_remote_state ();
3309 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3311 getpkt (&rs
->buf
, 0);
3313 if (rs
->buf
[0] == '\0')
3316 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3321 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3324 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3325 threadref
*nextthread
)
3327 *pkt
++ = 'q'; /* info query packet */
3328 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3329 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3330 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3331 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3336 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3339 remote_target::parse_threadlist_response (char *pkt
, int result_limit
,
3340 threadref
*original_echo
,
3341 threadref
*resultlist
,
3344 struct remote_state
*rs
= get_remote_state ();
3346 int count
, resultcount
, done
;
3349 /* Assume the 'q' and 'M chars have been stripped. */
3350 limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3351 /* done parse past here */
3352 pkt
= unpack_byte (pkt
, &count
); /* count field */
3353 pkt
= unpack_nibble (pkt
, &done
);
3354 /* The first threadid is the argument threadid. */
3355 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3356 while ((count
-- > 0) && (pkt
< limit
))
3358 pkt
= unpack_threadid (pkt
, resultlist
++);
3359 if (resultcount
++ >= result_limit
)
3367 /* Fetch the next batch of threads from the remote. Returns -1 if the
3368 qL packet is not supported, 0 on error and 1 on success. */
3371 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3372 int result_limit
, int *done
, int *result_count
,
3373 threadref
*threadlist
)
3375 struct remote_state
*rs
= get_remote_state ();
3378 /* Truncate result limit to be smaller than the packet size. */
3379 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3380 >= get_remote_packet_size ())
3381 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3383 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3386 getpkt (&rs
->buf
, 0);
3387 if (rs
->buf
[0] == '\0')
3389 /* Packet not supported. */
3394 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3395 &rs
->echo_nextthread
, threadlist
, done
);
3397 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3399 /* FIXME: This is a good reason to drop the packet. */
3400 /* Possibly, there is a duplicate response. */
3402 retransmit immediatly - race conditions
3403 retransmit after timeout - yes
3405 wait for packet, then exit
3407 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3408 return 0; /* I choose simply exiting. */
3410 if (*result_count
<= 0)
3414 warning (_("RMT ERROR : failed to get remote thread list."));
3417 return result
; /* break; */
3419 if (*result_count
> result_limit
)
3422 warning (_("RMT ERROR: threadlist response longer than requested."));
3428 /* Fetch the list of remote threads, with the qL packet, and call
3429 STEPFUNCTION for each thread found. Stops iterating and returns 1
3430 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3431 STEPFUNCTION returns false. If the packet is not supported,
3435 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3436 void *context
, int looplimit
)
3438 struct remote_state
*rs
= get_remote_state ();
3439 int done
, i
, result_count
;
3447 if (loopcount
++ > looplimit
)
3450 warning (_("Remote fetch threadlist -infinite loop-."));
3453 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3454 MAXTHREADLISTRESULTS
,
3455 &done
, &result_count
,
3456 rs
->resultthreadlist
);
3459 /* Clear for later iterations. */
3461 /* Setup to resume next batch of thread references, set nextthread. */
3462 if (result_count
>= 1)
3463 copy_threadref (&rs
->nextthread
,
3464 &rs
->resultthreadlist
[result_count
- 1]);
3466 while (result_count
--)
3468 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3478 /* A thread found on the remote target. */
3482 explicit thread_item (ptid_t ptid_
)
3486 thread_item (thread_item
&&other
) = default;
3487 thread_item
&operator= (thread_item
&&other
) = default;
3489 DISABLE_COPY_AND_ASSIGN (thread_item
);
3491 /* The thread's PTID. */
3494 /* The thread's extra info. */
3497 /* The thread's name. */
3500 /* The core the thread was running on. -1 if not known. */
3503 /* The thread handle associated with the thread. */
3504 gdb::byte_vector thread_handle
;
3507 /* Context passed around to the various methods listing remote
3508 threads. As new threads are found, they're added to the ITEMS
3511 struct threads_listing_context
3513 /* Return true if this object contains an entry for a thread with ptid
3516 bool contains_thread (ptid_t ptid
) const
3518 auto match_ptid
= [&] (const thread_item
&item
)
3520 return item
.ptid
== ptid
;
3523 auto it
= std::find_if (this->items
.begin (),
3527 return it
!= this->items
.end ();
3530 /* Remove the thread with ptid PTID. */
3532 void remove_thread (ptid_t ptid
)
3534 auto match_ptid
= [&] (const thread_item
&item
)
3536 return item
.ptid
== ptid
;
3539 auto it
= std::remove_if (this->items
.begin (),
3543 if (it
!= this->items
.end ())
3544 this->items
.erase (it
);
3547 /* The threads found on the remote target. */
3548 std::vector
<thread_item
> items
;
3552 remote_newthread_step (threadref
*ref
, void *data
)
3554 struct threads_listing_context
*context
3555 = (struct threads_listing_context
*) data
;
3556 int pid
= inferior_ptid
.pid ();
3557 int lwp
= threadref_to_int (ref
);
3558 ptid_t
ptid (pid
, lwp
);
3560 context
->items
.emplace_back (ptid
);
3562 return 1; /* continue iterator */
3565 #define CRAZY_MAX_THREADS 1000
3568 remote_target::remote_current_thread (ptid_t oldpid
)
3570 struct remote_state
*rs
= get_remote_state ();
3573 getpkt (&rs
->buf
, 0);
3574 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3579 result
= read_ptid (&rs
->buf
[2], &obuf
);
3580 if (*obuf
!= '\0' && remote_debug
)
3581 fprintf_unfiltered (gdb_stdlog
,
3582 "warning: garbage in qC reply\n");
3590 /* List remote threads using the deprecated qL packet. */
3593 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3595 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3596 CRAZY_MAX_THREADS
) >= 0)
3602 #if defined(HAVE_LIBEXPAT)
3605 start_thread (struct gdb_xml_parser
*parser
,
3606 const struct gdb_xml_element
*element
,
3608 std::vector
<gdb_xml_value
> &attributes
)
3610 struct threads_listing_context
*data
3611 = (struct threads_listing_context
*) user_data
;
3612 struct gdb_xml_value
*attr
;
3614 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3615 ptid_t ptid
= read_ptid (id
, NULL
);
3617 data
->items
.emplace_back (ptid
);
3618 thread_item
&item
= data
->items
.back ();
3620 attr
= xml_find_attribute (attributes
, "core");
3622 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3624 attr
= xml_find_attribute (attributes
, "name");
3626 item
.name
= (const char *) attr
->value
.get ();
3628 attr
= xml_find_attribute (attributes
, "handle");
3630 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3634 end_thread (struct gdb_xml_parser
*parser
,
3635 const struct gdb_xml_element
*element
,
3636 void *user_data
, const char *body_text
)
3638 struct threads_listing_context
*data
3639 = (struct threads_listing_context
*) user_data
;
3641 if (body_text
!= NULL
&& *body_text
!= '\0')
3642 data
->items
.back ().extra
= body_text
;
3645 const struct gdb_xml_attribute thread_attributes
[] = {
3646 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3647 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3648 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3649 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3650 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3653 const struct gdb_xml_element thread_children
[] = {
3654 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3657 const struct gdb_xml_element threads_children
[] = {
3658 { "thread", thread_attributes
, thread_children
,
3659 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3660 start_thread
, end_thread
},
3661 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3664 const struct gdb_xml_element threads_elements
[] = {
3665 { "threads", NULL
, threads_children
,
3666 GDB_XML_EF_NONE
, NULL
, NULL
},
3667 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3672 /* List remote threads using qXfer:threads:read. */
3675 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3677 #if defined(HAVE_LIBEXPAT)
3678 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3680 gdb::optional
<gdb::char_vector
> xml
3681 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3683 if (xml
&& (*xml
)[0] != '\0')
3685 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3686 threads_elements
, xml
->data (), context
);
3696 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3699 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3701 struct remote_state
*rs
= get_remote_state ();
3703 if (rs
->use_threadinfo_query
)
3707 putpkt ("qfThreadInfo");
3708 getpkt (&rs
->buf
, 0);
3709 bufp
= rs
->buf
.data ();
3710 if (bufp
[0] != '\0') /* q packet recognized */
3712 while (*bufp
++ == 'm') /* reply contains one or more TID */
3716 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3717 context
->items
.emplace_back (ptid
);
3719 while (*bufp
++ == ','); /* comma-separated list */
3720 putpkt ("qsThreadInfo");
3721 getpkt (&rs
->buf
, 0);
3722 bufp
= rs
->buf
.data ();
3728 /* Packet not recognized. */
3729 rs
->use_threadinfo_query
= 0;
3736 /* Implement the to_update_thread_list function for the remote
3740 remote_target::update_thread_list ()
3742 struct threads_listing_context context
;
3745 /* We have a few different mechanisms to fetch the thread list. Try
3746 them all, starting with the most preferred one first, falling
3747 back to older methods. */
3748 if (remote_get_threads_with_qxfer (&context
)
3749 || remote_get_threads_with_qthreadinfo (&context
)
3750 || remote_get_threads_with_ql (&context
))
3754 if (context
.items
.empty ()
3755 && remote_thread_always_alive (inferior_ptid
))
3757 /* Some targets don't really support threads, but still
3758 reply an (empty) thread list in response to the thread
3759 listing packets, instead of replying "packet not
3760 supported". Exit early so we don't delete the main
3765 /* CONTEXT now holds the current thread list on the remote
3766 target end. Delete GDB-side threads no longer found on the
3768 for (thread_info
*tp
: all_threads_safe ())
3770 if (!context
.contains_thread (tp
->ptid
))
3777 /* Remove any unreported fork child threads from CONTEXT so
3778 that we don't interfere with follow fork, which is where
3779 creation of such threads is handled. */
3780 remove_new_fork_children (&context
);
3782 /* And now add threads we don't know about yet to our list. */
3783 for (thread_item
&item
: context
.items
)
3785 if (item
.ptid
!= null_ptid
)
3787 /* In non-stop mode, we assume new found threads are
3788 executing until proven otherwise with a stop reply.
3789 In all-stop, we can only get here if all threads are
3791 int executing
= target_is_non_stop_p () ? 1 : 0;
3793 remote_notice_new_inferior (item
.ptid
, executing
);
3795 thread_info
*tp
= find_thread_ptid (item
.ptid
);
3796 remote_thread_info
*info
= get_remote_thread_info (tp
);
3797 info
->core
= item
.core
;
3798 info
->extra
= std::move (item
.extra
);
3799 info
->name
= std::move (item
.name
);
3800 info
->thread_handle
= std::move (item
.thread_handle
);
3807 /* If no thread listing method is supported, then query whether
3808 each known thread is alive, one by one, with the T packet.
3809 If the target doesn't support threads at all, then this is a
3810 no-op. See remote_thread_alive. */
3816 * Collect a descriptive string about the given thread.
3817 * The target may say anything it wants to about the thread
3818 * (typically info about its blocked / runnable state, name, etc.).
3819 * This string will appear in the info threads display.
3821 * Optional: targets are not required to implement this function.
3825 remote_target::extra_thread_info (thread_info
*tp
)
3827 struct remote_state
*rs
= get_remote_state ();
3830 struct gdb_ext_thread_info threadinfo
;
3832 if (rs
->remote_desc
== 0) /* paranoia */
3833 internal_error (__FILE__
, __LINE__
,
3834 _("remote_threads_extra_info"));
3836 if (tp
->ptid
== magic_null_ptid
3837 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
3838 /* This is the main thread which was added by GDB. The remote
3839 server doesn't know about it. */
3842 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
3844 /* If already have cached info, use it. */
3845 if (!extra
.empty ())
3846 return extra
.c_str ();
3848 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3850 /* If we're using qXfer:threads:read, then the extra info is
3851 included in the XML. So if we didn't have anything cached,
3852 it's because there's really no extra info. */
3856 if (rs
->use_threadextra_query
)
3858 char *b
= rs
->buf
.data ();
3859 char *endb
= b
+ get_remote_packet_size ();
3861 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3863 write_ptid (b
, endb
, tp
->ptid
);
3866 getpkt (&rs
->buf
, 0);
3867 if (rs
->buf
[0] != 0)
3869 extra
.resize (strlen (rs
->buf
.data ()) / 2);
3870 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
3871 return extra
.c_str ();
3875 /* If the above query fails, fall back to the old method. */
3876 rs
->use_threadextra_query
= 0;
3877 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3878 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3879 int_to_threadref (&id
, tp
->ptid
.lwp ());
3880 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3881 if (threadinfo
.active
)
3883 if (*threadinfo
.shortname
)
3884 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
3885 if (*threadinfo
.display
)
3887 if (!extra
.empty ())
3889 string_appendf (extra
, " State: %s", threadinfo
.display
);
3891 if (*threadinfo
.more_display
)
3893 if (!extra
.empty ())
3895 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
3897 return extra
.c_str ();
3904 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
3905 struct static_tracepoint_marker
*marker
)
3907 struct remote_state
*rs
= get_remote_state ();
3908 char *p
= rs
->buf
.data ();
3910 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3912 p
+= hexnumstr (p
, addr
);
3914 getpkt (&rs
->buf
, 0);
3915 p
= rs
->buf
.data ();
3918 error (_("Remote failure reply: %s"), p
);
3922 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
3929 std::vector
<static_tracepoint_marker
>
3930 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
3932 struct remote_state
*rs
= get_remote_state ();
3933 std::vector
<static_tracepoint_marker
> markers
;
3935 static_tracepoint_marker marker
;
3937 /* Ask for a first packet of static tracepoint marker
3940 getpkt (&rs
->buf
, 0);
3941 p
= rs
->buf
.data ();
3943 error (_("Remote failure reply: %s"), p
);
3949 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
3951 if (strid
== NULL
|| marker
.str_id
== strid
)
3952 markers
.push_back (std::move (marker
));
3954 while (*p
++ == ','); /* comma-separated list */
3955 /* Ask for another packet of static tracepoint definition. */
3957 getpkt (&rs
->buf
, 0);
3958 p
= rs
->buf
.data ();
3965 /* Implement the to_get_ada_task_ptid function for the remote targets. */
3968 remote_target::get_ada_task_ptid (long lwp
, long thread
)
3970 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3974 /* Restart the remote side; this is an extended protocol operation. */
3977 remote_target::extended_remote_restart ()
3979 struct remote_state
*rs
= get_remote_state ();
3981 /* Send the restart command; for reasons I don't understand the
3982 remote side really expects a number after the "R". */
3983 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
3986 remote_fileio_reset ();
3989 /* Clean up connection to a remote debugger. */
3992 remote_target::close ()
3994 /* Make sure we leave stdin registered in the event loop. */
3997 /* We don't have a connection to the remote stub anymore. Get rid
3998 of all the inferiors and their threads we were controlling.
3999 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
4000 will be unable to find the thread corresponding to (pid, 0, 0). */
4001 inferior_ptid
= null_ptid
;
4002 discard_all_inferiors ();
4004 trace_reset_local_state ();
4009 remote_target::~remote_target ()
4011 struct remote_state
*rs
= get_remote_state ();
4013 /* Check for NULL because we may get here with a partially
4014 constructed target/connection. */
4015 if (rs
->remote_desc
== nullptr)
4018 serial_close (rs
->remote_desc
);
4020 /* We are destroying the remote target, so we should discard
4021 everything of this target. */
4022 discard_pending_stop_replies_in_queue ();
4024 if (rs
->remote_async_inferior_event_token
)
4025 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4027 delete rs
->notif_state
;
4030 /* Query the remote side for the text, data and bss offsets. */
4033 remote_target::get_offsets ()
4035 struct remote_state
*rs
= get_remote_state ();
4038 int lose
, num_segments
= 0, do_sections
, do_segments
;
4039 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4040 struct section_offsets
*offs
;
4041 struct symfile_segment_data
*data
;
4043 if (symfile_objfile
== NULL
)
4046 putpkt ("qOffsets");
4047 getpkt (&rs
->buf
, 0);
4048 buf
= rs
->buf
.data ();
4050 if (buf
[0] == '\000')
4051 return; /* Return silently. Stub doesn't support
4055 warning (_("Remote failure reply: %s"), buf
);
4059 /* Pick up each field in turn. This used to be done with scanf, but
4060 scanf will make trouble if CORE_ADDR size doesn't match
4061 conversion directives correctly. The following code will work
4062 with any size of CORE_ADDR. */
4063 text_addr
= data_addr
= bss_addr
= 0;
4067 if (startswith (ptr
, "Text="))
4070 /* Don't use strtol, could lose on big values. */
4071 while (*ptr
&& *ptr
!= ';')
4072 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4074 if (startswith (ptr
, ";Data="))
4077 while (*ptr
&& *ptr
!= ';')
4078 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4083 if (!lose
&& startswith (ptr
, ";Bss="))
4086 while (*ptr
&& *ptr
!= ';')
4087 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4089 if (bss_addr
!= data_addr
)
4090 warning (_("Target reported unsupported offsets: %s"), buf
);
4095 else if (startswith (ptr
, "TextSeg="))
4098 /* Don't use strtol, could lose on big values. */
4099 while (*ptr
&& *ptr
!= ';')
4100 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4103 if (startswith (ptr
, ";DataSeg="))
4106 while (*ptr
&& *ptr
!= ';')
4107 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4115 error (_("Malformed response to offset query, %s"), buf
);
4116 else if (*ptr
!= '\0')
4117 warning (_("Target reported unsupported offsets: %s"), buf
);
4119 offs
= ((struct section_offsets
*)
4120 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
4121 memcpy (offs
, symfile_objfile
->section_offsets
,
4122 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
4124 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
4125 do_segments
= (data
!= NULL
);
4126 do_sections
= num_segments
== 0;
4128 if (num_segments
> 0)
4130 segments
[0] = text_addr
;
4131 segments
[1] = data_addr
;
4133 /* If we have two segments, we can still try to relocate everything
4134 by assuming that the .text and .data offsets apply to the whole
4135 text and data segments. Convert the offsets given in the packet
4136 to base addresses for symfile_map_offsets_to_segments. */
4137 else if (data
&& data
->num_segments
== 2)
4139 segments
[0] = data
->segment_bases
[0] + text_addr
;
4140 segments
[1] = data
->segment_bases
[1] + data_addr
;
4143 /* If the object file has only one segment, assume that it is text
4144 rather than data; main programs with no writable data are rare,
4145 but programs with no code are useless. Of course the code might
4146 have ended up in the data segment... to detect that we would need
4147 the permissions here. */
4148 else if (data
&& data
->num_segments
== 1)
4150 segments
[0] = data
->segment_bases
[0] + text_addr
;
4153 /* There's no way to relocate by segment. */
4159 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
4160 offs
, num_segments
, segments
);
4162 if (ret
== 0 && !do_sections
)
4163 error (_("Can not handle qOffsets TextSeg "
4164 "response with this symbol file"));
4171 free_symfile_segment_data (data
);
4175 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
4177 /* This is a temporary kludge to force data and bss to use the
4178 same offsets because that's what nlmconv does now. The real
4179 solution requires changes to the stub and remote.c that I
4180 don't have time to do right now. */
4182 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
4183 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
4186 objfile_relocate (symfile_objfile
, offs
);
4189 /* Send interrupt_sequence to remote target. */
4192 remote_target::send_interrupt_sequence ()
4194 struct remote_state
*rs
= get_remote_state ();
4196 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4197 remote_serial_write ("\x03", 1);
4198 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4199 serial_send_break (rs
->remote_desc
);
4200 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4202 serial_send_break (rs
->remote_desc
);
4203 remote_serial_write ("g", 1);
4206 internal_error (__FILE__
, __LINE__
,
4207 _("Invalid value for interrupt_sequence_mode: %s."),
4208 interrupt_sequence_mode
);
4212 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4213 and extract the PTID. Returns NULL_PTID if not found. */
4216 stop_reply_extract_thread (char *stop_reply
)
4218 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4222 /* Txx r:val ; r:val (...) */
4225 /* Look for "register" named "thread". */
4230 p1
= strchr (p
, ':');
4234 if (strncmp (p
, "thread", p1
- p
) == 0)
4235 return read_ptid (++p1
, &p
);
4237 p1
= strchr (p
, ';');
4249 /* Determine the remote side's current thread. If we have a stop
4250 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4251 "thread" register we can extract the current thread from. If not,
4252 ask the remote which is the current thread with qC. The former
4253 method avoids a roundtrip. */
4256 remote_target::get_current_thread (char *wait_status
)
4258 ptid_t ptid
= null_ptid
;
4260 /* Note we don't use remote_parse_stop_reply as that makes use of
4261 the target architecture, which we haven't yet fully determined at
4263 if (wait_status
!= NULL
)
4264 ptid
= stop_reply_extract_thread (wait_status
);
4265 if (ptid
== null_ptid
)
4266 ptid
= remote_current_thread (inferior_ptid
);
4271 /* Query the remote target for which is the current thread/process,
4272 add it to our tables, and update INFERIOR_PTID. The caller is
4273 responsible for setting the state such that the remote end is ready
4274 to return the current thread.
4276 This function is called after handling the '?' or 'vRun' packets,
4277 whose response is a stop reply from which we can also try
4278 extracting the thread. If the target doesn't support the explicit
4279 qC query, we infer the current thread from that stop reply, passed
4280 in in WAIT_STATUS, which may be NULL. */
4283 remote_target::add_current_inferior_and_thread (char *wait_status
)
4285 struct remote_state
*rs
= get_remote_state ();
4286 bool fake_pid_p
= false;
4288 inferior_ptid
= null_ptid
;
4290 /* Now, if we have thread information, update inferior_ptid. */
4291 ptid_t curr_ptid
= get_current_thread (wait_status
);
4293 if (curr_ptid
!= null_ptid
)
4295 if (!remote_multi_process_p (rs
))
4300 /* Without this, some commands which require an active target
4301 (such as kill) won't work. This variable serves (at least)
4302 double duty as both the pid of the target process (if it has
4303 such), and as a flag indicating that a target is active. */
4304 curr_ptid
= magic_null_ptid
;
4308 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4310 /* Add the main thread and switch to it. Don't try reading
4311 registers yet, since we haven't fetched the target description
4313 thread_info
*tp
= add_thread_silent (curr_ptid
);
4314 switch_to_thread_no_regs (tp
);
4317 /* Print info about a thread that was found already stopped on
4321 print_one_stopped_thread (struct thread_info
*thread
)
4323 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4325 switch_to_thread (thread
);
4326 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4327 set_current_sal_from_frame (get_current_frame ());
4329 thread
->suspend
.waitstatus_pending_p
= 0;
4331 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4333 enum gdb_signal sig
= ws
->value
.sig
;
4335 if (signal_print_state (sig
))
4336 gdb::observers::signal_received
.notify (sig
);
4338 gdb::observers::normal_stop
.notify (NULL
, 1);
4341 /* Process all initial stop replies the remote side sent in response
4342 to the ? packet. These indicate threads that were already stopped
4343 on initial connection. We mark these threads as stopped and print
4344 their current frame before giving the user the prompt. */
4347 remote_target::process_initial_stop_replies (int from_tty
)
4349 int pending_stop_replies
= stop_reply_queue_length ();
4350 struct thread_info
*selected
= NULL
;
4351 struct thread_info
*lowest_stopped
= NULL
;
4352 struct thread_info
*first
= NULL
;
4354 /* Consume the initial pending events. */
4355 while (pending_stop_replies
-- > 0)
4357 ptid_t waiton_ptid
= minus_one_ptid
;
4359 struct target_waitstatus ws
;
4360 int ignore_event
= 0;
4362 memset (&ws
, 0, sizeof (ws
));
4363 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4365 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4369 case TARGET_WAITKIND_IGNORE
:
4370 case TARGET_WAITKIND_NO_RESUMED
:
4371 case TARGET_WAITKIND_SIGNALLED
:
4372 case TARGET_WAITKIND_EXITED
:
4373 /* We shouldn't see these, but if we do, just ignore. */
4375 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
4379 case TARGET_WAITKIND_EXECD
:
4380 xfree (ws
.value
.execd_pathname
);
4389 struct thread_info
*evthread
= find_thread_ptid (event_ptid
);
4391 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4393 enum gdb_signal sig
= ws
.value
.sig
;
4395 /* Stubs traditionally report SIGTRAP as initial signal,
4396 instead of signal 0. Suppress it. */
4397 if (sig
== GDB_SIGNAL_TRAP
)
4399 evthread
->suspend
.stop_signal
= sig
;
4403 evthread
->suspend
.waitstatus
= ws
;
4405 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4406 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4407 evthread
->suspend
.waitstatus_pending_p
= 1;
4409 set_executing (event_ptid
, 0);
4410 set_running (event_ptid
, 0);
4411 get_remote_thread_info (evthread
)->vcont_resumed
= 0;
4414 /* "Notice" the new inferiors before anything related to
4415 registers/memory. */
4416 for (inferior
*inf
: all_non_exited_inferiors ())
4418 inf
->needs_setup
= 1;
4422 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4423 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4428 /* If all-stop on top of non-stop, pause all threads. Note this
4429 records the threads' stop pc, so must be done after "noticing"
4433 stop_all_threads ();
4435 /* If all threads of an inferior were already stopped, we
4436 haven't setup the inferior yet. */
4437 for (inferior
*inf
: all_non_exited_inferiors ())
4439 if (inf
->needs_setup
)
4441 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4442 switch_to_thread_no_regs (thread
);
4448 /* Now go over all threads that are stopped, and print their current
4449 frame. If all-stop, then if there's a signalled thread, pick
4451 for (thread_info
*thread
: all_non_exited_threads ())
4457 thread
->set_running (false);
4458 else if (thread
->state
!= THREAD_STOPPED
)
4461 if (selected
== NULL
4462 && thread
->suspend
.waitstatus_pending_p
)
4465 if (lowest_stopped
== NULL
4466 || thread
->inf
->num
< lowest_stopped
->inf
->num
4467 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4468 lowest_stopped
= thread
;
4471 print_one_stopped_thread (thread
);
4474 /* In all-stop, we only print the status of one thread, and leave
4475 others with their status pending. */
4478 thread_info
*thread
= selected
;
4480 thread
= lowest_stopped
;
4484 print_one_stopped_thread (thread
);
4487 /* For "info program". */
4488 thread_info
*thread
= inferior_thread ();
4489 if (thread
->state
== THREAD_STOPPED
)
4490 set_last_target_status (inferior_ptid
, thread
->suspend
.waitstatus
);
4493 /* Start the remote connection and sync state. */
4496 remote_target::start_remote (int from_tty
, int extended_p
)
4498 struct remote_state
*rs
= get_remote_state ();
4499 struct packet_config
*noack_config
;
4500 char *wait_status
= NULL
;
4502 /* Signal other parts that we're going through the initial setup,
4503 and so things may not be stable yet. E.g., we don't try to
4504 install tracepoints until we've relocated symbols. Also, a
4505 Ctrl-C before we're connected and synced up can't interrupt the
4506 target. Instead, it offers to drop the (potentially wedged)
4508 rs
->starting_up
= 1;
4512 if (interrupt_on_connect
)
4513 send_interrupt_sequence ();
4515 /* Ack any packet which the remote side has already sent. */
4516 remote_serial_write ("+", 1);
4518 /* The first packet we send to the target is the optional "supported
4519 packets" request. If the target can answer this, it will tell us
4520 which later probes to skip. */
4521 remote_query_supported ();
4523 /* If the stub wants to get a QAllow, compose one and send it. */
4524 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4527 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4528 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4529 as a reply to known packet. For packet "vFile:setfs:" it is an
4530 invalid reply and GDB would return error in
4531 remote_hostio_set_filesystem, making remote files access impossible.
4532 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4533 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4535 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4537 putpkt (v_mustreplyempty
);
4538 getpkt (&rs
->buf
, 0);
4539 if (strcmp (rs
->buf
.data (), "OK") == 0)
4540 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4541 else if (strcmp (rs
->buf
.data (), "") != 0)
4542 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4546 /* Next, we possibly activate noack mode.
4548 If the QStartNoAckMode packet configuration is set to AUTO,
4549 enable noack mode if the stub reported a wish for it with
4552 If set to TRUE, then enable noack mode even if the stub didn't
4553 report it in qSupported. If the stub doesn't reply OK, the
4554 session ends with an error.
4556 If FALSE, then don't activate noack mode, regardless of what the
4557 stub claimed should be the default with qSupported. */
4559 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4560 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4562 putpkt ("QStartNoAckMode");
4563 getpkt (&rs
->buf
, 0);
4564 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4570 /* Tell the remote that we are using the extended protocol. */
4572 getpkt (&rs
->buf
, 0);
4575 /* Let the target know which signals it is allowed to pass down to
4577 update_signals_program_target ();
4579 /* Next, if the target can specify a description, read it. We do
4580 this before anything involving memory or registers. */
4581 target_find_description ();
4583 /* Next, now that we know something about the target, update the
4584 address spaces in the program spaces. */
4585 update_address_spaces ();
4587 /* On OSs where the list of libraries is global to all
4588 processes, we fetch them early. */
4589 if (gdbarch_has_global_solist (target_gdbarch ()))
4590 solib_add (NULL
, from_tty
, auto_solib_add
);
4592 if (target_is_non_stop_p ())
4594 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4595 error (_("Non-stop mode requested, but remote "
4596 "does not support non-stop"));
4598 putpkt ("QNonStop:1");
4599 getpkt (&rs
->buf
, 0);
4601 if (strcmp (rs
->buf
.data (), "OK") != 0)
4602 error (_("Remote refused setting non-stop mode with: %s"),
4605 /* Find about threads and processes the stub is already
4606 controlling. We default to adding them in the running state.
4607 The '?' query below will then tell us about which threads are
4609 this->update_thread_list ();
4611 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4613 /* Don't assume that the stub can operate in all-stop mode.
4614 Request it explicitly. */
4615 putpkt ("QNonStop:0");
4616 getpkt (&rs
->buf
, 0);
4618 if (strcmp (rs
->buf
.data (), "OK") != 0)
4619 error (_("Remote refused setting all-stop mode with: %s"),
4623 /* Upload TSVs regardless of whether the target is running or not. The
4624 remote stub, such as GDBserver, may have some predefined or builtin
4625 TSVs, even if the target is not running. */
4626 if (get_trace_status (current_trace_status ()) != -1)
4628 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4630 upload_trace_state_variables (&uploaded_tsvs
);
4631 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4634 /* Check whether the target is running now. */
4636 getpkt (&rs
->buf
, 0);
4638 if (!target_is_non_stop_p ())
4640 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4643 error (_("The target is not running (try extended-remote?)"));
4645 /* We're connected, but not running. Drop out before we
4646 call start_remote. */
4647 rs
->starting_up
= 0;
4652 /* Save the reply for later. */
4653 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4654 strcpy (wait_status
, rs
->buf
.data ());
4657 /* Fetch thread list. */
4658 target_update_thread_list ();
4660 /* Let the stub know that we want it to return the thread. */
4661 set_continue_thread (minus_one_ptid
);
4663 if (thread_count () == 0)
4665 /* Target has no concept of threads at all. GDB treats
4666 non-threaded target as single-threaded; add a main
4668 add_current_inferior_and_thread (wait_status
);
4672 /* We have thread information; select the thread the target
4673 says should be current. If we're reconnecting to a
4674 multi-threaded program, this will ideally be the thread
4675 that last reported an event before GDB disconnected. */
4676 inferior_ptid
= get_current_thread (wait_status
);
4677 if (inferior_ptid
== null_ptid
)
4679 /* Odd... The target was able to list threads, but not
4680 tell us which thread was current (no "thread"
4681 register in T stop reply?). Just pick the first
4682 thread in the thread list then. */
4685 fprintf_unfiltered (gdb_stdlog
,
4686 "warning: couldn't determine remote "
4687 "current thread; picking first in list.\n");
4689 inferior_ptid
= inferior_list
->thread_list
->ptid
;
4693 /* init_wait_for_inferior should be called before get_offsets in order
4694 to manage `inserted' flag in bp loc in a correct state.
4695 breakpoint_init_inferior, called from init_wait_for_inferior, set
4696 `inserted' flag to 0, while before breakpoint_re_set, called from
4697 start_remote, set `inserted' flag to 1. In the initialization of
4698 inferior, breakpoint_init_inferior should be called first, and then
4699 breakpoint_re_set can be called. If this order is broken, state of
4700 `inserted' flag is wrong, and cause some problems on breakpoint
4702 init_wait_for_inferior ();
4704 get_offsets (); /* Get text, data & bss offsets. */
4706 /* If we could not find a description using qXfer, and we know
4707 how to do it some other way, try again. This is not
4708 supported for non-stop; it could be, but it is tricky if
4709 there are no stopped threads when we connect. */
4710 if (remote_read_description_p (this)
4711 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4713 target_clear_description ();
4714 target_find_description ();
4717 /* Use the previously fetched status. */
4718 gdb_assert (wait_status
!= NULL
);
4719 strcpy (rs
->buf
.data (), wait_status
);
4720 rs
->cached_wait_status
= 1;
4722 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4726 /* Clear WFI global state. Do this before finding about new
4727 threads and inferiors, and setting the current inferior.
4728 Otherwise we would clear the proceed status of the current
4729 inferior when we want its stop_soon state to be preserved
4730 (see notice_new_inferior). */
4731 init_wait_for_inferior ();
4733 /* In non-stop, we will either get an "OK", meaning that there
4734 are no stopped threads at this time; or, a regular stop
4735 reply. In the latter case, there may be more than one thread
4736 stopped --- we pull them all out using the vStopped
4738 if (strcmp (rs
->buf
.data (), "OK") != 0)
4740 struct notif_client
*notif
= ¬if_client_stop
;
4742 /* remote_notif_get_pending_replies acks this one, and gets
4744 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4745 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4746 remote_notif_get_pending_events (notif
);
4749 if (thread_count () == 0)
4752 error (_("The target is not running (try extended-remote?)"));
4754 /* We're connected, but not running. Drop out before we
4755 call start_remote. */
4756 rs
->starting_up
= 0;
4760 /* In non-stop mode, any cached wait status will be stored in
4761 the stop reply queue. */
4762 gdb_assert (wait_status
== NULL
);
4764 /* Report all signals during attach/startup. */
4767 /* If there are already stopped threads, mark them stopped and
4768 report their stops before giving the prompt to the user. */
4769 process_initial_stop_replies (from_tty
);
4771 if (target_can_async_p ())
4775 /* If we connected to a live target, do some additional setup. */
4776 if (target_has_execution
)
4778 if (symfile_objfile
) /* No use without a symbol-file. */
4779 remote_check_symbols ();
4782 /* Possibly the target has been engaged in a trace run started
4783 previously; find out where things are at. */
4784 if (get_trace_status (current_trace_status ()) != -1)
4786 struct uploaded_tp
*uploaded_tps
= NULL
;
4788 if (current_trace_status ()->running
)
4789 printf_filtered (_("Trace is already running on the target.\n"));
4791 upload_tracepoints (&uploaded_tps
);
4793 merge_uploaded_tracepoints (&uploaded_tps
);
4796 /* Possibly the target has been engaged in a btrace record started
4797 previously; find out where things are at. */
4798 remote_btrace_maybe_reopen ();
4800 /* The thread and inferior lists are now synchronized with the
4801 target, our symbols have been relocated, and we're merged the
4802 target's tracepoints with ours. We're done with basic start
4804 rs
->starting_up
= 0;
4806 /* Maybe breakpoints are global and need to be inserted now. */
4807 if (breakpoints_should_be_inserted_now ())
4808 insert_breakpoints ();
4811 /* Open a connection to a remote debugger.
4812 NAME is the filename used for communication. */
4815 remote_target::open (const char *name
, int from_tty
)
4817 open_1 (name
, from_tty
, 0);
4820 /* Open a connection to a remote debugger using the extended
4821 remote gdb protocol. NAME is the filename used for communication. */
4824 extended_remote_target::open (const char *name
, int from_tty
)
4826 open_1 (name
, from_tty
, 1 /*extended_p */);
4829 /* Reset all packets back to "unknown support". Called when opening a
4830 new connection to a remote target. */
4833 reset_all_packet_configs_support (void)
4837 for (i
= 0; i
< PACKET_MAX
; i
++)
4838 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4841 /* Initialize all packet configs. */
4844 init_all_packet_configs (void)
4848 for (i
= 0; i
< PACKET_MAX
; i
++)
4850 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4851 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4855 /* Symbol look-up. */
4858 remote_target::remote_check_symbols ()
4863 /* The remote side has no concept of inferiors that aren't running
4864 yet, it only knows about running processes. If we're connected
4865 but our current inferior is not running, we should not invite the
4866 remote target to request symbol lookups related to its
4867 (unrelated) current process. */
4868 if (!target_has_execution
)
4871 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4874 /* Make sure the remote is pointing at the right process. Note
4875 there's no way to select "no process". */
4876 set_general_process ();
4878 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4879 because we need both at the same time. */
4880 gdb::char_vector
msg (get_remote_packet_size ());
4881 gdb::char_vector
reply (get_remote_packet_size ());
4883 /* Invite target to request symbol lookups. */
4885 putpkt ("qSymbol::");
4887 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4889 while (startswith (reply
.data (), "qSymbol:"))
4891 struct bound_minimal_symbol sym
;
4894 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
4897 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
4898 if (sym
.minsym
== NULL
)
4899 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
4903 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4904 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4906 /* If this is a function address, return the start of code
4907 instead of any data function descriptor. */
4908 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4910 current_top_target ());
4912 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4913 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4916 putpkt (msg
.data ());
4921 static struct serial
*
4922 remote_serial_open (const char *name
)
4924 static int udp_warning
= 0;
4926 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4927 of in ser-tcp.c, because it is the remote protocol assuming that the
4928 serial connection is reliable and not the serial connection promising
4930 if (!udp_warning
&& startswith (name
, "udp:"))
4932 warning (_("The remote protocol may be unreliable over UDP.\n"
4933 "Some events may be lost, rendering further debugging "
4938 return serial_open (name
);
4941 /* Inform the target of our permission settings. The permission flags
4942 work without this, but if the target knows the settings, it can do
4943 a couple things. First, it can add its own check, to catch cases
4944 that somehow manage to get by the permissions checks in target
4945 methods. Second, if the target is wired to disallow particular
4946 settings (for instance, a system in the field that is not set up to
4947 be able to stop at a breakpoint), it can object to any unavailable
4951 remote_target::set_permissions ()
4953 struct remote_state
*rs
= get_remote_state ();
4955 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
4956 "WriteReg:%x;WriteMem:%x;"
4957 "InsertBreak:%x;InsertTrace:%x;"
4958 "InsertFastTrace:%x;Stop:%x",
4959 may_write_registers
, may_write_memory
,
4960 may_insert_breakpoints
, may_insert_tracepoints
,
4961 may_insert_fast_tracepoints
, may_stop
);
4963 getpkt (&rs
->buf
, 0);
4965 /* If the target didn't like the packet, warn the user. Do not try
4966 to undo the user's settings, that would just be maddening. */
4967 if (strcmp (rs
->buf
.data (), "OK") != 0)
4968 warning (_("Remote refused setting permissions with: %s"),
4972 /* This type describes each known response to the qSupported
4974 struct protocol_feature
4976 /* The name of this protocol feature. */
4979 /* The default for this protocol feature. */
4980 enum packet_support default_support
;
4982 /* The function to call when this feature is reported, or after
4983 qSupported processing if the feature is not supported.
4984 The first argument points to this structure. The second
4985 argument indicates whether the packet requested support be
4986 enabled, disabled, or probed (or the default, if this function
4987 is being called at the end of processing and this feature was
4988 not reported). The third argument may be NULL; if not NULL, it
4989 is a NUL-terminated string taken from the packet following
4990 this feature's name and an equals sign. */
4991 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
4992 enum packet_support
, const char *);
4994 /* The corresponding packet for this feature. Only used if
4995 FUNC is remote_supported_packet. */
5000 remote_supported_packet (remote_target
*remote
,
5001 const struct protocol_feature
*feature
,
5002 enum packet_support support
,
5003 const char *argument
)
5007 warning (_("Remote qSupported response supplied an unexpected value for"
5008 " \"%s\"."), feature
->name
);
5012 remote_protocol_packets
[feature
->packet
].support
= support
;
5016 remote_target::remote_packet_size (const protocol_feature
*feature
,
5017 enum packet_support support
, const char *value
)
5019 struct remote_state
*rs
= get_remote_state ();
5024 if (support
!= PACKET_ENABLE
)
5027 if (value
== NULL
|| *value
== '\0')
5029 warning (_("Remote target reported \"%s\" without a size."),
5035 packet_size
= strtol (value
, &value_end
, 16);
5036 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5038 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5039 feature
->name
, value
);
5043 /* Record the new maximum packet size. */
5044 rs
->explicit_packet_size
= packet_size
;
5048 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5049 enum packet_support support
, const char *value
)
5051 remote
->remote_packet_size (feature
, support
, value
);
5054 static const struct protocol_feature remote_protocol_features
[] = {
5055 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5056 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5057 PACKET_qXfer_auxv
},
5058 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5059 PACKET_qXfer_exec_file
},
5060 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5061 PACKET_qXfer_features
},
5062 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5063 PACKET_qXfer_libraries
},
5064 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5065 PACKET_qXfer_libraries_svr4
},
5066 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5067 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5068 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5069 PACKET_qXfer_memory_map
},
5070 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5071 PACKET_qXfer_osdata
},
5072 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5073 PACKET_qXfer_threads
},
5074 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5075 PACKET_qXfer_traceframe_info
},
5076 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5077 PACKET_QPassSignals
},
5078 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5079 PACKET_QCatchSyscalls
},
5080 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5081 PACKET_QProgramSignals
},
5082 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5083 PACKET_QSetWorkingDir
},
5084 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5085 PACKET_QStartupWithShell
},
5086 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5087 PACKET_QEnvironmentHexEncoded
},
5088 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5089 PACKET_QEnvironmentReset
},
5090 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5091 PACKET_QEnvironmentUnset
},
5092 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5093 PACKET_QStartNoAckMode
},
5094 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5095 PACKET_multiprocess_feature
},
5096 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5097 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5098 PACKET_qXfer_siginfo_read
},
5099 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5100 PACKET_qXfer_siginfo_write
},
5101 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5102 PACKET_ConditionalTracepoints
},
5103 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5104 PACKET_ConditionalBreakpoints
},
5105 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5106 PACKET_BreakpointCommands
},
5107 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5108 PACKET_FastTracepoints
},
5109 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5110 PACKET_StaticTracepoints
},
5111 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5112 PACKET_InstallInTrace
},
5113 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5114 PACKET_DisconnectedTracing_feature
},
5115 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5117 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5119 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5120 PACKET_TracepointSource
},
5121 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5123 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5124 PACKET_EnableDisableTracepoints_feature
},
5125 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5126 PACKET_qXfer_fdpic
},
5127 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5129 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5130 PACKET_QDisableRandomization
},
5131 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5132 { "QTBuffer:size", PACKET_DISABLE
,
5133 remote_supported_packet
, PACKET_QTBuffer_size
},
5134 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5135 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5136 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5137 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5138 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5139 PACKET_qXfer_btrace
},
5140 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5141 PACKET_qXfer_btrace_conf
},
5142 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5143 PACKET_Qbtrace_conf_bts_size
},
5144 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5145 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5146 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5147 PACKET_fork_event_feature
},
5148 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5149 PACKET_vfork_event_feature
},
5150 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5151 PACKET_exec_event_feature
},
5152 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5153 PACKET_Qbtrace_conf_pt_size
},
5154 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5155 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5156 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5159 static char *remote_support_xml
;
5161 /* Register string appended to "xmlRegisters=" in qSupported query. */
5164 register_remote_support_xml (const char *xml
)
5166 #if defined(HAVE_LIBEXPAT)
5167 if (remote_support_xml
== NULL
)
5168 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5171 char *copy
= xstrdup (remote_support_xml
+ 13);
5173 char *p
= strtok_r (copy
, ",", &saveptr
);
5177 if (strcmp (p
, xml
) == 0)
5184 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5187 remote_support_xml
= reconcat (remote_support_xml
,
5188 remote_support_xml
, ",", xml
,
5195 remote_query_supported_append (std::string
*msg
, const char *append
)
5199 msg
->append (append
);
5203 remote_target::remote_query_supported ()
5205 struct remote_state
*rs
= get_remote_state ();
5208 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5210 /* The packet support flags are handled differently for this packet
5211 than for most others. We treat an error, a disabled packet, and
5212 an empty response identically: any features which must be reported
5213 to be used will be automatically disabled. An empty buffer
5214 accomplishes this, since that is also the representation for a list
5215 containing no features. */
5218 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5222 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5223 remote_query_supported_append (&q
, "multiprocess+");
5225 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5226 remote_query_supported_append (&q
, "swbreak+");
5227 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5228 remote_query_supported_append (&q
, "hwbreak+");
5230 remote_query_supported_append (&q
, "qRelocInsn+");
5232 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5233 != AUTO_BOOLEAN_FALSE
)
5234 remote_query_supported_append (&q
, "fork-events+");
5235 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5236 != AUTO_BOOLEAN_FALSE
)
5237 remote_query_supported_append (&q
, "vfork-events+");
5238 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5239 != AUTO_BOOLEAN_FALSE
)
5240 remote_query_supported_append (&q
, "exec-events+");
5242 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5243 remote_query_supported_append (&q
, "vContSupported+");
5245 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5246 remote_query_supported_append (&q
, "QThreadEvents+");
5248 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5249 remote_query_supported_append (&q
, "no-resumed+");
5251 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5252 the qSupported:xmlRegisters=i386 handling. */
5253 if (remote_support_xml
!= NULL
5254 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5255 remote_query_supported_append (&q
, remote_support_xml
);
5257 q
= "qSupported:" + q
;
5258 putpkt (q
.c_str ());
5260 getpkt (&rs
->buf
, 0);
5262 /* If an error occured, warn, but do not return - just reset the
5263 buffer to empty and go on to disable features. */
5264 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5267 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5272 memset (seen
, 0, sizeof (seen
));
5274 next
= rs
->buf
.data ();
5277 enum packet_support is_supported
;
5278 char *p
, *end
, *name_end
, *value
;
5280 /* First separate out this item from the rest of the packet. If
5281 there's another item after this, we overwrite the separator
5282 (terminated strings are much easier to work with). */
5284 end
= strchr (p
, ';');
5287 end
= p
+ strlen (p
);
5297 warning (_("empty item in \"qSupported\" response"));
5302 name_end
= strchr (p
, '=');
5305 /* This is a name=value entry. */
5306 is_supported
= PACKET_ENABLE
;
5307 value
= name_end
+ 1;
5316 is_supported
= PACKET_ENABLE
;
5320 is_supported
= PACKET_DISABLE
;
5324 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5328 warning (_("unrecognized item \"%s\" "
5329 "in \"qSupported\" response"), p
);
5335 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5336 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5338 const struct protocol_feature
*feature
;
5341 feature
= &remote_protocol_features
[i
];
5342 feature
->func (this, feature
, is_supported
, value
);
5347 /* If we increased the packet size, make sure to increase the global
5348 buffer size also. We delay this until after parsing the entire
5349 qSupported packet, because this is the same buffer we were
5351 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5352 rs
->buf
.resize (rs
->explicit_packet_size
);
5354 /* Handle the defaults for unmentioned features. */
5355 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5358 const struct protocol_feature
*feature
;
5360 feature
= &remote_protocol_features
[i
];
5361 feature
->func (this, feature
, feature
->default_support
, NULL
);
5365 /* Serial QUIT handler for the remote serial descriptor.
5367 Defers handling a Ctrl-C until we're done with the current
5368 command/response packet sequence, unless:
5370 - We're setting up the connection. Don't send a remote interrupt
5371 request, as we're not fully synced yet. Quit immediately
5374 - The target has been resumed in the foreground
5375 (target_terminal::is_ours is false) with a synchronous resume
5376 packet, and we're blocked waiting for the stop reply, thus a
5377 Ctrl-C should be immediately sent to the target.
5379 - We get a second Ctrl-C while still within the same serial read or
5380 write. In that case the serial is seemingly wedged --- offer to
5383 - We see a second Ctrl-C without target response, after having
5384 previously interrupted the target. In that case the target/stub
5385 is probably wedged --- offer to quit/disconnect.
5389 remote_target::remote_serial_quit_handler ()
5391 struct remote_state
*rs
= get_remote_state ();
5393 if (check_quit_flag ())
5395 /* If we're starting up, we're not fully synced yet. Quit
5397 if (rs
->starting_up
)
5399 else if (rs
->got_ctrlc_during_io
)
5401 if (query (_("The target is not responding to GDB commands.\n"
5402 "Stop debugging it? ")))
5403 remote_unpush_and_throw ();
5405 /* If ^C has already been sent once, offer to disconnect. */
5406 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5408 /* All-stop protocol, and blocked waiting for stop reply. Send
5409 an interrupt request. */
5410 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5411 target_interrupt ();
5413 rs
->got_ctrlc_during_io
= 1;
5417 /* The remote_target that is current while the quit handler is
5418 overridden with remote_serial_quit_handler. */
5419 static remote_target
*curr_quit_handler_target
;
5422 remote_serial_quit_handler ()
5424 curr_quit_handler_target
->remote_serial_quit_handler ();
5427 /* Remove any of the remote.c targets from target stack. Upper targets depend
5428 on it so remove them first. */
5431 remote_unpush_target (void)
5433 pop_all_targets_at_and_above (process_stratum
);
5437 remote_unpush_and_throw (void)
5439 remote_unpush_target ();
5440 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5444 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5446 remote_target
*curr_remote
= get_current_remote_target ();
5449 error (_("To open a remote debug connection, you need to specify what\n"
5450 "serial device is attached to the remote system\n"
5451 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5453 /* If we're connected to a running target, target_preopen will kill it.
5454 Ask this question first, before target_preopen has a chance to kill
5456 if (curr_remote
!= NULL
&& !have_inferiors ())
5459 && !query (_("Already connected to a remote target. Disconnect? ")))
5460 error (_("Still connected."));
5463 /* Here the possibly existing remote target gets unpushed. */
5464 target_preopen (from_tty
);
5466 remote_fileio_reset ();
5467 reopen_exec_file ();
5470 remote_target
*remote
5471 = (extended_p
? new extended_remote_target () : new remote_target ());
5472 target_ops_up
target_holder (remote
);
5474 remote_state
*rs
= remote
->get_remote_state ();
5476 /* See FIXME above. */
5477 if (!target_async_permitted
)
5478 rs
->wait_forever_enabled_p
= 1;
5480 rs
->remote_desc
= remote_serial_open (name
);
5481 if (!rs
->remote_desc
)
5482 perror_with_name (name
);
5484 if (baud_rate
!= -1)
5486 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5488 /* The requested speed could not be set. Error out to
5489 top level after closing remote_desc. Take care to
5490 set remote_desc to NULL to avoid closing remote_desc
5492 serial_close (rs
->remote_desc
);
5493 rs
->remote_desc
= NULL
;
5494 perror_with_name (name
);
5498 serial_setparity (rs
->remote_desc
, serial_parity
);
5499 serial_raw (rs
->remote_desc
);
5501 /* If there is something sitting in the buffer we might take it as a
5502 response to a command, which would be bad. */
5503 serial_flush_input (rs
->remote_desc
);
5507 puts_filtered ("Remote debugging using ");
5508 puts_filtered (name
);
5509 puts_filtered ("\n");
5512 /* Switch to using the remote target now. */
5513 push_target (std::move (target_holder
));
5515 /* Register extra event sources in the event loop. */
5516 rs
->remote_async_inferior_event_token
5517 = create_async_event_handler (remote_async_inferior_event_handler
,
5519 rs
->notif_state
= remote_notif_state_allocate (remote
);
5521 /* Reset the target state; these things will be queried either by
5522 remote_query_supported or as they are needed. */
5523 reset_all_packet_configs_support ();
5524 rs
->cached_wait_status
= 0;
5525 rs
->explicit_packet_size
= 0;
5527 rs
->extended
= extended_p
;
5528 rs
->waiting_for_stop_reply
= 0;
5529 rs
->ctrlc_pending_p
= 0;
5530 rs
->got_ctrlc_during_io
= 0;
5532 rs
->general_thread
= not_sent_ptid
;
5533 rs
->continue_thread
= not_sent_ptid
;
5534 rs
->remote_traceframe_number
= -1;
5536 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5538 /* Probe for ability to use "ThreadInfo" query, as required. */
5539 rs
->use_threadinfo_query
= 1;
5540 rs
->use_threadextra_query
= 1;
5542 rs
->readahead_cache
.invalidate ();
5544 if (target_async_permitted
)
5546 /* FIXME: cagney/1999-09-23: During the initial connection it is
5547 assumed that the target is already ready and able to respond to
5548 requests. Unfortunately remote_start_remote() eventually calls
5549 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5550 around this. Eventually a mechanism that allows
5551 wait_for_inferior() to expect/get timeouts will be
5553 rs
->wait_forever_enabled_p
= 0;
5556 /* First delete any symbols previously loaded from shared libraries. */
5557 no_shared_libraries (NULL
, 0);
5559 /* Start the remote connection. If error() or QUIT, discard this
5560 target (we'd otherwise be in an inconsistent state) and then
5561 propogate the error on up the exception chain. This ensures that
5562 the caller doesn't stumble along blindly assuming that the
5563 function succeeded. The CLI doesn't have this problem but other
5564 UI's, such as MI do.
5566 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5567 this function should return an error indication letting the
5568 caller restore the previous state. Unfortunately the command
5569 ``target remote'' is directly wired to this function making that
5570 impossible. On a positive note, the CLI side of this problem has
5571 been fixed - the function set_cmd_context() makes it possible for
5572 all the ``target ....'' commands to share a common callback
5573 function. See cli-dump.c. */
5578 remote
->start_remote (from_tty
, extended_p
);
5580 catch (const gdb_exception
&ex
)
5582 /* Pop the partially set up target - unless something else did
5583 already before throwing the exception. */
5584 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5585 remote_unpush_target ();
5590 remote_btrace_reset (rs
);
5592 if (target_async_permitted
)
5593 rs
->wait_forever_enabled_p
= 1;
5596 /* Detach the specified process. */
5599 remote_target::remote_detach_pid (int pid
)
5601 struct remote_state
*rs
= get_remote_state ();
5603 /* This should not be necessary, but the handling for D;PID in
5604 GDBserver versions prior to 8.2 incorrectly assumes that the
5605 selected process points to the same process we're detaching,
5606 leading to misbehavior (and possibly GDBserver crashing) when it
5607 does not. Since it's easy and cheap, work around it by forcing
5608 GDBserver to select GDB's current process. */
5609 set_general_process ();
5611 if (remote_multi_process_p (rs
))
5612 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5614 strcpy (rs
->buf
.data (), "D");
5617 getpkt (&rs
->buf
, 0);
5619 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5621 else if (rs
->buf
[0] == '\0')
5622 error (_("Remote doesn't know how to detach"));
5624 error (_("Can't detach process."));
5627 /* This detaches a program to which we previously attached, using
5628 inferior_ptid to identify the process. After this is done, GDB
5629 can be used to debug some other program. We better not have left
5630 any breakpoints in the target program or it'll die when it hits
5634 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5636 int pid
= inferior_ptid
.pid ();
5637 struct remote_state
*rs
= get_remote_state ();
5640 if (!target_has_execution
)
5641 error (_("No process to detach from."));
5643 target_announce_detach (from_tty
);
5645 /* Tell the remote target to detach. */
5646 remote_detach_pid (pid
);
5648 /* Exit only if this is the only active inferior. */
5649 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors () == 1)
5650 puts_filtered (_("Ending remote debugging.\n"));
5652 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
5654 /* Check to see if we are detaching a fork parent. Note that if we
5655 are detaching a fork child, tp == NULL. */
5656 is_fork_parent
= (tp
!= NULL
5657 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5659 /* If doing detach-on-fork, we don't mourn, because that will delete
5660 breakpoints that should be available for the followed inferior. */
5661 if (!is_fork_parent
)
5663 /* Save the pid as a string before mourning, since that will
5664 unpush the remote target, and we need the string after. */
5665 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5667 target_mourn_inferior (inferior_ptid
);
5668 if (print_inferior_events
)
5669 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5670 inf
->num
, infpid
.c_str ());
5674 inferior_ptid
= null_ptid
;
5675 detach_inferior (current_inferior ());
5680 remote_target::detach (inferior
*inf
, int from_tty
)
5682 remote_detach_1 (inf
, from_tty
);
5686 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5688 remote_detach_1 (inf
, from_tty
);
5691 /* Target follow-fork function for remote targets. On entry, and
5692 at return, the current inferior is the fork parent.
5694 Note that although this is currently only used for extended-remote,
5695 it is named remote_follow_fork in anticipation of using it for the
5696 remote target as well. */
5699 remote_target::follow_fork (int follow_child
, int detach_fork
)
5701 struct remote_state
*rs
= get_remote_state ();
5702 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5704 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5705 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5707 /* When following the parent and detaching the child, we detach
5708 the child here. For the case of following the child and
5709 detaching the parent, the detach is done in the target-
5710 independent follow fork code in infrun.c. We can't use
5711 target_detach when detaching an unfollowed child because
5712 the client side doesn't know anything about the child. */
5713 if (detach_fork
&& !follow_child
)
5715 /* Detach the fork child. */
5719 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5720 child_pid
= child_ptid
.pid ();
5722 remote_detach_pid (child_pid
);
5728 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5729 in the program space of the new inferior. On entry and at return the
5730 current inferior is the exec'ing inferior. INF is the new exec'd
5731 inferior, which may be the same as the exec'ing inferior unless
5732 follow-exec-mode is "new". */
5735 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5737 /* We know that this is a target file name, so if it has the "target:"
5738 prefix we strip it off before saving it in the program space. */
5739 if (is_target_filename (execd_pathname
))
5740 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5742 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5745 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5748 remote_target::disconnect (const char *args
, int from_tty
)
5751 error (_("Argument given to \"disconnect\" when remotely debugging."));
5753 /* Make sure we unpush even the extended remote targets. Calling
5754 target_mourn_inferior won't unpush, and remote_mourn won't
5755 unpush if there is more than one inferior left. */
5756 unpush_target (this);
5757 generic_mourn_inferior ();
5760 puts_filtered ("Ending remote debugging.\n");
5763 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5764 be chatty about it. */
5767 extended_remote_target::attach (const char *args
, int from_tty
)
5769 struct remote_state
*rs
= get_remote_state ();
5771 char *wait_status
= NULL
;
5773 pid
= parse_pid_to_attach (args
);
5775 /* Remote PID can be freely equal to getpid, do not check it here the same
5776 way as in other targets. */
5778 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5779 error (_("This target does not support attaching to a process"));
5783 char *exec_file
= get_exec_file (0);
5786 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5787 target_pid_to_str (ptid_t (pid
)).c_str ());
5789 printf_unfiltered (_("Attaching to %s\n"),
5790 target_pid_to_str (ptid_t (pid
)).c_str ());
5793 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5795 getpkt (&rs
->buf
, 0);
5797 switch (packet_ok (rs
->buf
,
5798 &remote_protocol_packets
[PACKET_vAttach
]))
5801 if (!target_is_non_stop_p ())
5803 /* Save the reply for later. */
5804 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5805 strcpy (wait_status
, rs
->buf
.data ());
5807 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5808 error (_("Attaching to %s failed with: %s"),
5809 target_pid_to_str (ptid_t (pid
)).c_str (),
5812 case PACKET_UNKNOWN
:
5813 error (_("This target does not support attaching to a process"));
5815 error (_("Attaching to %s failed"),
5816 target_pid_to_str (ptid_t (pid
)).c_str ());
5819 set_current_inferior (remote_add_inferior (false, pid
, 1, 0));
5821 inferior_ptid
= ptid_t (pid
);
5823 if (target_is_non_stop_p ())
5825 struct thread_info
*thread
;
5827 /* Get list of threads. */
5828 update_thread_list ();
5830 thread
= first_thread_of_inferior (current_inferior ());
5832 inferior_ptid
= thread
->ptid
;
5834 inferior_ptid
= ptid_t (pid
);
5836 /* Invalidate our notion of the remote current thread. */
5837 record_currthread (rs
, minus_one_ptid
);
5841 /* Now, if we have thread information, update inferior_ptid. */
5842 inferior_ptid
= remote_current_thread (inferior_ptid
);
5844 /* Add the main thread to the thread list. */
5845 thread_info
*thr
= add_thread_silent (inferior_ptid
);
5846 /* Don't consider the thread stopped until we've processed the
5847 saved stop reply. */
5848 set_executing (thr
->ptid
, true);
5851 /* Next, if the target can specify a description, read it. We do
5852 this before anything involving memory or registers. */
5853 target_find_description ();
5855 if (!target_is_non_stop_p ())
5857 /* Use the previously fetched status. */
5858 gdb_assert (wait_status
!= NULL
);
5860 if (target_can_async_p ())
5862 struct notif_event
*reply
5863 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
5865 push_stop_reply ((struct stop_reply
*) reply
);
5871 gdb_assert (wait_status
!= NULL
);
5872 strcpy (rs
->buf
.data (), wait_status
);
5873 rs
->cached_wait_status
= 1;
5877 gdb_assert (wait_status
== NULL
);
5880 /* Implementation of the to_post_attach method. */
5883 extended_remote_target::post_attach (int pid
)
5885 /* Get text, data & bss offsets. */
5888 /* In certain cases GDB might not have had the chance to start
5889 symbol lookup up until now. This could happen if the debugged
5890 binary is not using shared libraries, the vsyscall page is not
5891 present (on Linux) and the binary itself hadn't changed since the
5892 debugging process was started. */
5893 if (symfile_objfile
!= NULL
)
5894 remote_check_symbols();
5898 /* Check for the availability of vCont. This function should also check
5902 remote_target::remote_vcont_probe ()
5904 remote_state
*rs
= get_remote_state ();
5907 strcpy (rs
->buf
.data (), "vCont?");
5909 getpkt (&rs
->buf
, 0);
5910 buf
= rs
->buf
.data ();
5912 /* Make sure that the features we assume are supported. */
5913 if (startswith (buf
, "vCont"))
5916 int support_c
, support_C
;
5918 rs
->supports_vCont
.s
= 0;
5919 rs
->supports_vCont
.S
= 0;
5922 rs
->supports_vCont
.t
= 0;
5923 rs
->supports_vCont
.r
= 0;
5924 while (p
&& *p
== ';')
5927 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5928 rs
->supports_vCont
.s
= 1;
5929 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5930 rs
->supports_vCont
.S
= 1;
5931 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5933 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5935 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5936 rs
->supports_vCont
.t
= 1;
5937 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5938 rs
->supports_vCont
.r
= 1;
5940 p
= strchr (p
, ';');
5943 /* If c, and C are not all supported, we can't use vCont. Clearing
5944 BUF will make packet_ok disable the packet. */
5945 if (!support_c
|| !support_C
)
5949 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
5952 /* Helper function for building "vCont" resumptions. Write a
5953 resumption to P. ENDP points to one-passed-the-end of the buffer
5954 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
5955 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5956 resumed thread should be single-stepped and/or signalled. If PTID
5957 equals minus_one_ptid, then all threads are resumed; if PTID
5958 represents a process, then all threads of the process are resumed;
5959 the thread to be stepped and/or signalled is given in the global
5963 remote_target::append_resumption (char *p
, char *endp
,
5964 ptid_t ptid
, int step
, gdb_signal siggnal
)
5966 struct remote_state
*rs
= get_remote_state ();
5968 if (step
&& siggnal
!= GDB_SIGNAL_0
)
5969 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
5971 /* GDB is willing to range step. */
5972 && use_range_stepping
5973 /* Target supports range stepping. */
5974 && rs
->supports_vCont
.r
5975 /* We don't currently support range stepping multiple
5976 threads with a wildcard (though the protocol allows it,
5977 so stubs shouldn't make an active effort to forbid
5979 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
5981 struct thread_info
*tp
;
5983 if (ptid
== minus_one_ptid
)
5985 /* If we don't know about the target thread's tid, then
5986 we're resuming magic_null_ptid (see caller). */
5987 tp
= find_thread_ptid (magic_null_ptid
);
5990 tp
= find_thread_ptid (ptid
);
5991 gdb_assert (tp
!= NULL
);
5993 if (tp
->control
.may_range_step
)
5995 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
5997 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
5998 phex_nz (tp
->control
.step_range_start
,
6000 phex_nz (tp
->control
.step_range_end
,
6004 p
+= xsnprintf (p
, endp
- p
, ";s");
6007 p
+= xsnprintf (p
, endp
- p
, ";s");
6008 else if (siggnal
!= GDB_SIGNAL_0
)
6009 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6011 p
+= xsnprintf (p
, endp
- p
, ";c");
6013 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6017 /* All (-1) threads of process. */
6018 nptid
= ptid_t (ptid
.pid (), -1, 0);
6020 p
+= xsnprintf (p
, endp
- p
, ":");
6021 p
= write_ptid (p
, endp
, nptid
);
6023 else if (ptid
!= minus_one_ptid
)
6025 p
+= xsnprintf (p
, endp
- p
, ":");
6026 p
= write_ptid (p
, endp
, ptid
);
6032 /* Clear the thread's private info on resume. */
6035 resume_clear_thread_private_info (struct thread_info
*thread
)
6037 if (thread
->priv
!= NULL
)
6039 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6041 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6042 priv
->watch_data_address
= 0;
6046 /* Append a vCont continue-with-signal action for threads that have a
6047 non-zero stop signal. */
6050 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6053 for (thread_info
*thread
: all_non_exited_threads (ptid
))
6054 if (inferior_ptid
!= thread
->ptid
6055 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6057 p
= append_resumption (p
, endp
, thread
->ptid
,
6058 0, thread
->suspend
.stop_signal
);
6059 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6060 resume_clear_thread_private_info (thread
);
6066 /* Set the target running, using the packets that use Hc
6070 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6073 struct remote_state
*rs
= get_remote_state ();
6076 rs
->last_sent_signal
= siggnal
;
6077 rs
->last_sent_step
= step
;
6079 /* The c/s/C/S resume packets use Hc, so set the continue
6081 if (ptid
== minus_one_ptid
)
6082 set_continue_thread (any_thread_ptid
);
6084 set_continue_thread (ptid
);
6086 for (thread_info
*thread
: all_non_exited_threads ())
6087 resume_clear_thread_private_info (thread
);
6089 buf
= rs
->buf
.data ();
6090 if (::execution_direction
== EXEC_REVERSE
)
6092 /* We don't pass signals to the target in reverse exec mode. */
6093 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6094 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6097 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6098 error (_("Remote reverse-step not supported."));
6099 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6100 error (_("Remote reverse-continue not supported."));
6102 strcpy (buf
, step
? "bs" : "bc");
6104 else if (siggnal
!= GDB_SIGNAL_0
)
6106 buf
[0] = step
? 'S' : 'C';
6107 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6108 buf
[2] = tohex (((int) siggnal
) & 0xf);
6112 strcpy (buf
, step
? "s" : "c");
6117 /* Resume the remote inferior by using a "vCont" packet. The thread
6118 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6119 resumed thread should be single-stepped and/or signalled. If PTID
6120 equals minus_one_ptid, then all threads are resumed; the thread to
6121 be stepped and/or signalled is given in the global INFERIOR_PTID.
6122 This function returns non-zero iff it resumes the inferior.
6124 This function issues a strict subset of all possible vCont commands
6128 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6129 enum gdb_signal siggnal
)
6131 struct remote_state
*rs
= get_remote_state ();
6135 /* No reverse execution actions defined for vCont. */
6136 if (::execution_direction
== EXEC_REVERSE
)
6139 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6140 remote_vcont_probe ();
6142 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6145 p
= rs
->buf
.data ();
6146 endp
= p
+ get_remote_packet_size ();
6148 /* If we could generate a wider range of packets, we'd have to worry
6149 about overflowing BUF. Should there be a generic
6150 "multi-part-packet" packet? */
6152 p
+= xsnprintf (p
, endp
- p
, "vCont");
6154 if (ptid
== magic_null_ptid
)
6156 /* MAGIC_NULL_PTID means that we don't have any active threads,
6157 so we don't have any TID numbers the inferior will
6158 understand. Make sure to only send forms that do not specify
6160 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6162 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6164 /* Resume all threads (of all processes, or of a single
6165 process), with preference for INFERIOR_PTID. This assumes
6166 inferior_ptid belongs to the set of all threads we are about
6168 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6170 /* Step inferior_ptid, with or without signal. */
6171 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6174 /* Also pass down any pending signaled resumption for other
6175 threads not the current. */
6176 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6178 /* And continue others without a signal. */
6179 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6183 /* Scheduler locking; resume only PTID. */
6184 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6187 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6190 if (target_is_non_stop_p ())
6192 /* In non-stop, the stub replies to vCont with "OK". The stop
6193 reply will be reported asynchronously by means of a `%Stop'
6195 getpkt (&rs
->buf
, 0);
6196 if (strcmp (rs
->buf
.data (), "OK") != 0)
6197 error (_("Unexpected vCont reply in non-stop mode: %s"),
6204 /* Tell the remote machine to resume. */
6207 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6209 struct remote_state
*rs
= get_remote_state ();
6211 /* When connected in non-stop mode, the core resumes threads
6212 individually. Resuming remote threads directly in target_resume
6213 would thus result in sending one packet per thread. Instead, to
6214 minimize roundtrip latency, here we just store the resume
6215 request; the actual remote resumption will be done in
6216 target_commit_resume / remote_commit_resume, where we'll be able
6217 to do vCont action coalescing. */
6218 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6220 remote_thread_info
*remote_thr
;
6222 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6223 remote_thr
= get_remote_thread_info (inferior_ptid
);
6225 remote_thr
= get_remote_thread_info (ptid
);
6227 remote_thr
->last_resume_step
= step
;
6228 remote_thr
->last_resume_sig
= siggnal
;
6232 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6233 (explained in remote-notif.c:handle_notification) so
6234 remote_notif_process is not called. We need find a place where
6235 it is safe to start a 'vNotif' sequence. It is good to do it
6236 before resuming inferior, because inferior was stopped and no RSP
6237 traffic at that moment. */
6238 if (!target_is_non_stop_p ())
6239 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6241 rs
->last_resume_exec_dir
= ::execution_direction
;
6243 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6244 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6245 remote_resume_with_hc (ptid
, step
, siggnal
);
6247 /* We are about to start executing the inferior, let's register it
6248 with the event loop. NOTE: this is the one place where all the
6249 execution commands end up. We could alternatively do this in each
6250 of the execution commands in infcmd.c. */
6251 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6252 into infcmd.c in order to allow inferior function calls to work
6253 NOT asynchronously. */
6254 if (target_can_async_p ())
6257 /* We've just told the target to resume. The remote server will
6258 wait for the inferior to stop, and then send a stop reply. In
6259 the mean time, we can't start another command/query ourselves
6260 because the stub wouldn't be ready to process it. This applies
6261 only to the base all-stop protocol, however. In non-stop (which
6262 only supports vCont), the stub replies with an "OK", and is
6263 immediate able to process further serial input. */
6264 if (!target_is_non_stop_p ())
6265 rs
->waiting_for_stop_reply
= 1;
6268 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6270 /* Private per-inferior info for target remote processes. */
6272 struct remote_inferior
: public private_inferior
6274 /* Whether we can send a wildcard vCont for this process. */
6275 bool may_wildcard_vcont
= true;
6278 /* Get the remote private inferior data associated to INF. */
6280 static remote_inferior
*
6281 get_remote_inferior (inferior
*inf
)
6283 if (inf
->priv
== NULL
)
6284 inf
->priv
.reset (new remote_inferior
);
6286 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6289 /* Class used to track the construction of a vCont packet in the
6290 outgoing packet buffer. This is used to send multiple vCont
6291 packets if we have more actions than would fit a single packet. */
6296 explicit vcont_builder (remote_target
*remote
)
6303 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6308 /* The remote target. */
6309 remote_target
*m_remote
;
6311 /* Pointer to the first action. P points here if no action has been
6313 char *m_first_action
;
6315 /* Where the next action will be appended. */
6318 /* The end of the buffer. Must never write past this. */
6322 /* Prepare the outgoing buffer for a new vCont packet. */
6325 vcont_builder::restart ()
6327 struct remote_state
*rs
= m_remote
->get_remote_state ();
6329 m_p
= rs
->buf
.data ();
6330 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6331 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6332 m_first_action
= m_p
;
6335 /* If the vCont packet being built has any action, send it to the
6339 vcont_builder::flush ()
6341 struct remote_state
*rs
;
6343 if (m_p
== m_first_action
)
6346 rs
= m_remote
->get_remote_state ();
6347 m_remote
->putpkt (rs
->buf
);
6348 m_remote
->getpkt (&rs
->buf
, 0);
6349 if (strcmp (rs
->buf
.data (), "OK") != 0)
6350 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6353 /* The largest action is range-stepping, with its two addresses. This
6354 is more than sufficient. If a new, bigger action is created, it'll
6355 quickly trigger a failed assertion in append_resumption (and we'll
6357 #define MAX_ACTION_SIZE 200
6359 /* Append a new vCont action in the outgoing packet being built. If
6360 the action doesn't fit the packet along with previous actions, push
6361 what we've got so far to the remote end and start over a new vCont
6362 packet (with the new action). */
6365 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6367 char buf
[MAX_ACTION_SIZE
+ 1];
6369 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6370 ptid
, step
, siggnal
);
6372 /* Check whether this new action would fit in the vCont packet along
6373 with previous actions. If not, send what we've got so far and
6374 start a new vCont packet. */
6375 size_t rsize
= endp
- buf
;
6376 if (rsize
> m_endp
- m_p
)
6381 /* Should now fit. */
6382 gdb_assert (rsize
<= m_endp
- m_p
);
6385 memcpy (m_p
, buf
, rsize
);
6390 /* to_commit_resume implementation. */
6393 remote_target::commit_resume ()
6395 int any_process_wildcard
;
6396 int may_global_wildcard_vcont
;
6398 /* If connected in all-stop mode, we'd send the remote resume
6399 request directly from remote_resume. Likewise if
6400 reverse-debugging, as there are no defined vCont actions for
6401 reverse execution. */
6402 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6405 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6406 instead of resuming all threads of each process individually.
6407 However, if any thread of a process must remain halted, we can't
6408 send wildcard resumes and must send one action per thread.
6410 Care must be taken to not resume threads/processes the server
6411 side already told us are stopped, but the core doesn't know about
6412 yet, because the events are still in the vStopped notification
6415 #1 => vCont s:p1.1;c
6417 #3 <= %Stopped T05 p1.1
6422 #8 (infrun handles the stop for p1.1 and continues stepping)
6423 #9 => vCont s:p1.1;c
6425 The last vCont above would resume thread p1.2 by mistake, because
6426 the server has no idea that the event for p1.2 had not been
6429 The server side must similarly ignore resume actions for the
6430 thread that has a pending %Stopped notification (and any other
6431 threads with events pending), until GDB acks the notification
6432 with vStopped. Otherwise, e.g., the following case is
6435 #1 => g (or any other packet)
6437 #3 <= %Stopped T05 p1.2
6438 #4 => vCont s:p1.1;c
6441 Above, the server must not resume thread p1.2. GDB can't know
6442 that p1.2 stopped until it acks the %Stopped notification, and
6443 since from GDB's perspective all threads should be running, it
6446 Finally, special care must also be given to handling fork/vfork
6447 events. A (v)fork event actually tells us that two processes
6448 stopped -- the parent and the child. Until we follow the fork,
6449 we must not resume the child. Therefore, if we have a pending
6450 fork follow, we must not send a global wildcard resume action
6451 (vCont;c). We can still send process-wide wildcards though. */
6453 /* Start by assuming a global wildcard (vCont;c) is possible. */
6454 may_global_wildcard_vcont
= 1;
6456 /* And assume every process is individually wildcard-able too. */
6457 for (inferior
*inf
: all_non_exited_inferiors ())
6459 remote_inferior
*priv
= get_remote_inferior (inf
);
6461 priv
->may_wildcard_vcont
= true;
6464 /* Check for any pending events (not reported or processed yet) and
6465 disable process and global wildcard resumes appropriately. */
6466 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6468 for (thread_info
*tp
: all_non_exited_threads ())
6470 /* If a thread of a process is not meant to be resumed, then we
6471 can't wildcard that process. */
6474 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6476 /* And if we can't wildcard a process, we can't wildcard
6477 everything either. */
6478 may_global_wildcard_vcont
= 0;
6482 /* If a thread is the parent of an unfollowed fork, then we
6483 can't do a global wildcard, as that would resume the fork
6485 if (is_pending_fork_parent_thread (tp
))
6486 may_global_wildcard_vcont
= 0;
6489 /* Now let's build the vCont packet(s). Actions must be appended
6490 from narrower to wider scopes (thread -> process -> global). If
6491 we end up with too many actions for a single packet vcont_builder
6492 flushes the current vCont packet to the remote side and starts a
6494 struct vcont_builder
vcont_builder (this);
6496 /* Threads first. */
6497 for (thread_info
*tp
: all_non_exited_threads ())
6499 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6501 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6504 gdb_assert (!thread_is_in_step_over_chain (tp
));
6506 if (!remote_thr
->last_resume_step
6507 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6508 && get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6510 /* We'll send a wildcard resume instead. */
6511 remote_thr
->vcont_resumed
= 1;
6515 vcont_builder
.push_action (tp
->ptid
,
6516 remote_thr
->last_resume_step
,
6517 remote_thr
->last_resume_sig
);
6518 remote_thr
->vcont_resumed
= 1;
6521 /* Now check whether we can send any process-wide wildcard. This is
6522 to avoid sending a global wildcard in the case nothing is
6523 supposed to be resumed. */
6524 any_process_wildcard
= 0;
6526 for (inferior
*inf
: all_non_exited_inferiors ())
6528 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6530 any_process_wildcard
= 1;
6535 if (any_process_wildcard
)
6537 /* If all processes are wildcard-able, then send a single "c"
6538 action, otherwise, send an "all (-1) threads of process"
6539 continue action for each running process, if any. */
6540 if (may_global_wildcard_vcont
)
6542 vcont_builder
.push_action (minus_one_ptid
,
6543 false, GDB_SIGNAL_0
);
6547 for (inferior
*inf
: all_non_exited_inferiors ())
6549 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6551 vcont_builder
.push_action (ptid_t (inf
->pid
),
6552 false, GDB_SIGNAL_0
);
6558 vcont_builder
.flush ();
6563 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6564 thread, all threads of a remote process, or all threads of all
6568 remote_target::remote_stop_ns (ptid_t ptid
)
6570 struct remote_state
*rs
= get_remote_state ();
6571 char *p
= rs
->buf
.data ();
6572 char *endp
= p
+ get_remote_packet_size ();
6574 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6575 remote_vcont_probe ();
6577 if (!rs
->supports_vCont
.t
)
6578 error (_("Remote server does not support stopping threads"));
6580 if (ptid
== minus_one_ptid
6581 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6582 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6587 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6590 /* All (-1) threads of process. */
6591 nptid
= ptid_t (ptid
.pid (), -1, 0);
6594 /* Small optimization: if we already have a stop reply for
6595 this thread, no use in telling the stub we want this
6597 if (peek_stop_reply (ptid
))
6603 write_ptid (p
, endp
, nptid
);
6606 /* In non-stop, we get an immediate OK reply. The stop reply will
6607 come in asynchronously by notification. */
6609 getpkt (&rs
->buf
, 0);
6610 if (strcmp (rs
->buf
.data (), "OK") != 0)
6611 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6615 /* All-stop version of target_interrupt. Sends a break or a ^C to
6616 interrupt the remote target. It is undefined which thread of which
6617 process reports the interrupt. */
6620 remote_target::remote_interrupt_as ()
6622 struct remote_state
*rs
= get_remote_state ();
6624 rs
->ctrlc_pending_p
= 1;
6626 /* If the inferior is stopped already, but the core didn't know
6627 about it yet, just ignore the request. The cached wait status
6628 will be collected in remote_wait. */
6629 if (rs
->cached_wait_status
)
6632 /* Send interrupt_sequence to remote target. */
6633 send_interrupt_sequence ();
6636 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6637 the remote target. It is undefined which thread of which process
6638 reports the interrupt. Throws an error if the packet is not
6639 supported by the server. */
6642 remote_target::remote_interrupt_ns ()
6644 struct remote_state
*rs
= get_remote_state ();
6645 char *p
= rs
->buf
.data ();
6646 char *endp
= p
+ get_remote_packet_size ();
6648 xsnprintf (p
, endp
- p
, "vCtrlC");
6650 /* In non-stop, we get an immediate OK reply. The stop reply will
6651 come in asynchronously by notification. */
6653 getpkt (&rs
->buf
, 0);
6655 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6659 case PACKET_UNKNOWN
:
6660 error (_("No support for interrupting the remote target."));
6662 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6666 /* Implement the to_stop function for the remote targets. */
6669 remote_target::stop (ptid_t ptid
)
6672 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6674 if (target_is_non_stop_p ())
6675 remote_stop_ns (ptid
);
6678 /* We don't currently have a way to transparently pause the
6679 remote target in all-stop mode. Interrupt it instead. */
6680 remote_interrupt_as ();
6684 /* Implement the to_interrupt function for the remote targets. */
6687 remote_target::interrupt ()
6690 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6692 if (target_is_non_stop_p ())
6693 remote_interrupt_ns ();
6695 remote_interrupt_as ();
6698 /* Implement the to_pass_ctrlc function for the remote targets. */
6701 remote_target::pass_ctrlc ()
6703 struct remote_state
*rs
= get_remote_state ();
6706 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6708 /* If we're starting up, we're not fully synced yet. Quit
6710 if (rs
->starting_up
)
6712 /* If ^C has already been sent once, offer to disconnect. */
6713 else if (rs
->ctrlc_pending_p
)
6716 target_interrupt ();
6719 /* Ask the user what to do when an interrupt is received. */
6722 remote_target::interrupt_query ()
6724 struct remote_state
*rs
= get_remote_state ();
6726 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6728 if (query (_("The target is not responding to interrupt requests.\n"
6729 "Stop debugging it? ")))
6731 remote_unpush_target ();
6732 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6737 if (query (_("Interrupted while waiting for the program.\n"
6738 "Give up waiting? ")))
6743 /* Enable/disable target terminal ownership. Most targets can use
6744 terminal groups to control terminal ownership. Remote targets are
6745 different in that explicit transfer of ownership to/from GDB/target
6749 remote_target::terminal_inferior ()
6751 /* NOTE: At this point we could also register our selves as the
6752 recipient of all input. Any characters typed could then be
6753 passed on down to the target. */
6757 remote_target::terminal_ours ()
6762 remote_console_output (const char *msg
)
6766 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6769 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6773 fputs_unfiltered (tb
, gdb_stdtarg
);
6775 gdb_flush (gdb_stdtarg
);
6778 struct stop_reply
: public notif_event
6782 /* The identifier of the thread about this event */
6785 /* The remote state this event is associated with. When the remote
6786 connection, represented by a remote_state object, is closed,
6787 all the associated stop_reply events should be released. */
6788 struct remote_state
*rs
;
6790 struct target_waitstatus ws
;
6792 /* The architecture associated with the expedited registers. */
6795 /* Expedited registers. This makes remote debugging a bit more
6796 efficient for those targets that provide critical registers as
6797 part of their normal status mechanism (as another roundtrip to
6798 fetch them is avoided). */
6799 std::vector
<cached_reg_t
> regcache
;
6801 enum target_stop_reason stop_reason
;
6803 CORE_ADDR watch_data_address
;
6808 /* Return the length of the stop reply queue. */
6811 remote_target::stop_reply_queue_length ()
6813 remote_state
*rs
= get_remote_state ();
6814 return rs
->stop_reply_queue
.size ();
6818 remote_notif_stop_parse (remote_target
*remote
,
6819 struct notif_client
*self
, const char *buf
,
6820 struct notif_event
*event
)
6822 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6826 remote_notif_stop_ack (remote_target
*remote
,
6827 struct notif_client
*self
, const char *buf
,
6828 struct notif_event
*event
)
6830 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6833 putpkt (remote
, self
->ack_command
);
6835 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6837 /* We got an unknown stop reply. */
6838 error (_("Unknown stop reply"));
6841 remote
->push_stop_reply (stop_reply
);
6845 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
6846 struct notif_client
*self
)
6848 /* We can't get pending events in remote_notif_process for
6849 notification stop, and we have to do this in remote_wait_ns
6850 instead. If we fetch all queued events from stub, remote stub
6851 may exit and we have no chance to process them back in
6853 remote_state
*rs
= remote
->get_remote_state ();
6854 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
6858 stop_reply::~stop_reply ()
6860 for (cached_reg_t
®
: regcache
)
6864 static notif_event_up
6865 remote_notif_stop_alloc_reply ()
6867 return notif_event_up (new struct stop_reply ());
6870 /* A client of notification Stop. */
6872 struct notif_client notif_client_stop
=
6876 remote_notif_stop_parse
,
6877 remote_notif_stop_ack
,
6878 remote_notif_stop_can_get_pending_events
,
6879 remote_notif_stop_alloc_reply
,
6883 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6884 the pid of the process that owns the threads we want to check, or
6885 -1 if we want to check all threads. */
6888 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6891 if (ws
->kind
== TARGET_WAITKIND_FORKED
6892 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6894 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
6901 /* Return the thread's pending status used to determine whether the
6902 thread is a fork parent stopped at a fork event. */
6904 static struct target_waitstatus
*
6905 thread_pending_fork_status (struct thread_info
*thread
)
6907 if (thread
->suspend
.waitstatus_pending_p
)
6908 return &thread
->suspend
.waitstatus
;
6910 return &thread
->pending_follow
;
6913 /* Determine if THREAD is a pending fork parent thread. */
6916 is_pending_fork_parent_thread (struct thread_info
*thread
)
6918 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6921 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6924 /* If CONTEXT contains any fork child threads that have not been
6925 reported yet, remove them from the CONTEXT list. If such a
6926 thread exists it is because we are stopped at a fork catchpoint
6927 and have not yet called follow_fork, which will set up the
6928 host-side data structures for the new process. */
6931 remote_target::remove_new_fork_children (threads_listing_context
*context
)
6934 struct notif_client
*notif
= ¬if_client_stop
;
6936 /* For any threads stopped at a fork event, remove the corresponding
6937 fork child threads from the CONTEXT list. */
6938 for (thread_info
*thread
: all_non_exited_threads ())
6940 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6942 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
6943 context
->remove_thread (ws
->value
.related_pid
);
6946 /* Check for any pending fork events (not reported or processed yet)
6947 in process PID and remove those fork child threads from the
6948 CONTEXT list as well. */
6949 remote_notif_get_pending_events (notif
);
6950 for (auto &event
: get_remote_state ()->stop_reply_queue
)
6951 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6952 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
6953 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
6954 context
->remove_thread (event
->ws
.value
.related_pid
);
6957 /* Check whether any event pending in the vStopped queue would prevent
6958 a global or process wildcard vCont action. Clear
6959 *may_global_wildcard if we can't do a global wildcard (vCont;c),
6960 and clear the event inferior's may_wildcard_vcont flag if we can't
6961 do a process-wide wildcard resume (vCont;c:pPID.-1). */
6964 remote_target::check_pending_events_prevent_wildcard_vcont
6965 (int *may_global_wildcard
)
6967 struct notif_client
*notif
= ¬if_client_stop
;
6969 remote_notif_get_pending_events (notif
);
6970 for (auto &event
: get_remote_state ()->stop_reply_queue
)
6972 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
6973 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
6976 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6977 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
6978 *may_global_wildcard
= 0;
6980 struct inferior
*inf
= find_inferior_ptid (event
->ptid
);
6982 /* This may be the first time we heard about this process.
6983 Regardless, we must not do a global wildcard resume, otherwise
6984 we'd resume this process too. */
6985 *may_global_wildcard
= 0;
6987 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
6991 /* Discard all pending stop replies of inferior INF. */
6994 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
6996 struct stop_reply
*reply
;
6997 struct remote_state
*rs
= get_remote_state ();
6998 struct remote_notif_state
*rns
= rs
->notif_state
;
7000 /* This function can be notified when an inferior exists. When the
7001 target is not remote, the notification state is NULL. */
7002 if (rs
->remote_desc
== NULL
)
7005 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7007 /* Discard the in-flight notification. */
7008 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7011 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7014 /* Discard the stop replies we have already pulled with
7016 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7017 rs
->stop_reply_queue
.end (),
7018 [=] (const stop_reply_up
&event
)
7020 return event
->ptid
.pid () == inf
->pid
;
7022 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7025 /* Discard the stop replies for RS in stop_reply_queue. */
7028 remote_target::discard_pending_stop_replies_in_queue ()
7030 remote_state
*rs
= get_remote_state ();
7032 /* Discard the stop replies we have already pulled with
7034 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7035 rs
->stop_reply_queue
.end (),
7036 [=] (const stop_reply_up
&event
)
7038 return event
->rs
== rs
;
7040 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7043 /* Remove the first reply in 'stop_reply_queue' which matches
7047 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7049 remote_state
*rs
= get_remote_state ();
7051 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7052 rs
->stop_reply_queue
.end (),
7053 [=] (const stop_reply_up
&event
)
7055 return event
->ptid
.matches (ptid
);
7057 struct stop_reply
*result
;
7058 if (iter
== rs
->stop_reply_queue
.end ())
7062 result
= iter
->release ();
7063 rs
->stop_reply_queue
.erase (iter
);
7067 fprintf_unfiltered (gdb_stdlog
,
7068 "notif: discard queued event: 'Stop' in %s\n",
7069 target_pid_to_str (ptid
).c_str ());
7074 /* Look for a queued stop reply belonging to PTID. If one is found,
7075 remove it from the queue, and return it. Returns NULL if none is
7076 found. If there are still queued events left to process, tell the
7077 event loop to get back to target_wait soon. */
7080 remote_target::queued_stop_reply (ptid_t ptid
)
7082 remote_state
*rs
= get_remote_state ();
7083 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7085 if (!rs
->stop_reply_queue
.empty ())
7087 /* There's still at least an event left. */
7088 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7094 /* Push a fully parsed stop reply in the stop reply queue. Since we
7095 know that we now have at least one queued event left to pass to the
7096 core side, tell the event loop to get back to target_wait soon. */
7099 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7101 remote_state
*rs
= get_remote_state ();
7102 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7105 fprintf_unfiltered (gdb_stdlog
,
7106 "notif: push 'Stop' %s to queue %d\n",
7107 target_pid_to_str (new_event
->ptid
).c_str (),
7108 int (rs
->stop_reply_queue
.size ()));
7110 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7113 /* Returns true if we have a stop reply for PTID. */
7116 remote_target::peek_stop_reply (ptid_t ptid
)
7118 remote_state
*rs
= get_remote_state ();
7119 for (auto &event
: rs
->stop_reply_queue
)
7120 if (ptid
== event
->ptid
7121 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7126 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7127 starting with P and ending with PEND matches PREFIX. */
7130 strprefix (const char *p
, const char *pend
, const char *prefix
)
7132 for ( ; p
< pend
; p
++, prefix
++)
7135 return *prefix
== '\0';
7138 /* Parse the stop reply in BUF. Either the function succeeds, and the
7139 result is stored in EVENT, or throws an error. */
7142 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7144 remote_arch_state
*rsa
= NULL
;
7149 event
->ptid
= null_ptid
;
7150 event
->rs
= get_remote_state ();
7151 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7152 event
->ws
.value
.integer
= 0;
7153 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7154 event
->regcache
.clear ();
7159 case 'T': /* Status with PC, SP, FP, ... */
7160 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7161 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7163 n... = register number
7164 r... = register contents
7167 p
= &buf
[3]; /* after Txx */
7173 p1
= strchr (p
, ':');
7175 error (_("Malformed packet(a) (missing colon): %s\n\
7179 error (_("Malformed packet(a) (missing register number): %s\n\
7183 /* Some "registers" are actually extended stop information.
7184 Note if you're adding a new entry here: GDB 7.9 and
7185 earlier assume that all register "numbers" that start
7186 with an hex digit are real register numbers. Make sure
7187 the server only sends such a packet if it knows the
7188 client understands it. */
7190 if (strprefix (p
, p1
, "thread"))
7191 event
->ptid
= read_ptid (++p1
, &p
);
7192 else if (strprefix (p
, p1
, "syscall_entry"))
7196 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7197 p
= unpack_varlen_hex (++p1
, &sysno
);
7198 event
->ws
.value
.syscall_number
= (int) sysno
;
7200 else if (strprefix (p
, p1
, "syscall_return"))
7204 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7205 p
= unpack_varlen_hex (++p1
, &sysno
);
7206 event
->ws
.value
.syscall_number
= (int) sysno
;
7208 else if (strprefix (p
, p1
, "watch")
7209 || strprefix (p
, p1
, "rwatch")
7210 || strprefix (p
, p1
, "awatch"))
7212 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7213 p
= unpack_varlen_hex (++p1
, &addr
);
7214 event
->watch_data_address
= (CORE_ADDR
) addr
;
7216 else if (strprefix (p
, p1
, "swbreak"))
7218 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7220 /* Make sure the stub doesn't forget to indicate support
7222 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7223 error (_("Unexpected swbreak stop reason"));
7225 /* The value part is documented as "must be empty",
7226 though we ignore it, in case we ever decide to make
7227 use of it in a backward compatible way. */
7228 p
= strchrnul (p1
+ 1, ';');
7230 else if (strprefix (p
, p1
, "hwbreak"))
7232 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7234 /* Make sure the stub doesn't forget to indicate support
7236 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7237 error (_("Unexpected hwbreak stop reason"));
7240 p
= strchrnul (p1
+ 1, ';');
7242 else if (strprefix (p
, p1
, "library"))
7244 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7245 p
= strchrnul (p1
+ 1, ';');
7247 else if (strprefix (p
, p1
, "replaylog"))
7249 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7250 /* p1 will indicate "begin" or "end", but it makes
7251 no difference for now, so ignore it. */
7252 p
= strchrnul (p1
+ 1, ';');
7254 else if (strprefix (p
, p1
, "core"))
7258 p
= unpack_varlen_hex (++p1
, &c
);
7261 else if (strprefix (p
, p1
, "fork"))
7263 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7264 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7266 else if (strprefix (p
, p1
, "vfork"))
7268 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7269 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7271 else if (strprefix (p
, p1
, "vforkdone"))
7273 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7274 p
= strchrnul (p1
+ 1, ';');
7276 else if (strprefix (p
, p1
, "exec"))
7281 /* Determine the length of the execd pathname. */
7282 p
= unpack_varlen_hex (++p1
, &ignored
);
7283 pathlen
= (p
- p1
) / 2;
7285 /* Save the pathname for event reporting and for
7286 the next run command. */
7287 gdb::unique_xmalloc_ptr
<char[]> pathname
7288 ((char *) xmalloc (pathlen
+ 1));
7289 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7290 pathname
[pathlen
] = '\0';
7292 /* This is freed during event handling. */
7293 event
->ws
.value
.execd_pathname
= pathname
.release ();
7294 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7296 /* Skip the registers included in this packet, since
7297 they may be for an architecture different from the
7298 one used by the original program. */
7301 else if (strprefix (p
, p1
, "create"))
7303 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7304 p
= strchrnul (p1
+ 1, ';');
7313 p
= strchrnul (p1
+ 1, ';');
7318 /* Maybe a real ``P'' register number. */
7319 p_temp
= unpack_varlen_hex (p
, &pnum
);
7320 /* If the first invalid character is the colon, we got a
7321 register number. Otherwise, it's an unknown stop
7325 /* If we haven't parsed the event's thread yet, find
7326 it now, in order to find the architecture of the
7327 reported expedited registers. */
7328 if (event
->ptid
== null_ptid
)
7330 const char *thr
= strstr (p1
+ 1, ";thread:");
7332 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7336 /* Either the current thread hasn't changed,
7337 or the inferior is not multi-threaded.
7338 The event must be for the thread we last
7339 set as (or learned as being) current. */
7340 event
->ptid
= event
->rs
->general_thread
;
7346 inferior
*inf
= (event
->ptid
== null_ptid
7348 : find_inferior_ptid (event
->ptid
));
7349 /* If this is the first time we learn anything
7350 about this process, skip the registers
7351 included in this packet, since we don't yet
7352 know which architecture to use to parse them.
7353 We'll determine the architecture later when
7354 we process the stop reply and retrieve the
7355 target description, via
7356 remote_notice_new_inferior ->
7357 post_create_inferior. */
7360 p
= strchrnul (p1
+ 1, ';');
7365 event
->arch
= inf
->gdbarch
;
7366 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7370 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7371 cached_reg_t cached_reg
;
7374 error (_("Remote sent bad register number %s: %s\n\
7376 hex_string (pnum
), p
, buf
);
7378 cached_reg
.num
= reg
->regnum
;
7379 cached_reg
.data
= (gdb_byte
*)
7380 xmalloc (register_size (event
->arch
, reg
->regnum
));
7383 fieldsize
= hex2bin (p
, cached_reg
.data
,
7384 register_size (event
->arch
, reg
->regnum
));
7386 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7387 warning (_("Remote reply is too short: %s"), buf
);
7389 event
->regcache
.push_back (cached_reg
);
7393 /* Not a number. Silently skip unknown optional
7395 p
= strchrnul (p1
+ 1, ';');
7400 error (_("Remote register badly formatted: %s\nhere: %s"),
7405 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7409 case 'S': /* Old style status, just signal only. */
7413 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7414 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7415 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7416 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7418 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7421 case 'w': /* Thread exited. */
7425 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7426 p
= unpack_varlen_hex (&buf
[1], &value
);
7427 event
->ws
.value
.integer
= value
;
7429 error (_("stop reply packet badly formatted: %s"), buf
);
7430 event
->ptid
= read_ptid (++p
, NULL
);
7433 case 'W': /* Target exited. */
7439 /* GDB used to accept only 2 hex chars here. Stubs should
7440 only send more if they detect GDB supports multi-process
7442 p
= unpack_varlen_hex (&buf
[1], &value
);
7446 /* The remote process exited. */
7447 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7448 event
->ws
.value
.integer
= value
;
7452 /* The remote process exited with a signal. */
7453 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7454 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7455 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7457 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7460 /* If no process is specified, assume inferior_ptid. */
7461 pid
= inferior_ptid
.pid ();
7470 else if (startswith (p
, "process:"))
7474 p
+= sizeof ("process:") - 1;
7475 unpack_varlen_hex (p
, &upid
);
7479 error (_("unknown stop reply packet: %s"), buf
);
7482 error (_("unknown stop reply packet: %s"), buf
);
7483 event
->ptid
= ptid_t (pid
);
7487 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7488 event
->ptid
= minus_one_ptid
;
7492 if (target_is_non_stop_p () && event
->ptid
== null_ptid
)
7493 error (_("No process or thread specified in stop reply: %s"), buf
);
7496 /* When the stub wants to tell GDB about a new notification reply, it
7497 sends a notification (%Stop, for example). Those can come it at
7498 any time, hence, we have to make sure that any pending
7499 putpkt/getpkt sequence we're making is finished, before querying
7500 the stub for more events with the corresponding ack command
7501 (vStopped, for example). E.g., if we started a vStopped sequence
7502 immediately upon receiving the notification, something like this
7510 1.6) <-- (registers reply to step #1.3)
7512 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7515 To solve this, whenever we parse a %Stop notification successfully,
7516 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7517 doing whatever we were doing:
7523 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7524 2.5) <-- (registers reply to step #2.3)
7526 Eventually after step #2.5, we return to the event loop, which
7527 notices there's an event on the
7528 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7529 associated callback --- the function below. At this point, we're
7530 always safe to start a vStopped sequence. :
7533 2.7) <-- T05 thread:2
7539 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7541 struct remote_state
*rs
= get_remote_state ();
7543 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7546 fprintf_unfiltered (gdb_stdlog
,
7547 "notif: process: '%s' ack pending event\n",
7551 nc
->ack (this, nc
, rs
->buf
.data (),
7552 rs
->notif_state
->pending_event
[nc
->id
]);
7553 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7557 getpkt (&rs
->buf
, 0);
7558 if (strcmp (rs
->buf
.data (), "OK") == 0)
7561 remote_notif_ack (this, nc
, rs
->buf
.data ());
7567 fprintf_unfiltered (gdb_stdlog
,
7568 "notif: process: '%s' no pending reply\n",
7573 /* Wrapper around remote_target::remote_notif_get_pending_events to
7574 avoid having to export the whole remote_target class. */
7577 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7579 remote
->remote_notif_get_pending_events (nc
);
7582 /* Called when it is decided that STOP_REPLY holds the info of the
7583 event that is to be returned to the core. This function always
7584 destroys STOP_REPLY. */
7587 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7588 struct target_waitstatus
*status
)
7592 *status
= stop_reply
->ws
;
7593 ptid
= stop_reply
->ptid
;
7595 /* If no thread/process was reported by the stub, assume the current
7597 if (ptid
== null_ptid
)
7598 ptid
= inferior_ptid
;
7600 if (status
->kind
!= TARGET_WAITKIND_EXITED
7601 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7602 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7604 /* Expedited registers. */
7605 if (!stop_reply
->regcache
.empty ())
7607 struct regcache
*regcache
7608 = get_thread_arch_regcache (ptid
, stop_reply
->arch
);
7610 for (cached_reg_t
®
: stop_reply
->regcache
)
7612 regcache
->raw_supply (reg
.num
, reg
.data
);
7616 stop_reply
->regcache
.clear ();
7619 remote_notice_new_inferior (ptid
, 0);
7620 remote_thread_info
*remote_thr
= get_remote_thread_info (ptid
);
7621 remote_thr
->core
= stop_reply
->core
;
7622 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7623 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7624 remote_thr
->vcont_resumed
= 0;
7631 /* The non-stop mode version of target_wait. */
7634 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7636 struct remote_state
*rs
= get_remote_state ();
7637 struct stop_reply
*stop_reply
;
7641 /* If in non-stop mode, get out of getpkt even if a
7642 notification is received. */
7644 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7647 if (ret
!= -1 && !is_notif
)
7650 case 'E': /* Error of some sort. */
7651 /* We're out of sync with the target now. Did it continue
7652 or not? We can't tell which thread it was in non-stop,
7653 so just ignore this. */
7654 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7656 case 'O': /* Console output. */
7657 remote_console_output (&rs
->buf
[1]);
7660 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7664 /* Acknowledge a pending stop reply that may have arrived in the
7666 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7667 remote_notif_get_pending_events (¬if_client_stop
);
7669 /* If indeed we noticed a stop reply, we're done. */
7670 stop_reply
= queued_stop_reply (ptid
);
7671 if (stop_reply
!= NULL
)
7672 return process_stop_reply (stop_reply
, status
);
7674 /* Still no event. If we're just polling for an event, then
7675 return to the event loop. */
7676 if (options
& TARGET_WNOHANG
)
7678 status
->kind
= TARGET_WAITKIND_IGNORE
;
7679 return minus_one_ptid
;
7682 /* Otherwise do a blocking wait. */
7683 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7687 /* Wait until the remote machine stops, then return, storing status in
7688 STATUS just as `wait' would. */
7691 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
, int options
)
7693 struct remote_state
*rs
= get_remote_state ();
7694 ptid_t event_ptid
= null_ptid
;
7696 struct stop_reply
*stop_reply
;
7700 status
->kind
= TARGET_WAITKIND_IGNORE
;
7701 status
->value
.integer
= 0;
7703 stop_reply
= queued_stop_reply (ptid
);
7704 if (stop_reply
!= NULL
)
7705 return process_stop_reply (stop_reply
, status
);
7707 if (rs
->cached_wait_status
)
7708 /* Use the cached wait status, but only once. */
7709 rs
->cached_wait_status
= 0;
7714 int forever
= ((options
& TARGET_WNOHANG
) == 0
7715 && rs
->wait_forever_enabled_p
);
7717 if (!rs
->waiting_for_stop_reply
)
7719 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7720 return minus_one_ptid
;
7723 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7724 _never_ wait for ever -> test on target_is_async_p().
7725 However, before we do that we need to ensure that the caller
7726 knows how to take the target into/out of async mode. */
7727 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
7729 /* GDB gets a notification. Return to core as this event is
7731 if (ret
!= -1 && is_notif
)
7732 return minus_one_ptid
;
7734 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7735 return minus_one_ptid
;
7738 buf
= rs
->buf
.data ();
7740 /* Assume that the target has acknowledged Ctrl-C unless we receive
7741 an 'F' or 'O' packet. */
7742 if (buf
[0] != 'F' && buf
[0] != 'O')
7743 rs
->ctrlc_pending_p
= 0;
7747 case 'E': /* Error of some sort. */
7748 /* We're out of sync with the target now. Did it continue or
7749 not? Not is more likely, so report a stop. */
7750 rs
->waiting_for_stop_reply
= 0;
7752 warning (_("Remote failure reply: %s"), buf
);
7753 status
->kind
= TARGET_WAITKIND_STOPPED
;
7754 status
->value
.sig
= GDB_SIGNAL_0
;
7756 case 'F': /* File-I/O request. */
7757 /* GDB may access the inferior memory while handling the File-I/O
7758 request, but we don't want GDB accessing memory while waiting
7759 for a stop reply. See the comments in putpkt_binary. Set
7760 waiting_for_stop_reply to 0 temporarily. */
7761 rs
->waiting_for_stop_reply
= 0;
7762 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
7763 rs
->ctrlc_pending_p
= 0;
7764 /* GDB handled the File-I/O request, and the target is running
7765 again. Keep waiting for events. */
7766 rs
->waiting_for_stop_reply
= 1;
7768 case 'N': case 'T': case 'S': case 'X': case 'W':
7770 /* There is a stop reply to handle. */
7771 rs
->waiting_for_stop_reply
= 0;
7774 = (struct stop_reply
*) remote_notif_parse (this,
7778 event_ptid
= process_stop_reply (stop_reply
, status
);
7781 case 'O': /* Console output. */
7782 remote_console_output (buf
+ 1);
7785 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7787 /* Zero length reply means that we tried 'S' or 'C' and the
7788 remote system doesn't support it. */
7789 target_terminal::ours_for_output ();
7791 ("Can't send signals to this remote system. %s not sent.\n",
7792 gdb_signal_to_name (rs
->last_sent_signal
));
7793 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7794 target_terminal::inferior ();
7796 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7802 warning (_("Invalid remote reply: %s"), buf
);
7806 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7807 return minus_one_ptid
;
7808 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7810 /* Nothing interesting happened. If we're doing a non-blocking
7811 poll, we're done. Otherwise, go back to waiting. */
7812 if (options
& TARGET_WNOHANG
)
7813 return minus_one_ptid
;
7817 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7818 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7820 if (event_ptid
!= null_ptid
)
7821 record_currthread (rs
, event_ptid
);
7823 event_ptid
= inferior_ptid
;
7826 /* A process exit. Invalidate our notion of current thread. */
7827 record_currthread (rs
, minus_one_ptid
);
7832 /* Wait until the remote machine stops, then return, storing status in
7833 STATUS just as `wait' would. */
7836 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7840 if (target_is_non_stop_p ())
7841 event_ptid
= wait_ns (ptid
, status
, options
);
7843 event_ptid
= wait_as (ptid
, status
, options
);
7845 if (target_is_async_p ())
7847 remote_state
*rs
= get_remote_state ();
7849 /* If there are are events left in the queue tell the event loop
7851 if (!rs
->stop_reply_queue
.empty ())
7852 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7858 /* Fetch a single register using a 'p' packet. */
7861 remote_target::fetch_register_using_p (struct regcache
*regcache
,
7864 struct gdbarch
*gdbarch
= regcache
->arch ();
7865 struct remote_state
*rs
= get_remote_state ();
7867 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7870 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7873 if (reg
->pnum
== -1)
7876 p
= rs
->buf
.data ();
7878 p
+= hexnumstr (p
, reg
->pnum
);
7881 getpkt (&rs
->buf
, 0);
7883 buf
= rs
->buf
.data ();
7885 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
7889 case PACKET_UNKNOWN
:
7892 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7893 gdbarch_register_name (regcache
->arch (),
7898 /* If this register is unfetchable, tell the regcache. */
7901 regcache
->raw_supply (reg
->regnum
, NULL
);
7905 /* Otherwise, parse and supply the value. */
7911 error (_("fetch_register_using_p: early buf termination"));
7913 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7916 regcache
->raw_supply (reg
->regnum
, regp
);
7920 /* Fetch the registers included in the target's 'g' packet. */
7923 remote_target::send_g_packet ()
7925 struct remote_state
*rs
= get_remote_state ();
7928 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
7930 getpkt (&rs
->buf
, 0);
7931 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
7932 error (_("Could not read registers; remote failure reply '%s'"),
7935 /* We can get out of synch in various cases. If the first character
7936 in the buffer is not a hex character, assume that has happened
7937 and try to fetch another packet to read. */
7938 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
7939 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
7940 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
7941 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
7944 fprintf_unfiltered (gdb_stdlog
,
7945 "Bad register packet; fetching a new packet\n");
7946 getpkt (&rs
->buf
, 0);
7949 buf_len
= strlen (rs
->buf
.data ());
7951 /* Sanity check the received packet. */
7952 if (buf_len
% 2 != 0)
7953 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
7959 remote_target::process_g_packet (struct regcache
*regcache
)
7961 struct gdbarch
*gdbarch
= regcache
->arch ();
7962 struct remote_state
*rs
= get_remote_state ();
7963 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
7968 buf_len
= strlen (rs
->buf
.data ());
7970 /* Further sanity checks, with knowledge of the architecture. */
7971 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
7972 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
7974 rsa
->sizeof_g_packet
, buf_len
/ 2,
7977 /* Save the size of the packet sent to us by the target. It is used
7978 as a heuristic when determining the max size of packets that the
7979 target can safely receive. */
7980 if (rsa
->actual_register_packet_size
== 0)
7981 rsa
->actual_register_packet_size
= buf_len
;
7983 /* If this is smaller than we guessed the 'g' packet would be,
7984 update our records. A 'g' reply that doesn't include a register's
7985 value implies either that the register is not available, or that
7986 the 'p' packet must be used. */
7987 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
7989 long sizeof_g_packet
= buf_len
/ 2;
7991 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
7993 long offset
= rsa
->regs
[i
].offset
;
7994 long reg_size
= register_size (gdbarch
, i
);
7996 if (rsa
->regs
[i
].pnum
== -1)
7999 if (offset
>= sizeof_g_packet
)
8000 rsa
->regs
[i
].in_g_packet
= 0;
8001 else if (offset
+ reg_size
> sizeof_g_packet
)
8002 error (_("Truncated register %d in remote 'g' packet"), i
);
8004 rsa
->regs
[i
].in_g_packet
= 1;
8007 /* Looks valid enough, we can assume this is the correct length
8008 for a 'g' packet. It's important not to adjust
8009 rsa->sizeof_g_packet if we have truncated registers otherwise
8010 this "if" won't be run the next time the method is called
8011 with a packet of the same size and one of the internal errors
8012 below will trigger instead. */
8013 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8016 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8018 /* Unimplemented registers read as all bits zero. */
8019 memset (regs
, 0, rsa
->sizeof_g_packet
);
8021 /* Reply describes registers byte by byte, each byte encoded as two
8022 hex characters. Suck them all up, then supply them to the
8023 register cacheing/storage mechanism. */
8025 p
= rs
->buf
.data ();
8026 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8028 if (p
[0] == 0 || p
[1] == 0)
8029 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8030 internal_error (__FILE__
, __LINE__
,
8031 _("unexpected end of 'g' packet reply"));
8033 if (p
[0] == 'x' && p
[1] == 'x')
8034 regs
[i
] = 0; /* 'x' */
8036 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8040 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8042 struct packet_reg
*r
= &rsa
->regs
[i
];
8043 long reg_size
= register_size (gdbarch
, i
);
8047 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8048 /* This shouldn't happen - we adjusted in_g_packet above. */
8049 internal_error (__FILE__
, __LINE__
,
8050 _("unexpected end of 'g' packet reply"));
8051 else if (rs
->buf
[r
->offset
* 2] == 'x')
8053 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8054 /* The register isn't available, mark it as such (at
8055 the same time setting the value to zero). */
8056 regcache
->raw_supply (r
->regnum
, NULL
);
8059 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8065 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8068 process_g_packet (regcache
);
8071 /* Make the remote selected traceframe match GDB's selected
8075 remote_target::set_remote_traceframe ()
8078 struct remote_state
*rs
= get_remote_state ();
8080 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8083 /* Avoid recursion, remote_trace_find calls us again. */
8084 rs
->remote_traceframe_number
= get_traceframe_number ();
8086 newnum
= target_trace_find (tfind_number
,
8087 get_traceframe_number (), 0, 0, NULL
);
8089 /* Should not happen. If it does, all bets are off. */
8090 if (newnum
!= get_traceframe_number ())
8091 warning (_("could not set remote traceframe"));
8095 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8097 struct gdbarch
*gdbarch
= regcache
->arch ();
8098 struct remote_state
*rs
= get_remote_state ();
8099 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8102 set_remote_traceframe ();
8103 set_general_thread (regcache
->ptid ());
8107 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8109 gdb_assert (reg
!= NULL
);
8111 /* If this register might be in the 'g' packet, try that first -
8112 we are likely to read more than one register. If this is the
8113 first 'g' packet, we might be overly optimistic about its
8114 contents, so fall back to 'p'. */
8115 if (reg
->in_g_packet
)
8117 fetch_registers_using_g (regcache
);
8118 if (reg
->in_g_packet
)
8122 if (fetch_register_using_p (regcache
, reg
))
8125 /* This register is not available. */
8126 regcache
->raw_supply (reg
->regnum
, NULL
);
8131 fetch_registers_using_g (regcache
);
8133 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8134 if (!rsa
->regs
[i
].in_g_packet
)
8135 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8137 /* This register is not available. */
8138 regcache
->raw_supply (i
, NULL
);
8142 /* Prepare to store registers. Since we may send them all (using a
8143 'G' request), we have to read out the ones we don't want to change
8147 remote_target::prepare_to_store (struct regcache
*regcache
)
8149 struct remote_state
*rs
= get_remote_state ();
8150 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8153 /* Make sure the entire registers array is valid. */
8154 switch (packet_support (PACKET_P
))
8156 case PACKET_DISABLE
:
8157 case PACKET_SUPPORT_UNKNOWN
:
8158 /* Make sure all the necessary registers are cached. */
8159 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8160 if (rsa
->regs
[i
].in_g_packet
)
8161 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8168 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8169 packet was not recognized. */
8172 remote_target::store_register_using_P (const struct regcache
*regcache
,
8175 struct gdbarch
*gdbarch
= regcache
->arch ();
8176 struct remote_state
*rs
= get_remote_state ();
8177 /* Try storing a single register. */
8178 char *buf
= rs
->buf
.data ();
8179 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8182 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8185 if (reg
->pnum
== -1)
8188 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8189 p
= buf
+ strlen (buf
);
8190 regcache
->raw_collect (reg
->regnum
, regp
);
8191 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8193 getpkt (&rs
->buf
, 0);
8195 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8200 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8201 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8202 case PACKET_UNKNOWN
:
8205 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8209 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8210 contents of the register cache buffer. FIXME: ignores errors. */
8213 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8215 struct remote_state
*rs
= get_remote_state ();
8216 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8220 /* Extract all the registers in the regcache copying them into a
8225 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8226 memset (regs
, 0, rsa
->sizeof_g_packet
);
8227 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8229 struct packet_reg
*r
= &rsa
->regs
[i
];
8232 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8236 /* Command describes registers byte by byte,
8237 each byte encoded as two hex characters. */
8238 p
= rs
->buf
.data ();
8240 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8242 getpkt (&rs
->buf
, 0);
8243 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8244 error (_("Could not write registers; remote failure reply '%s'"),
8248 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8249 of the register cache buffer. FIXME: ignores errors. */
8252 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8254 struct gdbarch
*gdbarch
= regcache
->arch ();
8255 struct remote_state
*rs
= get_remote_state ();
8256 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8259 set_remote_traceframe ();
8260 set_general_thread (regcache
->ptid ());
8264 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8266 gdb_assert (reg
!= NULL
);
8268 /* Always prefer to store registers using the 'P' packet if
8269 possible; we often change only a small number of registers.
8270 Sometimes we change a larger number; we'd need help from a
8271 higher layer to know to use 'G'. */
8272 if (store_register_using_P (regcache
, reg
))
8275 /* For now, don't complain if we have no way to write the
8276 register. GDB loses track of unavailable registers too
8277 easily. Some day, this may be an error. We don't have
8278 any way to read the register, either... */
8279 if (!reg
->in_g_packet
)
8282 store_registers_using_G (regcache
);
8286 store_registers_using_G (regcache
);
8288 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8289 if (!rsa
->regs
[i
].in_g_packet
)
8290 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8291 /* See above for why we do not issue an error here. */
8296 /* Return the number of hex digits in num. */
8299 hexnumlen (ULONGEST num
)
8303 for (i
= 0; num
!= 0; i
++)
8306 return std::max (i
, 1);
8309 /* Set BUF to the minimum number of hex digits representing NUM. */
8312 hexnumstr (char *buf
, ULONGEST num
)
8314 int len
= hexnumlen (num
);
8316 return hexnumnstr (buf
, num
, len
);
8320 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8323 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8329 for (i
= width
- 1; i
>= 0; i
--)
8331 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8338 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8341 remote_address_masked (CORE_ADDR addr
)
8343 unsigned int address_size
= remote_address_size
;
8345 /* If "remoteaddresssize" was not set, default to target address size. */
8347 address_size
= gdbarch_addr_bit (target_gdbarch ());
8349 if (address_size
> 0
8350 && address_size
< (sizeof (ULONGEST
) * 8))
8352 /* Only create a mask when that mask can safely be constructed
8353 in a ULONGEST variable. */
8356 mask
= (mask
<< address_size
) - 1;
8362 /* Determine whether the remote target supports binary downloading.
8363 This is accomplished by sending a no-op memory write of zero length
8364 to the target at the specified address. It does not suffice to send
8365 the whole packet, since many stubs strip the eighth bit and
8366 subsequently compute a wrong checksum, which causes real havoc with
8369 NOTE: This can still lose if the serial line is not eight-bit
8370 clean. In cases like this, the user should clear "remote
8374 remote_target::check_binary_download (CORE_ADDR addr
)
8376 struct remote_state
*rs
= get_remote_state ();
8378 switch (packet_support (PACKET_X
))
8380 case PACKET_DISABLE
:
8384 case PACKET_SUPPORT_UNKNOWN
:
8388 p
= rs
->buf
.data ();
8390 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8392 p
+= hexnumstr (p
, (ULONGEST
) 0);
8396 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8397 getpkt (&rs
->buf
, 0);
8399 if (rs
->buf
[0] == '\0')
8402 fprintf_unfiltered (gdb_stdlog
,
8403 "binary downloading NOT "
8404 "supported by target\n");
8405 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8410 fprintf_unfiltered (gdb_stdlog
,
8411 "binary downloading supported by target\n");
8412 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8419 /* Helper function to resize the payload in order to try to get a good
8420 alignment. We try to write an amount of data such that the next write will
8421 start on an address aligned on REMOTE_ALIGN_WRITES. */
8424 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8426 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8429 /* Write memory data directly to the remote machine.
8430 This does not inform the data cache; the data cache uses this.
8431 HEADER is the starting part of the packet.
8432 MEMADDR is the address in the remote memory space.
8433 MYADDR is the address of the buffer in our space.
8434 LEN_UNITS is the number of addressable units to write.
8435 UNIT_SIZE is the length in bytes of an addressable unit.
8436 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8437 should send data as binary ('X'), or hex-encoded ('M').
8439 The function creates packet of the form
8440 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8442 where encoding of <DATA> is terminated by PACKET_FORMAT.
8444 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8447 Return the transferred status, error or OK (an
8448 'enum target_xfer_status' value). Save the number of addressable units
8449 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8451 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8452 exchange between gdb and the stub could look like (?? in place of the
8458 -> $M1000,3:eeeeffffeeee#??
8462 <- eeeeffffeeeedddd */
8465 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8466 const gdb_byte
*myaddr
,
8469 ULONGEST
*xfered_len_units
,
8470 char packet_format
, int use_length
)
8472 struct remote_state
*rs
= get_remote_state ();
8478 int payload_capacity_bytes
;
8479 int payload_length_bytes
;
8481 if (packet_format
!= 'X' && packet_format
!= 'M')
8482 internal_error (__FILE__
, __LINE__
,
8483 _("remote_write_bytes_aux: bad packet format"));
8486 return TARGET_XFER_EOF
;
8488 payload_capacity_bytes
= get_memory_write_packet_size ();
8490 /* The packet buffer will be large enough for the payload;
8491 get_memory_packet_size ensures this. */
8494 /* Compute the size of the actual payload by subtracting out the
8495 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8497 payload_capacity_bytes
-= strlen ("$,:#NN");
8499 /* The comma won't be used. */
8500 payload_capacity_bytes
+= 1;
8501 payload_capacity_bytes
-= strlen (header
);
8502 payload_capacity_bytes
-= hexnumlen (memaddr
);
8504 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8506 strcat (rs
->buf
.data (), header
);
8507 p
= rs
->buf
.data () + strlen (header
);
8509 /* Compute a best guess of the number of bytes actually transfered. */
8510 if (packet_format
== 'X')
8512 /* Best guess at number of bytes that will fit. */
8513 todo_units
= std::min (len_units
,
8514 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8516 payload_capacity_bytes
-= hexnumlen (todo_units
);
8517 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8521 /* Number of bytes that will fit. */
8523 = std::min (len_units
,
8524 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8526 payload_capacity_bytes
-= hexnumlen (todo_units
);
8527 todo_units
= std::min (todo_units
,
8528 (payload_capacity_bytes
/ unit_size
) / 2);
8531 if (todo_units
<= 0)
8532 internal_error (__FILE__
, __LINE__
,
8533 _("minimum packet size too small to write data"));
8535 /* If we already need another packet, then try to align the end
8536 of this packet to a useful boundary. */
8537 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8538 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8540 /* Append "<memaddr>". */
8541 memaddr
= remote_address_masked (memaddr
);
8542 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8549 /* Append the length and retain its location and size. It may need to be
8550 adjusted once the packet body has been created. */
8552 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8560 /* Append the packet body. */
8561 if (packet_format
== 'X')
8563 /* Binary mode. Send target system values byte by byte, in
8564 increasing byte addresses. Only escape certain critical
8566 payload_length_bytes
=
8567 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8568 &units_written
, payload_capacity_bytes
);
8570 /* If not all TODO units fit, then we'll need another packet. Make
8571 a second try to keep the end of the packet aligned. Don't do
8572 this if the packet is tiny. */
8573 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8577 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8579 if (new_todo_units
!= units_written
)
8580 payload_length_bytes
=
8581 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8582 (gdb_byte
*) p
, &units_written
,
8583 payload_capacity_bytes
);
8586 p
+= payload_length_bytes
;
8587 if (use_length
&& units_written
< todo_units
)
8589 /* Escape chars have filled up the buffer prematurely,
8590 and we have actually sent fewer units than planned.
8591 Fix-up the length field of the packet. Use the same
8592 number of characters as before. */
8593 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8595 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8600 /* Normal mode: Send target system values byte by byte, in
8601 increasing byte addresses. Each byte is encoded as a two hex
8603 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8604 units_written
= todo_units
;
8607 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8608 getpkt (&rs
->buf
, 0);
8610 if (rs
->buf
[0] == 'E')
8611 return TARGET_XFER_E_IO
;
8613 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8614 send fewer units than we'd planned. */
8615 *xfered_len_units
= (ULONGEST
) units_written
;
8616 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8619 /* Write memory data directly to the remote machine.
8620 This does not inform the data cache; the data cache uses this.
8621 MEMADDR is the address in the remote memory space.
8622 MYADDR is the address of the buffer in our space.
8623 LEN is the number of bytes.
8625 Return the transferred status, error or OK (an
8626 'enum target_xfer_status' value). Save the number of bytes
8627 transferred in *XFERED_LEN. Only transfer a single packet. */
8630 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8631 ULONGEST len
, int unit_size
,
8632 ULONGEST
*xfered_len
)
8634 const char *packet_format
= NULL
;
8636 /* Check whether the target supports binary download. */
8637 check_binary_download (memaddr
);
8639 switch (packet_support (PACKET_X
))
8642 packet_format
= "X";
8644 case PACKET_DISABLE
:
8645 packet_format
= "M";
8647 case PACKET_SUPPORT_UNKNOWN
:
8648 internal_error (__FILE__
, __LINE__
,
8649 _("remote_write_bytes: bad internal state"));
8651 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8654 return remote_write_bytes_aux (packet_format
,
8655 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8656 packet_format
[0], 1);
8659 /* Read memory data directly from the remote machine.
8660 This does not use the data cache; the data cache uses this.
8661 MEMADDR is the address in the remote memory space.
8662 MYADDR is the address of the buffer in our space.
8663 LEN_UNITS is the number of addressable memory units to read..
8664 UNIT_SIZE is the length in bytes of an addressable unit.
8666 Return the transferred status, error or OK (an
8667 'enum target_xfer_status' value). Save the number of bytes
8668 transferred in *XFERED_LEN_UNITS.
8670 See the comment of remote_write_bytes_aux for an example of
8671 memory read/write exchange between gdb and the stub. */
8674 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8676 int unit_size
, ULONGEST
*xfered_len_units
)
8678 struct remote_state
*rs
= get_remote_state ();
8679 int buf_size_bytes
; /* Max size of packet output buffer. */
8684 buf_size_bytes
= get_memory_read_packet_size ();
8685 /* The packet buffer will be large enough for the payload;
8686 get_memory_packet_size ensures this. */
8688 /* Number of units that will fit. */
8689 todo_units
= std::min (len_units
,
8690 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8692 /* Construct "m"<memaddr>","<len>". */
8693 memaddr
= remote_address_masked (memaddr
);
8694 p
= rs
->buf
.data ();
8696 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8698 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8701 getpkt (&rs
->buf
, 0);
8702 if (rs
->buf
[0] == 'E'
8703 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8704 && rs
->buf
[3] == '\0')
8705 return TARGET_XFER_E_IO
;
8706 /* Reply describes memory byte by byte, each byte encoded as two hex
8708 p
= rs
->buf
.data ();
8709 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8710 /* Return what we have. Let higher layers handle partial reads. */
8711 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8712 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8715 /* Using the set of read-only target sections of remote, read live
8718 For interface/parameters/return description see target.h,
8722 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
8726 ULONGEST
*xfered_len
)
8728 struct target_section
*secp
;
8729 struct target_section_table
*table
;
8731 secp
= target_section_by_addr (this, memaddr
);
8733 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
8735 struct target_section
*p
;
8736 ULONGEST memend
= memaddr
+ len
;
8738 table
= target_get_section_table (this);
8740 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8742 if (memaddr
>= p
->addr
)
8744 if (memend
<= p
->endaddr
)
8746 /* Entire transfer is within this section. */
8747 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8750 else if (memaddr
>= p
->endaddr
)
8752 /* This section ends before the transfer starts. */
8757 /* This section overlaps the transfer. Just do half. */
8758 len
= p
->endaddr
- memaddr
;
8759 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8766 return TARGET_XFER_EOF
;
8769 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8770 first if the requested memory is unavailable in traceframe.
8771 Otherwise, fall back to remote_read_bytes_1. */
8774 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
8775 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8776 ULONGEST
*xfered_len
)
8779 return TARGET_XFER_EOF
;
8781 if (get_traceframe_number () != -1)
8783 std::vector
<mem_range
> available
;
8785 /* If we fail to get the set of available memory, then the
8786 target does not support querying traceframe info, and so we
8787 attempt reading from the traceframe anyway (assuming the
8788 target implements the old QTro packet then). */
8789 if (traceframe_available_memory (&available
, memaddr
, len
))
8791 if (available
.empty () || available
[0].start
!= memaddr
)
8793 enum target_xfer_status res
;
8795 /* Don't read into the traceframe's available
8797 if (!available
.empty ())
8799 LONGEST oldlen
= len
;
8801 len
= available
[0].start
- memaddr
;
8802 gdb_assert (len
<= oldlen
);
8805 /* This goes through the topmost target again. */
8806 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
8807 len
, unit_size
, xfered_len
);
8808 if (res
== TARGET_XFER_OK
)
8809 return TARGET_XFER_OK
;
8812 /* No use trying further, we know some memory starting
8813 at MEMADDR isn't available. */
8815 return (*xfered_len
!= 0) ?
8816 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
8820 /* Don't try to read more than how much is available, in
8821 case the target implements the deprecated QTro packet to
8822 cater for older GDBs (the target's knowledge of read-only
8823 sections may be outdated by now). */
8824 len
= available
[0].length
;
8828 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8833 /* Sends a packet with content determined by the printf format string
8834 FORMAT and the remaining arguments, then gets the reply. Returns
8835 whether the packet was a success, a failure, or unknown. */
8838 remote_target::remote_send_printf (const char *format
, ...)
8840 struct remote_state
*rs
= get_remote_state ();
8841 int max_size
= get_remote_packet_size ();
8844 va_start (ap
, format
);
8847 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
8851 if (size
>= max_size
)
8852 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8854 if (putpkt (rs
->buf
) < 0)
8855 error (_("Communication problem with target."));
8858 getpkt (&rs
->buf
, 0);
8860 return packet_check_result (rs
->buf
);
8863 /* Flash writing can take quite some time. We'll set
8864 effectively infinite timeout for flash operations.
8865 In future, we'll need to decide on a better approach. */
8866 static const int remote_flash_timeout
= 1000;
8869 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
8871 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8872 enum packet_result ret
;
8873 scoped_restore restore_timeout
8874 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8876 ret
= remote_send_printf ("vFlashErase:%s,%s",
8877 phex (address
, addr_size
),
8881 case PACKET_UNKNOWN
:
8882 error (_("Remote target does not support flash erase"));
8884 error (_("Error erasing flash with vFlashErase packet"));
8891 remote_target::remote_flash_write (ULONGEST address
,
8892 ULONGEST length
, ULONGEST
*xfered_len
,
8893 const gdb_byte
*data
)
8895 scoped_restore restore_timeout
8896 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8897 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8902 remote_target::flash_done ()
8906 scoped_restore restore_timeout
8907 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8909 ret
= remote_send_printf ("vFlashDone");
8913 case PACKET_UNKNOWN
:
8914 error (_("Remote target does not support vFlashDone"));
8916 error (_("Error finishing flash operation"));
8923 remote_target::files_info ()
8925 puts_filtered ("Debugging a target over a serial line.\n");
8928 /* Stuff for dealing with the packets which are part of this protocol.
8929 See comment at top of file for details. */
8931 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8932 error to higher layers. Called when a serial error is detected.
8933 The exception message is STRING, followed by a colon and a blank,
8934 the system error message for errno at function entry and final dot
8935 for output compatibility with throw_perror_with_name. */
8938 unpush_and_perror (const char *string
)
8940 int saved_errno
= errno
;
8942 remote_unpush_target ();
8943 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
8944 safe_strerror (saved_errno
));
8947 /* Read a single character from the remote end. The current quit
8948 handler is overridden to avoid quitting in the middle of packet
8949 sequence, as that would break communication with the remote server.
8950 See remote_serial_quit_handler for more detail. */
8953 remote_target::readchar (int timeout
)
8956 struct remote_state
*rs
= get_remote_state ();
8959 scoped_restore restore_quit_target
8960 = make_scoped_restore (&curr_quit_handler_target
, this);
8961 scoped_restore restore_quit
8962 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
8964 rs
->got_ctrlc_during_io
= 0;
8966 ch
= serial_readchar (rs
->remote_desc
, timeout
);
8968 if (rs
->got_ctrlc_during_io
)
8975 switch ((enum serial_rc
) ch
)
8978 remote_unpush_target ();
8979 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
8982 unpush_and_perror (_("Remote communication error. "
8983 "Target disconnected."));
8985 case SERIAL_TIMEOUT
:
8991 /* Wrapper for serial_write that closes the target and throws if
8992 writing fails. The current quit handler is overridden to avoid
8993 quitting in the middle of packet sequence, as that would break
8994 communication with the remote server. See
8995 remote_serial_quit_handler for more detail. */
8998 remote_target::remote_serial_write (const char *str
, int len
)
9000 struct remote_state
*rs
= get_remote_state ();
9002 scoped_restore restore_quit_target
9003 = make_scoped_restore (&curr_quit_handler_target
, this);
9004 scoped_restore restore_quit
9005 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9007 rs
->got_ctrlc_during_io
= 0;
9009 if (serial_write (rs
->remote_desc
, str
, len
))
9011 unpush_and_perror (_("Remote communication error. "
9012 "Target disconnected."));
9015 if (rs
->got_ctrlc_during_io
)
9019 /* Return a string representing an escaped version of BUF, of len N.
9020 E.g. \n is converted to \\n, \t to \\t, etc. */
9023 escape_buffer (const char *buf
, int n
)
9027 stb
.putstrn (buf
, n
, '\\');
9028 return std::move (stb
.string ());
9031 /* Display a null-terminated packet on stdout, for debugging, using C
9035 print_packet (const char *buf
)
9037 puts_filtered ("\"");
9038 fputstr_filtered (buf
, '"', gdb_stdout
);
9039 puts_filtered ("\"");
9043 remote_target::putpkt (const char *buf
)
9045 return putpkt_binary (buf
, strlen (buf
));
9048 /* Wrapper around remote_target::putpkt to avoid exporting
9052 putpkt (remote_target
*remote
, const char *buf
)
9054 return remote
->putpkt (buf
);
9057 /* Send a packet to the remote machine, with error checking. The data
9058 of the packet is in BUF. The string in BUF can be at most
9059 get_remote_packet_size () - 5 to account for the $, # and checksum,
9060 and for a possible /0 if we are debugging (remote_debug) and want
9061 to print the sent packet as a string. */
9064 remote_target::putpkt_binary (const char *buf
, int cnt
)
9066 struct remote_state
*rs
= get_remote_state ();
9068 unsigned char csum
= 0;
9069 gdb::def_vector
<char> data (cnt
+ 6);
9070 char *buf2
= data
.data ();
9076 /* Catch cases like trying to read memory or listing threads while
9077 we're waiting for a stop reply. The remote server wouldn't be
9078 ready to handle this request, so we'd hang and timeout. We don't
9079 have to worry about this in synchronous mode, because in that
9080 case it's not possible to issue a command while the target is
9081 running. This is not a problem in non-stop mode, because in that
9082 case, the stub is always ready to process serial input. */
9083 if (!target_is_non_stop_p ()
9084 && target_is_async_p ()
9085 && rs
->waiting_for_stop_reply
)
9087 error (_("Cannot execute this command while the target is running.\n"
9088 "Use the \"interrupt\" command to stop the target\n"
9089 "and then try again."));
9092 /* We're sending out a new packet. Make sure we don't look at a
9093 stale cached response. */
9094 rs
->cached_wait_status
= 0;
9096 /* Copy the packet into buffer BUF2, encapsulating it
9097 and giving it a checksum. */
9102 for (i
= 0; i
< cnt
; i
++)
9108 *p
++ = tohex ((csum
>> 4) & 0xf);
9109 *p
++ = tohex (csum
& 0xf);
9111 /* Send it over and over until we get a positive ack. */
9115 int started_error_output
= 0;
9121 int len
= (int) (p
- buf2
);
9124 = escape_buffer (buf2
, std::min (len
, REMOTE_DEBUG_MAX_CHAR
));
9126 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9128 if (len
> REMOTE_DEBUG_MAX_CHAR
)
9129 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9130 len
- REMOTE_DEBUG_MAX_CHAR
);
9132 fprintf_unfiltered (gdb_stdlog
, "...");
9134 gdb_flush (gdb_stdlog
);
9136 remote_serial_write (buf2
, p
- buf2
);
9138 /* If this is a no acks version of the remote protocol, send the
9139 packet and move on. */
9143 /* Read until either a timeout occurs (-2) or '+' is read.
9144 Handle any notification that arrives in the mean time. */
9147 ch
= readchar (remote_timeout
);
9155 case SERIAL_TIMEOUT
:
9158 if (started_error_output
)
9160 putchar_unfiltered ('\n');
9161 started_error_output
= 0;
9170 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9174 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9176 case SERIAL_TIMEOUT
:
9180 break; /* Retransmit buffer. */
9184 fprintf_unfiltered (gdb_stdlog
,
9185 "Packet instead of Ack, ignoring it\n");
9186 /* It's probably an old response sent because an ACK
9187 was lost. Gobble up the packet and ack it so it
9188 doesn't get retransmitted when we resend this
9191 remote_serial_write ("+", 1);
9192 continue; /* Now, go look for +. */
9199 /* If we got a notification, handle it, and go back to looking
9201 /* We've found the start of a notification. Now
9202 collect the data. */
9203 val
= read_frame (&rs
->buf
);
9208 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9210 fprintf_unfiltered (gdb_stdlog
,
9211 " Notification received: %s\n",
9214 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9215 /* We're in sync now, rewait for the ack. */
9222 if (!started_error_output
)
9224 started_error_output
= 1;
9225 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9227 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9228 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9237 if (!started_error_output
)
9239 started_error_output
= 1;
9240 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9242 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9246 break; /* Here to retransmit. */
9250 /* This is wrong. If doing a long backtrace, the user should be
9251 able to get out next time we call QUIT, without anything as
9252 violent as interrupt_query. If we want to provide a way out of
9253 here without getting to the next QUIT, it should be based on
9254 hitting ^C twice as in remote_wait. */
9266 /* Come here after finding the start of a frame when we expected an
9267 ack. Do our best to discard the rest of this packet. */
9270 remote_target::skip_frame ()
9276 c
= readchar (remote_timeout
);
9279 case SERIAL_TIMEOUT
:
9280 /* Nothing we can do. */
9283 /* Discard the two bytes of checksum and stop. */
9284 c
= readchar (remote_timeout
);
9286 c
= readchar (remote_timeout
);
9289 case '*': /* Run length encoding. */
9290 /* Discard the repeat count. */
9291 c
= readchar (remote_timeout
);
9296 /* A regular character. */
9302 /* Come here after finding the start of the frame. Collect the rest
9303 into *BUF, verifying the checksum, length, and handling run-length
9304 compression. NUL terminate the buffer. If there is not enough room,
9307 Returns -1 on error, number of characters in buffer (ignoring the
9308 trailing NULL) on success. (could be extended to return one of the
9309 SERIAL status indications). */
9312 remote_target::read_frame (gdb::char_vector
*buf_p
)
9317 char *buf
= buf_p
->data ();
9318 struct remote_state
*rs
= get_remote_state ();
9325 c
= readchar (remote_timeout
);
9328 case SERIAL_TIMEOUT
:
9330 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9334 fputs_filtered ("Saw new packet start in middle of old one\n",
9336 return -1; /* Start a new packet, count retries. */
9339 unsigned char pktcsum
;
9345 check_0
= readchar (remote_timeout
);
9347 check_1
= readchar (remote_timeout
);
9349 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9352 fputs_filtered ("Timeout in checksum, retrying\n",
9356 else if (check_0
< 0 || check_1
< 0)
9359 fputs_filtered ("Communication error in checksum\n",
9364 /* Don't recompute the checksum; with no ack packets we
9365 don't have any way to indicate a packet retransmission
9370 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9371 if (csum
== pktcsum
)
9376 std::string str
= escape_buffer (buf
, bc
);
9378 fprintf_unfiltered (gdb_stdlog
,
9379 "Bad checksum, sentsum=0x%x, "
9380 "csum=0x%x, buf=%s\n",
9381 pktcsum
, csum
, str
.c_str ());
9383 /* Number of characters in buffer ignoring trailing
9387 case '*': /* Run length encoding. */
9392 c
= readchar (remote_timeout
);
9394 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9396 /* The character before ``*'' is repeated. */
9398 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9400 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9402 /* Make some more room in the buffer. */
9403 buf_p
->resize (buf_p
->size () + repeat
);
9404 buf
= buf_p
->data ();
9407 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9413 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9417 if (bc
>= buf_p
->size () - 1)
9419 /* Make some more room in the buffer. */
9420 buf_p
->resize (buf_p
->size () * 2);
9421 buf
= buf_p
->data ();
9431 /* Set this to the maximum number of seconds to wait instead of waiting forever
9432 in target_wait(). If this timer times out, then it generates an error and
9433 the command is aborted. This replaces most of the need for timeouts in the
9434 GDB test suite, and makes it possible to distinguish between a hung target
9435 and one with slow communications. */
9437 static int watchdog
= 0;
9439 show_watchdog (struct ui_file
*file
, int from_tty
,
9440 struct cmd_list_element
*c
, const char *value
)
9442 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9445 /* Read a packet from the remote machine, with error checking, and
9446 store it in *BUF. Resize *BUF if necessary to hold the result. If
9447 FOREVER, wait forever rather than timing out; this is used (in
9448 synchronous mode) to wait for a target that is is executing user
9450 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9451 don't have to change all the calls to getpkt to deal with the
9452 return value, because at the moment I don't know what the right
9453 thing to do it for those. */
9456 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9458 getpkt_sane (buf
, forever
);
9462 /* Read a packet from the remote machine, with error checking, and
9463 store it in *BUF. Resize *BUF if necessary to hold the result. If
9464 FOREVER, wait forever rather than timing out; this is used (in
9465 synchronous mode) to wait for a target that is is executing user
9466 code to stop. If FOREVER == 0, this function is allowed to time
9467 out gracefully and return an indication of this to the caller.
9468 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9469 consider receiving a notification enough reason to return to the
9470 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9471 holds a notification or not (a regular packet). */
9474 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9475 int forever
, int expecting_notif
,
9478 struct remote_state
*rs
= get_remote_state ();
9484 /* We're reading a new response. Make sure we don't look at a
9485 previously cached response. */
9486 rs
->cached_wait_status
= 0;
9488 strcpy (buf
->data (), "timeout");
9491 timeout
= watchdog
> 0 ? watchdog
: -1;
9492 else if (expecting_notif
)
9493 timeout
= 0; /* There should already be a char in the buffer. If
9496 timeout
= remote_timeout
;
9500 /* Process any number of notifications, and then return when
9504 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9506 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9508 /* This can loop forever if the remote side sends us
9509 characters continuously, but if it pauses, we'll get
9510 SERIAL_TIMEOUT from readchar because of timeout. Then
9511 we'll count that as a retry.
9513 Note that even when forever is set, we will only wait
9514 forever prior to the start of a packet. After that, we
9515 expect characters to arrive at a brisk pace. They should
9516 show up within remote_timeout intervals. */
9518 c
= readchar (timeout
);
9519 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9521 if (c
== SERIAL_TIMEOUT
)
9523 if (expecting_notif
)
9524 return -1; /* Don't complain, it's normal to not get
9525 anything in this case. */
9527 if (forever
) /* Watchdog went off? Kill the target. */
9529 remote_unpush_target ();
9530 throw_error (TARGET_CLOSE_ERROR
,
9531 _("Watchdog timeout has expired. "
9532 "Target detached."));
9535 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9539 /* We've found the start of a packet or notification.
9540 Now collect the data. */
9541 val
= read_frame (buf
);
9546 remote_serial_write ("-", 1);
9549 if (tries
> MAX_TRIES
)
9551 /* We have tried hard enough, and just can't receive the
9552 packet/notification. Give up. */
9553 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9555 /* Skip the ack char if we're in no-ack mode. */
9556 if (!rs
->noack_mode
)
9557 remote_serial_write ("+", 1);
9561 /* If we got an ordinary packet, return that to our caller. */
9567 = escape_buffer (buf
->data (),
9568 std::min (val
, REMOTE_DEBUG_MAX_CHAR
));
9570 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9573 if (val
> REMOTE_DEBUG_MAX_CHAR
)
9574 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9575 val
- REMOTE_DEBUG_MAX_CHAR
);
9577 fprintf_unfiltered (gdb_stdlog
, "\n");
9580 /* Skip the ack char if we're in no-ack mode. */
9581 if (!rs
->noack_mode
)
9582 remote_serial_write ("+", 1);
9583 if (is_notif
!= NULL
)
9588 /* If we got a notification, handle it, and go back to looking
9592 gdb_assert (c
== '%');
9596 std::string str
= escape_buffer (buf
->data (), val
);
9598 fprintf_unfiltered (gdb_stdlog
,
9599 " Notification received: %s\n",
9602 if (is_notif
!= NULL
)
9605 handle_notification (rs
->notif_state
, buf
->data ());
9607 /* Notifications require no acknowledgement. */
9609 if (expecting_notif
)
9616 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9618 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9622 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9625 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9628 /* Kill any new fork children of process PID that haven't been
9629 processed by follow_fork. */
9632 remote_target::kill_new_fork_children (int pid
)
9634 remote_state
*rs
= get_remote_state ();
9635 struct notif_client
*notif
= ¬if_client_stop
;
9637 /* Kill the fork child threads of any threads in process PID
9638 that are stopped at a fork event. */
9639 for (thread_info
*thread
: all_non_exited_threads ())
9641 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9643 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9645 int child_pid
= ws
->value
.related_pid
.pid ();
9648 res
= remote_vkill (child_pid
);
9650 error (_("Can't kill fork child process %d"), child_pid
);
9654 /* Check for any pending fork events (not reported or processed yet)
9655 in process PID and kill those fork child threads as well. */
9656 remote_notif_get_pending_events (notif
);
9657 for (auto &event
: rs
->stop_reply_queue
)
9658 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9660 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9663 res
= remote_vkill (child_pid
);
9665 error (_("Can't kill fork child process %d"), child_pid
);
9670 /* Target hook to kill the current inferior. */
9673 remote_target::kill ()
9676 int pid
= inferior_ptid
.pid ();
9677 struct remote_state
*rs
= get_remote_state ();
9679 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9681 /* If we're stopped while forking and we haven't followed yet,
9682 kill the child task. We need to do this before killing the
9683 parent task because if this is a vfork then the parent will
9685 kill_new_fork_children (pid
);
9687 res
= remote_vkill (pid
);
9690 target_mourn_inferior (inferior_ptid
);
9695 /* If we are in 'target remote' mode and we are killing the only
9696 inferior, then we will tell gdbserver to exit and unpush the
9698 if (res
== -1 && !remote_multi_process_p (rs
)
9699 && number_of_live_inferiors () == 1)
9703 /* We've killed the remote end, we get to mourn it. If we are
9704 not in extended mode, mourning the inferior also unpushes
9705 remote_ops from the target stack, which closes the remote
9707 target_mourn_inferior (inferior_ptid
);
9712 error (_("Can't kill process"));
9715 /* Send a kill request to the target using the 'vKill' packet. */
9718 remote_target::remote_vkill (int pid
)
9720 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9723 remote_state
*rs
= get_remote_state ();
9725 /* Tell the remote target to detach. */
9726 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
9728 getpkt (&rs
->buf
, 0);
9730 switch (packet_ok (rs
->buf
,
9731 &remote_protocol_packets
[PACKET_vKill
]))
9737 case PACKET_UNKNOWN
:
9740 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9744 /* Send a kill request to the target using the 'k' packet. */
9747 remote_target::remote_kill_k ()
9749 /* Catch errors so the user can quit from gdb even when we
9750 aren't on speaking terms with the remote system. */
9755 catch (const gdb_exception_error
&ex
)
9757 if (ex
.error
== TARGET_CLOSE_ERROR
)
9759 /* If we got an (EOF) error that caused the target
9760 to go away, then we're done, that's what we wanted.
9761 "k" is susceptible to cause a premature EOF, given
9762 that the remote server isn't actually required to
9763 reply to "k", and it can happen that it doesn't
9764 even get to reply ACK to the "k". */
9768 /* Otherwise, something went wrong. We didn't actually kill
9769 the target. Just propagate the exception, and let the
9770 user or higher layers decide what to do. */
9776 remote_target::mourn_inferior ()
9778 struct remote_state
*rs
= get_remote_state ();
9780 /* We're no longer interested in notification events of an inferior
9781 that exited or was killed/detached. */
9782 discard_pending_stop_replies (current_inferior ());
9784 /* In 'target remote' mode with one inferior, we close the connection. */
9785 if (!rs
->extended
&& number_of_live_inferiors () <= 1)
9787 unpush_target (this);
9789 /* remote_close takes care of doing most of the clean up. */
9790 generic_mourn_inferior ();
9794 /* In case we got here due to an error, but we're going to stay
9796 rs
->waiting_for_stop_reply
= 0;
9798 /* If the current general thread belonged to the process we just
9799 detached from or has exited, the remote side current general
9800 thread becomes undefined. Considering a case like this:
9802 - We just got here due to a detach.
9803 - The process that we're detaching from happens to immediately
9804 report a global breakpoint being hit in non-stop mode, in the
9805 same thread we had selected before.
9806 - GDB attaches to this process again.
9807 - This event happens to be the next event we handle.
9809 GDB would consider that the current general thread didn't need to
9810 be set on the stub side (with Hg), since for all it knew,
9811 GENERAL_THREAD hadn't changed.
9813 Notice that although in all-stop mode, the remote server always
9814 sets the current thread to the thread reporting the stop event,
9815 that doesn't happen in non-stop mode; in non-stop, the stub *must
9816 not* change the current thread when reporting a breakpoint hit,
9817 due to the decoupling of event reporting and event handling.
9819 To keep things simple, we always invalidate our notion of the
9821 record_currthread (rs
, minus_one_ptid
);
9823 /* Call common code to mark the inferior as not running. */
9824 generic_mourn_inferior ();
9826 if (!have_inferiors ())
9828 if (!remote_multi_process_p (rs
))
9830 /* Check whether the target is running now - some remote stubs
9831 automatically restart after kill. */
9833 getpkt (&rs
->buf
, 0);
9835 if (rs
->buf
[0] == 'S' || rs
->buf
[0] == 'T')
9837 /* Assume that the target has been restarted. Set
9838 inferior_ptid so that bits of core GDB realizes
9839 there's something here, e.g., so that the user can
9840 say "kill" again. */
9841 inferior_ptid
= magic_null_ptid
;
9848 extended_remote_target::supports_disable_randomization ()
9850 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9854 remote_target::extended_remote_disable_randomization (int val
)
9856 struct remote_state
*rs
= get_remote_state ();
9859 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9860 "QDisableRandomization:%x", val
);
9862 reply
= remote_get_noisy_reply ();
9864 error (_("Target does not support QDisableRandomization."));
9865 if (strcmp (reply
, "OK") != 0)
9866 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9870 remote_target::extended_remote_run (const std::string
&args
)
9872 struct remote_state
*rs
= get_remote_state ();
9874 const char *remote_exec_file
= get_remote_exec_file ();
9876 /* If the user has disabled vRun support, or we have detected that
9877 support is not available, do not try it. */
9878 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9881 strcpy (rs
->buf
.data (), "vRun;");
9882 len
= strlen (rs
->buf
.data ());
9884 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9885 error (_("Remote file name too long for run packet"));
9886 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
9887 strlen (remote_exec_file
));
9893 gdb_argv
argv (args
.c_str ());
9894 for (i
= 0; argv
[i
] != NULL
; i
++)
9896 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9897 error (_("Argument list too long for run packet"));
9898 rs
->buf
[len
++] = ';';
9899 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
9904 rs
->buf
[len
++] = '\0';
9907 getpkt (&rs
->buf
, 0);
9909 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9912 /* We have a wait response. All is well. */
9914 case PACKET_UNKNOWN
:
9917 if (remote_exec_file
[0] == '\0')
9918 error (_("Running the default executable on the remote target failed; "
9919 "try \"set remote exec-file\"?"));
9921 error (_("Running \"%s\" on the remote target failed"),
9924 gdb_assert_not_reached (_("bad switch"));
9928 /* Helper function to send set/unset environment packets. ACTION is
9929 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
9930 or "QEnvironmentUnsetVariable". VALUE is the variable to be
9934 remote_target::send_environment_packet (const char *action
,
9938 remote_state
*rs
= get_remote_state ();
9940 /* Convert the environment variable to an hex string, which
9941 is the best format to be transmitted over the wire. */
9942 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
9945 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9946 "%s:%s", packet
, encoded_value
.c_str ());
9949 getpkt (&rs
->buf
, 0);
9950 if (strcmp (rs
->buf
.data (), "OK") != 0)
9951 warning (_("Unable to %s environment variable '%s' on remote."),
9955 /* Helper function to handle the QEnvironment* packets. */
9958 remote_target::extended_remote_environment_support ()
9960 remote_state
*rs
= get_remote_state ();
9962 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
9964 putpkt ("QEnvironmentReset");
9965 getpkt (&rs
->buf
, 0);
9966 if (strcmp (rs
->buf
.data (), "OK") != 0)
9967 warning (_("Unable to reset environment on remote."));
9970 gdb_environ
*e
= ¤t_inferior ()->environment
;
9972 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
9973 for (const std::string
&el
: e
->user_set_env ())
9974 send_environment_packet ("set", "QEnvironmentHexEncoded",
9977 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
9978 for (const std::string
&el
: e
->user_unset_env ())
9979 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
9982 /* Helper function to set the current working directory for the
9983 inferior in the remote target. */
9986 remote_target::extended_remote_set_inferior_cwd ()
9988 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
9990 const char *inferior_cwd
= get_inferior_cwd ();
9991 remote_state
*rs
= get_remote_state ();
9993 if (inferior_cwd
!= NULL
)
9995 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
9996 strlen (inferior_cwd
));
9998 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9999 "QSetWorkingDir:%s", hexpath
.c_str ());
10003 /* An empty inferior_cwd means that the user wants us to
10004 reset the remote server's inferior's cwd. */
10005 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10006 "QSetWorkingDir:");
10010 getpkt (&rs
->buf
, 0);
10011 if (packet_ok (rs
->buf
,
10012 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10015 Remote replied unexpectedly while setting the inferior's working\n\
10022 /* In the extended protocol we want to be able to do things like
10023 "run" and have them basically work as expected. So we need
10024 a special create_inferior function. We support changing the
10025 executable file and the command line arguments, but not the
10029 extended_remote_target::create_inferior (const char *exec_file
,
10030 const std::string
&args
,
10031 char **env
, int from_tty
)
10035 struct remote_state
*rs
= get_remote_state ();
10036 const char *remote_exec_file
= get_remote_exec_file ();
10038 /* If running asynchronously, register the target file descriptor
10039 with the event loop. */
10040 if (target_can_async_p ())
10043 /* Disable address space randomization if requested (and supported). */
10044 if (supports_disable_randomization ())
10045 extended_remote_disable_randomization (disable_randomization
);
10047 /* If startup-with-shell is on, we inform gdbserver to start the
10048 remote inferior using a shell. */
10049 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10051 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10052 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10054 getpkt (&rs
->buf
, 0);
10055 if (strcmp (rs
->buf
.data (), "OK") != 0)
10057 Remote replied unexpectedly while setting startup-with-shell: %s"),
10061 extended_remote_environment_support ();
10063 extended_remote_set_inferior_cwd ();
10065 /* Now restart the remote server. */
10066 run_worked
= extended_remote_run (args
) != -1;
10069 /* vRun was not supported. Fail if we need it to do what the
10071 if (remote_exec_file
[0])
10072 error (_("Remote target does not support \"set remote exec-file\""));
10073 if (!args
.empty ())
10074 error (_("Remote target does not support \"set args\" or run ARGS"));
10076 /* Fall back to "R". */
10077 extended_remote_restart ();
10080 /* vRun's success return is a stop reply. */
10081 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10082 add_current_inferior_and_thread (stop_reply
);
10084 /* Get updated offsets, if the stub uses qOffsets. */
10089 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10090 the list of conditions (in agent expression bytecode format), if any, the
10091 target needs to evaluate. The output is placed into the packet buffer
10092 started from BUF and ended at BUF_END. */
10095 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10096 struct bp_target_info
*bp_tgt
, char *buf
,
10099 if (bp_tgt
->conditions
.empty ())
10102 buf
+= strlen (buf
);
10103 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10106 /* Send conditions to the target. */
10107 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10109 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10110 buf
+= strlen (buf
);
10111 for (int i
= 0; i
< aexpr
->len
; ++i
)
10112 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10119 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10120 struct bp_target_info
*bp_tgt
, char *buf
)
10122 if (bp_tgt
->tcommands
.empty ())
10125 buf
+= strlen (buf
);
10127 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10128 buf
+= strlen (buf
);
10130 /* Concatenate all the agent expressions that are commands into the
10132 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10134 sprintf (buf
, "X%x,", aexpr
->len
);
10135 buf
+= strlen (buf
);
10136 for (int i
= 0; i
< aexpr
->len
; ++i
)
10137 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10142 /* Insert a breakpoint. On targets that have software breakpoint
10143 support, we ask the remote target to do the work; on targets
10144 which don't, we insert a traditional memory breakpoint. */
10147 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10148 struct bp_target_info
*bp_tgt
)
10150 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10151 If it succeeds, then set the support to PACKET_ENABLE. If it
10152 fails, and the user has explicitly requested the Z support then
10153 report an error, otherwise, mark it disabled and go on. */
10155 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10157 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10158 struct remote_state
*rs
;
10161 /* Make sure the remote is pointing at the right process, if
10163 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10164 set_general_process ();
10166 rs
= get_remote_state ();
10167 p
= rs
->buf
.data ();
10168 endbuf
= p
+ get_remote_packet_size ();
10173 addr
= (ULONGEST
) remote_address_masked (addr
);
10174 p
+= hexnumstr (p
, addr
);
10175 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10177 if (supports_evaluation_of_breakpoint_conditions ())
10178 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10180 if (can_run_breakpoint_commands ())
10181 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10184 getpkt (&rs
->buf
, 0);
10186 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10192 case PACKET_UNKNOWN
:
10197 /* If this breakpoint has target-side commands but this stub doesn't
10198 support Z0 packets, throw error. */
10199 if (!bp_tgt
->tcommands
.empty ())
10200 throw_error (NOT_SUPPORTED_ERROR
, _("\
10201 Target doesn't support breakpoints that have target side commands."));
10203 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10207 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10208 struct bp_target_info
*bp_tgt
,
10209 enum remove_bp_reason reason
)
10211 CORE_ADDR addr
= bp_tgt
->placed_address
;
10212 struct remote_state
*rs
= get_remote_state ();
10214 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10216 char *p
= rs
->buf
.data ();
10217 char *endbuf
= p
+ get_remote_packet_size ();
10219 /* Make sure the remote is pointing at the right process, if
10221 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10222 set_general_process ();
10228 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10229 p
+= hexnumstr (p
, addr
);
10230 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10233 getpkt (&rs
->buf
, 0);
10235 return (rs
->buf
[0] == 'E');
10238 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10241 static enum Z_packet_type
10242 watchpoint_to_Z_packet (int type
)
10247 return Z_PACKET_WRITE_WP
;
10250 return Z_PACKET_READ_WP
;
10253 return Z_PACKET_ACCESS_WP
;
10256 internal_error (__FILE__
, __LINE__
,
10257 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10262 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10263 enum target_hw_bp_type type
, struct expression
*cond
)
10265 struct remote_state
*rs
= get_remote_state ();
10266 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10268 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10270 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10273 /* Make sure the remote is pointing at the right process, if
10275 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10276 set_general_process ();
10278 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10279 p
= strchr (rs
->buf
.data (), '\0');
10280 addr
= remote_address_masked (addr
);
10281 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10282 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10285 getpkt (&rs
->buf
, 0);
10287 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10291 case PACKET_UNKNOWN
:
10296 internal_error (__FILE__
, __LINE__
,
10297 _("remote_insert_watchpoint: reached end of function"));
10301 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10302 CORE_ADDR start
, int length
)
10304 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10306 return diff
< length
;
10311 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10312 enum target_hw_bp_type type
, struct expression
*cond
)
10314 struct remote_state
*rs
= get_remote_state ();
10315 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10317 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10319 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10322 /* Make sure the remote is pointing at the right process, if
10324 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10325 set_general_process ();
10327 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10328 p
= strchr (rs
->buf
.data (), '\0');
10329 addr
= remote_address_masked (addr
);
10330 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10331 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10333 getpkt (&rs
->buf
, 0);
10335 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10338 case PACKET_UNKNOWN
:
10343 internal_error (__FILE__
, __LINE__
,
10344 _("remote_remove_watchpoint: reached end of function"));
10348 static int remote_hw_watchpoint_limit
= -1;
10349 static int remote_hw_watchpoint_length_limit
= -1;
10350 static int remote_hw_breakpoint_limit
= -1;
10353 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10355 if (remote_hw_watchpoint_length_limit
== 0)
10357 else if (remote_hw_watchpoint_length_limit
< 0)
10359 else if (len
<= remote_hw_watchpoint_length_limit
)
10366 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10368 if (type
== bp_hardware_breakpoint
)
10370 if (remote_hw_breakpoint_limit
== 0)
10372 else if (remote_hw_breakpoint_limit
< 0)
10374 else if (cnt
<= remote_hw_breakpoint_limit
)
10379 if (remote_hw_watchpoint_limit
== 0)
10381 else if (remote_hw_watchpoint_limit
< 0)
10385 else if (cnt
<= remote_hw_watchpoint_limit
)
10391 /* The to_stopped_by_sw_breakpoint method of target remote. */
10394 remote_target::stopped_by_sw_breakpoint ()
10396 struct thread_info
*thread
= inferior_thread ();
10398 return (thread
->priv
!= NULL
10399 && (get_remote_thread_info (thread
)->stop_reason
10400 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10403 /* The to_supports_stopped_by_sw_breakpoint method of target
10407 remote_target::supports_stopped_by_sw_breakpoint ()
10409 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10412 /* The to_stopped_by_hw_breakpoint method of target remote. */
10415 remote_target::stopped_by_hw_breakpoint ()
10417 struct thread_info
*thread
= inferior_thread ();
10419 return (thread
->priv
!= NULL
10420 && (get_remote_thread_info (thread
)->stop_reason
10421 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10424 /* The to_supports_stopped_by_hw_breakpoint method of target
10428 remote_target::supports_stopped_by_hw_breakpoint ()
10430 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10434 remote_target::stopped_by_watchpoint ()
10436 struct thread_info
*thread
= inferior_thread ();
10438 return (thread
->priv
!= NULL
10439 && (get_remote_thread_info (thread
)->stop_reason
10440 == TARGET_STOPPED_BY_WATCHPOINT
));
10444 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10446 struct thread_info
*thread
= inferior_thread ();
10448 if (thread
->priv
!= NULL
10449 && (get_remote_thread_info (thread
)->stop_reason
10450 == TARGET_STOPPED_BY_WATCHPOINT
))
10452 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10461 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10462 struct bp_target_info
*bp_tgt
)
10464 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10465 struct remote_state
*rs
;
10469 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10472 /* Make sure the remote is pointing at the right process, if
10474 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10475 set_general_process ();
10477 rs
= get_remote_state ();
10478 p
= rs
->buf
.data ();
10479 endbuf
= p
+ get_remote_packet_size ();
10485 addr
= remote_address_masked (addr
);
10486 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10487 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10489 if (supports_evaluation_of_breakpoint_conditions ())
10490 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10492 if (can_run_breakpoint_commands ())
10493 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10496 getpkt (&rs
->buf
, 0);
10498 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10501 if (rs
->buf
[1] == '.')
10503 message
= strchr (&rs
->buf
[2], '.');
10505 error (_("Remote failure reply: %s"), message
+ 1);
10508 case PACKET_UNKNOWN
:
10513 internal_error (__FILE__
, __LINE__
,
10514 _("remote_insert_hw_breakpoint: reached end of function"));
10519 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10520 struct bp_target_info
*bp_tgt
)
10523 struct remote_state
*rs
= get_remote_state ();
10524 char *p
= rs
->buf
.data ();
10525 char *endbuf
= p
+ get_remote_packet_size ();
10527 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10530 /* Make sure the remote is pointing at the right process, if
10532 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10533 set_general_process ();
10539 addr
= remote_address_masked (bp_tgt
->placed_address
);
10540 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10541 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10544 getpkt (&rs
->buf
, 0);
10546 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10549 case PACKET_UNKNOWN
:
10554 internal_error (__FILE__
, __LINE__
,
10555 _("remote_remove_hw_breakpoint: reached end of function"));
10558 /* Verify memory using the "qCRC:" request. */
10561 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10563 struct remote_state
*rs
= get_remote_state ();
10564 unsigned long host_crc
, target_crc
;
10567 /* It doesn't make sense to use qCRC if the remote target is
10568 connected but not running. */
10569 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10571 enum packet_result result
;
10573 /* Make sure the remote is pointing at the right process. */
10574 set_general_process ();
10576 /* FIXME: assumes lma can fit into long. */
10577 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10578 (long) lma
, (long) size
);
10581 /* Be clever; compute the host_crc before waiting for target
10583 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10585 getpkt (&rs
->buf
, 0);
10587 result
= packet_ok (rs
->buf
,
10588 &remote_protocol_packets
[PACKET_qCRC
]);
10589 if (result
== PACKET_ERROR
)
10591 else if (result
== PACKET_OK
)
10593 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10594 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10596 return (host_crc
== target_crc
);
10600 return simple_verify_memory (this, data
, lma
, size
);
10603 /* compare-sections command
10605 With no arguments, compares each loadable section in the exec bfd
10606 with the same memory range on the target, and reports mismatches.
10607 Useful for verifying the image on the target against the exec file. */
10610 compare_sections_command (const char *args
, int from_tty
)
10613 const char *sectname
;
10614 bfd_size_type size
;
10617 int mismatched
= 0;
10622 error (_("command cannot be used without an exec file"));
10624 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10630 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10632 if (!(s
->flags
& SEC_LOAD
))
10633 continue; /* Skip non-loadable section. */
10635 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10636 continue; /* Skip writeable sections */
10638 size
= bfd_section_size (s
);
10640 continue; /* Skip zero-length section. */
10642 sectname
= bfd_section_name (s
);
10643 if (args
&& strcmp (args
, sectname
) != 0)
10644 continue; /* Not the section selected by user. */
10646 matched
= 1; /* Do this section. */
10649 gdb::byte_vector
sectdata (size
);
10650 bfd_get_section_contents (exec_bfd
, s
, sectdata
.data (), 0, size
);
10652 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10655 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10656 paddress (target_gdbarch (), lma
),
10657 paddress (target_gdbarch (), lma
+ size
));
10659 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10660 paddress (target_gdbarch (), lma
),
10661 paddress (target_gdbarch (), lma
+ size
));
10663 printf_filtered ("matched.\n");
10666 printf_filtered ("MIS-MATCHED!\n");
10670 if (mismatched
> 0)
10671 warning (_("One or more sections of the target image does not match\n\
10672 the loaded file\n"));
10673 if (args
&& !matched
)
10674 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10677 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10678 into remote target. The number of bytes written to the remote
10679 target is returned, or -1 for error. */
10682 remote_target::remote_write_qxfer (const char *object_name
,
10683 const char *annex
, const gdb_byte
*writebuf
,
10684 ULONGEST offset
, LONGEST len
,
10685 ULONGEST
*xfered_len
,
10686 struct packet_config
*packet
)
10690 struct remote_state
*rs
= get_remote_state ();
10691 int max_size
= get_memory_write_packet_size ();
10693 if (packet_config_support (packet
) == PACKET_DISABLE
)
10694 return TARGET_XFER_E_IO
;
10696 /* Insert header. */
10697 i
= snprintf (rs
->buf
.data (), max_size
,
10698 "qXfer:%s:write:%s:%s:",
10699 object_name
, annex
? annex
: "",
10700 phex_nz (offset
, sizeof offset
));
10701 max_size
-= (i
+ 1);
10703 /* Escape as much data as fits into rs->buf. */
10704 buf_len
= remote_escape_output
10705 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10707 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10708 || getpkt_sane (&rs
->buf
, 0) < 0
10709 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10710 return TARGET_XFER_E_IO
;
10712 unpack_varlen_hex (rs
->buf
.data (), &n
);
10715 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10718 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10719 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10720 number of bytes read is returned, or 0 for EOF, or -1 for error.
10721 The number of bytes read may be less than LEN without indicating an
10722 EOF. PACKET is checked and updated to indicate whether the remote
10723 target supports this object. */
10726 remote_target::remote_read_qxfer (const char *object_name
,
10728 gdb_byte
*readbuf
, ULONGEST offset
,
10730 ULONGEST
*xfered_len
,
10731 struct packet_config
*packet
)
10733 struct remote_state
*rs
= get_remote_state ();
10734 LONGEST i
, n
, packet_len
;
10736 if (packet_config_support (packet
) == PACKET_DISABLE
)
10737 return TARGET_XFER_E_IO
;
10739 /* Check whether we've cached an end-of-object packet that matches
10741 if (rs
->finished_object
)
10743 if (strcmp (object_name
, rs
->finished_object
) == 0
10744 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10745 && offset
== rs
->finished_offset
)
10746 return TARGET_XFER_EOF
;
10749 /* Otherwise, we're now reading something different. Discard
10751 xfree (rs
->finished_object
);
10752 xfree (rs
->finished_annex
);
10753 rs
->finished_object
= NULL
;
10754 rs
->finished_annex
= NULL
;
10757 /* Request only enough to fit in a single packet. The actual data
10758 may not, since we don't know how much of it will need to be escaped;
10759 the target is free to respond with slightly less data. We subtract
10760 five to account for the response type and the protocol frame. */
10761 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10762 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
10763 "qXfer:%s:read:%s:%s,%s",
10764 object_name
, annex
? annex
: "",
10765 phex_nz (offset
, sizeof offset
),
10766 phex_nz (n
, sizeof n
));
10767 i
= putpkt (rs
->buf
);
10769 return TARGET_XFER_E_IO
;
10772 packet_len
= getpkt_sane (&rs
->buf
, 0);
10773 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10774 return TARGET_XFER_E_IO
;
10776 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10777 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
10779 /* 'm' means there is (or at least might be) more data after this
10780 batch. That does not make sense unless there's at least one byte
10781 of data in this reply. */
10782 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10783 error (_("Remote qXfer reply contained no data."));
10785 /* Got some data. */
10786 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
10787 packet_len
- 1, readbuf
, n
);
10789 /* 'l' is an EOF marker, possibly including a final block of data,
10790 or possibly empty. If we have the final block of a non-empty
10791 object, record this fact to bypass a subsequent partial read. */
10792 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10794 rs
->finished_object
= xstrdup (object_name
);
10795 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10796 rs
->finished_offset
= offset
+ i
;
10800 return TARGET_XFER_EOF
;
10804 return TARGET_XFER_OK
;
10808 enum target_xfer_status
10809 remote_target::xfer_partial (enum target_object object
,
10810 const char *annex
, gdb_byte
*readbuf
,
10811 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10812 ULONGEST
*xfered_len
)
10814 struct remote_state
*rs
;
10818 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10820 set_remote_traceframe ();
10821 set_general_thread (inferior_ptid
);
10823 rs
= get_remote_state ();
10825 /* Handle memory using the standard memory routines. */
10826 if (object
== TARGET_OBJECT_MEMORY
)
10828 /* If the remote target is connected but not running, we should
10829 pass this request down to a lower stratum (e.g. the executable
10831 if (!target_has_execution
)
10832 return TARGET_XFER_EOF
;
10834 if (writebuf
!= NULL
)
10835 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10838 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
10842 /* Handle extra signal info using qxfer packets. */
10843 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10846 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
10847 xfered_len
, &remote_protocol_packets
10848 [PACKET_qXfer_siginfo_read
]);
10850 return remote_write_qxfer ("siginfo", annex
,
10851 writebuf
, offset
, len
, xfered_len
,
10852 &remote_protocol_packets
10853 [PACKET_qXfer_siginfo_write
]);
10856 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10859 return remote_read_qxfer ("statictrace", annex
,
10860 readbuf
, offset
, len
, xfered_len
,
10861 &remote_protocol_packets
10862 [PACKET_qXfer_statictrace_read
]);
10864 return TARGET_XFER_E_IO
;
10867 /* Only handle flash writes. */
10868 if (writebuf
!= NULL
)
10872 case TARGET_OBJECT_FLASH
:
10873 return remote_flash_write (offset
, len
, xfered_len
,
10877 return TARGET_XFER_E_IO
;
10881 /* Map pre-existing objects onto letters. DO NOT do this for new
10882 objects!!! Instead specify new query packets. */
10885 case TARGET_OBJECT_AVR
:
10889 case TARGET_OBJECT_AUXV
:
10890 gdb_assert (annex
== NULL
);
10891 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
10893 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10895 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10896 return remote_read_qxfer
10897 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
10898 &remote_protocol_packets
[PACKET_qXfer_features
]);
10900 case TARGET_OBJECT_LIBRARIES
:
10901 return remote_read_qxfer
10902 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10903 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10905 case TARGET_OBJECT_LIBRARIES_SVR4
:
10906 return remote_read_qxfer
10907 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10908 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10910 case TARGET_OBJECT_MEMORY_MAP
:
10911 gdb_assert (annex
== NULL
);
10912 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
10914 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10916 case TARGET_OBJECT_OSDATA
:
10917 /* Should only get here if we're connected. */
10918 gdb_assert (rs
->remote_desc
);
10919 return remote_read_qxfer
10920 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
10921 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
10923 case TARGET_OBJECT_THREADS
:
10924 gdb_assert (annex
== NULL
);
10925 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
10927 &remote_protocol_packets
[PACKET_qXfer_threads
]);
10929 case TARGET_OBJECT_TRACEFRAME_INFO
:
10930 gdb_assert (annex
== NULL
);
10931 return remote_read_qxfer
10932 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
10933 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
10935 case TARGET_OBJECT_FDPIC
:
10936 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
10938 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
10940 case TARGET_OBJECT_OPENVMS_UIB
:
10941 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
10943 &remote_protocol_packets
[PACKET_qXfer_uib
]);
10945 case TARGET_OBJECT_BTRACE
:
10946 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
10948 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
10950 case TARGET_OBJECT_BTRACE_CONF
:
10951 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
10953 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
10955 case TARGET_OBJECT_EXEC_FILE
:
10956 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
10958 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
10961 return TARGET_XFER_E_IO
;
10964 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
10965 large enough let the caller deal with it. */
10966 if (len
< get_remote_packet_size ())
10967 return TARGET_XFER_E_IO
;
10968 len
= get_remote_packet_size ();
10970 /* Except for querying the minimum buffer size, target must be open. */
10971 if (!rs
->remote_desc
)
10972 error (_("remote query is only available after target open"));
10974 gdb_assert (annex
!= NULL
);
10975 gdb_assert (readbuf
!= NULL
);
10977 p2
= rs
->buf
.data ();
10979 *p2
++ = query_type
;
10981 /* We used one buffer char for the remote protocol q command and
10982 another for the query type. As the remote protocol encapsulation
10983 uses 4 chars plus one extra in case we are debugging
10984 (remote_debug), we have PBUFZIZ - 7 left to pack the query
10987 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
10989 /* Bad caller may have sent forbidden characters. */
10990 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
10995 gdb_assert (annex
[i
] == '\0');
10997 i
= putpkt (rs
->buf
);
10999 return TARGET_XFER_E_IO
;
11001 getpkt (&rs
->buf
, 0);
11002 strcpy ((char *) readbuf
, rs
->buf
.data ());
11004 *xfered_len
= strlen ((char *) readbuf
);
11005 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11008 /* Implementation of to_get_memory_xfer_limit. */
11011 remote_target::get_memory_xfer_limit ()
11013 return get_memory_write_packet_size ();
11017 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11018 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11019 CORE_ADDR
*found_addrp
)
11021 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11022 struct remote_state
*rs
= get_remote_state ();
11023 int max_size
= get_memory_write_packet_size ();
11024 struct packet_config
*packet
=
11025 &remote_protocol_packets
[PACKET_qSearch_memory
];
11026 /* Number of packet bytes used to encode the pattern;
11027 this could be more than PATTERN_LEN due to escape characters. */
11028 int escaped_pattern_len
;
11029 /* Amount of pattern that was encodable in the packet. */
11030 int used_pattern_len
;
11033 ULONGEST found_addr
;
11035 /* Don't go to the target if we don't have to. This is done before
11036 checking packet_config_support to avoid the possibility that a
11037 success for this edge case means the facility works in
11039 if (pattern_len
> search_space_len
)
11041 if (pattern_len
== 0)
11043 *found_addrp
= start_addr
;
11047 /* If we already know the packet isn't supported, fall back to the simple
11048 way of searching memory. */
11050 if (packet_config_support (packet
) == PACKET_DISABLE
)
11052 /* Target doesn't provided special support, fall back and use the
11053 standard support (copy memory and do the search here). */
11054 return simple_search_memory (this, start_addr
, search_space_len
,
11055 pattern
, pattern_len
, found_addrp
);
11058 /* Make sure the remote is pointing at the right process. */
11059 set_general_process ();
11061 /* Insert header. */
11062 i
= snprintf (rs
->buf
.data (), max_size
,
11063 "qSearch:memory:%s;%s;",
11064 phex_nz (start_addr
, addr_size
),
11065 phex_nz (search_space_len
, sizeof (search_space_len
)));
11066 max_size
-= (i
+ 1);
11068 /* Escape as much data as fits into rs->buf. */
11069 escaped_pattern_len
=
11070 remote_escape_output (pattern
, pattern_len
, 1,
11071 (gdb_byte
*) rs
->buf
.data () + i
,
11072 &used_pattern_len
, max_size
);
11074 /* Bail if the pattern is too large. */
11075 if (used_pattern_len
!= pattern_len
)
11076 error (_("Pattern is too large to transmit to remote target."));
11078 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11079 || getpkt_sane (&rs
->buf
, 0) < 0
11080 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11082 /* The request may not have worked because the command is not
11083 supported. If so, fall back to the simple way. */
11084 if (packet_config_support (packet
) == PACKET_DISABLE
)
11086 return simple_search_memory (this, start_addr
, search_space_len
,
11087 pattern
, pattern_len
, found_addrp
);
11092 if (rs
->buf
[0] == '0')
11094 else if (rs
->buf
[0] == '1')
11097 if (rs
->buf
[1] != ',')
11098 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11099 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11100 *found_addrp
= found_addr
;
11103 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11109 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11111 struct remote_state
*rs
= get_remote_state ();
11112 char *p
= rs
->buf
.data ();
11114 if (!rs
->remote_desc
)
11115 error (_("remote rcmd is only available after target open"));
11117 /* Send a NULL command across as an empty command. */
11118 if (command
== NULL
)
11121 /* The query prefix. */
11122 strcpy (rs
->buf
.data (), "qRcmd,");
11123 p
= strchr (rs
->buf
.data (), '\0');
11125 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11126 > get_remote_packet_size ())
11127 error (_("\"monitor\" command ``%s'' is too long."), command
);
11129 /* Encode the actual command. */
11130 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11132 if (putpkt (rs
->buf
) < 0)
11133 error (_("Communication problem with target."));
11135 /* get/display the response */
11140 /* XXX - see also remote_get_noisy_reply(). */
11141 QUIT
; /* Allow user to bail out with ^C. */
11143 if (getpkt_sane (&rs
->buf
, 0) == -1)
11145 /* Timeout. Continue to (try to) read responses.
11146 This is better than stopping with an error, assuming the stub
11147 is still executing the (long) monitor command.
11148 If needed, the user can interrupt gdb using C-c, obtaining
11149 an effect similar to stop on timeout. */
11152 buf
= rs
->buf
.data ();
11153 if (buf
[0] == '\0')
11154 error (_("Target does not support this command."));
11155 if (buf
[0] == 'O' && buf
[1] != 'K')
11157 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11160 if (strcmp (buf
, "OK") == 0)
11162 if (strlen (buf
) == 3 && buf
[0] == 'E'
11163 && isdigit (buf
[1]) && isdigit (buf
[2]))
11165 error (_("Protocol error with Rcmd"));
11167 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11169 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11171 fputc_unfiltered (c
, outbuf
);
11177 std::vector
<mem_region
>
11178 remote_target::memory_map ()
11180 std::vector
<mem_region
> result
;
11181 gdb::optional
<gdb::char_vector
> text
11182 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11185 result
= parse_memory_map (text
->data ());
11191 packet_command (const char *args
, int from_tty
)
11193 remote_target
*remote
= get_current_remote_target ();
11195 if (remote
== nullptr)
11196 error (_("command can only be used with remote target"));
11198 remote
->packet_command (args
, from_tty
);
11202 remote_target::packet_command (const char *args
, int from_tty
)
11205 error (_("remote-packet command requires packet text as argument"));
11207 puts_filtered ("sending: ");
11208 print_packet (args
);
11209 puts_filtered ("\n");
11212 remote_state
*rs
= get_remote_state ();
11214 getpkt (&rs
->buf
, 0);
11215 puts_filtered ("received: ");
11216 print_packet (rs
->buf
.data ());
11217 puts_filtered ("\n");
11221 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11223 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11225 static void threadset_test_cmd (char *cmd
, int tty
);
11227 static void threadalive_test (char *cmd
, int tty
);
11229 static void threadlist_test_cmd (char *cmd
, int tty
);
11231 int get_and_display_threadinfo (threadref
*ref
);
11233 static void threadinfo_test_cmd (char *cmd
, int tty
);
11235 static int thread_display_step (threadref
*ref
, void *context
);
11237 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11239 static void init_remote_threadtests (void);
11241 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11244 threadset_test_cmd (const char *cmd
, int tty
)
11246 int sample_thread
= SAMPLE_THREAD
;
11248 printf_filtered (_("Remote threadset test\n"));
11249 set_general_thread (sample_thread
);
11254 threadalive_test (const char *cmd
, int tty
)
11256 int sample_thread
= SAMPLE_THREAD
;
11257 int pid
= inferior_ptid
.pid ();
11258 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11260 if (remote_thread_alive (ptid
))
11261 printf_filtered ("PASS: Thread alive test\n");
11263 printf_filtered ("FAIL: Thread alive test\n");
11266 void output_threadid (char *title
, threadref
*ref
);
11269 output_threadid (char *title
, threadref
*ref
)
11273 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11275 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11279 threadlist_test_cmd (const char *cmd
, int tty
)
11282 threadref nextthread
;
11283 int done
, result_count
;
11284 threadref threadlist
[3];
11286 printf_filtered ("Remote Threadlist test\n");
11287 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11288 &result_count
, &threadlist
[0]))
11289 printf_filtered ("FAIL: threadlist test\n");
11292 threadref
*scan
= threadlist
;
11293 threadref
*limit
= scan
+ result_count
;
11295 while (scan
< limit
)
11296 output_threadid (" thread ", scan
++);
11301 display_thread_info (struct gdb_ext_thread_info
*info
)
11303 output_threadid ("Threadid: ", &info
->threadid
);
11304 printf_filtered ("Name: %s\n ", info
->shortname
);
11305 printf_filtered ("State: %s\n", info
->display
);
11306 printf_filtered ("other: %s\n\n", info
->more_display
);
11310 get_and_display_threadinfo (threadref
*ref
)
11314 struct gdb_ext_thread_info threadinfo
;
11316 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11317 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11318 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11319 display_thread_info (&threadinfo
);
11324 threadinfo_test_cmd (const char *cmd
, int tty
)
11326 int athread
= SAMPLE_THREAD
;
11330 int_to_threadref (&thread
, athread
);
11331 printf_filtered ("Remote Threadinfo test\n");
11332 if (!get_and_display_threadinfo (&thread
))
11333 printf_filtered ("FAIL cannot get thread info\n");
11337 thread_display_step (threadref
*ref
, void *context
)
11339 /* output_threadid(" threadstep ",ref); *//* simple test */
11340 return get_and_display_threadinfo (ref
);
11344 threadlist_update_test_cmd (const char *cmd
, int tty
)
11346 printf_filtered ("Remote Threadlist update test\n");
11347 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11351 init_remote_threadtests (void)
11353 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11354 _("Fetch and print the remote list of "
11355 "thread identifiers, one pkt only."));
11356 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11357 _("Fetch and display info about one thread."));
11358 add_com ("tset", class_obscure
, threadset_test_cmd
,
11359 _("Test setting to a different thread."));
11360 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11361 _("Iterate through updating all remote thread info."));
11362 add_com ("talive", class_obscure
, threadalive_test
,
11363 _("Remote thread alive test."));
11368 /* Convert a thread ID to a string. */
11371 remote_target::pid_to_str (ptid_t ptid
)
11373 struct remote_state
*rs
= get_remote_state ();
11375 if (ptid
== null_ptid
)
11376 return normal_pid_to_str (ptid
);
11377 else if (ptid
.is_pid ())
11379 /* Printing an inferior target id. */
11381 /* When multi-process extensions are off, there's no way in the
11382 remote protocol to know the remote process id, if there's any
11383 at all. There's one exception --- when we're connected with
11384 target extended-remote, and we manually attached to a process
11385 with "attach PID". We don't record anywhere a flag that
11386 allows us to distinguish that case from the case of
11387 connecting with extended-remote and the stub already being
11388 attached to a process, and reporting yes to qAttached, hence
11389 no smart special casing here. */
11390 if (!remote_multi_process_p (rs
))
11391 return "Remote target";
11393 return normal_pid_to_str (ptid
);
11397 if (magic_null_ptid
== ptid
)
11398 return "Thread <main>";
11399 else if (remote_multi_process_p (rs
))
11400 if (ptid
.lwp () == 0)
11401 return normal_pid_to_str (ptid
);
11403 return string_printf ("Thread %d.%ld",
11404 ptid
.pid (), ptid
.lwp ());
11406 return string_printf ("Thread %ld", ptid
.lwp ());
11410 /* Get the address of the thread local variable in OBJFILE which is
11411 stored at OFFSET within the thread local storage for thread PTID. */
11414 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11417 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11419 struct remote_state
*rs
= get_remote_state ();
11420 char *p
= rs
->buf
.data ();
11421 char *endp
= p
+ get_remote_packet_size ();
11422 enum packet_result result
;
11424 strcpy (p
, "qGetTLSAddr:");
11426 p
= write_ptid (p
, endp
, ptid
);
11428 p
+= hexnumstr (p
, offset
);
11430 p
+= hexnumstr (p
, lm
);
11434 getpkt (&rs
->buf
, 0);
11435 result
= packet_ok (rs
->buf
,
11436 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11437 if (result
== PACKET_OK
)
11441 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11444 else if (result
== PACKET_UNKNOWN
)
11445 throw_error (TLS_GENERIC_ERROR
,
11446 _("Remote target doesn't support qGetTLSAddr packet"));
11448 throw_error (TLS_GENERIC_ERROR
,
11449 _("Remote target failed to process qGetTLSAddr request"));
11452 throw_error (TLS_GENERIC_ERROR
,
11453 _("TLS not supported or disabled on this target"));
11458 /* Provide thread local base, i.e. Thread Information Block address.
11459 Returns 1 if ptid is found and thread_local_base is non zero. */
11462 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11464 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11466 struct remote_state
*rs
= get_remote_state ();
11467 char *p
= rs
->buf
.data ();
11468 char *endp
= p
+ get_remote_packet_size ();
11469 enum packet_result result
;
11471 strcpy (p
, "qGetTIBAddr:");
11473 p
= write_ptid (p
, endp
, ptid
);
11477 getpkt (&rs
->buf
, 0);
11478 result
= packet_ok (rs
->buf
,
11479 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11480 if (result
== PACKET_OK
)
11483 unpack_varlen_hex (rs
->buf
.data (), &val
);
11485 *addr
= (CORE_ADDR
) val
;
11488 else if (result
== PACKET_UNKNOWN
)
11489 error (_("Remote target doesn't support qGetTIBAddr packet"));
11491 error (_("Remote target failed to process qGetTIBAddr request"));
11494 error (_("qGetTIBAddr not supported or disabled on this target"));
11499 /* Support for inferring a target description based on the current
11500 architecture and the size of a 'g' packet. While the 'g' packet
11501 can have any size (since optional registers can be left off the
11502 end), some sizes are easily recognizable given knowledge of the
11503 approximate architecture. */
11505 struct remote_g_packet_guess
11507 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11514 const struct target_desc
*tdesc
;
11517 struct remote_g_packet_data
: public allocate_on_obstack
11519 std::vector
<remote_g_packet_guess
> guesses
;
11522 static struct gdbarch_data
*remote_g_packet_data_handle
;
11525 remote_g_packet_data_init (struct obstack
*obstack
)
11527 return new (obstack
) remote_g_packet_data
;
11531 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11532 const struct target_desc
*tdesc
)
11534 struct remote_g_packet_data
*data
11535 = ((struct remote_g_packet_data
*)
11536 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11538 gdb_assert (tdesc
!= NULL
);
11540 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11541 if (guess
.bytes
== bytes
)
11542 internal_error (__FILE__
, __LINE__
,
11543 _("Duplicate g packet description added for size %d"),
11546 data
->guesses
.emplace_back (bytes
, tdesc
);
11549 /* Return true if remote_read_description would do anything on this target
11550 and architecture, false otherwise. */
11553 remote_read_description_p (struct target_ops
*target
)
11555 struct remote_g_packet_data
*data
11556 = ((struct remote_g_packet_data
*)
11557 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11559 return !data
->guesses
.empty ();
11562 const struct target_desc
*
11563 remote_target::read_description ()
11565 struct remote_g_packet_data
*data
11566 = ((struct remote_g_packet_data
*)
11567 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11569 /* Do not try this during initial connection, when we do not know
11570 whether there is a running but stopped thread. */
11571 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
11572 return beneath ()->read_description ();
11574 if (!data
->guesses
.empty ())
11576 int bytes
= send_g_packet ();
11578 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11579 if (guess
.bytes
== bytes
)
11580 return guess
.tdesc
;
11582 /* We discard the g packet. A minor optimization would be to
11583 hold on to it, and fill the register cache once we have selected
11584 an architecture, but it's too tricky to do safely. */
11587 return beneath ()->read_description ();
11590 /* Remote file transfer support. This is host-initiated I/O, not
11591 target-initiated; for target-initiated, see remote-fileio.c. */
11593 /* If *LEFT is at least the length of STRING, copy STRING to
11594 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11595 decrease *LEFT. Otherwise raise an error. */
11598 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11600 int len
= strlen (string
);
11603 error (_("Packet too long for target."));
11605 memcpy (*buffer
, string
, len
);
11609 /* NUL-terminate the buffer as a convenience, if there is
11615 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11616 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11617 decrease *LEFT. Otherwise raise an error. */
11620 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11623 if (2 * len
> *left
)
11624 error (_("Packet too long for target."));
11626 bin2hex (bytes
, *buffer
, len
);
11627 *buffer
+= 2 * len
;
11630 /* NUL-terminate the buffer as a convenience, if there is
11636 /* If *LEFT is large enough, convert VALUE to hex and add it to
11637 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11638 decrease *LEFT. Otherwise raise an error. */
11641 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11643 int len
= hexnumlen (value
);
11646 error (_("Packet too long for target."));
11648 hexnumstr (*buffer
, value
);
11652 /* NUL-terminate the buffer as a convenience, if there is
11658 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11659 value, *REMOTE_ERRNO to the remote error number or zero if none
11660 was included, and *ATTACHMENT to point to the start of the annex
11661 if any. The length of the packet isn't needed here; there may
11662 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11664 Return 0 if the packet could be parsed, -1 if it could not. If
11665 -1 is returned, the other variables may not be initialized. */
11668 remote_hostio_parse_result (char *buffer
, int *retcode
,
11669 int *remote_errno
, char **attachment
)
11674 *attachment
= NULL
;
11676 if (buffer
[0] != 'F')
11680 *retcode
= strtol (&buffer
[1], &p
, 16);
11681 if (errno
!= 0 || p
== &buffer
[1])
11684 /* Check for ",errno". */
11688 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11689 if (errno
!= 0 || p
+ 1 == p2
)
11694 /* Check for ";attachment". If there is no attachment, the
11695 packet should end here. */
11698 *attachment
= p
+ 1;
11701 else if (*p
== '\0')
11707 /* Send a prepared I/O packet to the target and read its response.
11708 The prepared packet is in the global RS->BUF before this function
11709 is called, and the answer is there when we return.
11711 COMMAND_BYTES is the length of the request to send, which may include
11712 binary data. WHICH_PACKET is the packet configuration to check
11713 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11714 is set to the error number and -1 is returned. Otherwise the value
11715 returned by the function is returned.
11717 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11718 attachment is expected; an error will be reported if there's a
11719 mismatch. If one is found, *ATTACHMENT will be set to point into
11720 the packet buffer and *ATTACHMENT_LEN will be set to the
11721 attachment's length. */
11724 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11725 int *remote_errno
, char **attachment
,
11726 int *attachment_len
)
11728 struct remote_state
*rs
= get_remote_state ();
11729 int ret
, bytes_read
;
11730 char *attachment_tmp
;
11732 if (packet_support (which_packet
) == PACKET_DISABLE
)
11734 *remote_errno
= FILEIO_ENOSYS
;
11738 putpkt_binary (rs
->buf
.data (), command_bytes
);
11739 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11741 /* If it timed out, something is wrong. Don't try to parse the
11743 if (bytes_read
< 0)
11745 *remote_errno
= FILEIO_EINVAL
;
11749 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11752 *remote_errno
= FILEIO_EINVAL
;
11754 case PACKET_UNKNOWN
:
11755 *remote_errno
= FILEIO_ENOSYS
;
11761 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
11764 *remote_errno
= FILEIO_EINVAL
;
11768 /* Make sure we saw an attachment if and only if we expected one. */
11769 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11770 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11772 *remote_errno
= FILEIO_EINVAL
;
11776 /* If an attachment was found, it must point into the packet buffer;
11777 work out how many bytes there were. */
11778 if (attachment_tmp
!= NULL
)
11780 *attachment
= attachment_tmp
;
11781 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
11787 /* See declaration.h. */
11790 readahead_cache::invalidate ()
11795 /* See declaration.h. */
11798 readahead_cache::invalidate_fd (int fd
)
11800 if (this->fd
== fd
)
11804 /* Set the filesystem remote_hostio functions that take FILENAME
11805 arguments will use. Return 0 on success, or -1 if an error
11806 occurs (and set *REMOTE_ERRNO). */
11809 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
11812 struct remote_state
*rs
= get_remote_state ();
11813 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11814 char *p
= rs
->buf
.data ();
11815 int left
= get_remote_packet_size () - 1;
11819 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11822 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11825 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11827 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11828 remote_buffer_add_string (&p
, &left
, arg
);
11830 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
11831 remote_errno
, NULL
, NULL
);
11833 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11837 rs
->fs_pid
= required_pid
;
11842 /* Implementation of to_fileio_open. */
11845 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
11846 int flags
, int mode
, int warn_if_slow
,
11849 struct remote_state
*rs
= get_remote_state ();
11850 char *p
= rs
->buf
.data ();
11851 int left
= get_remote_packet_size () - 1;
11855 static int warning_issued
= 0;
11857 printf_unfiltered (_("Reading %s from remote target...\n"),
11860 if (!warning_issued
)
11862 warning (_("File transfers from remote targets can be slow."
11863 " Use \"set sysroot\" to access files locally"
11865 warning_issued
= 1;
11869 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11872 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11874 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11875 strlen (filename
));
11876 remote_buffer_add_string (&p
, &left
, ",");
11878 remote_buffer_add_int (&p
, &left
, flags
);
11879 remote_buffer_add_string (&p
, &left
, ",");
11881 remote_buffer_add_int (&p
, &left
, mode
);
11883 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
11884 remote_errno
, NULL
, NULL
);
11888 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
11889 int flags
, int mode
, int warn_if_slow
,
11892 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
11896 /* Implementation of to_fileio_pwrite. */
11899 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11900 ULONGEST offset
, int *remote_errno
)
11902 struct remote_state
*rs
= get_remote_state ();
11903 char *p
= rs
->buf
.data ();
11904 int left
= get_remote_packet_size ();
11907 rs
->readahead_cache
.invalidate_fd (fd
);
11909 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11911 remote_buffer_add_int (&p
, &left
, fd
);
11912 remote_buffer_add_string (&p
, &left
, ",");
11914 remote_buffer_add_int (&p
, &left
, offset
);
11915 remote_buffer_add_string (&p
, &left
, ",");
11917 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
11918 (get_remote_packet_size ()
11919 - (p
- rs
->buf
.data ())));
11921 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
11922 remote_errno
, NULL
, NULL
);
11926 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11927 ULONGEST offset
, int *remote_errno
)
11929 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
11932 /* Helper for the implementation of to_fileio_pread. Read the file
11933 from the remote side with vFile:pread. */
11936 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
11937 ULONGEST offset
, int *remote_errno
)
11939 struct remote_state
*rs
= get_remote_state ();
11940 char *p
= rs
->buf
.data ();
11942 int left
= get_remote_packet_size ();
11943 int ret
, attachment_len
;
11946 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
11948 remote_buffer_add_int (&p
, &left
, fd
);
11949 remote_buffer_add_string (&p
, &left
, ",");
11951 remote_buffer_add_int (&p
, &left
, len
);
11952 remote_buffer_add_string (&p
, &left
, ",");
11954 remote_buffer_add_int (&p
, &left
, offset
);
11956 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
11957 remote_errno
, &attachment
,
11963 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11965 if (read_len
!= ret
)
11966 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
11971 /* See declaration.h. */
11974 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
11978 && this->offset
<= offset
11979 && offset
< this->offset
+ this->bufsize
)
11981 ULONGEST max
= this->offset
+ this->bufsize
;
11983 if (offset
+ len
> max
)
11984 len
= max
- offset
;
11986 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
11993 /* Implementation of to_fileio_pread. */
11996 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
11997 ULONGEST offset
, int *remote_errno
)
12000 struct remote_state
*rs
= get_remote_state ();
12001 readahead_cache
*cache
= &rs
->readahead_cache
;
12003 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12006 cache
->hit_count
++;
12009 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12010 pulongest (cache
->hit_count
));
12014 cache
->miss_count
++;
12016 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12017 pulongest (cache
->miss_count
));
12020 cache
->offset
= offset
;
12021 cache
->bufsize
= get_remote_packet_size ();
12022 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12024 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12025 cache
->offset
, remote_errno
);
12028 cache
->invalidate_fd (fd
);
12032 cache
->bufsize
= ret
;
12033 return cache
->pread (fd
, read_buf
, len
, offset
);
12037 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12038 ULONGEST offset
, int *remote_errno
)
12040 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12043 /* Implementation of to_fileio_close. */
12046 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12048 struct remote_state
*rs
= get_remote_state ();
12049 char *p
= rs
->buf
.data ();
12050 int left
= get_remote_packet_size () - 1;
12052 rs
->readahead_cache
.invalidate_fd (fd
);
12054 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12056 remote_buffer_add_int (&p
, &left
, fd
);
12058 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12059 remote_errno
, NULL
, NULL
);
12063 remote_target::fileio_close (int fd
, int *remote_errno
)
12065 return remote_hostio_close (fd
, remote_errno
);
12068 /* Implementation of to_fileio_unlink. */
12071 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12074 struct remote_state
*rs
= get_remote_state ();
12075 char *p
= rs
->buf
.data ();
12076 int left
= get_remote_packet_size () - 1;
12078 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12081 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12083 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12084 strlen (filename
));
12086 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12087 remote_errno
, NULL
, NULL
);
12091 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12094 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12097 /* Implementation of to_fileio_readlink. */
12099 gdb::optional
<std::string
>
12100 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12103 struct remote_state
*rs
= get_remote_state ();
12104 char *p
= rs
->buf
.data ();
12106 int left
= get_remote_packet_size ();
12107 int len
, attachment_len
;
12110 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12113 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12115 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12116 strlen (filename
));
12118 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12119 remote_errno
, &attachment
,
12125 std::string
ret (len
, '\0');
12127 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12128 (gdb_byte
*) &ret
[0], len
);
12129 if (read_len
!= len
)
12130 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12135 /* Implementation of to_fileio_fstat. */
12138 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12140 struct remote_state
*rs
= get_remote_state ();
12141 char *p
= rs
->buf
.data ();
12142 int left
= get_remote_packet_size ();
12143 int attachment_len
, ret
;
12145 struct fio_stat fst
;
12148 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12150 remote_buffer_add_int (&p
, &left
, fd
);
12152 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12153 remote_errno
, &attachment
,
12157 if (*remote_errno
!= FILEIO_ENOSYS
)
12160 /* Strictly we should return -1, ENOSYS here, but when
12161 "set sysroot remote:" was implemented in August 2008
12162 BFD's need for a stat function was sidestepped with
12163 this hack. This was not remedied until March 2015
12164 so we retain the previous behavior to avoid breaking
12167 Note that the memset is a March 2015 addition; older
12168 GDBs set st_size *and nothing else* so the structure
12169 would have garbage in all other fields. This might
12170 break something but retaining the previous behavior
12171 here would be just too wrong. */
12173 memset (st
, 0, sizeof (struct stat
));
12174 st
->st_size
= INT_MAX
;
12178 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12179 (gdb_byte
*) &fst
, sizeof (fst
));
12181 if (read_len
!= ret
)
12182 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12184 if (read_len
!= sizeof (fst
))
12185 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12186 read_len
, (int) sizeof (fst
));
12188 remote_fileio_to_host_stat (&fst
, st
);
12193 /* Implementation of to_filesystem_is_local. */
12196 remote_target::filesystem_is_local ()
12198 /* Valgrind GDB presents itself as a remote target but works
12199 on the local filesystem: it does not implement remote get
12200 and users are not expected to set a sysroot. To handle
12201 this case we treat the remote filesystem as local if the
12202 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12203 does not support vFile:open. */
12204 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12206 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12208 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12210 int fd
, remote_errno
;
12212 /* Try opening a file to probe support. The supplied
12213 filename is irrelevant, we only care about whether
12214 the stub recognizes the packet or not. */
12215 fd
= remote_hostio_open (NULL
, "just probing",
12216 FILEIO_O_RDONLY
, 0700, 0,
12220 remote_hostio_close (fd
, &remote_errno
);
12222 ps
= packet_support (PACKET_vFile_open
);
12225 if (ps
== PACKET_DISABLE
)
12227 static int warning_issued
= 0;
12229 if (!warning_issued
)
12231 warning (_("remote target does not support file"
12232 " transfer, attempting to access files"
12233 " from local filesystem."));
12234 warning_issued
= 1;
12245 remote_fileio_errno_to_host (int errnum
)
12251 case FILEIO_ENOENT
:
12259 case FILEIO_EACCES
:
12261 case FILEIO_EFAULT
:
12265 case FILEIO_EEXIST
:
12267 case FILEIO_ENODEV
:
12269 case FILEIO_ENOTDIR
:
12271 case FILEIO_EISDIR
:
12273 case FILEIO_EINVAL
:
12275 case FILEIO_ENFILE
:
12277 case FILEIO_EMFILE
:
12281 case FILEIO_ENOSPC
:
12283 case FILEIO_ESPIPE
:
12287 case FILEIO_ENOSYS
:
12289 case FILEIO_ENAMETOOLONG
:
12290 return ENAMETOOLONG
;
12296 remote_hostio_error (int errnum
)
12298 int host_error
= remote_fileio_errno_to_host (errnum
);
12300 if (host_error
== -1)
12301 error (_("Unknown remote I/O error %d"), errnum
);
12303 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12306 /* A RAII wrapper around a remote file descriptor. */
12308 class scoped_remote_fd
12311 scoped_remote_fd (remote_target
*remote
, int fd
)
12312 : m_remote (remote
), m_fd (fd
)
12316 ~scoped_remote_fd ()
12323 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12327 /* Swallow exception before it escapes the dtor. If
12328 something goes wrong, likely the connection is gone,
12329 and there's nothing else that can be done. */
12334 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12336 /* Release ownership of the file descriptor, and return it. */
12337 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12344 /* Return the owned file descriptor. */
12345 int get () const noexcept
12351 /* The remote target. */
12352 remote_target
*m_remote
;
12354 /* The owned remote I/O file descriptor. */
12359 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12361 remote_target
*remote
= get_current_remote_target ();
12363 if (remote
== nullptr)
12364 error (_("command can only be used with remote target"));
12366 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12370 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12373 int retcode
, remote_errno
, bytes
, io_size
;
12374 int bytes_in_buffer
;
12378 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12380 perror_with_name (local_file
);
12382 scoped_remote_fd fd
12383 (this, remote_hostio_open (NULL
,
12384 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12386 0700, 0, &remote_errno
));
12387 if (fd
.get () == -1)
12388 remote_hostio_error (remote_errno
);
12390 /* Send up to this many bytes at once. They won't all fit in the
12391 remote packet limit, so we'll transfer slightly fewer. */
12392 io_size
= get_remote_packet_size ();
12393 gdb::byte_vector
buffer (io_size
);
12395 bytes_in_buffer
= 0;
12398 while (bytes_in_buffer
|| !saw_eof
)
12402 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12403 io_size
- bytes_in_buffer
,
12407 if (ferror (file
.get ()))
12408 error (_("Error reading %s."), local_file
);
12411 /* EOF. Unless there is something still in the
12412 buffer from the last iteration, we are done. */
12414 if (bytes_in_buffer
== 0)
12422 bytes
+= bytes_in_buffer
;
12423 bytes_in_buffer
= 0;
12425 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12426 offset
, &remote_errno
);
12429 remote_hostio_error (remote_errno
);
12430 else if (retcode
== 0)
12431 error (_("Remote write of %d bytes returned 0!"), bytes
);
12432 else if (retcode
< bytes
)
12434 /* Short write. Save the rest of the read data for the next
12436 bytes_in_buffer
= bytes
- retcode
;
12437 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12443 if (remote_hostio_close (fd
.release (), &remote_errno
))
12444 remote_hostio_error (remote_errno
);
12447 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12451 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12453 remote_target
*remote
= get_current_remote_target ();
12455 if (remote
== nullptr)
12456 error (_("command can only be used with remote target"));
12458 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12462 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12465 int remote_errno
, bytes
, io_size
;
12468 scoped_remote_fd fd
12469 (this, remote_hostio_open (NULL
,
12470 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12472 if (fd
.get () == -1)
12473 remote_hostio_error (remote_errno
);
12475 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12477 perror_with_name (local_file
);
12479 /* Send up to this many bytes at once. They won't all fit in the
12480 remote packet limit, so we'll transfer slightly fewer. */
12481 io_size
= get_remote_packet_size ();
12482 gdb::byte_vector
buffer (io_size
);
12487 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12490 /* Success, but no bytes, means end-of-file. */
12493 remote_hostio_error (remote_errno
);
12497 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12499 perror_with_name (local_file
);
12502 if (remote_hostio_close (fd
.release (), &remote_errno
))
12503 remote_hostio_error (remote_errno
);
12506 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12510 remote_file_delete (const char *remote_file
, int from_tty
)
12512 remote_target
*remote
= get_current_remote_target ();
12514 if (remote
== nullptr)
12515 error (_("command can only be used with remote target"));
12517 remote
->remote_file_delete (remote_file
, from_tty
);
12521 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12523 int retcode
, remote_errno
;
12525 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12527 remote_hostio_error (remote_errno
);
12530 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12534 remote_put_command (const char *args
, int from_tty
)
12537 error_no_arg (_("file to put"));
12539 gdb_argv
argv (args
);
12540 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12541 error (_("Invalid parameters to remote put"));
12543 remote_file_put (argv
[0], argv
[1], from_tty
);
12547 remote_get_command (const char *args
, int from_tty
)
12550 error_no_arg (_("file to get"));
12552 gdb_argv
argv (args
);
12553 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12554 error (_("Invalid parameters to remote get"));
12556 remote_file_get (argv
[0], argv
[1], from_tty
);
12560 remote_delete_command (const char *args
, int from_tty
)
12563 error_no_arg (_("file to delete"));
12565 gdb_argv
argv (args
);
12566 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12567 error (_("Invalid parameters to remote delete"));
12569 remote_file_delete (argv
[0], from_tty
);
12573 remote_command (const char *args
, int from_tty
)
12575 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12579 remote_target::can_execute_reverse ()
12581 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12582 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12589 remote_target::supports_non_stop ()
12595 remote_target::supports_disable_randomization ()
12597 /* Only supported in extended mode. */
12602 remote_target::supports_multi_process ()
12604 struct remote_state
*rs
= get_remote_state ();
12606 return remote_multi_process_p (rs
);
12610 remote_supports_cond_tracepoints ()
12612 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12616 remote_target::supports_evaluation_of_breakpoint_conditions ()
12618 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12622 remote_supports_fast_tracepoints ()
12624 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12628 remote_supports_static_tracepoints ()
12630 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12634 remote_supports_install_in_trace ()
12636 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12640 remote_target::supports_enable_disable_tracepoint ()
12642 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12647 remote_target::supports_string_tracing ()
12649 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12653 remote_target::can_run_breakpoint_commands ()
12655 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12659 remote_target::trace_init ()
12661 struct remote_state
*rs
= get_remote_state ();
12664 remote_get_noisy_reply ();
12665 if (strcmp (rs
->buf
.data (), "OK") != 0)
12666 error (_("Target does not support this command."));
12669 /* Recursive routine to walk through command list including loops, and
12670 download packets for each command. */
12673 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12674 struct command_line
*cmds
)
12676 struct remote_state
*rs
= get_remote_state ();
12677 struct command_line
*cmd
;
12679 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12681 QUIT
; /* Allow user to bail out with ^C. */
12682 strcpy (rs
->buf
.data (), "QTDPsrc:");
12683 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12684 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12685 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12687 remote_get_noisy_reply ();
12688 if (strcmp (rs
->buf
.data (), "OK"))
12689 warning (_("Target does not support source download."));
12691 if (cmd
->control_type
== while_control
12692 || cmd
->control_type
== while_stepping_control
)
12694 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12696 QUIT
; /* Allow user to bail out with ^C. */
12697 strcpy (rs
->buf
.data (), "QTDPsrc:");
12698 encode_source_string (num
, addr
, "cmd", "end",
12699 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12700 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12702 remote_get_noisy_reply ();
12703 if (strcmp (rs
->buf
.data (), "OK"))
12704 warning (_("Target does not support source download."));
12710 remote_target::download_tracepoint (struct bp_location
*loc
)
12714 std::vector
<std::string
> tdp_actions
;
12715 std::vector
<std::string
> stepping_actions
;
12717 struct breakpoint
*b
= loc
->owner
;
12718 struct tracepoint
*t
= (struct tracepoint
*) b
;
12719 struct remote_state
*rs
= get_remote_state ();
12721 const char *err_msg
= _("Tracepoint packet too large for target.");
12724 /* We use a buffer other than rs->buf because we'll build strings
12725 across multiple statements, and other statements in between could
12727 gdb::char_vector
buf (get_remote_packet_size ());
12729 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12731 tpaddr
= loc
->address
;
12732 sprintf_vma (addrbuf
, tpaddr
);
12733 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12734 b
->number
, addrbuf
, /* address */
12735 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12736 t
->step_count
, t
->pass_count
);
12738 if (ret
< 0 || ret
>= buf
.size ())
12739 error ("%s", err_msg
);
12741 /* Fast tracepoints are mostly handled by the target, but we can
12742 tell the target how big of an instruction block should be moved
12744 if (b
->type
== bp_fast_tracepoint
)
12746 /* Only test for support at download time; we may not know
12747 target capabilities at definition time. */
12748 if (remote_supports_fast_tracepoints ())
12750 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12753 size_left
= buf
.size () - strlen (buf
.data ());
12754 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12756 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12758 if (ret
< 0 || ret
>= size_left
)
12759 error ("%s", err_msg
);
12762 /* If it passed validation at definition but fails now,
12763 something is very wrong. */
12764 internal_error (__FILE__
, __LINE__
,
12765 _("Fast tracepoint not "
12766 "valid during download"));
12769 /* Fast tracepoints are functionally identical to regular
12770 tracepoints, so don't take lack of support as a reason to
12771 give up on the trace run. */
12772 warning (_("Target does not support fast tracepoints, "
12773 "downloading %d as regular tracepoint"), b
->number
);
12775 else if (b
->type
== bp_static_tracepoint
)
12777 /* Only test for support at download time; we may not know
12778 target capabilities at definition time. */
12779 if (remote_supports_static_tracepoints ())
12781 struct static_tracepoint_marker marker
;
12783 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12785 size_left
= buf
.size () - strlen (buf
.data ());
12786 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12789 if (ret
< 0 || ret
>= size_left
)
12790 error ("%s", err_msg
);
12793 error (_("Static tracepoint not valid during download"));
12796 /* Fast tracepoints are functionally identical to regular
12797 tracepoints, so don't take lack of support as a reason
12798 to give up on the trace run. */
12799 error (_("Target does not support static tracepoints"));
12801 /* If the tracepoint has a conditional, make it into an agent
12802 expression and append to the definition. */
12805 /* Only test support at download time, we may not know target
12806 capabilities at definition time. */
12807 if (remote_supports_cond_tracepoints ())
12809 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
12812 size_left
= buf
.size () - strlen (buf
.data ());
12814 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12815 size_left
, ":X%x,", aexpr
->len
);
12817 if (ret
< 0 || ret
>= size_left
)
12818 error ("%s", err_msg
);
12820 size_left
= buf
.size () - strlen (buf
.data ());
12822 /* Two bytes to encode each aexpr byte, plus the terminating
12824 if (aexpr
->len
* 2 + 1 > size_left
)
12825 error ("%s", err_msg
);
12827 pkt
= buf
.data () + strlen (buf
.data ());
12829 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12830 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12834 warning (_("Target does not support conditional tracepoints, "
12835 "ignoring tp %d cond"), b
->number
);
12838 if (b
->commands
|| *default_collect
)
12840 size_left
= buf
.size () - strlen (buf
.data ());
12842 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12845 if (ret
< 0 || ret
>= size_left
)
12846 error ("%s", err_msg
);
12849 putpkt (buf
.data ());
12850 remote_get_noisy_reply ();
12851 if (strcmp (rs
->buf
.data (), "OK"))
12852 error (_("Target does not support tracepoints."));
12854 /* do_single_steps (t); */
12855 for (auto action_it
= tdp_actions
.begin ();
12856 action_it
!= tdp_actions
.end (); action_it
++)
12858 QUIT
; /* Allow user to bail out with ^C. */
12860 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
12861 || !stepping_actions
.empty ());
12863 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
12864 b
->number
, addrbuf
, /* address */
12865 action_it
->c_str (),
12866 has_more
? '-' : 0);
12868 if (ret
< 0 || ret
>= buf
.size ())
12869 error ("%s", err_msg
);
12871 putpkt (buf
.data ());
12872 remote_get_noisy_reply ();
12873 if (strcmp (rs
->buf
.data (), "OK"))
12874 error (_("Error on target while setting tracepoints."));
12877 for (auto action_it
= stepping_actions
.begin ();
12878 action_it
!= stepping_actions
.end (); action_it
++)
12880 QUIT
; /* Allow user to bail out with ^C. */
12882 bool is_first
= action_it
== stepping_actions
.begin ();
12883 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
12885 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
12886 b
->number
, addrbuf
, /* address */
12887 is_first
? "S" : "",
12888 action_it
->c_str (),
12889 has_more
? "-" : "");
12891 if (ret
< 0 || ret
>= buf
.size ())
12892 error ("%s", err_msg
);
12894 putpkt (buf
.data ());
12895 remote_get_noisy_reply ();
12896 if (strcmp (rs
->buf
.data (), "OK"))
12897 error (_("Error on target while setting tracepoints."));
12900 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12902 if (b
->location
!= NULL
)
12904 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12906 if (ret
< 0 || ret
>= buf
.size ())
12907 error ("%s", err_msg
);
12909 encode_source_string (b
->number
, loc
->address
, "at",
12910 event_location_to_string (b
->location
.get ()),
12911 buf
.data () + strlen (buf
.data ()),
12912 buf
.size () - strlen (buf
.data ()));
12913 putpkt (buf
.data ());
12914 remote_get_noisy_reply ();
12915 if (strcmp (rs
->buf
.data (), "OK"))
12916 warning (_("Target does not support source download."));
12918 if (b
->cond_string
)
12920 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12922 if (ret
< 0 || ret
>= buf
.size ())
12923 error ("%s", err_msg
);
12925 encode_source_string (b
->number
, loc
->address
,
12926 "cond", b
->cond_string
,
12927 buf
.data () + strlen (buf
.data ()),
12928 buf
.size () - strlen (buf
.data ()));
12929 putpkt (buf
.data ());
12930 remote_get_noisy_reply ();
12931 if (strcmp (rs
->buf
.data (), "OK"))
12932 warning (_("Target does not support source download."));
12934 remote_download_command_source (b
->number
, loc
->address
,
12935 breakpoint_commands (b
));
12940 remote_target::can_download_tracepoint ()
12942 struct remote_state
*rs
= get_remote_state ();
12943 struct trace_status
*ts
;
12946 /* Don't try to install tracepoints until we've relocated our
12947 symbols, and fetched and merged the target's tracepoint list with
12949 if (rs
->starting_up
)
12952 ts
= current_trace_status ();
12953 status
= get_trace_status (ts
);
12955 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
12958 /* If we are in a tracing experiment, but remote stub doesn't support
12959 installing tracepoint in trace, we have to return. */
12960 if (!remote_supports_install_in_trace ())
12968 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
12970 struct remote_state
*rs
= get_remote_state ();
12973 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
12974 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
12976 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
12977 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
12978 >= get_remote_packet_size ())
12979 error (_("Trace state variable name too long for tsv definition packet"));
12980 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
12983 remote_get_noisy_reply ();
12984 if (rs
->buf
[0] == '\0')
12985 error (_("Target does not support this command."));
12986 if (strcmp (rs
->buf
.data (), "OK") != 0)
12987 error (_("Error on target while downloading trace state variable."));
12991 remote_target::enable_tracepoint (struct bp_location
*location
)
12993 struct remote_state
*rs
= get_remote_state ();
12996 sprintf_vma (addr_buf
, location
->address
);
12997 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
12998 location
->owner
->number
, addr_buf
);
13000 remote_get_noisy_reply ();
13001 if (rs
->buf
[0] == '\0')
13002 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13003 if (strcmp (rs
->buf
.data (), "OK") != 0)
13004 error (_("Error on target while enabling tracepoint."));
13008 remote_target::disable_tracepoint (struct bp_location
*location
)
13010 struct remote_state
*rs
= get_remote_state ();
13013 sprintf_vma (addr_buf
, location
->address
);
13014 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13015 location
->owner
->number
, addr_buf
);
13017 remote_get_noisy_reply ();
13018 if (rs
->buf
[0] == '\0')
13019 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13020 if (strcmp (rs
->buf
.data (), "OK") != 0)
13021 error (_("Error on target while disabling tracepoint."));
13025 remote_target::trace_set_readonly_regions ()
13028 bfd_size_type size
;
13034 return; /* No information to give. */
13036 struct remote_state
*rs
= get_remote_state ();
13038 strcpy (rs
->buf
.data (), "QTro");
13039 offset
= strlen (rs
->buf
.data ());
13040 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
13042 char tmp1
[40], tmp2
[40];
13045 if ((s
->flags
& SEC_LOAD
) == 0 ||
13046 /* (s->flags & SEC_CODE) == 0 || */
13047 (s
->flags
& SEC_READONLY
) == 0)
13051 vma
= bfd_section_vma (s
);
13052 size
= bfd_section_size (s
);
13053 sprintf_vma (tmp1
, vma
);
13054 sprintf_vma (tmp2
, vma
+ size
);
13055 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13056 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13058 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13060 Too many sections for read-only sections definition packet."));
13063 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13065 offset
+= sec_length
;
13070 getpkt (&rs
->buf
, 0);
13075 remote_target::trace_start ()
13077 struct remote_state
*rs
= get_remote_state ();
13079 putpkt ("QTStart");
13080 remote_get_noisy_reply ();
13081 if (rs
->buf
[0] == '\0')
13082 error (_("Target does not support this command."));
13083 if (strcmp (rs
->buf
.data (), "OK") != 0)
13084 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13088 remote_target::get_trace_status (struct trace_status
*ts
)
13090 /* Initialize it just to avoid a GCC false warning. */
13092 enum packet_result result
;
13093 struct remote_state
*rs
= get_remote_state ();
13095 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13098 /* FIXME we need to get register block size some other way. */
13099 trace_regblock_size
13100 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13102 putpkt ("qTStatus");
13106 p
= remote_get_noisy_reply ();
13108 catch (const gdb_exception_error
&ex
)
13110 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13112 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13118 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13120 /* If the remote target doesn't do tracing, flag it. */
13121 if (result
== PACKET_UNKNOWN
)
13124 /* We're working with a live target. */
13125 ts
->filename
= NULL
;
13128 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13130 /* Function 'parse_trace_status' sets default value of each field of
13131 'ts' at first, so we don't have to do it here. */
13132 parse_trace_status (p
, ts
);
13134 return ts
->running
;
13138 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13139 struct uploaded_tp
*utp
)
13141 struct remote_state
*rs
= get_remote_state ();
13143 struct bp_location
*loc
;
13144 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13145 size_t size
= get_remote_packet_size ();
13150 tp
->traceframe_usage
= 0;
13151 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13153 /* If the tracepoint was never downloaded, don't go asking for
13155 if (tp
->number_on_target
== 0)
13157 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13158 phex_nz (loc
->address
, 0));
13160 reply
= remote_get_noisy_reply ();
13161 if (reply
&& *reply
)
13164 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13170 utp
->hit_count
= 0;
13171 utp
->traceframe_usage
= 0;
13172 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13173 phex_nz (utp
->addr
, 0));
13175 reply
= remote_get_noisy_reply ();
13176 if (reply
&& *reply
)
13179 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13185 remote_target::trace_stop ()
13187 struct remote_state
*rs
= get_remote_state ();
13190 remote_get_noisy_reply ();
13191 if (rs
->buf
[0] == '\0')
13192 error (_("Target does not support this command."));
13193 if (strcmp (rs
->buf
.data (), "OK") != 0)
13194 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13198 remote_target::trace_find (enum trace_find_type type
, int num
,
13199 CORE_ADDR addr1
, CORE_ADDR addr2
,
13202 struct remote_state
*rs
= get_remote_state ();
13203 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13205 int target_frameno
= -1, target_tracept
= -1;
13207 /* Lookups other than by absolute frame number depend on the current
13208 trace selected, so make sure it is correct on the remote end
13210 if (type
!= tfind_number
)
13211 set_remote_traceframe ();
13213 p
= rs
->buf
.data ();
13214 strcpy (p
, "QTFrame:");
13215 p
= strchr (p
, '\0');
13219 xsnprintf (p
, endbuf
- p
, "%x", num
);
13222 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13225 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13228 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13229 phex_nz (addr2
, 0));
13231 case tfind_outside
:
13232 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13233 phex_nz (addr2
, 0));
13236 error (_("Unknown trace find type %d"), type
);
13240 reply
= remote_get_noisy_reply ();
13241 if (*reply
== '\0')
13242 error (_("Target does not support this command."));
13244 while (reply
&& *reply
)
13249 target_frameno
= (int) strtol (p
, &reply
, 16);
13251 error (_("Unable to parse trace frame number"));
13252 /* Don't update our remote traceframe number cache on failure
13253 to select a remote traceframe. */
13254 if (target_frameno
== -1)
13259 target_tracept
= (int) strtol (p
, &reply
, 16);
13261 error (_("Unable to parse tracepoint number"));
13263 case 'O': /* "OK"? */
13264 if (reply
[1] == 'K' && reply
[2] == '\0')
13267 error (_("Bogus reply from target: %s"), reply
);
13270 error (_("Bogus reply from target: %s"), reply
);
13273 *tpp
= target_tracept
;
13275 rs
->remote_traceframe_number
= target_frameno
;
13276 return target_frameno
;
13280 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13282 struct remote_state
*rs
= get_remote_state ();
13286 set_remote_traceframe ();
13288 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13290 reply
= remote_get_noisy_reply ();
13291 if (reply
&& *reply
)
13295 unpack_varlen_hex (reply
+ 1, &uval
);
13296 *val
= (LONGEST
) uval
;
13304 remote_target::save_trace_data (const char *filename
)
13306 struct remote_state
*rs
= get_remote_state ();
13309 p
= rs
->buf
.data ();
13310 strcpy (p
, "QTSave:");
13312 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13313 >= get_remote_packet_size ())
13314 error (_("Remote file name too long for trace save packet"));
13315 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13318 reply
= remote_get_noisy_reply ();
13319 if (*reply
== '\0')
13320 error (_("Target does not support this command."));
13321 if (strcmp (reply
, "OK") != 0)
13322 error (_("Bogus reply from target: %s"), reply
);
13326 /* This is basically a memory transfer, but needs to be its own packet
13327 because we don't know how the target actually organizes its trace
13328 memory, plus we want to be able to ask for as much as possible, but
13329 not be unhappy if we don't get as much as we ask for. */
13332 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13334 struct remote_state
*rs
= get_remote_state ();
13339 p
= rs
->buf
.data ();
13340 strcpy (p
, "qTBuffer:");
13342 p
+= hexnumstr (p
, offset
);
13344 p
+= hexnumstr (p
, len
);
13348 reply
= remote_get_noisy_reply ();
13349 if (reply
&& *reply
)
13351 /* 'l' by itself means we're at the end of the buffer and
13352 there is nothing more to get. */
13356 /* Convert the reply into binary. Limit the number of bytes to
13357 convert according to our passed-in buffer size, rather than
13358 what was returned in the packet; if the target is
13359 unexpectedly generous and gives us a bigger reply than we
13360 asked for, we don't want to crash. */
13361 rslt
= hex2bin (reply
, buf
, len
);
13365 /* Something went wrong, flag as an error. */
13370 remote_target::set_disconnected_tracing (int val
)
13372 struct remote_state
*rs
= get_remote_state ();
13374 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13378 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13379 "QTDisconnected:%x", val
);
13381 reply
= remote_get_noisy_reply ();
13382 if (*reply
== '\0')
13383 error (_("Target does not support this command."));
13384 if (strcmp (reply
, "OK") != 0)
13385 error (_("Bogus reply from target: %s"), reply
);
13388 warning (_("Target does not support disconnected tracing."));
13392 remote_target::core_of_thread (ptid_t ptid
)
13394 struct thread_info
*info
= find_thread_ptid (ptid
);
13396 if (info
!= NULL
&& info
->priv
!= NULL
)
13397 return get_remote_thread_info (info
)->core
;
13403 remote_target::set_circular_trace_buffer (int val
)
13405 struct remote_state
*rs
= get_remote_state ();
13408 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13409 "QTBuffer:circular:%x", val
);
13411 reply
= remote_get_noisy_reply ();
13412 if (*reply
== '\0')
13413 error (_("Target does not support this command."));
13414 if (strcmp (reply
, "OK") != 0)
13415 error (_("Bogus reply from target: %s"), reply
);
13419 remote_target::traceframe_info ()
13421 gdb::optional
<gdb::char_vector
> text
13422 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13425 return parse_traceframe_info (text
->data ());
13430 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13431 instruction on which a fast tracepoint may be placed. Returns -1
13432 if the packet is not supported, and 0 if the minimum instruction
13433 length is unknown. */
13436 remote_target::get_min_fast_tracepoint_insn_len ()
13438 struct remote_state
*rs
= get_remote_state ();
13441 /* If we're not debugging a process yet, the IPA can't be
13443 if (!target_has_execution
)
13446 /* Make sure the remote is pointing at the right process. */
13447 set_general_process ();
13449 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13451 reply
= remote_get_noisy_reply ();
13452 if (*reply
== '\0')
13456 ULONGEST min_insn_len
;
13458 unpack_varlen_hex (reply
, &min_insn_len
);
13460 return (int) min_insn_len
;
13465 remote_target::set_trace_buffer_size (LONGEST val
)
13467 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13469 struct remote_state
*rs
= get_remote_state ();
13470 char *buf
= rs
->buf
.data ();
13471 char *endbuf
= buf
+ get_remote_packet_size ();
13472 enum packet_result result
;
13474 gdb_assert (val
>= 0 || val
== -1);
13475 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13476 /* Send -1 as literal "-1" to avoid host size dependency. */
13480 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13483 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13486 remote_get_noisy_reply ();
13487 result
= packet_ok (rs
->buf
,
13488 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13490 if (result
!= PACKET_OK
)
13491 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13496 remote_target::set_trace_notes (const char *user
, const char *notes
,
13497 const char *stop_notes
)
13499 struct remote_state
*rs
= get_remote_state ();
13501 char *buf
= rs
->buf
.data ();
13502 char *endbuf
= buf
+ get_remote_packet_size ();
13505 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13508 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13509 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13515 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13516 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13522 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13523 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13527 /* Ensure the buffer is terminated. */
13531 reply
= remote_get_noisy_reply ();
13532 if (*reply
== '\0')
13535 if (strcmp (reply
, "OK") != 0)
13536 error (_("Bogus reply from target: %s"), reply
);
13542 remote_target::use_agent (bool use
)
13544 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13546 struct remote_state
*rs
= get_remote_state ();
13548 /* If the stub supports QAgent. */
13549 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13551 getpkt (&rs
->buf
, 0);
13553 if (strcmp (rs
->buf
.data (), "OK") == 0)
13564 remote_target::can_use_agent ()
13566 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13569 struct btrace_target_info
13571 /* The ptid of the traced thread. */
13574 /* The obtained branch trace configuration. */
13575 struct btrace_config conf
;
13578 /* Reset our idea of our target's btrace configuration. */
13581 remote_btrace_reset (remote_state
*rs
)
13583 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13586 /* Synchronize the configuration with the target. */
13589 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13591 struct packet_config
*packet
;
13592 struct remote_state
*rs
;
13593 char *buf
, *pos
, *endbuf
;
13595 rs
= get_remote_state ();
13596 buf
= rs
->buf
.data ();
13597 endbuf
= buf
+ get_remote_packet_size ();
13599 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13600 if (packet_config_support (packet
) == PACKET_ENABLE
13601 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13604 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13608 getpkt (&rs
->buf
, 0);
13610 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13612 if (buf
[0] == 'E' && buf
[1] == '.')
13613 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13615 error (_("Failed to configure the BTS buffer size."));
13618 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13621 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13622 if (packet_config_support (packet
) == PACKET_ENABLE
13623 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13626 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13630 getpkt (&rs
->buf
, 0);
13632 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13634 if (buf
[0] == 'E' && buf
[1] == '.')
13635 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13637 error (_("Failed to configure the trace buffer size."));
13640 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13644 /* Read the current thread's btrace configuration from the target and
13645 store it into CONF. */
13648 btrace_read_config (struct btrace_config
*conf
)
13650 gdb::optional
<gdb::char_vector
> xml
13651 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13653 parse_xml_btrace_conf (conf
, xml
->data ());
13656 /* Maybe reopen target btrace. */
13659 remote_target::remote_btrace_maybe_reopen ()
13661 struct remote_state
*rs
= get_remote_state ();
13662 int btrace_target_pushed
= 0;
13663 #if !defined (HAVE_LIBIPT)
13667 /* Don't bother walking the entirety of the remote thread list when
13668 we know the feature isn't supported by the remote. */
13669 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13672 scoped_restore_current_thread restore_thread
;
13674 for (thread_info
*tp
: all_non_exited_threads ())
13676 set_general_thread (tp
->ptid
);
13678 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13679 btrace_read_config (&rs
->btrace_config
);
13681 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13684 #if !defined (HAVE_LIBIPT)
13685 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13690 warning (_("Target is recording using Intel Processor Trace "
13691 "but support was disabled at compile time."));
13696 #endif /* !defined (HAVE_LIBIPT) */
13698 /* Push target, once, but before anything else happens. This way our
13699 changes to the threads will be cleaned up by unpushing the target
13700 in case btrace_read_config () throws. */
13701 if (!btrace_target_pushed
)
13703 btrace_target_pushed
= 1;
13704 record_btrace_push_target ();
13705 printf_filtered (_("Target is recording using %s.\n"),
13706 btrace_format_string (rs
->btrace_config
.format
));
13709 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13710 tp
->btrace
.target
->ptid
= tp
->ptid
;
13711 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13715 /* Enable branch tracing. */
13717 struct btrace_target_info
*
13718 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13720 struct btrace_target_info
*tinfo
= NULL
;
13721 struct packet_config
*packet
= NULL
;
13722 struct remote_state
*rs
= get_remote_state ();
13723 char *buf
= rs
->buf
.data ();
13724 char *endbuf
= buf
+ get_remote_packet_size ();
13726 switch (conf
->format
)
13728 case BTRACE_FORMAT_BTS
:
13729 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13732 case BTRACE_FORMAT_PT
:
13733 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13737 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13738 error (_("Target does not support branch tracing."));
13740 btrace_sync_conf (conf
);
13742 set_general_thread (ptid
);
13744 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13746 getpkt (&rs
->buf
, 0);
13748 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13750 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13751 error (_("Could not enable branch tracing for %s: %s"),
13752 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
13754 error (_("Could not enable branch tracing for %s."),
13755 target_pid_to_str (ptid
).c_str ());
13758 tinfo
= XCNEW (struct btrace_target_info
);
13759 tinfo
->ptid
= ptid
;
13761 /* If we fail to read the configuration, we lose some information, but the
13762 tracing itself is not impacted. */
13765 btrace_read_config (&tinfo
->conf
);
13767 catch (const gdb_exception_error
&err
)
13769 if (err
.message
!= NULL
)
13770 warning ("%s", err
.what ());
13776 /* Disable branch tracing. */
13779 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
13781 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13782 struct remote_state
*rs
= get_remote_state ();
13783 char *buf
= rs
->buf
.data ();
13784 char *endbuf
= buf
+ get_remote_packet_size ();
13786 if (packet_config_support (packet
) != PACKET_ENABLE
)
13787 error (_("Target does not support branch tracing."));
13789 set_general_thread (tinfo
->ptid
);
13791 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13793 getpkt (&rs
->buf
, 0);
13795 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13797 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13798 error (_("Could not disable branch tracing for %s: %s"),
13799 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
13801 error (_("Could not disable branch tracing for %s."),
13802 target_pid_to_str (tinfo
->ptid
).c_str ());
13808 /* Teardown branch tracing. */
13811 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
13813 /* We must not talk to the target during teardown. */
13817 /* Read the branch trace. */
13820 remote_target::read_btrace (struct btrace_data
*btrace
,
13821 struct btrace_target_info
*tinfo
,
13822 enum btrace_read_type type
)
13824 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13827 if (packet_config_support (packet
) != PACKET_ENABLE
)
13828 error (_("Target does not support branch tracing."));
13830 #if !defined(HAVE_LIBEXPAT)
13831 error (_("Cannot process branch tracing result. XML parsing not supported."));
13836 case BTRACE_READ_ALL
:
13839 case BTRACE_READ_NEW
:
13842 case BTRACE_READ_DELTA
:
13846 internal_error (__FILE__
, __LINE__
,
13847 _("Bad branch tracing read type: %u."),
13848 (unsigned int) type
);
13851 gdb::optional
<gdb::char_vector
> xml
13852 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
13854 return BTRACE_ERR_UNKNOWN
;
13856 parse_xml_btrace (btrace
, xml
->data ());
13858 return BTRACE_ERR_NONE
;
13861 const struct btrace_config
*
13862 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
13864 return &tinfo
->conf
;
13868 remote_target::augmented_libraries_svr4_read ()
13870 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13874 /* Implementation of to_load. */
13877 remote_target::load (const char *name
, int from_tty
)
13879 generic_load (name
, from_tty
);
13882 /* Accepts an integer PID; returns a string representing a file that
13883 can be opened on the remote side to get the symbols for the child
13884 process. Returns NULL if the operation is not supported. */
13887 remote_target::pid_to_exec_file (int pid
)
13889 static gdb::optional
<gdb::char_vector
> filename
;
13890 struct inferior
*inf
;
13891 char *annex
= NULL
;
13893 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13896 inf
= find_inferior_pid (pid
);
13898 internal_error (__FILE__
, __LINE__
,
13899 _("not currently attached to process %d"), pid
);
13901 if (!inf
->fake_pid_p
)
13903 const int annex_size
= 9;
13905 annex
= (char *) alloca (annex_size
);
13906 xsnprintf (annex
, annex_size
, "%x", pid
);
13909 filename
= target_read_stralloc (current_top_target (),
13910 TARGET_OBJECT_EXEC_FILE
, annex
);
13912 return filename
? filename
->data () : nullptr;
13915 /* Implement the to_can_do_single_step target_ops method. */
13918 remote_target::can_do_single_step ()
13920 /* We can only tell whether target supports single step or not by
13921 supported s and S vCont actions if the stub supports vContSupported
13922 feature. If the stub doesn't support vContSupported feature,
13923 we have conservatively to think target doesn't supports single
13925 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
13927 struct remote_state
*rs
= get_remote_state ();
13929 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13930 remote_vcont_probe ();
13932 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
13938 /* Implementation of the to_execution_direction method for the remote
13941 enum exec_direction_kind
13942 remote_target::execution_direction ()
13944 struct remote_state
*rs
= get_remote_state ();
13946 return rs
->last_resume_exec_dir
;
13949 /* Return pointer to the thread_info struct which corresponds to
13950 THREAD_HANDLE (having length HANDLE_LEN). */
13953 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
13957 for (thread_info
*tp
: all_non_exited_threads ())
13959 remote_thread_info
*priv
= get_remote_thread_info (tp
);
13961 if (tp
->inf
== inf
&& priv
!= NULL
)
13963 if (handle_len
!= priv
->thread_handle
.size ())
13964 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
13965 handle_len
, priv
->thread_handle
.size ());
13966 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
13976 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
13978 remote_thread_info
*priv
= get_remote_thread_info (tp
);
13979 return priv
->thread_handle
;
13983 remote_target::can_async_p ()
13985 struct remote_state
*rs
= get_remote_state ();
13987 /* We don't go async if the user has explicitly prevented it with the
13988 "maint set target-async" command. */
13989 if (!target_async_permitted
)
13992 /* We're async whenever the serial device is. */
13993 return serial_can_async_p (rs
->remote_desc
);
13997 remote_target::is_async_p ()
13999 struct remote_state
*rs
= get_remote_state ();
14001 if (!target_async_permitted
)
14002 /* We only enable async when the user specifically asks for it. */
14005 /* We're async whenever the serial device is. */
14006 return serial_is_async_p (rs
->remote_desc
);
14009 /* Pass the SERIAL event on and up to the client. One day this code
14010 will be able to delay notifying the client of an event until the
14011 point where an entire packet has been received. */
14013 static serial_event_ftype remote_async_serial_handler
;
14016 remote_async_serial_handler (struct serial
*scb
, void *context
)
14018 /* Don't propogate error information up to the client. Instead let
14019 the client find out about the error by querying the target. */
14020 inferior_event_handler (INF_REG_EVENT
, NULL
);
14024 remote_async_inferior_event_handler (gdb_client_data data
)
14026 inferior_event_handler (INF_REG_EVENT
, data
);
14030 remote_target::async (int enable
)
14032 struct remote_state
*rs
= get_remote_state ();
14036 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14038 /* If there are pending events in the stop reply queue tell the
14039 event loop to process them. */
14040 if (!rs
->stop_reply_queue
.empty ())
14041 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14042 /* For simplicity, below we clear the pending events token
14043 without remembering whether it is marked, so here we always
14044 mark it. If there's actually no pending notification to
14045 process, this ends up being a no-op (other than a spurious
14046 event-loop wakeup). */
14047 if (target_is_non_stop_p ())
14048 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14052 serial_async (rs
->remote_desc
, NULL
, NULL
);
14053 /* If the core is disabling async, it doesn't want to be
14054 disturbed with target events. Clear all async event sources
14056 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14057 if (target_is_non_stop_p ())
14058 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14062 /* Implementation of the to_thread_events method. */
14065 remote_target::thread_events (int enable
)
14067 struct remote_state
*rs
= get_remote_state ();
14068 size_t size
= get_remote_packet_size ();
14070 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14073 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14075 getpkt (&rs
->buf
, 0);
14077 switch (packet_ok (rs
->buf
,
14078 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14081 if (strcmp (rs
->buf
.data (), "OK") != 0)
14082 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14085 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14087 case PACKET_UNKNOWN
:
14093 set_remote_cmd (const char *args
, int from_tty
)
14095 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
14099 show_remote_cmd (const char *args
, int from_tty
)
14101 /* We can't just use cmd_show_list here, because we want to skip
14102 the redundant "show remote Z-packet" and the legacy aliases. */
14103 struct cmd_list_element
*list
= remote_show_cmdlist
;
14104 struct ui_out
*uiout
= current_uiout
;
14106 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14107 for (; list
!= NULL
; list
= list
->next
)
14108 if (strcmp (list
->name
, "Z-packet") == 0)
14110 else if (list
->type
== not_set_cmd
)
14111 /* Alias commands are exactly like the original, except they
14112 don't have the normal type. */
14116 ui_out_emit_tuple
option_emitter (uiout
, "option");
14118 uiout
->field_string ("name", list
->name
);
14119 uiout
->text (": ");
14120 if (list
->type
== show_cmd
)
14121 do_show_command (NULL
, from_tty
, list
);
14123 cmd_func (list
, NULL
, from_tty
);
14128 /* Function to be called whenever a new objfile (shlib) is detected. */
14130 remote_new_objfile (struct objfile
*objfile
)
14132 remote_target
*remote
= get_current_remote_target ();
14134 if (remote
!= NULL
) /* Have a remote connection. */
14135 remote
->remote_check_symbols ();
14138 /* Pull all the tracepoints defined on the target and create local
14139 data structures representing them. We don't want to create real
14140 tracepoints yet, we don't want to mess up the user's existing
14144 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14146 struct remote_state
*rs
= get_remote_state ();
14149 /* Ask for a first packet of tracepoint definition. */
14151 getpkt (&rs
->buf
, 0);
14152 p
= rs
->buf
.data ();
14153 while (*p
&& *p
!= 'l')
14155 parse_tracepoint_definition (p
, utpp
);
14156 /* Ask for another packet of tracepoint definition. */
14158 getpkt (&rs
->buf
, 0);
14159 p
= rs
->buf
.data ();
14165 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14167 struct remote_state
*rs
= get_remote_state ();
14170 /* Ask for a first packet of variable definition. */
14172 getpkt (&rs
->buf
, 0);
14173 p
= rs
->buf
.data ();
14174 while (*p
&& *p
!= 'l')
14176 parse_tsv_definition (p
, utsvp
);
14177 /* Ask for another packet of variable definition. */
14179 getpkt (&rs
->buf
, 0);
14180 p
= rs
->buf
.data ();
14185 /* The "set/show range-stepping" show hook. */
14188 show_range_stepping (struct ui_file
*file
, int from_tty
,
14189 struct cmd_list_element
*c
,
14192 fprintf_filtered (file
,
14193 _("Debugger's willingness to use range stepping "
14194 "is %s.\n"), value
);
14197 /* Return true if the vCont;r action is supported by the remote
14201 remote_target::vcont_r_supported ()
14203 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14204 remote_vcont_probe ();
14206 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14207 && get_remote_state ()->supports_vCont
.r
);
14210 /* The "set/show range-stepping" set hook. */
14213 set_range_stepping (const char *ignore_args
, int from_tty
,
14214 struct cmd_list_element
*c
)
14216 /* When enabling, check whether range stepping is actually supported
14217 by the target, and warn if not. */
14218 if (use_range_stepping
)
14220 remote_target
*remote
= get_current_remote_target ();
14222 || !remote
->vcont_r_supported ())
14223 warning (_("Range stepping is not supported by the current target"));
14228 _initialize_remote (void)
14230 struct cmd_list_element
*cmd
;
14231 const char *cmd_name
;
14233 /* architecture specific data */
14234 remote_g_packet_data_handle
=
14235 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14237 add_target (remote_target_info
, remote_target::open
);
14238 add_target (extended_remote_target_info
, extended_remote_target::open
);
14240 /* Hook into new objfile notification. */
14241 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14244 init_remote_threadtests ();
14247 /* set/show remote ... */
14249 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14250 Remote protocol specific variables.\n\
14251 Configure various remote-protocol specific variables such as\n\
14252 the packets being used."),
14253 &remote_set_cmdlist
, "set remote ",
14254 0 /* allow-unknown */, &setlist
);
14255 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14256 Remote protocol specific variables.\n\
14257 Configure various remote-protocol specific variables such as\n\
14258 the packets being used."),
14259 &remote_show_cmdlist
, "show remote ",
14260 0 /* allow-unknown */, &showlist
);
14262 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14263 Compare section data on target to the exec file.\n\
14264 Argument is a single section name (default: all loaded sections).\n\
14265 To compare only read-only loaded sections, specify the -r option."),
14268 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14269 Send an arbitrary packet to a remote target.\n\
14270 maintenance packet TEXT\n\
14271 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14272 this command sends the string TEXT to the inferior, and displays the\n\
14273 response packet. GDB supplies the initial `$' character, and the\n\
14274 terminating `#' character and checksum."),
14277 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14278 Set whether to send break if interrupted."), _("\
14279 Show whether to send break if interrupted."), _("\
14280 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14281 set_remotebreak
, show_remotebreak
,
14282 &setlist
, &showlist
);
14283 cmd_name
= "remotebreak";
14284 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14285 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14286 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14287 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14288 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14290 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14291 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14293 Set interrupt sequence to remote target."), _("\
14294 Show interrupt sequence to remote target."), _("\
14295 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14296 NULL
, show_interrupt_sequence
,
14297 &remote_set_cmdlist
,
14298 &remote_show_cmdlist
);
14300 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14301 &interrupt_on_connect
, _("\
14302 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14303 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14304 If set, interrupt sequence is sent to remote target."),
14306 &remote_set_cmdlist
, &remote_show_cmdlist
);
14308 /* Install commands for configuring memory read/write packets. */
14310 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14311 Set the maximum number of bytes per memory write packet (deprecated)."),
14313 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14314 Show the maximum number of bytes per memory write packet (deprecated)."),
14316 add_cmd ("memory-write-packet-size", no_class
,
14317 set_memory_write_packet_size
, _("\
14318 Set the maximum number of bytes per memory-write packet.\n\
14319 Specify the number of bytes in a packet or 0 (zero) for the\n\
14320 default packet size. The actual limit is further reduced\n\
14321 dependent on the target. Specify ``fixed'' to disable the\n\
14322 further restriction and ``limit'' to enable that restriction."),
14323 &remote_set_cmdlist
);
14324 add_cmd ("memory-read-packet-size", no_class
,
14325 set_memory_read_packet_size
, _("\
14326 Set the maximum number of bytes per memory-read packet.\n\
14327 Specify the number of bytes in a packet or 0 (zero) for the\n\
14328 default packet size. The actual limit is further reduced\n\
14329 dependent on the target. Specify ``fixed'' to disable the\n\
14330 further restriction and ``limit'' to enable that restriction."),
14331 &remote_set_cmdlist
);
14332 add_cmd ("memory-write-packet-size", no_class
,
14333 show_memory_write_packet_size
,
14334 _("Show the maximum number of bytes per memory-write packet."),
14335 &remote_show_cmdlist
);
14336 add_cmd ("memory-read-packet-size", no_class
,
14337 show_memory_read_packet_size
,
14338 _("Show the maximum number of bytes per memory-read packet."),
14339 &remote_show_cmdlist
);
14341 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14342 &remote_hw_watchpoint_limit
, _("\
14343 Set the maximum number of target hardware watchpoints."), _("\
14344 Show the maximum number of target hardware watchpoints."), _("\
14345 Specify \"unlimited\" for unlimited hardware watchpoints."),
14346 NULL
, show_hardware_watchpoint_limit
,
14347 &remote_set_cmdlist
,
14348 &remote_show_cmdlist
);
14349 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14351 &remote_hw_watchpoint_length_limit
, _("\
14352 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14353 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14354 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14355 NULL
, show_hardware_watchpoint_length_limit
,
14356 &remote_set_cmdlist
, &remote_show_cmdlist
);
14357 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14358 &remote_hw_breakpoint_limit
, _("\
14359 Set the maximum number of target hardware breakpoints."), _("\
14360 Show the maximum number of target hardware breakpoints."), _("\
14361 Specify \"unlimited\" for unlimited hardware breakpoints."),
14362 NULL
, show_hardware_breakpoint_limit
,
14363 &remote_set_cmdlist
, &remote_show_cmdlist
);
14365 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14366 &remote_address_size
, _("\
14367 Set the maximum size of the address (in bits) in a memory packet."), _("\
14368 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14370 NULL
, /* FIXME: i18n: */
14371 &setlist
, &showlist
);
14373 init_all_packet_configs ();
14375 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14376 "X", "binary-download", 1);
14378 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14379 "vCont", "verbose-resume", 0);
14381 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14382 "QPassSignals", "pass-signals", 0);
14384 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14385 "QCatchSyscalls", "catch-syscalls", 0);
14387 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14388 "QProgramSignals", "program-signals", 0);
14390 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14391 "QSetWorkingDir", "set-working-dir", 0);
14393 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14394 "QStartupWithShell", "startup-with-shell", 0);
14396 add_packet_config_cmd (&remote_protocol_packets
14397 [PACKET_QEnvironmentHexEncoded
],
14398 "QEnvironmentHexEncoded", "environment-hex-encoded",
14401 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14402 "QEnvironmentReset", "environment-reset",
14405 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14406 "QEnvironmentUnset", "environment-unset",
14409 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14410 "qSymbol", "symbol-lookup", 0);
14412 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14413 "P", "set-register", 1);
14415 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14416 "p", "fetch-register", 1);
14418 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14419 "Z0", "software-breakpoint", 0);
14421 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14422 "Z1", "hardware-breakpoint", 0);
14424 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14425 "Z2", "write-watchpoint", 0);
14427 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14428 "Z3", "read-watchpoint", 0);
14430 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14431 "Z4", "access-watchpoint", 0);
14433 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14434 "qXfer:auxv:read", "read-aux-vector", 0);
14436 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14437 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14439 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14440 "qXfer:features:read", "target-features", 0);
14442 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14443 "qXfer:libraries:read", "library-info", 0);
14445 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14446 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14448 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14449 "qXfer:memory-map:read", "memory-map", 0);
14451 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14452 "qXfer:osdata:read", "osdata", 0);
14454 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14455 "qXfer:threads:read", "threads", 0);
14457 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14458 "qXfer:siginfo:read", "read-siginfo-object", 0);
14460 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14461 "qXfer:siginfo:write", "write-siginfo-object", 0);
14463 add_packet_config_cmd
14464 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14465 "qXfer:traceframe-info:read", "traceframe-info", 0);
14467 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14468 "qXfer:uib:read", "unwind-info-block", 0);
14470 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14471 "qGetTLSAddr", "get-thread-local-storage-address",
14474 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14475 "qGetTIBAddr", "get-thread-information-block-address",
14478 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14479 "bc", "reverse-continue", 0);
14481 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14482 "bs", "reverse-step", 0);
14484 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14485 "qSupported", "supported-packets", 0);
14487 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14488 "qSearch:memory", "search-memory", 0);
14490 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14491 "qTStatus", "trace-status", 0);
14493 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14494 "vFile:setfs", "hostio-setfs", 0);
14496 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14497 "vFile:open", "hostio-open", 0);
14499 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14500 "vFile:pread", "hostio-pread", 0);
14502 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14503 "vFile:pwrite", "hostio-pwrite", 0);
14505 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14506 "vFile:close", "hostio-close", 0);
14508 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14509 "vFile:unlink", "hostio-unlink", 0);
14511 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14512 "vFile:readlink", "hostio-readlink", 0);
14514 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14515 "vFile:fstat", "hostio-fstat", 0);
14517 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14518 "vAttach", "attach", 0);
14520 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14523 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14524 "QStartNoAckMode", "noack", 0);
14526 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14527 "vKill", "kill", 0);
14529 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14530 "qAttached", "query-attached", 0);
14532 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14533 "ConditionalTracepoints",
14534 "conditional-tracepoints", 0);
14536 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14537 "ConditionalBreakpoints",
14538 "conditional-breakpoints", 0);
14540 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14541 "BreakpointCommands",
14542 "breakpoint-commands", 0);
14544 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14545 "FastTracepoints", "fast-tracepoints", 0);
14547 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14548 "TracepointSource", "TracepointSource", 0);
14550 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14551 "QAllow", "allow", 0);
14553 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14554 "StaticTracepoints", "static-tracepoints", 0);
14556 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14557 "InstallInTrace", "install-in-trace", 0);
14559 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14560 "qXfer:statictrace:read", "read-sdata-object", 0);
14562 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14563 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14565 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14566 "QDisableRandomization", "disable-randomization", 0);
14568 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14569 "QAgent", "agent", 0);
14571 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14572 "QTBuffer:size", "trace-buffer-size", 0);
14574 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14575 "Qbtrace:off", "disable-btrace", 0);
14577 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14578 "Qbtrace:bts", "enable-btrace-bts", 0);
14580 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14581 "Qbtrace:pt", "enable-btrace-pt", 0);
14583 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14584 "qXfer:btrace", "read-btrace", 0);
14586 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14587 "qXfer:btrace-conf", "read-btrace-conf", 0);
14589 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14590 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14592 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14593 "multiprocess-feature", "multiprocess-feature", 0);
14595 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14596 "swbreak-feature", "swbreak-feature", 0);
14598 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14599 "hwbreak-feature", "hwbreak-feature", 0);
14601 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14602 "fork-event-feature", "fork-event-feature", 0);
14604 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14605 "vfork-event-feature", "vfork-event-feature", 0);
14607 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14608 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14610 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14611 "vContSupported", "verbose-resume-supported", 0);
14613 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14614 "exec-event-feature", "exec-event-feature", 0);
14616 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14617 "vCtrlC", "ctrl-c", 0);
14619 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14620 "QThreadEvents", "thread-events", 0);
14622 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14623 "N stop reply", "no-resumed-stop-reply", 0);
14625 /* Assert that we've registered "set remote foo-packet" commands
14626 for all packet configs. */
14630 for (i
= 0; i
< PACKET_MAX
; i
++)
14632 /* Ideally all configs would have a command associated. Some
14633 still don't though. */
14638 case PACKET_QNonStop
:
14639 case PACKET_EnableDisableTracepoints_feature
:
14640 case PACKET_tracenz_feature
:
14641 case PACKET_DisconnectedTracing_feature
:
14642 case PACKET_augmented_libraries_svr4_read_feature
:
14644 /* Additions to this list need to be well justified:
14645 pre-existing packets are OK; new packets are not. */
14653 /* This catches both forgetting to add a config command, and
14654 forgetting to remove a packet from the exception list. */
14655 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14659 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14660 Z sub-packet has its own set and show commands, but users may
14661 have sets to this variable in their .gdbinit files (or in their
14663 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14664 &remote_Z_packet_detect
, _("\
14665 Set use of remote protocol `Z' packets."), _("\
14666 Show use of remote protocol `Z' packets."), _("\
14667 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14669 set_remote_protocol_Z_packet_cmd
,
14670 show_remote_protocol_Z_packet_cmd
,
14671 /* FIXME: i18n: Use of remote protocol
14672 `Z' packets is %s. */
14673 &remote_set_cmdlist
, &remote_show_cmdlist
);
14675 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14676 Manipulate files on the remote system.\n\
14677 Transfer files to and from the remote target system."),
14678 &remote_cmdlist
, "remote ",
14679 0 /* allow-unknown */, &cmdlist
);
14681 add_cmd ("put", class_files
, remote_put_command
,
14682 _("Copy a local file to the remote system."),
14685 add_cmd ("get", class_files
, remote_get_command
,
14686 _("Copy a remote file to the local system."),
14689 add_cmd ("delete", class_files
, remote_delete_command
,
14690 _("Delete a remote file."),
14693 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14694 &remote_exec_file_var
, _("\
14695 Set the remote pathname for \"run\"."), _("\
14696 Show the remote pathname for \"run\"."), NULL
,
14697 set_remote_exec_file
,
14698 show_remote_exec_file
,
14699 &remote_set_cmdlist
,
14700 &remote_show_cmdlist
);
14702 add_setshow_boolean_cmd ("range-stepping", class_run
,
14703 &use_range_stepping
, _("\
14704 Enable or disable range stepping."), _("\
14705 Show whether target-assisted range stepping is enabled."), _("\
14706 If on, and the target supports it, when stepping a source line, GDB\n\
14707 tells the target to step the corresponding range of addresses itself instead\n\
14708 of issuing multiple single-steps. This speeds up source level\n\
14709 stepping. If off, GDB always issues single-steps, even if range\n\
14710 stepping is supported by the target. The default is on."),
14711 set_range_stepping
,
14712 show_range_stepping
,
14716 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
14717 Set watchdog timer."), _("\
14718 Show watchdog timer."), _("\
14719 When non-zero, this timeout is used instead of waiting forever for a target\n\
14720 to finish a low-level step or continue operation. If the specified amount\n\
14721 of time passes without a response from the target, an error occurs."),
14724 &setlist
, &showlist
);
14726 /* Eventually initialize fileio. See fileio.c */
14727 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);