1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* See the GDB User Guide for details of the GDB remote protocol. */
30 #include "process-stratum-target.h"
33 #include "gdb-stabs.h"
34 #include "gdbthread.h"
36 #include "remote-notif.h"
39 #include "observable.h"
41 #include "cli/cli-decode.h"
42 #include "cli/cli-setshow.h"
43 #include "target-descriptions.h"
45 #include "gdbsupport/filestuff.h"
46 #include "gdbsupport/rsp-low.h"
50 #include "gdbsupport/gdb_sys_time.h"
52 #include "event-loop.h"
53 #include "event-top.h"
59 #include "gdbcore.h" /* for exec_bfd */
61 #include "remote-fileio.h"
62 #include "gdb/fileio.h"
64 #include "xml-support.h"
66 #include "memory-map.h"
68 #include "tracepoint.h"
71 #include "gdbsupport/agent.h"
73 #include "record-btrace.h"
75 #include "gdbsupport/scoped_restore.h"
76 #include "gdbsupport/environ.h"
77 #include "gdbsupport/byte-vector.h"
79 #include <unordered_map>
81 /* The remote target. */
83 static const char remote_doc
[] = N_("\
84 Use a remote computer via a serial line, using a gdb-specific protocol.\n\
85 Specify the serial device it is connected to\n\
86 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
88 #define OPAQUETHREADBYTES 8
90 /* a 64 bit opaque identifier */
91 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
93 struct gdb_ext_thread_info
;
94 struct threads_listing_context
;
95 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
96 struct protocol_feature
;
100 typedef std::unique_ptr
<stop_reply
> stop_reply_up
;
102 /* Generic configuration support for packets the stub optionally
103 supports. Allows the user to specify the use of the packet as well
104 as allowing GDB to auto-detect support in the remote stub. */
108 PACKET_SUPPORT_UNKNOWN
= 0,
113 /* Analyze a packet's return value and update the packet config
123 struct threads_listing_context
;
125 /* Stub vCont actions support.
127 Each field is a boolean flag indicating whether the stub reports
128 support for the corresponding action. */
130 struct vCont_action_support
145 /* About this many threadids fit in a packet. */
147 #define MAXTHREADLISTRESULTS 32
149 /* Data for the vFile:pread readahead cache. */
151 struct readahead_cache
153 /* Invalidate the readahead cache. */
156 /* Invalidate the readahead cache if it is holding data for FD. */
157 void invalidate_fd (int fd
);
159 /* Serve pread from the readahead cache. Returns number of bytes
160 read, or 0 if the request can't be served from the cache. */
161 int pread (int fd
, gdb_byte
*read_buf
, size_t len
, ULONGEST offset
);
163 /* The file descriptor for the file that is being cached. -1 if the
167 /* The offset into the file that the cache buffer corresponds
171 /* The buffer holding the cache contents. */
172 gdb_byte
*buf
= nullptr;
173 /* The buffer's size. We try to read as much as fits into a packet
177 /* Cache hit and miss counters. */
178 ULONGEST hit_count
= 0;
179 ULONGEST miss_count
= 0;
182 /* Description of the remote protocol for a given architecture. */
186 long offset
; /* Offset into G packet. */
187 long regnum
; /* GDB's internal register number. */
188 LONGEST pnum
; /* Remote protocol register number. */
189 int in_g_packet
; /* Always part of G packet. */
190 /* long size in bytes; == register_size (target_gdbarch (), regnum);
192 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
196 struct remote_arch_state
198 explicit remote_arch_state (struct gdbarch
*gdbarch
);
200 /* Description of the remote protocol registers. */
201 long sizeof_g_packet
;
203 /* Description of the remote protocol registers indexed by REGNUM
204 (making an array gdbarch_num_regs in size). */
205 std::unique_ptr
<packet_reg
[]> regs
;
207 /* This is the size (in chars) of the first response to the ``g''
208 packet. It is used as a heuristic when determining the maximum
209 size of memory-read and memory-write packets. A target will
210 typically only reserve a buffer large enough to hold the ``g''
211 packet. The size does not include packet overhead (headers and
213 long actual_register_packet_size
;
215 /* This is the maximum size (in chars) of a non read/write packet.
216 It is also used as a cap on the size of read/write packets. */
217 long remote_packet_size
;
220 /* Description of the remote protocol state for the currently
221 connected target. This is per-target state, and independent of the
222 selected architecture. */
231 /* Get the remote arch state for GDBARCH. */
232 struct remote_arch_state
*get_remote_arch_state (struct gdbarch
*gdbarch
);
236 /* A buffer to use for incoming packets, and its current size. The
237 buffer is grown dynamically for larger incoming packets.
238 Outgoing packets may also be constructed in this buffer.
239 The size of the buffer is always at least REMOTE_PACKET_SIZE;
240 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
242 gdb::char_vector buf
;
244 /* True if we're going through initial connection setup (finding out
245 about the remote side's threads, relocating symbols, etc.). */
246 bool starting_up
= false;
248 /* If we negotiated packet size explicitly (and thus can bypass
249 heuristics for the largest packet size that will not overflow
250 a buffer in the stub), this will be set to that packet size.
251 Otherwise zero, meaning to use the guessed size. */
252 long explicit_packet_size
= 0;
254 /* remote_wait is normally called when the target is running and
255 waits for a stop reply packet. But sometimes we need to call it
256 when the target is already stopped. We can send a "?" packet
257 and have remote_wait read the response. Or, if we already have
258 the response, we can stash it in BUF and tell remote_wait to
259 skip calling getpkt. This flag is set when BUF contains a
260 stop reply packet and the target is not waiting. */
261 int cached_wait_status
= 0;
263 /* True, if in no ack mode. That is, neither GDB nor the stub will
264 expect acks from each other. The connection is assumed to be
266 bool noack_mode
= false;
268 /* True if we're connected in extended remote mode. */
269 bool extended
= false;
271 /* True if we resumed the target and we're waiting for the target to
272 stop. In the mean time, we can't start another command/query.
273 The remote server wouldn't be ready to process it, so we'd
274 timeout waiting for a reply that would never come and eventually
275 we'd close the connection. This can happen in asynchronous mode
276 because we allow GDB commands while the target is running. */
277 bool waiting_for_stop_reply
= false;
279 /* The status of the stub support for the various vCont actions. */
280 vCont_action_support supports_vCont
;
282 /* True if the user has pressed Ctrl-C, but the target hasn't
283 responded to that. */
284 bool ctrlc_pending_p
= false;
286 /* True if we saw a Ctrl-C while reading or writing from/to the
287 remote descriptor. At that point it is not safe to send a remote
288 interrupt packet, so we instead remember we saw the Ctrl-C and
289 process it once we're done with sending/receiving the current
290 packet, which should be shortly. If however that takes too long,
291 and the user presses Ctrl-C again, we offer to disconnect. */
292 bool got_ctrlc_during_io
= false;
294 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
295 remote_open knows that we don't have a file open when the program
297 struct serial
*remote_desc
= nullptr;
299 /* These are the threads which we last sent to the remote system. The
300 TID member will be -1 for all or -2 for not sent yet. */
301 ptid_t general_thread
= null_ptid
;
302 ptid_t continue_thread
= null_ptid
;
304 /* This is the traceframe which we last selected on the remote system.
305 It will be -1 if no traceframe is selected. */
306 int remote_traceframe_number
= -1;
308 char *last_pass_packet
= nullptr;
310 /* The last QProgramSignals packet sent to the target. We bypass
311 sending a new program signals list down to the target if the new
312 packet is exactly the same as the last we sent. IOW, we only let
313 the target know about program signals list changes. */
314 char *last_program_signals_packet
= nullptr;
316 gdb_signal last_sent_signal
= GDB_SIGNAL_0
;
318 bool last_sent_step
= false;
320 /* The execution direction of the last resume we got. */
321 exec_direction_kind last_resume_exec_dir
= EXEC_FORWARD
;
323 char *finished_object
= nullptr;
324 char *finished_annex
= nullptr;
325 ULONGEST finished_offset
= 0;
327 /* Should we try the 'ThreadInfo' query packet?
329 This variable (NOT available to the user: auto-detect only!)
330 determines whether GDB will use the new, simpler "ThreadInfo"
331 query or the older, more complex syntax for thread queries.
332 This is an auto-detect variable (set to true at each connect,
333 and set to false when the target fails to recognize it). */
334 bool use_threadinfo_query
= false;
335 bool use_threadextra_query
= false;
337 threadref echo_nextthread
{};
338 threadref nextthread
{};
339 threadref resultthreadlist
[MAXTHREADLISTRESULTS
] {};
341 /* The state of remote notification. */
342 struct remote_notif_state
*notif_state
= nullptr;
344 /* The branch trace configuration. */
345 struct btrace_config btrace_config
{};
347 /* The argument to the last "vFile:setfs:" packet we sent, used
348 to avoid sending repeated unnecessary "vFile:setfs:" packets.
349 Initialized to -1 to indicate that no "vFile:setfs:" packet
350 has yet been sent. */
353 /* A readahead cache for vFile:pread. Often, reading a binary
354 involves a sequence of small reads. E.g., when parsing an ELF
355 file. A readahead cache helps mostly the case of remote
356 debugging on a connection with higher latency, due to the
357 request/reply nature of the RSP. We only cache data for a single
358 file descriptor at a time. */
359 struct readahead_cache readahead_cache
;
361 /* The list of already fetched and acknowledged stop events. This
362 queue is used for notification Stop, and other notifications
363 don't need queue for their events, because the notification
364 events of Stop can't be consumed immediately, so that events
365 should be queued first, and be consumed by remote_wait_{ns,as}
366 one per time. Other notifications can consume their events
367 immediately, so queue is not needed for them. */
368 std::vector
<stop_reply_up
> stop_reply_queue
;
370 /* Asynchronous signal handle registered as event loop source for
371 when we have pending events ready to be passed to the core. */
372 struct async_event_handler
*remote_async_inferior_event_token
= nullptr;
374 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
375 ``forever'' still use the normal timeout mechanism. This is
376 currently used by the ASYNC code to guarentee that target reads
377 during the initial connect always time-out. Once getpkt has been
378 modified to return a timeout indication and, in turn
379 remote_wait()/wait_for_inferior() have gained a timeout parameter
381 int wait_forever_enabled_p
= 1;
384 /* Mapping of remote protocol data for each gdbarch. Usually there
385 is only one entry here, though we may see more with stubs that
386 support multi-process. */
387 std::unordered_map
<struct gdbarch
*, remote_arch_state
>
391 static const target_info remote_target_info
= {
393 N_("Remote serial target in gdb-specific protocol"),
397 class remote_target
: public process_stratum_target
400 remote_target () = default;
401 ~remote_target () override
;
403 const target_info
&info () const override
404 { return remote_target_info
; }
406 thread_control_capabilities
get_thread_control_capabilities () override
407 { return tc_schedlock
; }
409 /* Open a remote connection. */
410 static void open (const char *, int);
412 void close () override
;
414 void detach (inferior
*, int) override
;
415 void disconnect (const char *, int) override
;
417 void commit_resume () override
;
418 void resume (ptid_t
, int, enum gdb_signal
) override
;
419 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
421 void fetch_registers (struct regcache
*, int) override
;
422 void store_registers (struct regcache
*, int) override
;
423 void prepare_to_store (struct regcache
*) override
;
425 void files_info () override
;
427 int insert_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
429 int remove_breakpoint (struct gdbarch
*, struct bp_target_info
*,
430 enum remove_bp_reason
) override
;
433 bool stopped_by_sw_breakpoint () override
;
434 bool supports_stopped_by_sw_breakpoint () override
;
436 bool stopped_by_hw_breakpoint () override
;
438 bool supports_stopped_by_hw_breakpoint () override
;
440 bool stopped_by_watchpoint () override
;
442 bool stopped_data_address (CORE_ADDR
*) override
;
444 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
446 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
448 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
450 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
452 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
454 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
455 struct expression
*) override
;
457 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
458 struct expression
*) override
;
460 void kill () override
;
462 void load (const char *, int) override
;
464 void mourn_inferior () override
;
466 void pass_signals (gdb::array_view
<const unsigned char>) override
;
468 int set_syscall_catchpoint (int, bool, int,
469 gdb::array_view
<const int>) override
;
471 void program_signals (gdb::array_view
<const unsigned char>) override
;
473 bool thread_alive (ptid_t ptid
) override
;
475 const char *thread_name (struct thread_info
*) override
;
477 void update_thread_list () override
;
479 std::string
pid_to_str (ptid_t
) override
;
481 const char *extra_thread_info (struct thread_info
*) override
;
483 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
485 thread_info
*thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
487 inferior
*inf
) override
;
489 gdb::byte_vector
thread_info_to_thread_handle (struct thread_info
*tp
)
492 void stop (ptid_t
) override
;
494 void interrupt () override
;
496 void pass_ctrlc () override
;
498 enum target_xfer_status
xfer_partial (enum target_object object
,
501 const gdb_byte
*writebuf
,
502 ULONGEST offset
, ULONGEST len
,
503 ULONGEST
*xfered_len
) override
;
505 ULONGEST
get_memory_xfer_limit () override
;
507 void rcmd (const char *command
, struct ui_file
*output
) override
;
509 char *pid_to_exec_file (int pid
) override
;
511 void log_command (const char *cmd
) override
513 serial_log_command (this, cmd
);
516 CORE_ADDR
get_thread_local_address (ptid_t ptid
,
517 CORE_ADDR load_module_addr
,
518 CORE_ADDR offset
) override
;
520 bool can_execute_reverse () override
;
522 std::vector
<mem_region
> memory_map () override
;
524 void flash_erase (ULONGEST address
, LONGEST length
) override
;
526 void flash_done () override
;
528 const struct target_desc
*read_description () override
;
530 int search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
531 const gdb_byte
*pattern
, ULONGEST pattern_len
,
532 CORE_ADDR
*found_addrp
) override
;
534 bool can_async_p () override
;
536 bool is_async_p () override
;
538 void async (int) override
;
540 void thread_events (int) override
;
542 int can_do_single_step () override
;
544 void terminal_inferior () override
;
546 void terminal_ours () override
;
548 bool supports_non_stop () override
;
550 bool supports_multi_process () override
;
552 bool supports_disable_randomization () override
;
554 bool filesystem_is_local () override
;
557 int fileio_open (struct inferior
*inf
, const char *filename
,
558 int flags
, int mode
, int warn_if_slow
,
559 int *target_errno
) override
;
561 int fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
562 ULONGEST offset
, int *target_errno
) override
;
564 int fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
565 ULONGEST offset
, int *target_errno
) override
;
567 int fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
) override
;
569 int fileio_close (int fd
, int *target_errno
) override
;
571 int fileio_unlink (struct inferior
*inf
,
572 const char *filename
,
573 int *target_errno
) override
;
575 gdb::optional
<std::string
>
576 fileio_readlink (struct inferior
*inf
,
577 const char *filename
,
578 int *target_errno
) override
;
580 bool supports_enable_disable_tracepoint () override
;
582 bool supports_string_tracing () override
;
584 bool supports_evaluation_of_breakpoint_conditions () override
;
586 bool can_run_breakpoint_commands () override
;
588 void trace_init () override
;
590 void download_tracepoint (struct bp_location
*location
) override
;
592 bool can_download_tracepoint () override
;
594 void download_trace_state_variable (const trace_state_variable
&tsv
) override
;
596 void enable_tracepoint (struct bp_location
*location
) override
;
598 void disable_tracepoint (struct bp_location
*location
) override
;
600 void trace_set_readonly_regions () override
;
602 void trace_start () override
;
604 int get_trace_status (struct trace_status
*ts
) override
;
606 void get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
609 void trace_stop () override
;
611 int trace_find (enum trace_find_type type
, int num
,
612 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
) override
;
614 bool get_trace_state_variable_value (int tsv
, LONGEST
*val
) override
;
616 int save_trace_data (const char *filename
) override
;
618 int upload_tracepoints (struct uploaded_tp
**utpp
) override
;
620 int upload_trace_state_variables (struct uploaded_tsv
**utsvp
) override
;
622 LONGEST
get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
) override
;
624 int get_min_fast_tracepoint_insn_len () override
;
626 void set_disconnected_tracing (int val
) override
;
628 void set_circular_trace_buffer (int val
) override
;
630 void set_trace_buffer_size (LONGEST val
) override
;
632 bool set_trace_notes (const char *user
, const char *notes
,
633 const char *stopnotes
) override
;
635 int core_of_thread (ptid_t ptid
) override
;
637 int verify_memory (const gdb_byte
*data
,
638 CORE_ADDR memaddr
, ULONGEST size
) override
;
641 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
643 void set_permissions () override
;
645 bool static_tracepoint_marker_at (CORE_ADDR
,
646 struct static_tracepoint_marker
*marker
)
649 std::vector
<static_tracepoint_marker
>
650 static_tracepoint_markers_by_strid (const char *id
) override
;
652 traceframe_info_up
traceframe_info () override
;
654 bool use_agent (bool use
) override
;
655 bool can_use_agent () override
;
657 struct btrace_target_info
*enable_btrace (ptid_t ptid
,
658 const struct btrace_config
*conf
) override
;
660 void disable_btrace (struct btrace_target_info
*tinfo
) override
;
662 void teardown_btrace (struct btrace_target_info
*tinfo
) override
;
664 enum btrace_error
read_btrace (struct btrace_data
*data
,
665 struct btrace_target_info
*btinfo
,
666 enum btrace_read_type type
) override
;
668 const struct btrace_config
*btrace_conf (const struct btrace_target_info
*) override
;
669 bool augmented_libraries_svr4_read () override
;
670 int follow_fork (int, int) override
;
671 void follow_exec (struct inferior
*, const char *) override
;
672 int insert_fork_catchpoint (int) override
;
673 int remove_fork_catchpoint (int) override
;
674 int insert_vfork_catchpoint (int) override
;
675 int remove_vfork_catchpoint (int) override
;
676 int insert_exec_catchpoint (int) override
;
677 int remove_exec_catchpoint (int) override
;
678 enum exec_direction_kind
execution_direction () override
;
680 public: /* Remote specific methods. */
682 void remote_download_command_source (int num
, ULONGEST addr
,
683 struct command_line
*cmds
);
685 void remote_file_put (const char *local_file
, const char *remote_file
,
687 void remote_file_get (const char *remote_file
, const char *local_file
,
689 void remote_file_delete (const char *remote_file
, int from_tty
);
691 int remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
692 ULONGEST offset
, int *remote_errno
);
693 int remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
694 ULONGEST offset
, int *remote_errno
);
695 int remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
696 ULONGEST offset
, int *remote_errno
);
698 int remote_hostio_send_command (int command_bytes
, int which_packet
,
699 int *remote_errno
, char **attachment
,
700 int *attachment_len
);
701 int remote_hostio_set_filesystem (struct inferior
*inf
,
703 /* We should get rid of this and use fileio_open directly. */
704 int remote_hostio_open (struct inferior
*inf
, const char *filename
,
705 int flags
, int mode
, int warn_if_slow
,
707 int remote_hostio_close (int fd
, int *remote_errno
);
709 int remote_hostio_unlink (inferior
*inf
, const char *filename
,
712 struct remote_state
*get_remote_state ();
714 long get_remote_packet_size (void);
715 long get_memory_packet_size (struct memory_packet_config
*config
);
717 long get_memory_write_packet_size ();
718 long get_memory_read_packet_size ();
720 char *append_pending_thread_resumptions (char *p
, char *endp
,
722 static void open_1 (const char *name
, int from_tty
, int extended_p
);
723 void start_remote (int from_tty
, int extended_p
);
724 void remote_detach_1 (struct inferior
*inf
, int from_tty
);
726 char *append_resumption (char *p
, char *endp
,
727 ptid_t ptid
, int step
, gdb_signal siggnal
);
728 int remote_resume_with_vcont (ptid_t ptid
, int step
,
731 void add_current_inferior_and_thread (char *wait_status
);
733 ptid_t
wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
735 ptid_t
wait_as (ptid_t ptid
, target_waitstatus
*status
,
738 ptid_t
process_stop_reply (struct stop_reply
*stop_reply
,
739 target_waitstatus
*status
);
741 void remote_notice_new_inferior (ptid_t currthread
, int executing
);
743 void process_initial_stop_replies (int from_tty
);
745 thread_info
*remote_add_thread (ptid_t ptid
, bool running
, bool executing
);
747 void btrace_sync_conf (const btrace_config
*conf
);
749 void remote_btrace_maybe_reopen ();
751 void remove_new_fork_children (threads_listing_context
*context
);
752 void kill_new_fork_children (int pid
);
753 void discard_pending_stop_replies (struct inferior
*inf
);
754 int stop_reply_queue_length ();
756 void check_pending_events_prevent_wildcard_vcont
757 (int *may_global_wildcard_vcont
);
759 void discard_pending_stop_replies_in_queue ();
760 struct stop_reply
*remote_notif_remove_queued_reply (ptid_t ptid
);
761 struct stop_reply
*queued_stop_reply (ptid_t ptid
);
762 int peek_stop_reply (ptid_t ptid
);
763 void remote_parse_stop_reply (const char *buf
, stop_reply
*event
);
765 void remote_stop_ns (ptid_t ptid
);
766 void remote_interrupt_as ();
767 void remote_interrupt_ns ();
769 char *remote_get_noisy_reply ();
770 int remote_query_attached (int pid
);
771 inferior
*remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
774 ptid_t
remote_current_thread (ptid_t oldpid
);
775 ptid_t
get_current_thread (char *wait_status
);
777 void set_thread (ptid_t ptid
, int gen
);
778 void set_general_thread (ptid_t ptid
);
779 void set_continue_thread (ptid_t ptid
);
780 void set_general_process ();
782 char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
784 int remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
785 gdb_ext_thread_info
*info
);
786 int remote_get_threadinfo (threadref
*threadid
, int fieldset
,
787 gdb_ext_thread_info
*info
);
789 int parse_threadlist_response (char *pkt
, int result_limit
,
790 threadref
*original_echo
,
791 threadref
*resultlist
,
793 int remote_get_threadlist (int startflag
, threadref
*nextthread
,
794 int result_limit
, int *done
, int *result_count
,
795 threadref
*threadlist
);
797 int remote_threadlist_iterator (rmt_thread_action stepfunction
,
798 void *context
, int looplimit
);
800 int remote_get_threads_with_ql (threads_listing_context
*context
);
801 int remote_get_threads_with_qxfer (threads_listing_context
*context
);
802 int remote_get_threads_with_qthreadinfo (threads_listing_context
*context
);
804 void extended_remote_restart ();
808 void remote_check_symbols ();
810 void remote_supported_packet (const struct protocol_feature
*feature
,
811 enum packet_support support
,
812 const char *argument
);
814 void remote_query_supported ();
816 void remote_packet_size (const protocol_feature
*feature
,
817 packet_support support
, const char *value
);
819 void remote_serial_quit_handler ();
821 void remote_detach_pid (int pid
);
823 void remote_vcont_probe ();
825 void remote_resume_with_hc (ptid_t ptid
, int step
,
828 void send_interrupt_sequence ();
829 void interrupt_query ();
831 void remote_notif_get_pending_events (notif_client
*nc
);
833 int fetch_register_using_p (struct regcache
*regcache
,
835 int send_g_packet ();
836 void process_g_packet (struct regcache
*regcache
);
837 void fetch_registers_using_g (struct regcache
*regcache
);
838 int store_register_using_P (const struct regcache
*regcache
,
840 void store_registers_using_G (const struct regcache
*regcache
);
842 void set_remote_traceframe ();
844 void check_binary_download (CORE_ADDR addr
);
846 target_xfer_status
remote_write_bytes_aux (const char *header
,
848 const gdb_byte
*myaddr
,
851 ULONGEST
*xfered_len_units
,
855 target_xfer_status
remote_write_bytes (CORE_ADDR memaddr
,
856 const gdb_byte
*myaddr
, ULONGEST len
,
857 int unit_size
, ULONGEST
*xfered_len
);
859 target_xfer_status
remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
861 int unit_size
, ULONGEST
*xfered_len_units
);
863 target_xfer_status
remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
867 ULONGEST
*xfered_len
);
869 target_xfer_status
remote_read_bytes (CORE_ADDR memaddr
,
870 gdb_byte
*myaddr
, ULONGEST len
,
872 ULONGEST
*xfered_len
);
874 packet_result
remote_send_printf (const char *format
, ...)
875 ATTRIBUTE_PRINTF (2, 3);
877 target_xfer_status
remote_flash_write (ULONGEST address
,
878 ULONGEST length
, ULONGEST
*xfered_len
,
879 const gdb_byte
*data
);
881 int readchar (int timeout
);
883 void remote_serial_write (const char *str
, int len
);
885 int putpkt (const char *buf
);
886 int putpkt_binary (const char *buf
, int cnt
);
888 int putpkt (const gdb::char_vector
&buf
)
890 return putpkt (buf
.data ());
894 long read_frame (gdb::char_vector
*buf_p
);
895 void getpkt (gdb::char_vector
*buf
, int forever
);
896 int getpkt_or_notif_sane_1 (gdb::char_vector
*buf
, int forever
,
897 int expecting_notif
, int *is_notif
);
898 int getpkt_sane (gdb::char_vector
*buf
, int forever
);
899 int getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
901 int remote_vkill (int pid
);
902 void remote_kill_k ();
904 void extended_remote_disable_randomization (int val
);
905 int extended_remote_run (const std::string
&args
);
907 void send_environment_packet (const char *action
,
911 void extended_remote_environment_support ();
912 void extended_remote_set_inferior_cwd ();
914 target_xfer_status
remote_write_qxfer (const char *object_name
,
916 const gdb_byte
*writebuf
,
917 ULONGEST offset
, LONGEST len
,
918 ULONGEST
*xfered_len
,
919 struct packet_config
*packet
);
921 target_xfer_status
remote_read_qxfer (const char *object_name
,
923 gdb_byte
*readbuf
, ULONGEST offset
,
925 ULONGEST
*xfered_len
,
926 struct packet_config
*packet
);
928 void push_stop_reply (struct stop_reply
*new_event
);
930 bool vcont_r_supported ();
932 void packet_command (const char *args
, int from_tty
);
934 private: /* data fields */
936 /* The remote state. Don't reference this directly. Use the
937 get_remote_state method instead. */
938 remote_state m_remote_state
;
941 static const target_info extended_remote_target_info
= {
943 N_("Extended remote serial target in gdb-specific protocol"),
947 /* Set up the extended remote target by extending the standard remote
948 target and adding to it. */
950 class extended_remote_target final
: public remote_target
953 const target_info
&info () const override
954 { return extended_remote_target_info
; }
956 /* Open an extended-remote connection. */
957 static void open (const char *, int);
959 bool can_create_inferior () override
{ return true; }
960 void create_inferior (const char *, const std::string
&,
961 char **, int) override
;
963 void detach (inferior
*, int) override
;
965 bool can_attach () override
{ return true; }
966 void attach (const char *, int) override
;
968 void post_attach (int) override
;
969 bool supports_disable_randomization () override
;
972 /* Per-program-space data key. */
973 static const struct program_space_key
<char, gdb::xfree_deleter
<char>>
976 /* The variable registered as the control variable used by the
977 remote exec-file commands. While the remote exec-file setting is
978 per-program-space, the set/show machinery uses this as the
979 location of the remote exec-file value. */
980 static char *remote_exec_file_var
;
982 /* The size to align memory write packets, when practical. The protocol
983 does not guarantee any alignment, and gdb will generate short
984 writes and unaligned writes, but even as a best-effort attempt this
985 can improve bulk transfers. For instance, if a write is misaligned
986 relative to the target's data bus, the stub may need to make an extra
987 round trip fetching data from the target. This doesn't make a
988 huge difference, but it's easy to do, so we try to be helpful.
990 The alignment chosen is arbitrary; usually data bus width is
991 important here, not the possibly larger cache line size. */
992 enum { REMOTE_ALIGN_WRITES
= 16 };
994 /* Prototypes for local functions. */
996 static int hexnumlen (ULONGEST num
);
998 static int stubhex (int ch
);
1000 static int hexnumstr (char *, ULONGEST
);
1002 static int hexnumnstr (char *, ULONGEST
, int);
1004 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
1006 static void print_packet (const char *);
1008 static int stub_unpack_int (char *buff
, int fieldlength
);
1010 struct packet_config
;
1012 static void show_packet_config_cmd (struct packet_config
*config
);
1014 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
1016 struct cmd_list_element
*c
,
1019 static ptid_t
read_ptid (const char *buf
, const char **obuf
);
1021 static void remote_async_inferior_event_handler (gdb_client_data
);
1023 static bool remote_read_description_p (struct target_ops
*target
);
1025 static void remote_console_output (const char *msg
);
1027 static void remote_btrace_reset (remote_state
*rs
);
1029 static void remote_unpush_and_throw (void);
1033 static struct cmd_list_element
*remote_cmdlist
;
1035 /* For "set remote" and "show remote". */
1037 static struct cmd_list_element
*remote_set_cmdlist
;
1038 static struct cmd_list_element
*remote_show_cmdlist
;
1040 /* Controls whether GDB is willing to use range stepping. */
1042 static bool use_range_stepping
= true;
1044 /* Private data that we'll store in (struct thread_info)->priv. */
1045 struct remote_thread_info
: public private_thread_info
1051 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1052 sequence of bytes. */
1053 gdb::byte_vector thread_handle
;
1055 /* Whether the target stopped for a breakpoint/watchpoint. */
1056 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1058 /* This is set to the data address of the access causing the target
1059 to stop for a watchpoint. */
1060 CORE_ADDR watch_data_address
= 0;
1062 /* Fields used by the vCont action coalescing implemented in
1063 remote_resume / remote_commit_resume. remote_resume stores each
1064 thread's last resume request in these fields, so that a later
1065 remote_commit_resume knows which is the proper action for this
1066 thread to include in the vCont packet. */
1068 /* True if the last target_resume call for this thread was a step
1069 request, false if a continue request. */
1070 int last_resume_step
= 0;
1072 /* The signal specified in the last target_resume call for this
1074 gdb_signal last_resume_sig
= GDB_SIGNAL_0
;
1076 /* Whether this thread was already vCont-resumed on the remote
1078 int vcont_resumed
= 0;
1081 remote_state::remote_state ()
1086 remote_state::~remote_state ()
1088 xfree (this->last_pass_packet
);
1089 xfree (this->last_program_signals_packet
);
1090 xfree (this->finished_object
);
1091 xfree (this->finished_annex
);
1094 /* Utility: generate error from an incoming stub packet. */
1096 trace_error (char *buf
)
1099 return; /* not an error msg */
1102 case '1': /* malformed packet error */
1103 if (*++buf
== '0') /* general case: */
1104 error (_("remote.c: error in outgoing packet."));
1106 error (_("remote.c: error in outgoing packet at field #%ld."),
1107 strtol (buf
, NULL
, 16));
1109 error (_("Target returns error code '%s'."), buf
);
1113 /* Utility: wait for reply from stub, while accepting "O" packets. */
1116 remote_target::remote_get_noisy_reply ()
1118 struct remote_state
*rs
= get_remote_state ();
1120 do /* Loop on reply from remote stub. */
1124 QUIT
; /* Allow user to bail out with ^C. */
1125 getpkt (&rs
->buf
, 0);
1126 buf
= rs
->buf
.data ();
1129 else if (startswith (buf
, "qRelocInsn:"))
1132 CORE_ADDR from
, to
, org_to
;
1134 int adjusted_size
= 0;
1137 p
= buf
+ strlen ("qRelocInsn:");
1138 pp
= unpack_varlen_hex (p
, &ul
);
1140 error (_("invalid qRelocInsn packet: %s"), buf
);
1144 unpack_varlen_hex (p
, &ul
);
1151 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1154 catch (const gdb_exception
&ex
)
1156 if (ex
.error
== MEMORY_ERROR
)
1158 /* Propagate memory errors silently back to the
1159 target. The stub may have limited the range of
1160 addresses we can write to, for example. */
1164 /* Something unexpectedly bad happened. Be verbose
1165 so we can tell what, and propagate the error back
1166 to the stub, so it doesn't get stuck waiting for
1168 exception_fprintf (gdb_stderr
, ex
,
1169 _("warning: relocating instruction: "));
1176 adjusted_size
= to
- org_to
;
1178 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1182 else if (buf
[0] == 'O' && buf
[1] != 'K')
1183 remote_console_output (buf
+ 1); /* 'O' message from stub */
1185 return buf
; /* Here's the actual reply. */
1190 struct remote_arch_state
*
1191 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1193 remote_arch_state
*rsa
;
1195 auto it
= this->m_arch_states
.find (gdbarch
);
1196 if (it
== this->m_arch_states
.end ())
1198 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1199 std::forward_as_tuple (gdbarch
),
1200 std::forward_as_tuple (gdbarch
));
1201 rsa
= &p
.first
->second
;
1203 /* Make sure that the packet buffer is plenty big enough for
1204 this architecture. */
1205 if (this->buf
.size () < rsa
->remote_packet_size
)
1206 this->buf
.resize (2 * rsa
->remote_packet_size
);
1214 /* Fetch the global remote target state. */
1217 remote_target::get_remote_state ()
1219 /* Make sure that the remote architecture state has been
1220 initialized, because doing so might reallocate rs->buf. Any
1221 function which calls getpkt also needs to be mindful of changes
1222 to rs->buf, but this call limits the number of places which run
1224 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1226 return &m_remote_state
;
1229 /* Fetch the remote exec-file from the current program space. */
1232 get_remote_exec_file (void)
1234 char *remote_exec_file
;
1236 remote_exec_file
= remote_pspace_data
.get (current_program_space
);
1237 if (remote_exec_file
== NULL
)
1240 return remote_exec_file
;
1243 /* Set the remote exec file for PSPACE. */
1246 set_pspace_remote_exec_file (struct program_space
*pspace
,
1247 const char *remote_exec_file
)
1249 char *old_file
= remote_pspace_data
.get (pspace
);
1252 remote_pspace_data
.set (pspace
, xstrdup (remote_exec_file
));
1255 /* The "set/show remote exec-file" set command hook. */
1258 set_remote_exec_file (const char *ignored
, int from_tty
,
1259 struct cmd_list_element
*c
)
1261 gdb_assert (remote_exec_file_var
!= NULL
);
1262 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
1265 /* The "set/show remote exec-file" show command hook. */
1268 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1269 struct cmd_list_element
*cmd
, const char *value
)
1271 fprintf_filtered (file
, "%s\n", get_remote_exec_file ());
1275 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1277 int regnum
, num_remote_regs
, offset
;
1278 struct packet_reg
**remote_regs
;
1280 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1282 struct packet_reg
*r
= ®s
[regnum
];
1284 if (register_size (gdbarch
, regnum
) == 0)
1285 /* Do not try to fetch zero-sized (placeholder) registers. */
1288 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1293 /* Define the g/G packet format as the contents of each register
1294 with a remote protocol number, in order of ascending protocol
1297 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1298 for (num_remote_regs
= 0, regnum
= 0;
1299 regnum
< gdbarch_num_regs (gdbarch
);
1301 if (regs
[regnum
].pnum
!= -1)
1302 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1304 std::sort (remote_regs
, remote_regs
+ num_remote_regs
,
1305 [] (const packet_reg
*a
, const packet_reg
*b
)
1306 { return a
->pnum
< b
->pnum
; });
1308 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1310 remote_regs
[regnum
]->in_g_packet
= 1;
1311 remote_regs
[regnum
]->offset
= offset
;
1312 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1318 /* Given the architecture described by GDBARCH, return the remote
1319 protocol register's number and the register's offset in the g/G
1320 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1321 If the target does not have a mapping for REGNUM, return false,
1322 otherwise, return true. */
1325 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1326 int *pnum
, int *poffset
)
1328 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1330 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1332 map_regcache_remote_table (gdbarch
, regs
.data ());
1334 *pnum
= regs
[regnum
].pnum
;
1335 *poffset
= regs
[regnum
].offset
;
1340 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1342 /* Use the architecture to build a regnum<->pnum table, which will be
1343 1:1 unless a feature set specifies otherwise. */
1344 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1346 /* Record the maximum possible size of the g packet - it may turn out
1348 this->sizeof_g_packet
1349 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1351 /* Default maximum number of characters in a packet body. Many
1352 remote stubs have a hardwired buffer size of 400 bytes
1353 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1354 as the maximum packet-size to ensure that the packet and an extra
1355 NUL character can always fit in the buffer. This stops GDB
1356 trashing stubs that try to squeeze an extra NUL into what is
1357 already a full buffer (As of 1999-12-04 that was most stubs). */
1358 this->remote_packet_size
= 400 - 1;
1360 /* This one is filled in when a ``g'' packet is received. */
1361 this->actual_register_packet_size
= 0;
1363 /* Should rsa->sizeof_g_packet needs more space than the
1364 default, adjust the size accordingly. Remember that each byte is
1365 encoded as two characters. 32 is the overhead for the packet
1366 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1367 (``$NN:G...#NN'') is a better guess, the below has been padded a
1369 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1370 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1373 /* Get a pointer to the current remote target. If not connected to a
1374 remote target, return NULL. */
1376 static remote_target
*
1377 get_current_remote_target ()
1379 target_ops
*proc_target
= find_target_at (process_stratum
);
1380 return dynamic_cast<remote_target
*> (proc_target
);
1383 /* Return the current allowed size of a remote packet. This is
1384 inferred from the current architecture, and should be used to
1385 limit the length of outgoing packets. */
1387 remote_target::get_remote_packet_size ()
1389 struct remote_state
*rs
= get_remote_state ();
1390 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1392 if (rs
->explicit_packet_size
)
1393 return rs
->explicit_packet_size
;
1395 return rsa
->remote_packet_size
;
1398 static struct packet_reg
*
1399 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1402 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1406 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1408 gdb_assert (r
->regnum
== regnum
);
1413 static struct packet_reg
*
1414 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1419 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1421 struct packet_reg
*r
= &rsa
->regs
[i
];
1423 if (r
->pnum
== pnum
)
1429 /* Allow the user to specify what sequence to send to the remote
1430 when he requests a program interruption: Although ^C is usually
1431 what remote systems expect (this is the default, here), it is
1432 sometimes preferable to send a break. On other systems such
1433 as the Linux kernel, a break followed by g, which is Magic SysRq g
1434 is required in order to interrupt the execution. */
1435 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1436 const char interrupt_sequence_break
[] = "BREAK";
1437 const char interrupt_sequence_break_g
[] = "BREAK-g";
1438 static const char *const interrupt_sequence_modes
[] =
1440 interrupt_sequence_control_c
,
1441 interrupt_sequence_break
,
1442 interrupt_sequence_break_g
,
1445 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1448 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1449 struct cmd_list_element
*c
,
1452 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1453 fprintf_filtered (file
,
1454 _("Send the ASCII ETX character (Ctrl-c) "
1455 "to the remote target to interrupt the "
1456 "execution of the program.\n"));
1457 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1458 fprintf_filtered (file
,
1459 _("send a break signal to the remote target "
1460 "to interrupt the execution of the program.\n"));
1461 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1462 fprintf_filtered (file
,
1463 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1464 "the remote target to interrupt the execution "
1465 "of Linux kernel.\n"));
1467 internal_error (__FILE__
, __LINE__
,
1468 _("Invalid value for interrupt_sequence_mode: %s."),
1469 interrupt_sequence_mode
);
1472 /* This boolean variable specifies whether interrupt_sequence is sent
1473 to the remote target when gdb connects to it.
1474 This is mostly needed when you debug the Linux kernel: The Linux kernel
1475 expects BREAK g which is Magic SysRq g for connecting gdb. */
1476 static bool interrupt_on_connect
= false;
1478 /* This variable is used to implement the "set/show remotebreak" commands.
1479 Since these commands are now deprecated in favor of "set/show remote
1480 interrupt-sequence", it no longer has any effect on the code. */
1481 static bool remote_break
;
1484 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1487 interrupt_sequence_mode
= interrupt_sequence_break
;
1489 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1493 show_remotebreak (struct ui_file
*file
, int from_tty
,
1494 struct cmd_list_element
*c
,
1499 /* This variable sets the number of bits in an address that are to be
1500 sent in a memory ("M" or "m") packet. Normally, after stripping
1501 leading zeros, the entire address would be sent. This variable
1502 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1503 initial implementation of remote.c restricted the address sent in
1504 memory packets to ``host::sizeof long'' bytes - (typically 32
1505 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1506 address was never sent. Since fixing this bug may cause a break in
1507 some remote targets this variable is principally provided to
1508 facilitate backward compatibility. */
1510 static unsigned int remote_address_size
;
1513 /* User configurable variables for the number of characters in a
1514 memory read/write packet. MIN (rsa->remote_packet_size,
1515 rsa->sizeof_g_packet) is the default. Some targets need smaller
1516 values (fifo overruns, et.al.) and some users need larger values
1517 (speed up transfers). The variables ``preferred_*'' (the user
1518 request), ``current_*'' (what was actually set) and ``forced_*''
1519 (Positive - a soft limit, negative - a hard limit). */
1521 struct memory_packet_config
1528 /* The default max memory-write-packet-size, when the setting is
1529 "fixed". The 16k is historical. (It came from older GDB's using
1530 alloca for buffers and the knowledge (folklore?) that some hosts
1531 don't cope very well with large alloca calls.) */
1532 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1534 /* The minimum remote packet size for memory transfers. Ensures we
1535 can write at least one byte. */
1536 #define MIN_MEMORY_PACKET_SIZE 20
1538 /* Get the memory packet size, assuming it is fixed. */
1541 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1543 gdb_assert (config
->fixed_p
);
1545 if (config
->size
<= 0)
1546 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1548 return config
->size
;
1551 /* Compute the current size of a read/write packet. Since this makes
1552 use of ``actual_register_packet_size'' the computation is dynamic. */
1555 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1557 struct remote_state
*rs
= get_remote_state ();
1558 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1561 if (config
->fixed_p
)
1562 what_they_get
= get_fixed_memory_packet_size (config
);
1565 what_they_get
= get_remote_packet_size ();
1566 /* Limit the packet to the size specified by the user. */
1567 if (config
->size
> 0
1568 && what_they_get
> config
->size
)
1569 what_they_get
= config
->size
;
1571 /* Limit it to the size of the targets ``g'' response unless we have
1572 permission from the stub to use a larger packet size. */
1573 if (rs
->explicit_packet_size
== 0
1574 && rsa
->actual_register_packet_size
> 0
1575 && what_they_get
> rsa
->actual_register_packet_size
)
1576 what_they_get
= rsa
->actual_register_packet_size
;
1578 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1579 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1581 /* Make sure there is room in the global buffer for this packet
1582 (including its trailing NUL byte). */
1583 if (rs
->buf
.size () < what_they_get
+ 1)
1584 rs
->buf
.resize (2 * what_they_get
);
1586 return what_they_get
;
1589 /* Update the size of a read/write packet. If they user wants
1590 something really big then do a sanity check. */
1593 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1595 int fixed_p
= config
->fixed_p
;
1596 long size
= config
->size
;
1599 error (_("Argument required (integer, `fixed' or `limited')."));
1600 else if (strcmp (args
, "hard") == 0
1601 || strcmp (args
, "fixed") == 0)
1603 else if (strcmp (args
, "soft") == 0
1604 || strcmp (args
, "limit") == 0)
1610 size
= strtoul (args
, &end
, 0);
1612 error (_("Invalid %s (bad syntax)."), config
->name
);
1614 /* Instead of explicitly capping the size of a packet to or
1615 disallowing it, the user is allowed to set the size to
1616 something arbitrarily large. */
1620 if (fixed_p
&& !config
->fixed_p
)
1622 /* So that the query shows the correct value. */
1623 long query_size
= (size
<= 0
1624 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1627 if (! query (_("The target may not be able to correctly handle a %s\n"
1628 "of %ld bytes. Change the packet size? "),
1629 config
->name
, query_size
))
1630 error (_("Packet size not changed."));
1632 /* Update the config. */
1633 config
->fixed_p
= fixed_p
;
1634 config
->size
= size
;
1638 show_memory_packet_size (struct memory_packet_config
*config
)
1640 if (config
->size
== 0)
1641 printf_filtered (_("The %s is 0 (default). "), config
->name
);
1643 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1644 if (config
->fixed_p
)
1645 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1646 get_fixed_memory_packet_size (config
));
1649 remote_target
*remote
= get_current_remote_target ();
1652 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1653 remote
->get_memory_packet_size (config
));
1655 puts_filtered ("The actual limit will be further reduced "
1656 "dependent on the target.\n");
1660 static struct memory_packet_config memory_write_packet_config
=
1662 "memory-write-packet-size",
1666 set_memory_write_packet_size (const char *args
, int from_tty
)
1668 set_memory_packet_size (args
, &memory_write_packet_config
);
1672 show_memory_write_packet_size (const char *args
, int from_tty
)
1674 show_memory_packet_size (&memory_write_packet_config
);
1677 /* Show the number of hardware watchpoints that can be used. */
1680 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1681 struct cmd_list_element
*c
,
1684 fprintf_filtered (file
, _("The maximum number of target hardware "
1685 "watchpoints is %s.\n"), value
);
1688 /* Show the length limit (in bytes) for hardware watchpoints. */
1691 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1692 struct cmd_list_element
*c
,
1695 fprintf_filtered (file
, _("The maximum length (in bytes) of a target "
1696 "hardware watchpoint is %s.\n"), value
);
1699 /* Show the number of hardware breakpoints that can be used. */
1702 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1703 struct cmd_list_element
*c
,
1706 fprintf_filtered (file
, _("The maximum number of target hardware "
1707 "breakpoints is %s.\n"), value
);
1710 /* Controls the maximum number of characters to display in the debug output
1711 for each remote packet. The remaining characters are omitted. */
1713 static int remote_packet_max_chars
= 512;
1715 /* Show the maximum number of characters to display for each remote packet
1716 when remote debugging is enabled. */
1719 show_remote_packet_max_chars (struct ui_file
*file
, int from_tty
,
1720 struct cmd_list_element
*c
,
1723 fprintf_filtered (file
, _("Number of remote packet characters to "
1724 "display is %s.\n"), value
);
1728 remote_target::get_memory_write_packet_size ()
1730 return get_memory_packet_size (&memory_write_packet_config
);
1733 static struct memory_packet_config memory_read_packet_config
=
1735 "memory-read-packet-size",
1739 set_memory_read_packet_size (const char *args
, int from_tty
)
1741 set_memory_packet_size (args
, &memory_read_packet_config
);
1745 show_memory_read_packet_size (const char *args
, int from_tty
)
1747 show_memory_packet_size (&memory_read_packet_config
);
1751 remote_target::get_memory_read_packet_size ()
1753 long size
= get_memory_packet_size (&memory_read_packet_config
);
1755 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1756 extra buffer size argument before the memory read size can be
1757 increased beyond this. */
1758 if (size
> get_remote_packet_size ())
1759 size
= get_remote_packet_size ();
1765 struct packet_config
1770 /* If auto, GDB auto-detects support for this packet or feature,
1771 either through qSupported, or by trying the packet and looking
1772 at the response. If true, GDB assumes the target supports this
1773 packet. If false, the packet is disabled. Configs that don't
1774 have an associated command always have this set to auto. */
1775 enum auto_boolean detect
;
1777 /* Does the target support this packet? */
1778 enum packet_support support
;
1781 static enum packet_support
packet_config_support (struct packet_config
*config
);
1782 static enum packet_support
packet_support (int packet
);
1785 show_packet_config_cmd (struct packet_config
*config
)
1787 const char *support
= "internal-error";
1789 switch (packet_config_support (config
))
1792 support
= "enabled";
1794 case PACKET_DISABLE
:
1795 support
= "disabled";
1797 case PACKET_SUPPORT_UNKNOWN
:
1798 support
= "unknown";
1801 switch (config
->detect
)
1803 case AUTO_BOOLEAN_AUTO
:
1804 printf_filtered (_("Support for the `%s' packet "
1805 "is auto-detected, currently %s.\n"),
1806 config
->name
, support
);
1808 case AUTO_BOOLEAN_TRUE
:
1809 case AUTO_BOOLEAN_FALSE
:
1810 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1811 config
->name
, support
);
1817 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1818 const char *title
, int legacy
)
1824 config
->name
= name
;
1825 config
->title
= title
;
1826 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1828 show_doc
= xstrprintf ("Show current use of remote "
1829 "protocol `%s' (%s) packet.",
1831 /* set/show TITLE-packet {auto,on,off} */
1832 cmd_name
= xstrprintf ("%s-packet", title
);
1833 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1834 &config
->detect
, set_doc
,
1835 show_doc
, NULL
, /* help_doc */
1837 show_remote_protocol_packet_cmd
,
1838 &remote_set_cmdlist
, &remote_show_cmdlist
);
1839 /* The command code copies the documentation strings. */
1842 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1847 legacy_name
= xstrprintf ("%s-packet", name
);
1848 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1849 &remote_set_cmdlist
);
1850 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1851 &remote_show_cmdlist
);
1855 static enum packet_result
1856 packet_check_result (const char *buf
)
1860 /* The stub recognized the packet request. Check that the
1861 operation succeeded. */
1863 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1865 /* "Enn" - definitely an error. */
1866 return PACKET_ERROR
;
1868 /* Always treat "E." as an error. This will be used for
1869 more verbose error messages, such as E.memtypes. */
1870 if (buf
[0] == 'E' && buf
[1] == '.')
1871 return PACKET_ERROR
;
1873 /* The packet may or may not be OK. Just assume it is. */
1877 /* The stub does not support the packet. */
1878 return PACKET_UNKNOWN
;
1881 static enum packet_result
1882 packet_check_result (const gdb::char_vector
&buf
)
1884 return packet_check_result (buf
.data ());
1887 static enum packet_result
1888 packet_ok (const char *buf
, struct packet_config
*config
)
1890 enum packet_result result
;
1892 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1893 && config
->support
== PACKET_DISABLE
)
1894 internal_error (__FILE__
, __LINE__
,
1895 _("packet_ok: attempt to use a disabled packet"));
1897 result
= packet_check_result (buf
);
1902 /* The stub recognized the packet request. */
1903 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1906 fprintf_unfiltered (gdb_stdlog
,
1907 "Packet %s (%s) is supported\n",
1908 config
->name
, config
->title
);
1909 config
->support
= PACKET_ENABLE
;
1912 case PACKET_UNKNOWN
:
1913 /* The stub does not support the packet. */
1914 if (config
->detect
== AUTO_BOOLEAN_AUTO
1915 && config
->support
== PACKET_ENABLE
)
1917 /* If the stub previously indicated that the packet was
1918 supported then there is a protocol error. */
1919 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1920 config
->name
, config
->title
);
1922 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
1924 /* The user set it wrong. */
1925 error (_("Enabled packet %s (%s) not recognized by stub"),
1926 config
->name
, config
->title
);
1930 fprintf_unfiltered (gdb_stdlog
,
1931 "Packet %s (%s) is NOT supported\n",
1932 config
->name
, config
->title
);
1933 config
->support
= PACKET_DISABLE
;
1940 static enum packet_result
1941 packet_ok (const gdb::char_vector
&buf
, struct packet_config
*config
)
1943 return packet_ok (buf
.data (), config
);
1960 PACKET_vFile_pwrite
,
1962 PACKET_vFile_unlink
,
1963 PACKET_vFile_readlink
,
1966 PACKET_qXfer_features
,
1967 PACKET_qXfer_exec_file
,
1968 PACKET_qXfer_libraries
,
1969 PACKET_qXfer_libraries_svr4
,
1970 PACKET_qXfer_memory_map
,
1971 PACKET_qXfer_osdata
,
1972 PACKET_qXfer_threads
,
1973 PACKET_qXfer_statictrace_read
,
1974 PACKET_qXfer_traceframe_info
,
1980 PACKET_QPassSignals
,
1981 PACKET_QCatchSyscalls
,
1982 PACKET_QProgramSignals
,
1983 PACKET_QSetWorkingDir
,
1984 PACKET_QStartupWithShell
,
1985 PACKET_QEnvironmentHexEncoded
,
1986 PACKET_QEnvironmentReset
,
1987 PACKET_QEnvironmentUnset
,
1989 PACKET_qSearch_memory
,
1992 PACKET_QStartNoAckMode
,
1994 PACKET_qXfer_siginfo_read
,
1995 PACKET_qXfer_siginfo_write
,
1998 /* Support for conditional tracepoints. */
1999 PACKET_ConditionalTracepoints
,
2001 /* Support for target-side breakpoint conditions. */
2002 PACKET_ConditionalBreakpoints
,
2004 /* Support for target-side breakpoint commands. */
2005 PACKET_BreakpointCommands
,
2007 /* Support for fast tracepoints. */
2008 PACKET_FastTracepoints
,
2010 /* Support for static tracepoints. */
2011 PACKET_StaticTracepoints
,
2013 /* Support for installing tracepoints while a trace experiment is
2015 PACKET_InstallInTrace
,
2019 PACKET_TracepointSource
,
2022 PACKET_QDisableRandomization
,
2024 PACKET_QTBuffer_size
,
2028 PACKET_qXfer_btrace
,
2030 /* Support for the QNonStop packet. */
2033 /* Support for the QThreadEvents packet. */
2034 PACKET_QThreadEvents
,
2036 /* Support for multi-process extensions. */
2037 PACKET_multiprocess_feature
,
2039 /* Support for enabling and disabling tracepoints while a trace
2040 experiment is running. */
2041 PACKET_EnableDisableTracepoints_feature
,
2043 /* Support for collecting strings using the tracenz bytecode. */
2044 PACKET_tracenz_feature
,
2046 /* Support for continuing to run a trace experiment while GDB is
2048 PACKET_DisconnectedTracing_feature
,
2050 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2051 PACKET_augmented_libraries_svr4_read_feature
,
2053 /* Support for the qXfer:btrace-conf:read packet. */
2054 PACKET_qXfer_btrace_conf
,
2056 /* Support for the Qbtrace-conf:bts:size packet. */
2057 PACKET_Qbtrace_conf_bts_size
,
2059 /* Support for swbreak+ feature. */
2060 PACKET_swbreak_feature
,
2062 /* Support for hwbreak+ feature. */
2063 PACKET_hwbreak_feature
,
2065 /* Support for fork events. */
2066 PACKET_fork_event_feature
,
2068 /* Support for vfork events. */
2069 PACKET_vfork_event_feature
,
2071 /* Support for the Qbtrace-conf:pt:size packet. */
2072 PACKET_Qbtrace_conf_pt_size
,
2074 /* Support for exec events. */
2075 PACKET_exec_event_feature
,
2077 /* Support for query supported vCont actions. */
2078 PACKET_vContSupported
,
2080 /* Support remote CTRL-C. */
2083 /* Support TARGET_WAITKIND_NO_RESUMED. */
2089 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
2091 /* Returns the packet's corresponding "set remote foo-packet" command
2092 state. See struct packet_config for more details. */
2094 static enum auto_boolean
2095 packet_set_cmd_state (int packet
)
2097 return remote_protocol_packets
[packet
].detect
;
2100 /* Returns whether a given packet or feature is supported. This takes
2101 into account the state of the corresponding "set remote foo-packet"
2102 command, which may be used to bypass auto-detection. */
2104 static enum packet_support
2105 packet_config_support (struct packet_config
*config
)
2107 switch (config
->detect
)
2109 case AUTO_BOOLEAN_TRUE
:
2110 return PACKET_ENABLE
;
2111 case AUTO_BOOLEAN_FALSE
:
2112 return PACKET_DISABLE
;
2113 case AUTO_BOOLEAN_AUTO
:
2114 return config
->support
;
2116 gdb_assert_not_reached (_("bad switch"));
2120 /* Same as packet_config_support, but takes the packet's enum value as
2123 static enum packet_support
2124 packet_support (int packet
)
2126 struct packet_config
*config
= &remote_protocol_packets
[packet
];
2128 return packet_config_support (config
);
2132 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
2133 struct cmd_list_element
*c
,
2136 struct packet_config
*packet
;
2138 for (packet
= remote_protocol_packets
;
2139 packet
< &remote_protocol_packets
[PACKET_MAX
];
2142 if (&packet
->detect
== c
->var
)
2144 show_packet_config_cmd (packet
);
2148 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
2152 /* Should we try one of the 'Z' requests? */
2156 Z_PACKET_SOFTWARE_BP
,
2157 Z_PACKET_HARDWARE_BP
,
2164 /* For compatibility with older distributions. Provide a ``set remote
2165 Z-packet ...'' command that updates all the Z packet types. */
2167 static enum auto_boolean remote_Z_packet_detect
;
2170 set_remote_protocol_Z_packet_cmd (const char *args
, int from_tty
,
2171 struct cmd_list_element
*c
)
2175 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2176 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
2180 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
2181 struct cmd_list_element
*c
,
2186 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2188 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
2192 /* Returns true if the multi-process extensions are in effect. */
2195 remote_multi_process_p (struct remote_state
*rs
)
2197 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
2200 /* Returns true if fork events are supported. */
2203 remote_fork_event_p (struct remote_state
*rs
)
2205 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
2208 /* Returns true if vfork events are supported. */
2211 remote_vfork_event_p (struct remote_state
*rs
)
2213 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
2216 /* Returns true if exec events are supported. */
2219 remote_exec_event_p (struct remote_state
*rs
)
2221 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
2224 /* Insert fork catchpoint target routine. If fork events are enabled
2225 then return success, nothing more to do. */
2228 remote_target::insert_fork_catchpoint (int pid
)
2230 struct remote_state
*rs
= get_remote_state ();
2232 return !remote_fork_event_p (rs
);
2235 /* Remove fork catchpoint target routine. Nothing to do, just
2239 remote_target::remove_fork_catchpoint (int pid
)
2244 /* Insert vfork catchpoint target routine. If vfork events are enabled
2245 then return success, nothing more to do. */
2248 remote_target::insert_vfork_catchpoint (int pid
)
2250 struct remote_state
*rs
= get_remote_state ();
2252 return !remote_vfork_event_p (rs
);
2255 /* Remove vfork catchpoint target routine. Nothing to do, just
2259 remote_target::remove_vfork_catchpoint (int pid
)
2264 /* Insert exec catchpoint target routine. If exec events are
2265 enabled, just return success. */
2268 remote_target::insert_exec_catchpoint (int pid
)
2270 struct remote_state
*rs
= get_remote_state ();
2272 return !remote_exec_event_p (rs
);
2275 /* Remove exec catchpoint target routine. Nothing to do, just
2279 remote_target::remove_exec_catchpoint (int pid
)
2286 /* Take advantage of the fact that the TID field is not used, to tag
2287 special ptids with it set to != 0. */
2288 static const ptid_t
magic_null_ptid (42000, -1, 1);
2289 static const ptid_t
not_sent_ptid (42000, -2, 1);
2290 static const ptid_t
any_thread_ptid (42000, 0, 1);
2292 /* Find out if the stub attached to PID (and hence GDB should offer to
2293 detach instead of killing it when bailing out). */
2296 remote_target::remote_query_attached (int pid
)
2298 struct remote_state
*rs
= get_remote_state ();
2299 size_t size
= get_remote_packet_size ();
2301 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
2304 if (remote_multi_process_p (rs
))
2305 xsnprintf (rs
->buf
.data (), size
, "qAttached:%x", pid
);
2307 xsnprintf (rs
->buf
.data (), size
, "qAttached");
2310 getpkt (&rs
->buf
, 0);
2312 switch (packet_ok (rs
->buf
,
2313 &remote_protocol_packets
[PACKET_qAttached
]))
2316 if (strcmp (rs
->buf
.data (), "1") == 0)
2320 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
2322 case PACKET_UNKNOWN
:
2329 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2330 has been invented by GDB, instead of reported by the target. Since
2331 we can be connected to a remote system before before knowing about
2332 any inferior, mark the target with execution when we find the first
2333 inferior. If ATTACHED is 1, then we had just attached to this
2334 inferior. If it is 0, then we just created this inferior. If it
2335 is -1, then try querying the remote stub to find out if it had
2336 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2337 attempt to open this inferior's executable as the main executable
2338 if no main executable is open already. */
2341 remote_target::remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
2344 struct inferior
*inf
;
2346 /* Check whether this process we're learning about is to be
2347 considered attached, or if is to be considered to have been
2348 spawned by the stub. */
2350 attached
= remote_query_attached (pid
);
2352 if (gdbarch_has_global_solist (target_gdbarch ()))
2354 /* If the target shares code across all inferiors, then every
2355 attach adds a new inferior. */
2356 inf
= add_inferior (pid
);
2358 /* ... and every inferior is bound to the same program space.
2359 However, each inferior may still have its own address
2361 inf
->aspace
= maybe_new_address_space ();
2362 inf
->pspace
= current_program_space
;
2366 /* In the traditional debugging scenario, there's a 1-1 match
2367 between program/address spaces. We simply bind the inferior
2368 to the program space's address space. */
2369 inf
= current_inferior ();
2370 inferior_appeared (inf
, pid
);
2373 inf
->attach_flag
= attached
;
2374 inf
->fake_pid_p
= fake_pid_p
;
2376 /* If no main executable is currently open then attempt to
2377 open the file that was executed to create this inferior. */
2378 if (try_open_exec
&& get_exec_file (0) == NULL
)
2379 exec_file_locate_attach (pid
, 0, 1);
2384 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2385 static remote_thread_info
*get_remote_thread_info (ptid_t ptid
);
2387 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2388 according to RUNNING. */
2391 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
)
2393 struct remote_state
*rs
= get_remote_state ();
2394 struct thread_info
*thread
;
2396 /* GDB historically didn't pull threads in the initial connection
2397 setup. If the remote target doesn't even have a concept of
2398 threads (e.g., a bare-metal target), even if internally we
2399 consider that a single-threaded target, mentioning a new thread
2400 might be confusing to the user. Be silent then, preserving the
2401 age old behavior. */
2402 if (rs
->starting_up
)
2403 thread
= add_thread_silent (ptid
);
2405 thread
= add_thread (ptid
);
2407 get_remote_thread_info (thread
)->vcont_resumed
= executing
;
2408 set_executing (ptid
, executing
);
2409 set_running (ptid
, running
);
2414 /* Come here when we learn about a thread id from the remote target.
2415 It may be the first time we hear about such thread, so take the
2416 opportunity to add it to GDB's thread list. In case this is the
2417 first time we're noticing its corresponding inferior, add it to
2418 GDB's inferior list as well. EXECUTING indicates whether the
2419 thread is (internally) executing or stopped. */
2422 remote_target::remote_notice_new_inferior (ptid_t currthread
, int executing
)
2424 /* In non-stop mode, we assume new found threads are (externally)
2425 running until proven otherwise with a stop reply. In all-stop,
2426 we can only get here if all threads are stopped. */
2427 int running
= target_is_non_stop_p () ? 1 : 0;
2429 /* If this is a new thread, add it to GDB's thread list.
2430 If we leave it up to WFI to do this, bad things will happen. */
2432 thread_info
*tp
= find_thread_ptid (currthread
);
2433 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2435 /* We're seeing an event on a thread id we knew had exited.
2436 This has to be a new thread reusing the old id. Add it. */
2437 remote_add_thread (currthread
, running
, executing
);
2441 if (!in_thread_list (currthread
))
2443 struct inferior
*inf
= NULL
;
2444 int pid
= currthread
.pid ();
2446 if (inferior_ptid
.is_pid ()
2447 && pid
== inferior_ptid
.pid ())
2449 /* inferior_ptid has no thread member yet. This can happen
2450 with the vAttach -> remote_wait,"TAAthread:" path if the
2451 stub doesn't support qC. This is the first stop reported
2452 after an attach, so this is the main thread. Update the
2453 ptid in the thread list. */
2454 if (in_thread_list (ptid_t (pid
)))
2455 thread_change_ptid (inferior_ptid
, currthread
);
2458 remote_add_thread (currthread
, running
, executing
);
2459 inferior_ptid
= currthread
;
2464 if (magic_null_ptid
== inferior_ptid
)
2466 /* inferior_ptid is not set yet. This can happen with the
2467 vRun -> remote_wait,"TAAthread:" path if the stub
2468 doesn't support qC. This is the first stop reported
2469 after an attach, so this is the main thread. Update the
2470 ptid in the thread list. */
2471 thread_change_ptid (inferior_ptid
, currthread
);
2475 /* When connecting to a target remote, or to a target
2476 extended-remote which already was debugging an inferior, we
2477 may not know about it yet. Add it before adding its child
2478 thread, so notifications are emitted in a sensible order. */
2479 if (find_inferior_pid (currthread
.pid ()) == NULL
)
2481 struct remote_state
*rs
= get_remote_state ();
2482 bool fake_pid_p
= !remote_multi_process_p (rs
);
2484 inf
= remote_add_inferior (fake_pid_p
,
2485 currthread
.pid (), -1, 1);
2488 /* This is really a new thread. Add it. */
2489 thread_info
*new_thr
2490 = remote_add_thread (currthread
, running
, executing
);
2492 /* If we found a new inferior, let the common code do whatever
2493 it needs to with it (e.g., read shared libraries, insert
2494 breakpoints), unless we're just setting up an all-stop
2498 struct remote_state
*rs
= get_remote_state ();
2500 if (!rs
->starting_up
)
2501 notice_new_inferior (new_thr
, executing
, 0);
2506 /* Return THREAD's private thread data, creating it if necessary. */
2508 static remote_thread_info
*
2509 get_remote_thread_info (thread_info
*thread
)
2511 gdb_assert (thread
!= NULL
);
2513 if (thread
->priv
== NULL
)
2514 thread
->priv
.reset (new remote_thread_info
);
2516 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2519 static remote_thread_info
*
2520 get_remote_thread_info (ptid_t ptid
)
2522 thread_info
*thr
= find_thread_ptid (ptid
);
2523 return get_remote_thread_info (thr
);
2526 /* Call this function as a result of
2527 1) A halt indication (T packet) containing a thread id
2528 2) A direct query of currthread
2529 3) Successful execution of set thread */
2532 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2534 rs
->general_thread
= currthread
;
2537 /* If 'QPassSignals' is supported, tell the remote stub what signals
2538 it can simply pass through to the inferior without reporting. */
2541 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2543 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2545 char *pass_packet
, *p
;
2547 struct remote_state
*rs
= get_remote_state ();
2549 gdb_assert (pass_signals
.size () < 256);
2550 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2552 if (pass_signals
[i
])
2555 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2556 strcpy (pass_packet
, "QPassSignals:");
2557 p
= pass_packet
+ strlen (pass_packet
);
2558 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2560 if (pass_signals
[i
])
2563 *p
++ = tohex (i
>> 4);
2564 *p
++ = tohex (i
& 15);
2573 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2575 putpkt (pass_packet
);
2576 getpkt (&rs
->buf
, 0);
2577 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2578 if (rs
->last_pass_packet
)
2579 xfree (rs
->last_pass_packet
);
2580 rs
->last_pass_packet
= pass_packet
;
2583 xfree (pass_packet
);
2587 /* If 'QCatchSyscalls' is supported, tell the remote stub
2588 to report syscalls to GDB. */
2591 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2592 gdb::array_view
<const int> syscall_counts
)
2594 const char *catch_packet
;
2595 enum packet_result result
;
2598 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2600 /* Not supported. */
2604 if (needed
&& any_count
== 0)
2606 /* Count how many syscalls are to be caught. */
2607 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2609 if (syscall_counts
[i
] != 0)
2616 fprintf_unfiltered (gdb_stdlog
,
2617 "remote_set_syscall_catchpoint "
2618 "pid %d needed %d any_count %d n_sysno %d\n",
2619 pid
, needed
, any_count
, n_sysno
);
2622 std::string built_packet
;
2625 /* Prepare a packet with the sysno list, assuming max 8+1
2626 characters for a sysno. If the resulting packet size is too
2627 big, fallback on the non-selective packet. */
2628 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2629 built_packet
.reserve (maxpktsz
);
2630 built_packet
= "QCatchSyscalls:1";
2633 /* Add in each syscall to be caught. */
2634 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2636 if (syscall_counts
[i
] != 0)
2637 string_appendf (built_packet
, ";%zx", i
);
2640 if (built_packet
.size () > get_remote_packet_size ())
2642 /* catch_packet too big. Fallback to less efficient
2643 non selective mode, with GDB doing the filtering. */
2644 catch_packet
= "QCatchSyscalls:1";
2647 catch_packet
= built_packet
.c_str ();
2650 catch_packet
= "QCatchSyscalls:0";
2652 struct remote_state
*rs
= get_remote_state ();
2654 putpkt (catch_packet
);
2655 getpkt (&rs
->buf
, 0);
2656 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2657 if (result
== PACKET_OK
)
2663 /* If 'QProgramSignals' is supported, tell the remote stub what
2664 signals it should pass through to the inferior when detaching. */
2667 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2669 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2673 struct remote_state
*rs
= get_remote_state ();
2675 gdb_assert (signals
.size () < 256);
2676 for (size_t i
= 0; i
< signals
.size (); i
++)
2681 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2682 strcpy (packet
, "QProgramSignals:");
2683 p
= packet
+ strlen (packet
);
2684 for (size_t i
= 0; i
< signals
.size (); i
++)
2686 if (signal_pass_state (i
))
2689 *p
++ = tohex (i
>> 4);
2690 *p
++ = tohex (i
& 15);
2699 if (!rs
->last_program_signals_packet
2700 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2703 getpkt (&rs
->buf
, 0);
2704 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2705 xfree (rs
->last_program_signals_packet
);
2706 rs
->last_program_signals_packet
= packet
;
2713 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2714 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2715 thread. If GEN is set, set the general thread, if not, then set
2716 the step/continue thread. */
2718 remote_target::set_thread (ptid_t ptid
, int gen
)
2720 struct remote_state
*rs
= get_remote_state ();
2721 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2722 char *buf
= rs
->buf
.data ();
2723 char *endbuf
= buf
+ get_remote_packet_size ();
2729 *buf
++ = gen
? 'g' : 'c';
2730 if (ptid
== magic_null_ptid
)
2731 xsnprintf (buf
, endbuf
- buf
, "0");
2732 else if (ptid
== any_thread_ptid
)
2733 xsnprintf (buf
, endbuf
- buf
, "0");
2734 else if (ptid
== minus_one_ptid
)
2735 xsnprintf (buf
, endbuf
- buf
, "-1");
2737 write_ptid (buf
, endbuf
, ptid
);
2739 getpkt (&rs
->buf
, 0);
2741 rs
->general_thread
= ptid
;
2743 rs
->continue_thread
= ptid
;
2747 remote_target::set_general_thread (ptid_t ptid
)
2749 set_thread (ptid
, 1);
2753 remote_target::set_continue_thread (ptid_t ptid
)
2755 set_thread (ptid
, 0);
2758 /* Change the remote current process. Which thread within the process
2759 ends up selected isn't important, as long as it is the same process
2760 as what INFERIOR_PTID points to.
2762 This comes from that fact that there is no explicit notion of
2763 "selected process" in the protocol. The selected process for
2764 general operations is the process the selected general thread
2768 remote_target::set_general_process ()
2770 struct remote_state
*rs
= get_remote_state ();
2772 /* If the remote can't handle multiple processes, don't bother. */
2773 if (!remote_multi_process_p (rs
))
2776 /* We only need to change the remote current thread if it's pointing
2777 at some other process. */
2778 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2779 set_general_thread (inferior_ptid
);
2783 /* Return nonzero if this is the main thread that we made up ourselves
2784 to model non-threaded targets as single-threaded. */
2787 remote_thread_always_alive (ptid_t ptid
)
2789 if (ptid
== magic_null_ptid
)
2790 /* The main thread is always alive. */
2793 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2794 /* The main thread is always alive. This can happen after a
2795 vAttach, if the remote side doesn't support
2802 /* Return nonzero if the thread PTID is still alive on the remote
2806 remote_target::thread_alive (ptid_t ptid
)
2808 struct remote_state
*rs
= get_remote_state ();
2811 /* Check if this is a thread that we made up ourselves to model
2812 non-threaded targets as single-threaded. */
2813 if (remote_thread_always_alive (ptid
))
2816 p
= rs
->buf
.data ();
2817 endp
= p
+ get_remote_packet_size ();
2820 write_ptid (p
, endp
, ptid
);
2823 getpkt (&rs
->buf
, 0);
2824 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2827 /* Return a pointer to a thread name if we know it and NULL otherwise.
2828 The thread_info object owns the memory for the name. */
2831 remote_target::thread_name (struct thread_info
*info
)
2833 if (info
->priv
!= NULL
)
2835 const std::string
&name
= get_remote_thread_info (info
)->name
;
2836 return !name
.empty () ? name
.c_str () : NULL
;
2842 /* About these extended threadlist and threadinfo packets. They are
2843 variable length packets but, the fields within them are often fixed
2844 length. They are redundant enough to send over UDP as is the
2845 remote protocol in general. There is a matching unit test module
2848 /* WARNING: This threadref data structure comes from the remote O.S.,
2849 libstub protocol encoding, and remote.c. It is not particularly
2852 /* Right now, the internal structure is int. We want it to be bigger.
2853 Plan to fix this. */
2855 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2857 /* gdb_ext_thread_info is an internal GDB data structure which is
2858 equivalent to the reply of the remote threadinfo packet. */
2860 struct gdb_ext_thread_info
2862 threadref threadid
; /* External form of thread reference. */
2863 int active
; /* Has state interesting to GDB?
2865 char display
[256]; /* Brief state display, name,
2866 blocked/suspended. */
2867 char shortname
[32]; /* To be used to name threads. */
2868 char more_display
[256]; /* Long info, statistics, queue depth,
2872 /* The volume of remote transfers can be limited by submitting
2873 a mask containing bits specifying the desired information.
2874 Use a union of these values as the 'selection' parameter to
2875 get_thread_info. FIXME: Make these TAG names more thread specific. */
2877 #define TAG_THREADID 1
2878 #define TAG_EXISTS 2
2879 #define TAG_DISPLAY 4
2880 #define TAG_THREADNAME 8
2881 #define TAG_MOREDISPLAY 16
2883 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2885 static char *unpack_nibble (char *buf
, int *val
);
2887 static char *unpack_byte (char *buf
, int *value
);
2889 static char *pack_int (char *buf
, int value
);
2891 static char *unpack_int (char *buf
, int *value
);
2893 static char *unpack_string (char *src
, char *dest
, int length
);
2895 static char *pack_threadid (char *pkt
, threadref
*id
);
2897 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2899 void int_to_threadref (threadref
*id
, int value
);
2901 static int threadref_to_int (threadref
*ref
);
2903 static void copy_threadref (threadref
*dest
, threadref
*src
);
2905 static int threadmatch (threadref
*dest
, threadref
*src
);
2907 static char *pack_threadinfo_request (char *pkt
, int mode
,
2910 static char *pack_threadlist_request (char *pkt
, int startflag
,
2912 threadref
*nextthread
);
2914 static int remote_newthread_step (threadref
*ref
, void *context
);
2917 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2918 buffer we're allowed to write to. Returns
2919 BUF+CHARACTERS_WRITTEN. */
2922 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2925 struct remote_state
*rs
= get_remote_state ();
2927 if (remote_multi_process_p (rs
))
2931 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2933 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2937 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2939 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2944 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2945 last parsed char. Returns null_ptid if no thread id is found, and
2946 throws an error if the thread id has an invalid format. */
2949 read_ptid (const char *buf
, const char **obuf
)
2951 const char *p
= buf
;
2953 ULONGEST pid
= 0, tid
= 0;
2957 /* Multi-process ptid. */
2958 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2960 error (_("invalid remote ptid: %s"), p
);
2963 pp
= unpack_varlen_hex (p
+ 1, &tid
);
2966 return ptid_t (pid
, tid
, 0);
2969 /* No multi-process. Just a tid. */
2970 pp
= unpack_varlen_hex (p
, &tid
);
2972 /* Return null_ptid when no thread id is found. */
2980 /* Since the stub is not sending a process id, then default to
2981 what's in inferior_ptid, unless it's null at this point. If so,
2982 then since there's no way to know the pid of the reported
2983 threads, use the magic number. */
2984 if (inferior_ptid
== null_ptid
)
2985 pid
= magic_null_ptid
.pid ();
2987 pid
= inferior_ptid
.pid ();
2991 return ptid_t (pid
, tid
, 0);
2997 if (ch
>= 'a' && ch
<= 'f')
2998 return ch
- 'a' + 10;
2999 if (ch
>= '0' && ch
<= '9')
3001 if (ch
>= 'A' && ch
<= 'F')
3002 return ch
- 'A' + 10;
3007 stub_unpack_int (char *buff
, int fieldlength
)
3014 nibble
= stubhex (*buff
++);
3018 retval
= retval
<< 4;
3024 unpack_nibble (char *buf
, int *val
)
3026 *val
= fromhex (*buf
++);
3031 unpack_byte (char *buf
, int *value
)
3033 *value
= stub_unpack_int (buf
, 2);
3038 pack_int (char *buf
, int value
)
3040 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3041 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3042 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3043 buf
= pack_hex_byte (buf
, (value
& 0xff));
3048 unpack_int (char *buf
, int *value
)
3050 *value
= stub_unpack_int (buf
, 8);
3054 #if 0 /* Currently unused, uncomment when needed. */
3055 static char *pack_string (char *pkt
, char *string
);
3058 pack_string (char *pkt
, char *string
)
3063 len
= strlen (string
);
3065 len
= 200; /* Bigger than most GDB packets, junk??? */
3066 pkt
= pack_hex_byte (pkt
, len
);
3070 if ((ch
== '\0') || (ch
== '#'))
3071 ch
= '*'; /* Protect encapsulation. */
3076 #endif /* 0 (unused) */
3079 unpack_string (char *src
, char *dest
, int length
)
3088 pack_threadid (char *pkt
, threadref
*id
)
3091 unsigned char *altid
;
3093 altid
= (unsigned char *) id
;
3094 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3096 pkt
= pack_hex_byte (pkt
, *altid
++);
3102 unpack_threadid (char *inbuf
, threadref
*id
)
3105 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3108 altref
= (char *) id
;
3110 while (inbuf
< limit
)
3112 x
= stubhex (*inbuf
++);
3113 y
= stubhex (*inbuf
++);
3114 *altref
++ = (x
<< 4) | y
;
3119 /* Externally, threadrefs are 64 bits but internally, they are still
3120 ints. This is due to a mismatch of specifications. We would like
3121 to use 64bit thread references internally. This is an adapter
3125 int_to_threadref (threadref
*id
, int value
)
3127 unsigned char *scan
;
3129 scan
= (unsigned char *) id
;
3135 *scan
++ = (value
>> 24) & 0xff;
3136 *scan
++ = (value
>> 16) & 0xff;
3137 *scan
++ = (value
>> 8) & 0xff;
3138 *scan
++ = (value
& 0xff);
3142 threadref_to_int (threadref
*ref
)
3145 unsigned char *scan
;
3151 value
= (value
<< 8) | ((*scan
++) & 0xff);
3156 copy_threadref (threadref
*dest
, threadref
*src
)
3159 unsigned char *csrc
, *cdest
;
3161 csrc
= (unsigned char *) src
;
3162 cdest
= (unsigned char *) dest
;
3169 threadmatch (threadref
*dest
, threadref
*src
)
3171 /* Things are broken right now, so just assume we got a match. */
3173 unsigned char *srcp
, *destp
;
3175 srcp
= (char *) src
;
3176 destp
= (char *) dest
;
3180 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3187 threadid:1, # always request threadid
3194 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3197 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3199 *pkt
++ = 'q'; /* Info Query */
3200 *pkt
++ = 'P'; /* process or thread info */
3201 pkt
= pack_int (pkt
, mode
); /* mode */
3202 pkt
= pack_threadid (pkt
, id
); /* threadid */
3203 *pkt
= '\0'; /* terminate */
3207 /* These values tag the fields in a thread info response packet. */
3208 /* Tagging the fields allows us to request specific fields and to
3209 add more fields as time goes by. */
3211 #define TAG_THREADID 1 /* Echo the thread identifier. */
3212 #define TAG_EXISTS 2 /* Is this process defined enough to
3213 fetch registers and its stack? */
3214 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3215 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3216 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3220 remote_target::remote_unpack_thread_info_response (char *pkt
,
3221 threadref
*expectedref
,
3222 gdb_ext_thread_info
*info
)
3224 struct remote_state
*rs
= get_remote_state ();
3228 char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3231 /* info->threadid = 0; FIXME: implement zero_threadref. */
3233 info
->display
[0] = '\0';
3234 info
->shortname
[0] = '\0';
3235 info
->more_display
[0] = '\0';
3237 /* Assume the characters indicating the packet type have been
3239 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3240 pkt
= unpack_threadid (pkt
, &ref
);
3243 warning (_("Incomplete response to threadinfo request."));
3244 if (!threadmatch (&ref
, expectedref
))
3245 { /* This is an answer to a different request. */
3246 warning (_("ERROR RMT Thread info mismatch."));
3249 copy_threadref (&info
->threadid
, &ref
);
3251 /* Loop on tagged fields , try to bail if something goes wrong. */
3253 /* Packets are terminated with nulls. */
3254 while ((pkt
< limit
) && mask
&& *pkt
)
3256 pkt
= unpack_int (pkt
, &tag
); /* tag */
3257 pkt
= unpack_byte (pkt
, &length
); /* length */
3258 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3260 warning (_("ERROR RMT: threadinfo tag mismatch."));
3264 if (tag
== TAG_THREADID
)
3268 warning (_("ERROR RMT: length of threadid is not 16."));
3272 pkt
= unpack_threadid (pkt
, &ref
);
3273 mask
= mask
& ~TAG_THREADID
;
3276 if (tag
== TAG_EXISTS
)
3278 info
->active
= stub_unpack_int (pkt
, length
);
3280 mask
= mask
& ~(TAG_EXISTS
);
3283 warning (_("ERROR RMT: 'exists' length too long."));
3289 if (tag
== TAG_THREADNAME
)
3291 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3292 mask
= mask
& ~TAG_THREADNAME
;
3295 if (tag
== TAG_DISPLAY
)
3297 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3298 mask
= mask
& ~TAG_DISPLAY
;
3301 if (tag
== TAG_MOREDISPLAY
)
3303 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3304 mask
= mask
& ~TAG_MOREDISPLAY
;
3307 warning (_("ERROR RMT: unknown thread info tag."));
3308 break; /* Not a tag we know about. */
3314 remote_target::remote_get_threadinfo (threadref
*threadid
,
3316 gdb_ext_thread_info
*info
)
3318 struct remote_state
*rs
= get_remote_state ();
3321 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3323 getpkt (&rs
->buf
, 0);
3325 if (rs
->buf
[0] == '\0')
3328 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3333 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3336 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3337 threadref
*nextthread
)
3339 *pkt
++ = 'q'; /* info query packet */
3340 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3341 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3342 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3343 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3348 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3351 remote_target::parse_threadlist_response (char *pkt
, int result_limit
,
3352 threadref
*original_echo
,
3353 threadref
*resultlist
,
3356 struct remote_state
*rs
= get_remote_state ();
3358 int count
, resultcount
, done
;
3361 /* Assume the 'q' and 'M chars have been stripped. */
3362 limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3363 /* done parse past here */
3364 pkt
= unpack_byte (pkt
, &count
); /* count field */
3365 pkt
= unpack_nibble (pkt
, &done
);
3366 /* The first threadid is the argument threadid. */
3367 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3368 while ((count
-- > 0) && (pkt
< limit
))
3370 pkt
= unpack_threadid (pkt
, resultlist
++);
3371 if (resultcount
++ >= result_limit
)
3379 /* Fetch the next batch of threads from the remote. Returns -1 if the
3380 qL packet is not supported, 0 on error and 1 on success. */
3383 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3384 int result_limit
, int *done
, int *result_count
,
3385 threadref
*threadlist
)
3387 struct remote_state
*rs
= get_remote_state ();
3390 /* Truncate result limit to be smaller than the packet size. */
3391 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3392 >= get_remote_packet_size ())
3393 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3395 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3398 getpkt (&rs
->buf
, 0);
3399 if (rs
->buf
[0] == '\0')
3401 /* Packet not supported. */
3406 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3407 &rs
->echo_nextthread
, threadlist
, done
);
3409 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3411 /* FIXME: This is a good reason to drop the packet. */
3412 /* Possibly, there is a duplicate response. */
3414 retransmit immediatly - race conditions
3415 retransmit after timeout - yes
3417 wait for packet, then exit
3419 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3420 return 0; /* I choose simply exiting. */
3422 if (*result_count
<= 0)
3426 warning (_("RMT ERROR : failed to get remote thread list."));
3429 return result
; /* break; */
3431 if (*result_count
> result_limit
)
3434 warning (_("RMT ERROR: threadlist response longer than requested."));
3440 /* Fetch the list of remote threads, with the qL packet, and call
3441 STEPFUNCTION for each thread found. Stops iterating and returns 1
3442 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3443 STEPFUNCTION returns false. If the packet is not supported,
3447 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3448 void *context
, int looplimit
)
3450 struct remote_state
*rs
= get_remote_state ();
3451 int done
, i
, result_count
;
3459 if (loopcount
++ > looplimit
)
3462 warning (_("Remote fetch threadlist -infinite loop-."));
3465 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3466 MAXTHREADLISTRESULTS
,
3467 &done
, &result_count
,
3468 rs
->resultthreadlist
);
3471 /* Clear for later iterations. */
3473 /* Setup to resume next batch of thread references, set nextthread. */
3474 if (result_count
>= 1)
3475 copy_threadref (&rs
->nextthread
,
3476 &rs
->resultthreadlist
[result_count
- 1]);
3478 while (result_count
--)
3480 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3490 /* A thread found on the remote target. */
3494 explicit thread_item (ptid_t ptid_
)
3498 thread_item (thread_item
&&other
) = default;
3499 thread_item
&operator= (thread_item
&&other
) = default;
3501 DISABLE_COPY_AND_ASSIGN (thread_item
);
3503 /* The thread's PTID. */
3506 /* The thread's extra info. */
3509 /* The thread's name. */
3512 /* The core the thread was running on. -1 if not known. */
3515 /* The thread handle associated with the thread. */
3516 gdb::byte_vector thread_handle
;
3519 /* Context passed around to the various methods listing remote
3520 threads. As new threads are found, they're added to the ITEMS
3523 struct threads_listing_context
3525 /* Return true if this object contains an entry for a thread with ptid
3528 bool contains_thread (ptid_t ptid
) const
3530 auto match_ptid
= [&] (const thread_item
&item
)
3532 return item
.ptid
== ptid
;
3535 auto it
= std::find_if (this->items
.begin (),
3539 return it
!= this->items
.end ();
3542 /* Remove the thread with ptid PTID. */
3544 void remove_thread (ptid_t ptid
)
3546 auto match_ptid
= [&] (const thread_item
&item
)
3548 return item
.ptid
== ptid
;
3551 auto it
= std::remove_if (this->items
.begin (),
3555 if (it
!= this->items
.end ())
3556 this->items
.erase (it
);
3559 /* The threads found on the remote target. */
3560 std::vector
<thread_item
> items
;
3564 remote_newthread_step (threadref
*ref
, void *data
)
3566 struct threads_listing_context
*context
3567 = (struct threads_listing_context
*) data
;
3568 int pid
= inferior_ptid
.pid ();
3569 int lwp
= threadref_to_int (ref
);
3570 ptid_t
ptid (pid
, lwp
);
3572 context
->items
.emplace_back (ptid
);
3574 return 1; /* continue iterator */
3577 #define CRAZY_MAX_THREADS 1000
3580 remote_target::remote_current_thread (ptid_t oldpid
)
3582 struct remote_state
*rs
= get_remote_state ();
3585 getpkt (&rs
->buf
, 0);
3586 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3591 result
= read_ptid (&rs
->buf
[2], &obuf
);
3592 if (*obuf
!= '\0' && remote_debug
)
3593 fprintf_unfiltered (gdb_stdlog
,
3594 "warning: garbage in qC reply\n");
3602 /* List remote threads using the deprecated qL packet. */
3605 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3607 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3608 CRAZY_MAX_THREADS
) >= 0)
3614 #if defined(HAVE_LIBEXPAT)
3617 start_thread (struct gdb_xml_parser
*parser
,
3618 const struct gdb_xml_element
*element
,
3620 std::vector
<gdb_xml_value
> &attributes
)
3622 struct threads_listing_context
*data
3623 = (struct threads_listing_context
*) user_data
;
3624 struct gdb_xml_value
*attr
;
3626 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3627 ptid_t ptid
= read_ptid (id
, NULL
);
3629 data
->items
.emplace_back (ptid
);
3630 thread_item
&item
= data
->items
.back ();
3632 attr
= xml_find_attribute (attributes
, "core");
3634 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3636 attr
= xml_find_attribute (attributes
, "name");
3638 item
.name
= (const char *) attr
->value
.get ();
3640 attr
= xml_find_attribute (attributes
, "handle");
3642 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3646 end_thread (struct gdb_xml_parser
*parser
,
3647 const struct gdb_xml_element
*element
,
3648 void *user_data
, const char *body_text
)
3650 struct threads_listing_context
*data
3651 = (struct threads_listing_context
*) user_data
;
3653 if (body_text
!= NULL
&& *body_text
!= '\0')
3654 data
->items
.back ().extra
= body_text
;
3657 const struct gdb_xml_attribute thread_attributes
[] = {
3658 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3659 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3660 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3661 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3662 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3665 const struct gdb_xml_element thread_children
[] = {
3666 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3669 const struct gdb_xml_element threads_children
[] = {
3670 { "thread", thread_attributes
, thread_children
,
3671 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3672 start_thread
, end_thread
},
3673 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3676 const struct gdb_xml_element threads_elements
[] = {
3677 { "threads", NULL
, threads_children
,
3678 GDB_XML_EF_NONE
, NULL
, NULL
},
3679 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3684 /* List remote threads using qXfer:threads:read. */
3687 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3689 #if defined(HAVE_LIBEXPAT)
3690 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3692 gdb::optional
<gdb::char_vector
> xml
3693 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3695 if (xml
&& (*xml
)[0] != '\0')
3697 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3698 threads_elements
, xml
->data (), context
);
3708 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3711 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3713 struct remote_state
*rs
= get_remote_state ();
3715 if (rs
->use_threadinfo_query
)
3719 putpkt ("qfThreadInfo");
3720 getpkt (&rs
->buf
, 0);
3721 bufp
= rs
->buf
.data ();
3722 if (bufp
[0] != '\0') /* q packet recognized */
3724 while (*bufp
++ == 'm') /* reply contains one or more TID */
3728 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3729 context
->items
.emplace_back (ptid
);
3731 while (*bufp
++ == ','); /* comma-separated list */
3732 putpkt ("qsThreadInfo");
3733 getpkt (&rs
->buf
, 0);
3734 bufp
= rs
->buf
.data ();
3740 /* Packet not recognized. */
3741 rs
->use_threadinfo_query
= 0;
3748 /* Implement the to_update_thread_list function for the remote
3752 remote_target::update_thread_list ()
3754 struct threads_listing_context context
;
3757 /* We have a few different mechanisms to fetch the thread list. Try
3758 them all, starting with the most preferred one first, falling
3759 back to older methods. */
3760 if (remote_get_threads_with_qxfer (&context
)
3761 || remote_get_threads_with_qthreadinfo (&context
)
3762 || remote_get_threads_with_ql (&context
))
3766 if (context
.items
.empty ()
3767 && remote_thread_always_alive (inferior_ptid
))
3769 /* Some targets don't really support threads, but still
3770 reply an (empty) thread list in response to the thread
3771 listing packets, instead of replying "packet not
3772 supported". Exit early so we don't delete the main
3777 /* CONTEXT now holds the current thread list on the remote
3778 target end. Delete GDB-side threads no longer found on the
3780 for (thread_info
*tp
: all_threads_safe ())
3782 if (!context
.contains_thread (tp
->ptid
))
3789 /* Remove any unreported fork child threads from CONTEXT so
3790 that we don't interfere with follow fork, which is where
3791 creation of such threads is handled. */
3792 remove_new_fork_children (&context
);
3794 /* And now add threads we don't know about yet to our list. */
3795 for (thread_item
&item
: context
.items
)
3797 if (item
.ptid
!= null_ptid
)
3799 /* In non-stop mode, we assume new found threads are
3800 executing until proven otherwise with a stop reply.
3801 In all-stop, we can only get here if all threads are
3803 int executing
= target_is_non_stop_p () ? 1 : 0;
3805 remote_notice_new_inferior (item
.ptid
, executing
);
3807 thread_info
*tp
= find_thread_ptid (item
.ptid
);
3808 remote_thread_info
*info
= get_remote_thread_info (tp
);
3809 info
->core
= item
.core
;
3810 info
->extra
= std::move (item
.extra
);
3811 info
->name
= std::move (item
.name
);
3812 info
->thread_handle
= std::move (item
.thread_handle
);
3819 /* If no thread listing method is supported, then query whether
3820 each known thread is alive, one by one, with the T packet.
3821 If the target doesn't support threads at all, then this is a
3822 no-op. See remote_thread_alive. */
3828 * Collect a descriptive string about the given thread.
3829 * The target may say anything it wants to about the thread
3830 * (typically info about its blocked / runnable state, name, etc.).
3831 * This string will appear in the info threads display.
3833 * Optional: targets are not required to implement this function.
3837 remote_target::extra_thread_info (thread_info
*tp
)
3839 struct remote_state
*rs
= get_remote_state ();
3842 struct gdb_ext_thread_info threadinfo
;
3844 if (rs
->remote_desc
== 0) /* paranoia */
3845 internal_error (__FILE__
, __LINE__
,
3846 _("remote_threads_extra_info"));
3848 if (tp
->ptid
== magic_null_ptid
3849 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
3850 /* This is the main thread which was added by GDB. The remote
3851 server doesn't know about it. */
3854 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
3856 /* If already have cached info, use it. */
3857 if (!extra
.empty ())
3858 return extra
.c_str ();
3860 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3862 /* If we're using qXfer:threads:read, then the extra info is
3863 included in the XML. So if we didn't have anything cached,
3864 it's because there's really no extra info. */
3868 if (rs
->use_threadextra_query
)
3870 char *b
= rs
->buf
.data ();
3871 char *endb
= b
+ get_remote_packet_size ();
3873 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3875 write_ptid (b
, endb
, tp
->ptid
);
3878 getpkt (&rs
->buf
, 0);
3879 if (rs
->buf
[0] != 0)
3881 extra
.resize (strlen (rs
->buf
.data ()) / 2);
3882 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
3883 return extra
.c_str ();
3887 /* If the above query fails, fall back to the old method. */
3888 rs
->use_threadextra_query
= 0;
3889 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3890 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3891 int_to_threadref (&id
, tp
->ptid
.lwp ());
3892 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3893 if (threadinfo
.active
)
3895 if (*threadinfo
.shortname
)
3896 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
3897 if (*threadinfo
.display
)
3899 if (!extra
.empty ())
3901 string_appendf (extra
, " State: %s", threadinfo
.display
);
3903 if (*threadinfo
.more_display
)
3905 if (!extra
.empty ())
3907 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
3909 return extra
.c_str ();
3916 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
3917 struct static_tracepoint_marker
*marker
)
3919 struct remote_state
*rs
= get_remote_state ();
3920 char *p
= rs
->buf
.data ();
3922 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3924 p
+= hexnumstr (p
, addr
);
3926 getpkt (&rs
->buf
, 0);
3927 p
= rs
->buf
.data ();
3930 error (_("Remote failure reply: %s"), p
);
3934 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
3941 std::vector
<static_tracepoint_marker
>
3942 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
3944 struct remote_state
*rs
= get_remote_state ();
3945 std::vector
<static_tracepoint_marker
> markers
;
3947 static_tracepoint_marker marker
;
3949 /* Ask for a first packet of static tracepoint marker
3952 getpkt (&rs
->buf
, 0);
3953 p
= rs
->buf
.data ();
3955 error (_("Remote failure reply: %s"), p
);
3961 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
3963 if (strid
== NULL
|| marker
.str_id
== strid
)
3964 markers
.push_back (std::move (marker
));
3966 while (*p
++ == ','); /* comma-separated list */
3967 /* Ask for another packet of static tracepoint definition. */
3969 getpkt (&rs
->buf
, 0);
3970 p
= rs
->buf
.data ();
3977 /* Implement the to_get_ada_task_ptid function for the remote targets. */
3980 remote_target::get_ada_task_ptid (long lwp
, long thread
)
3982 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3986 /* Restart the remote side; this is an extended protocol operation. */
3989 remote_target::extended_remote_restart ()
3991 struct remote_state
*rs
= get_remote_state ();
3993 /* Send the restart command; for reasons I don't understand the
3994 remote side really expects a number after the "R". */
3995 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
3998 remote_fileio_reset ();
4001 /* Clean up connection to a remote debugger. */
4004 remote_target::close ()
4006 /* Make sure we leave stdin registered in the event loop. */
4009 /* We don't have a connection to the remote stub anymore. Get rid
4010 of all the inferiors and their threads we were controlling.
4011 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
4012 will be unable to find the thread corresponding to (pid, 0, 0). */
4013 inferior_ptid
= null_ptid
;
4014 discard_all_inferiors ();
4016 trace_reset_local_state ();
4021 remote_target::~remote_target ()
4023 struct remote_state
*rs
= get_remote_state ();
4025 /* Check for NULL because we may get here with a partially
4026 constructed target/connection. */
4027 if (rs
->remote_desc
== nullptr)
4030 serial_close (rs
->remote_desc
);
4032 /* We are destroying the remote target, so we should discard
4033 everything of this target. */
4034 discard_pending_stop_replies_in_queue ();
4036 if (rs
->remote_async_inferior_event_token
)
4037 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4039 delete rs
->notif_state
;
4042 /* Query the remote side for the text, data and bss offsets. */
4045 remote_target::get_offsets ()
4047 struct remote_state
*rs
= get_remote_state ();
4050 int lose
, num_segments
= 0, do_sections
, do_segments
;
4051 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4052 struct symfile_segment_data
*data
;
4054 if (symfile_objfile
== NULL
)
4057 putpkt ("qOffsets");
4058 getpkt (&rs
->buf
, 0);
4059 buf
= rs
->buf
.data ();
4061 if (buf
[0] == '\000')
4062 return; /* Return silently. Stub doesn't support
4066 warning (_("Remote failure reply: %s"), buf
);
4070 /* Pick up each field in turn. This used to be done with scanf, but
4071 scanf will make trouble if CORE_ADDR size doesn't match
4072 conversion directives correctly. The following code will work
4073 with any size of CORE_ADDR. */
4074 text_addr
= data_addr
= bss_addr
= 0;
4078 if (startswith (ptr
, "Text="))
4081 /* Don't use strtol, could lose on big values. */
4082 while (*ptr
&& *ptr
!= ';')
4083 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4085 if (startswith (ptr
, ";Data="))
4088 while (*ptr
&& *ptr
!= ';')
4089 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4094 if (!lose
&& startswith (ptr
, ";Bss="))
4097 while (*ptr
&& *ptr
!= ';')
4098 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4100 if (bss_addr
!= data_addr
)
4101 warning (_("Target reported unsupported offsets: %s"), buf
);
4106 else if (startswith (ptr
, "TextSeg="))
4109 /* Don't use strtol, could lose on big values. */
4110 while (*ptr
&& *ptr
!= ';')
4111 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4114 if (startswith (ptr
, ";DataSeg="))
4117 while (*ptr
&& *ptr
!= ';')
4118 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4126 error (_("Malformed response to offset query, %s"), buf
);
4127 else if (*ptr
!= '\0')
4128 warning (_("Target reported unsupported offsets: %s"), buf
);
4130 section_offsets offs
= symfile_objfile
->section_offsets
;
4132 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
4133 do_segments
= (data
!= NULL
);
4134 do_sections
= num_segments
== 0;
4136 if (num_segments
> 0)
4138 segments
[0] = text_addr
;
4139 segments
[1] = data_addr
;
4141 /* If we have two segments, we can still try to relocate everything
4142 by assuming that the .text and .data offsets apply to the whole
4143 text and data segments. Convert the offsets given in the packet
4144 to base addresses for symfile_map_offsets_to_segments. */
4145 else if (data
&& data
->num_segments
== 2)
4147 segments
[0] = data
->segment_bases
[0] + text_addr
;
4148 segments
[1] = data
->segment_bases
[1] + data_addr
;
4151 /* If the object file has only one segment, assume that it is text
4152 rather than data; main programs with no writable data are rare,
4153 but programs with no code are useless. Of course the code might
4154 have ended up in the data segment... to detect that we would need
4155 the permissions here. */
4156 else if (data
&& data
->num_segments
== 1)
4158 segments
[0] = data
->segment_bases
[0] + text_addr
;
4161 /* There's no way to relocate by segment. */
4167 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
4168 offs
, num_segments
, segments
);
4170 if (ret
== 0 && !do_sections
)
4171 error (_("Can not handle qOffsets TextSeg "
4172 "response with this symbol file"));
4179 free_symfile_segment_data (data
);
4183 offs
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
4185 /* This is a temporary kludge to force data and bss to use the
4186 same offsets because that's what nlmconv does now. The real
4187 solution requires changes to the stub and remote.c that I
4188 don't have time to do right now. */
4190 offs
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
4191 offs
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
4194 objfile_relocate (symfile_objfile
, offs
);
4197 /* Send interrupt_sequence to remote target. */
4200 remote_target::send_interrupt_sequence ()
4202 struct remote_state
*rs
= get_remote_state ();
4204 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4205 remote_serial_write ("\x03", 1);
4206 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4207 serial_send_break (rs
->remote_desc
);
4208 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4210 serial_send_break (rs
->remote_desc
);
4211 remote_serial_write ("g", 1);
4214 internal_error (__FILE__
, __LINE__
,
4215 _("Invalid value for interrupt_sequence_mode: %s."),
4216 interrupt_sequence_mode
);
4220 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4221 and extract the PTID. Returns NULL_PTID if not found. */
4224 stop_reply_extract_thread (char *stop_reply
)
4226 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4230 /* Txx r:val ; r:val (...) */
4233 /* Look for "register" named "thread". */
4238 p1
= strchr (p
, ':');
4242 if (strncmp (p
, "thread", p1
- p
) == 0)
4243 return read_ptid (++p1
, &p
);
4245 p1
= strchr (p
, ';');
4257 /* Determine the remote side's current thread. If we have a stop
4258 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4259 "thread" register we can extract the current thread from. If not,
4260 ask the remote which is the current thread with qC. The former
4261 method avoids a roundtrip. */
4264 remote_target::get_current_thread (char *wait_status
)
4266 ptid_t ptid
= null_ptid
;
4268 /* Note we don't use remote_parse_stop_reply as that makes use of
4269 the target architecture, which we haven't yet fully determined at
4271 if (wait_status
!= NULL
)
4272 ptid
= stop_reply_extract_thread (wait_status
);
4273 if (ptid
== null_ptid
)
4274 ptid
= remote_current_thread (inferior_ptid
);
4279 /* Query the remote target for which is the current thread/process,
4280 add it to our tables, and update INFERIOR_PTID. The caller is
4281 responsible for setting the state such that the remote end is ready
4282 to return the current thread.
4284 This function is called after handling the '?' or 'vRun' packets,
4285 whose response is a stop reply from which we can also try
4286 extracting the thread. If the target doesn't support the explicit
4287 qC query, we infer the current thread from that stop reply, passed
4288 in in WAIT_STATUS, which may be NULL. */
4291 remote_target::add_current_inferior_and_thread (char *wait_status
)
4293 struct remote_state
*rs
= get_remote_state ();
4294 bool fake_pid_p
= false;
4296 inferior_ptid
= null_ptid
;
4298 /* Now, if we have thread information, update inferior_ptid. */
4299 ptid_t curr_ptid
= get_current_thread (wait_status
);
4301 if (curr_ptid
!= null_ptid
)
4303 if (!remote_multi_process_p (rs
))
4308 /* Without this, some commands which require an active target
4309 (such as kill) won't work. This variable serves (at least)
4310 double duty as both the pid of the target process (if it has
4311 such), and as a flag indicating that a target is active. */
4312 curr_ptid
= magic_null_ptid
;
4316 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4318 /* Add the main thread and switch to it. Don't try reading
4319 registers yet, since we haven't fetched the target description
4321 thread_info
*tp
= add_thread_silent (curr_ptid
);
4322 switch_to_thread_no_regs (tp
);
4325 /* Print info about a thread that was found already stopped on
4329 print_one_stopped_thread (struct thread_info
*thread
)
4331 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4333 switch_to_thread (thread
);
4334 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4335 set_current_sal_from_frame (get_current_frame ());
4337 thread
->suspend
.waitstatus_pending_p
= 0;
4339 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4341 enum gdb_signal sig
= ws
->value
.sig
;
4343 if (signal_print_state (sig
))
4344 gdb::observers::signal_received
.notify (sig
);
4346 gdb::observers::normal_stop
.notify (NULL
, 1);
4349 /* Process all initial stop replies the remote side sent in response
4350 to the ? packet. These indicate threads that were already stopped
4351 on initial connection. We mark these threads as stopped and print
4352 their current frame before giving the user the prompt. */
4355 remote_target::process_initial_stop_replies (int from_tty
)
4357 int pending_stop_replies
= stop_reply_queue_length ();
4358 struct thread_info
*selected
= NULL
;
4359 struct thread_info
*lowest_stopped
= NULL
;
4360 struct thread_info
*first
= NULL
;
4362 /* Consume the initial pending events. */
4363 while (pending_stop_replies
-- > 0)
4365 ptid_t waiton_ptid
= minus_one_ptid
;
4367 struct target_waitstatus ws
;
4368 int ignore_event
= 0;
4370 memset (&ws
, 0, sizeof (ws
));
4371 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4373 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4377 case TARGET_WAITKIND_IGNORE
:
4378 case TARGET_WAITKIND_NO_RESUMED
:
4379 case TARGET_WAITKIND_SIGNALLED
:
4380 case TARGET_WAITKIND_EXITED
:
4381 /* We shouldn't see these, but if we do, just ignore. */
4383 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
4387 case TARGET_WAITKIND_EXECD
:
4388 xfree (ws
.value
.execd_pathname
);
4397 struct thread_info
*evthread
= find_thread_ptid (event_ptid
);
4399 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4401 enum gdb_signal sig
= ws
.value
.sig
;
4403 /* Stubs traditionally report SIGTRAP as initial signal,
4404 instead of signal 0. Suppress it. */
4405 if (sig
== GDB_SIGNAL_TRAP
)
4407 evthread
->suspend
.stop_signal
= sig
;
4411 evthread
->suspend
.waitstatus
= ws
;
4413 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4414 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4415 evthread
->suspend
.waitstatus_pending_p
= 1;
4417 set_executing (event_ptid
, 0);
4418 set_running (event_ptid
, 0);
4419 get_remote_thread_info (evthread
)->vcont_resumed
= 0;
4422 /* "Notice" the new inferiors before anything related to
4423 registers/memory. */
4424 for (inferior
*inf
: all_non_exited_inferiors ())
4426 inf
->needs_setup
= 1;
4430 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4431 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4436 /* If all-stop on top of non-stop, pause all threads. Note this
4437 records the threads' stop pc, so must be done after "noticing"
4441 stop_all_threads ();
4443 /* If all threads of an inferior were already stopped, we
4444 haven't setup the inferior yet. */
4445 for (inferior
*inf
: all_non_exited_inferiors ())
4447 if (inf
->needs_setup
)
4449 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4450 switch_to_thread_no_regs (thread
);
4456 /* Now go over all threads that are stopped, and print their current
4457 frame. If all-stop, then if there's a signalled thread, pick
4459 for (thread_info
*thread
: all_non_exited_threads ())
4465 thread
->set_running (false);
4466 else if (thread
->state
!= THREAD_STOPPED
)
4469 if (selected
== NULL
4470 && thread
->suspend
.waitstatus_pending_p
)
4473 if (lowest_stopped
== NULL
4474 || thread
->inf
->num
< lowest_stopped
->inf
->num
4475 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4476 lowest_stopped
= thread
;
4479 print_one_stopped_thread (thread
);
4482 /* In all-stop, we only print the status of one thread, and leave
4483 others with their status pending. */
4486 thread_info
*thread
= selected
;
4488 thread
= lowest_stopped
;
4492 print_one_stopped_thread (thread
);
4495 /* For "info program". */
4496 thread_info
*thread
= inferior_thread ();
4497 if (thread
->state
== THREAD_STOPPED
)
4498 set_last_target_status (inferior_ptid
, thread
->suspend
.waitstatus
);
4501 /* Start the remote connection and sync state. */
4504 remote_target::start_remote (int from_tty
, int extended_p
)
4506 struct remote_state
*rs
= get_remote_state ();
4507 struct packet_config
*noack_config
;
4508 char *wait_status
= NULL
;
4510 /* Signal other parts that we're going through the initial setup,
4511 and so things may not be stable yet. E.g., we don't try to
4512 install tracepoints until we've relocated symbols. Also, a
4513 Ctrl-C before we're connected and synced up can't interrupt the
4514 target. Instead, it offers to drop the (potentially wedged)
4516 rs
->starting_up
= 1;
4520 if (interrupt_on_connect
)
4521 send_interrupt_sequence ();
4523 /* Ack any packet which the remote side has already sent. */
4524 remote_serial_write ("+", 1);
4526 /* The first packet we send to the target is the optional "supported
4527 packets" request. If the target can answer this, it will tell us
4528 which later probes to skip. */
4529 remote_query_supported ();
4531 /* If the stub wants to get a QAllow, compose one and send it. */
4532 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4535 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4536 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4537 as a reply to known packet. For packet "vFile:setfs:" it is an
4538 invalid reply and GDB would return error in
4539 remote_hostio_set_filesystem, making remote files access impossible.
4540 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4541 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4543 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4545 putpkt (v_mustreplyempty
);
4546 getpkt (&rs
->buf
, 0);
4547 if (strcmp (rs
->buf
.data (), "OK") == 0)
4548 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4549 else if (strcmp (rs
->buf
.data (), "") != 0)
4550 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4554 /* Next, we possibly activate noack mode.
4556 If the QStartNoAckMode packet configuration is set to AUTO,
4557 enable noack mode if the stub reported a wish for it with
4560 If set to TRUE, then enable noack mode even if the stub didn't
4561 report it in qSupported. If the stub doesn't reply OK, the
4562 session ends with an error.
4564 If FALSE, then don't activate noack mode, regardless of what the
4565 stub claimed should be the default with qSupported. */
4567 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4568 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4570 putpkt ("QStartNoAckMode");
4571 getpkt (&rs
->buf
, 0);
4572 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4578 /* Tell the remote that we are using the extended protocol. */
4580 getpkt (&rs
->buf
, 0);
4583 /* Let the target know which signals it is allowed to pass down to
4585 update_signals_program_target ();
4587 /* Next, if the target can specify a description, read it. We do
4588 this before anything involving memory or registers. */
4589 target_find_description ();
4591 /* Next, now that we know something about the target, update the
4592 address spaces in the program spaces. */
4593 update_address_spaces ();
4595 /* On OSs where the list of libraries is global to all
4596 processes, we fetch them early. */
4597 if (gdbarch_has_global_solist (target_gdbarch ()))
4598 solib_add (NULL
, from_tty
, auto_solib_add
);
4600 if (target_is_non_stop_p ())
4602 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4603 error (_("Non-stop mode requested, but remote "
4604 "does not support non-stop"));
4606 putpkt ("QNonStop:1");
4607 getpkt (&rs
->buf
, 0);
4609 if (strcmp (rs
->buf
.data (), "OK") != 0)
4610 error (_("Remote refused setting non-stop mode with: %s"),
4613 /* Find about threads and processes the stub is already
4614 controlling. We default to adding them in the running state.
4615 The '?' query below will then tell us about which threads are
4617 this->update_thread_list ();
4619 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4621 /* Don't assume that the stub can operate in all-stop mode.
4622 Request it explicitly. */
4623 putpkt ("QNonStop:0");
4624 getpkt (&rs
->buf
, 0);
4626 if (strcmp (rs
->buf
.data (), "OK") != 0)
4627 error (_("Remote refused setting all-stop mode with: %s"),
4631 /* Upload TSVs regardless of whether the target is running or not. The
4632 remote stub, such as GDBserver, may have some predefined or builtin
4633 TSVs, even if the target is not running. */
4634 if (get_trace_status (current_trace_status ()) != -1)
4636 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4638 upload_trace_state_variables (&uploaded_tsvs
);
4639 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4642 /* Check whether the target is running now. */
4644 getpkt (&rs
->buf
, 0);
4646 if (!target_is_non_stop_p ())
4648 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4651 error (_("The target is not running (try extended-remote?)"));
4653 /* We're connected, but not running. Drop out before we
4654 call start_remote. */
4655 rs
->starting_up
= 0;
4660 /* Save the reply for later. */
4661 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4662 strcpy (wait_status
, rs
->buf
.data ());
4665 /* Fetch thread list. */
4666 target_update_thread_list ();
4668 /* Let the stub know that we want it to return the thread. */
4669 set_continue_thread (minus_one_ptid
);
4671 if (thread_count () == 0)
4673 /* Target has no concept of threads at all. GDB treats
4674 non-threaded target as single-threaded; add a main
4676 add_current_inferior_and_thread (wait_status
);
4680 /* We have thread information; select the thread the target
4681 says should be current. If we're reconnecting to a
4682 multi-threaded program, this will ideally be the thread
4683 that last reported an event before GDB disconnected. */
4684 inferior_ptid
= get_current_thread (wait_status
);
4685 if (inferior_ptid
== null_ptid
)
4687 /* Odd... The target was able to list threads, but not
4688 tell us which thread was current (no "thread"
4689 register in T stop reply?). Just pick the first
4690 thread in the thread list then. */
4693 fprintf_unfiltered (gdb_stdlog
,
4694 "warning: couldn't determine remote "
4695 "current thread; picking first in list.\n");
4697 inferior_ptid
= inferior_list
->thread_list
->ptid
;
4701 /* init_wait_for_inferior should be called before get_offsets in order
4702 to manage `inserted' flag in bp loc in a correct state.
4703 breakpoint_init_inferior, called from init_wait_for_inferior, set
4704 `inserted' flag to 0, while before breakpoint_re_set, called from
4705 start_remote, set `inserted' flag to 1. In the initialization of
4706 inferior, breakpoint_init_inferior should be called first, and then
4707 breakpoint_re_set can be called. If this order is broken, state of
4708 `inserted' flag is wrong, and cause some problems on breakpoint
4710 init_wait_for_inferior ();
4712 get_offsets (); /* Get text, data & bss offsets. */
4714 /* If we could not find a description using qXfer, and we know
4715 how to do it some other way, try again. This is not
4716 supported for non-stop; it could be, but it is tricky if
4717 there are no stopped threads when we connect. */
4718 if (remote_read_description_p (this)
4719 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4721 target_clear_description ();
4722 target_find_description ();
4725 /* Use the previously fetched status. */
4726 gdb_assert (wait_status
!= NULL
);
4727 strcpy (rs
->buf
.data (), wait_status
);
4728 rs
->cached_wait_status
= 1;
4730 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4734 /* Clear WFI global state. Do this before finding about new
4735 threads and inferiors, and setting the current inferior.
4736 Otherwise we would clear the proceed status of the current
4737 inferior when we want its stop_soon state to be preserved
4738 (see notice_new_inferior). */
4739 init_wait_for_inferior ();
4741 /* In non-stop, we will either get an "OK", meaning that there
4742 are no stopped threads at this time; or, a regular stop
4743 reply. In the latter case, there may be more than one thread
4744 stopped --- we pull them all out using the vStopped
4746 if (strcmp (rs
->buf
.data (), "OK") != 0)
4748 struct notif_client
*notif
= ¬if_client_stop
;
4750 /* remote_notif_get_pending_replies acks this one, and gets
4752 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4753 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4754 remote_notif_get_pending_events (notif
);
4757 if (thread_count () == 0)
4760 error (_("The target is not running (try extended-remote?)"));
4762 /* We're connected, but not running. Drop out before we
4763 call start_remote. */
4764 rs
->starting_up
= 0;
4768 /* In non-stop mode, any cached wait status will be stored in
4769 the stop reply queue. */
4770 gdb_assert (wait_status
== NULL
);
4772 /* Report all signals during attach/startup. */
4775 /* If there are already stopped threads, mark them stopped and
4776 report their stops before giving the prompt to the user. */
4777 process_initial_stop_replies (from_tty
);
4779 if (target_can_async_p ())
4783 /* If we connected to a live target, do some additional setup. */
4784 if (target_has_execution
)
4786 if (symfile_objfile
) /* No use without a symbol-file. */
4787 remote_check_symbols ();
4790 /* Possibly the target has been engaged in a trace run started
4791 previously; find out where things are at. */
4792 if (get_trace_status (current_trace_status ()) != -1)
4794 struct uploaded_tp
*uploaded_tps
= NULL
;
4796 if (current_trace_status ()->running
)
4797 printf_filtered (_("Trace is already running on the target.\n"));
4799 upload_tracepoints (&uploaded_tps
);
4801 merge_uploaded_tracepoints (&uploaded_tps
);
4804 /* Possibly the target has been engaged in a btrace record started
4805 previously; find out where things are at. */
4806 remote_btrace_maybe_reopen ();
4808 /* The thread and inferior lists are now synchronized with the
4809 target, our symbols have been relocated, and we're merged the
4810 target's tracepoints with ours. We're done with basic start
4812 rs
->starting_up
= 0;
4814 /* Maybe breakpoints are global and need to be inserted now. */
4815 if (breakpoints_should_be_inserted_now ())
4816 insert_breakpoints ();
4819 /* Open a connection to a remote debugger.
4820 NAME is the filename used for communication. */
4823 remote_target::open (const char *name
, int from_tty
)
4825 open_1 (name
, from_tty
, 0);
4828 /* Open a connection to a remote debugger using the extended
4829 remote gdb protocol. NAME is the filename used for communication. */
4832 extended_remote_target::open (const char *name
, int from_tty
)
4834 open_1 (name
, from_tty
, 1 /*extended_p */);
4837 /* Reset all packets back to "unknown support". Called when opening a
4838 new connection to a remote target. */
4841 reset_all_packet_configs_support (void)
4845 for (i
= 0; i
< PACKET_MAX
; i
++)
4846 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4849 /* Initialize all packet configs. */
4852 init_all_packet_configs (void)
4856 for (i
= 0; i
< PACKET_MAX
; i
++)
4858 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4859 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4863 /* Symbol look-up. */
4866 remote_target::remote_check_symbols ()
4871 /* The remote side has no concept of inferiors that aren't running
4872 yet, it only knows about running processes. If we're connected
4873 but our current inferior is not running, we should not invite the
4874 remote target to request symbol lookups related to its
4875 (unrelated) current process. */
4876 if (!target_has_execution
)
4879 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4882 /* Make sure the remote is pointing at the right process. Note
4883 there's no way to select "no process". */
4884 set_general_process ();
4886 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4887 because we need both at the same time. */
4888 gdb::char_vector
msg (get_remote_packet_size ());
4889 gdb::char_vector
reply (get_remote_packet_size ());
4891 /* Invite target to request symbol lookups. */
4893 putpkt ("qSymbol::");
4895 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4897 while (startswith (reply
.data (), "qSymbol:"))
4899 struct bound_minimal_symbol sym
;
4902 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
4905 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
4906 if (sym
.minsym
== NULL
)
4907 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
4911 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4912 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4914 /* If this is a function address, return the start of code
4915 instead of any data function descriptor. */
4916 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4918 current_top_target ());
4920 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4921 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4924 putpkt (msg
.data ());
4929 static struct serial
*
4930 remote_serial_open (const char *name
)
4932 static int udp_warning
= 0;
4934 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4935 of in ser-tcp.c, because it is the remote protocol assuming that the
4936 serial connection is reliable and not the serial connection promising
4938 if (!udp_warning
&& startswith (name
, "udp:"))
4940 warning (_("The remote protocol may be unreliable over UDP.\n"
4941 "Some events may be lost, rendering further debugging "
4946 return serial_open (name
);
4949 /* Inform the target of our permission settings. The permission flags
4950 work without this, but if the target knows the settings, it can do
4951 a couple things. First, it can add its own check, to catch cases
4952 that somehow manage to get by the permissions checks in target
4953 methods. Second, if the target is wired to disallow particular
4954 settings (for instance, a system in the field that is not set up to
4955 be able to stop at a breakpoint), it can object to any unavailable
4959 remote_target::set_permissions ()
4961 struct remote_state
*rs
= get_remote_state ();
4963 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
4964 "WriteReg:%x;WriteMem:%x;"
4965 "InsertBreak:%x;InsertTrace:%x;"
4966 "InsertFastTrace:%x;Stop:%x",
4967 may_write_registers
, may_write_memory
,
4968 may_insert_breakpoints
, may_insert_tracepoints
,
4969 may_insert_fast_tracepoints
, may_stop
);
4971 getpkt (&rs
->buf
, 0);
4973 /* If the target didn't like the packet, warn the user. Do not try
4974 to undo the user's settings, that would just be maddening. */
4975 if (strcmp (rs
->buf
.data (), "OK") != 0)
4976 warning (_("Remote refused setting permissions with: %s"),
4980 /* This type describes each known response to the qSupported
4982 struct protocol_feature
4984 /* The name of this protocol feature. */
4987 /* The default for this protocol feature. */
4988 enum packet_support default_support
;
4990 /* The function to call when this feature is reported, or after
4991 qSupported processing if the feature is not supported.
4992 The first argument points to this structure. The second
4993 argument indicates whether the packet requested support be
4994 enabled, disabled, or probed (or the default, if this function
4995 is being called at the end of processing and this feature was
4996 not reported). The third argument may be NULL; if not NULL, it
4997 is a NUL-terminated string taken from the packet following
4998 this feature's name and an equals sign. */
4999 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5000 enum packet_support
, const char *);
5002 /* The corresponding packet for this feature. Only used if
5003 FUNC is remote_supported_packet. */
5008 remote_supported_packet (remote_target
*remote
,
5009 const struct protocol_feature
*feature
,
5010 enum packet_support support
,
5011 const char *argument
)
5015 warning (_("Remote qSupported response supplied an unexpected value for"
5016 " \"%s\"."), feature
->name
);
5020 remote_protocol_packets
[feature
->packet
].support
= support
;
5024 remote_target::remote_packet_size (const protocol_feature
*feature
,
5025 enum packet_support support
, const char *value
)
5027 struct remote_state
*rs
= get_remote_state ();
5032 if (support
!= PACKET_ENABLE
)
5035 if (value
== NULL
|| *value
== '\0')
5037 warning (_("Remote target reported \"%s\" without a size."),
5043 packet_size
= strtol (value
, &value_end
, 16);
5044 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5046 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5047 feature
->name
, value
);
5051 /* Record the new maximum packet size. */
5052 rs
->explicit_packet_size
= packet_size
;
5056 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5057 enum packet_support support
, const char *value
)
5059 remote
->remote_packet_size (feature
, support
, value
);
5062 static const struct protocol_feature remote_protocol_features
[] = {
5063 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5064 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5065 PACKET_qXfer_auxv
},
5066 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5067 PACKET_qXfer_exec_file
},
5068 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5069 PACKET_qXfer_features
},
5070 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5071 PACKET_qXfer_libraries
},
5072 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5073 PACKET_qXfer_libraries_svr4
},
5074 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5075 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5076 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5077 PACKET_qXfer_memory_map
},
5078 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5079 PACKET_qXfer_osdata
},
5080 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5081 PACKET_qXfer_threads
},
5082 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5083 PACKET_qXfer_traceframe_info
},
5084 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5085 PACKET_QPassSignals
},
5086 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5087 PACKET_QCatchSyscalls
},
5088 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5089 PACKET_QProgramSignals
},
5090 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5091 PACKET_QSetWorkingDir
},
5092 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5093 PACKET_QStartupWithShell
},
5094 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5095 PACKET_QEnvironmentHexEncoded
},
5096 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5097 PACKET_QEnvironmentReset
},
5098 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5099 PACKET_QEnvironmentUnset
},
5100 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5101 PACKET_QStartNoAckMode
},
5102 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5103 PACKET_multiprocess_feature
},
5104 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5105 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5106 PACKET_qXfer_siginfo_read
},
5107 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5108 PACKET_qXfer_siginfo_write
},
5109 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5110 PACKET_ConditionalTracepoints
},
5111 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5112 PACKET_ConditionalBreakpoints
},
5113 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5114 PACKET_BreakpointCommands
},
5115 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5116 PACKET_FastTracepoints
},
5117 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5118 PACKET_StaticTracepoints
},
5119 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5120 PACKET_InstallInTrace
},
5121 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5122 PACKET_DisconnectedTracing_feature
},
5123 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5125 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5127 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5128 PACKET_TracepointSource
},
5129 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5131 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5132 PACKET_EnableDisableTracepoints_feature
},
5133 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5134 PACKET_qXfer_fdpic
},
5135 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5137 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5138 PACKET_QDisableRandomization
},
5139 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5140 { "QTBuffer:size", PACKET_DISABLE
,
5141 remote_supported_packet
, PACKET_QTBuffer_size
},
5142 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5143 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5144 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5145 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5146 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5147 PACKET_qXfer_btrace
},
5148 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5149 PACKET_qXfer_btrace_conf
},
5150 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5151 PACKET_Qbtrace_conf_bts_size
},
5152 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5153 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5154 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5155 PACKET_fork_event_feature
},
5156 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5157 PACKET_vfork_event_feature
},
5158 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5159 PACKET_exec_event_feature
},
5160 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5161 PACKET_Qbtrace_conf_pt_size
},
5162 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5163 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5164 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5167 static char *remote_support_xml
;
5169 /* Register string appended to "xmlRegisters=" in qSupported query. */
5172 register_remote_support_xml (const char *xml
)
5174 #if defined(HAVE_LIBEXPAT)
5175 if (remote_support_xml
== NULL
)
5176 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5179 char *copy
= xstrdup (remote_support_xml
+ 13);
5181 char *p
= strtok_r (copy
, ",", &saveptr
);
5185 if (strcmp (p
, xml
) == 0)
5192 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5195 remote_support_xml
= reconcat (remote_support_xml
,
5196 remote_support_xml
, ",", xml
,
5203 remote_query_supported_append (std::string
*msg
, const char *append
)
5207 msg
->append (append
);
5211 remote_target::remote_query_supported ()
5213 struct remote_state
*rs
= get_remote_state ();
5216 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5218 /* The packet support flags are handled differently for this packet
5219 than for most others. We treat an error, a disabled packet, and
5220 an empty response identically: any features which must be reported
5221 to be used will be automatically disabled. An empty buffer
5222 accomplishes this, since that is also the representation for a list
5223 containing no features. */
5226 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5230 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5231 remote_query_supported_append (&q
, "multiprocess+");
5233 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5234 remote_query_supported_append (&q
, "swbreak+");
5235 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5236 remote_query_supported_append (&q
, "hwbreak+");
5238 remote_query_supported_append (&q
, "qRelocInsn+");
5240 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5241 != AUTO_BOOLEAN_FALSE
)
5242 remote_query_supported_append (&q
, "fork-events+");
5243 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5244 != AUTO_BOOLEAN_FALSE
)
5245 remote_query_supported_append (&q
, "vfork-events+");
5246 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5247 != AUTO_BOOLEAN_FALSE
)
5248 remote_query_supported_append (&q
, "exec-events+");
5250 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5251 remote_query_supported_append (&q
, "vContSupported+");
5253 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5254 remote_query_supported_append (&q
, "QThreadEvents+");
5256 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5257 remote_query_supported_append (&q
, "no-resumed+");
5259 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5260 the qSupported:xmlRegisters=i386 handling. */
5261 if (remote_support_xml
!= NULL
5262 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5263 remote_query_supported_append (&q
, remote_support_xml
);
5265 q
= "qSupported:" + q
;
5266 putpkt (q
.c_str ());
5268 getpkt (&rs
->buf
, 0);
5270 /* If an error occured, warn, but do not return - just reset the
5271 buffer to empty and go on to disable features. */
5272 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5275 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5280 memset (seen
, 0, sizeof (seen
));
5282 next
= rs
->buf
.data ();
5285 enum packet_support is_supported
;
5286 char *p
, *end
, *name_end
, *value
;
5288 /* First separate out this item from the rest of the packet. If
5289 there's another item after this, we overwrite the separator
5290 (terminated strings are much easier to work with). */
5292 end
= strchr (p
, ';');
5295 end
= p
+ strlen (p
);
5305 warning (_("empty item in \"qSupported\" response"));
5310 name_end
= strchr (p
, '=');
5313 /* This is a name=value entry. */
5314 is_supported
= PACKET_ENABLE
;
5315 value
= name_end
+ 1;
5324 is_supported
= PACKET_ENABLE
;
5328 is_supported
= PACKET_DISABLE
;
5332 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5336 warning (_("unrecognized item \"%s\" "
5337 "in \"qSupported\" response"), p
);
5343 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5344 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5346 const struct protocol_feature
*feature
;
5349 feature
= &remote_protocol_features
[i
];
5350 feature
->func (this, feature
, is_supported
, value
);
5355 /* If we increased the packet size, make sure to increase the global
5356 buffer size also. We delay this until after parsing the entire
5357 qSupported packet, because this is the same buffer we were
5359 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5360 rs
->buf
.resize (rs
->explicit_packet_size
);
5362 /* Handle the defaults for unmentioned features. */
5363 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5366 const struct protocol_feature
*feature
;
5368 feature
= &remote_protocol_features
[i
];
5369 feature
->func (this, feature
, feature
->default_support
, NULL
);
5373 /* Serial QUIT handler for the remote serial descriptor.
5375 Defers handling a Ctrl-C until we're done with the current
5376 command/response packet sequence, unless:
5378 - We're setting up the connection. Don't send a remote interrupt
5379 request, as we're not fully synced yet. Quit immediately
5382 - The target has been resumed in the foreground
5383 (target_terminal::is_ours is false) with a synchronous resume
5384 packet, and we're blocked waiting for the stop reply, thus a
5385 Ctrl-C should be immediately sent to the target.
5387 - We get a second Ctrl-C while still within the same serial read or
5388 write. In that case the serial is seemingly wedged --- offer to
5391 - We see a second Ctrl-C without target response, after having
5392 previously interrupted the target. In that case the target/stub
5393 is probably wedged --- offer to quit/disconnect.
5397 remote_target::remote_serial_quit_handler ()
5399 struct remote_state
*rs
= get_remote_state ();
5401 if (check_quit_flag ())
5403 /* If we're starting up, we're not fully synced yet. Quit
5405 if (rs
->starting_up
)
5407 else if (rs
->got_ctrlc_during_io
)
5409 if (query (_("The target is not responding to GDB commands.\n"
5410 "Stop debugging it? ")))
5411 remote_unpush_and_throw ();
5413 /* If ^C has already been sent once, offer to disconnect. */
5414 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5416 /* All-stop protocol, and blocked waiting for stop reply. Send
5417 an interrupt request. */
5418 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5419 target_interrupt ();
5421 rs
->got_ctrlc_during_io
= 1;
5425 /* The remote_target that is current while the quit handler is
5426 overridden with remote_serial_quit_handler. */
5427 static remote_target
*curr_quit_handler_target
;
5430 remote_serial_quit_handler ()
5432 curr_quit_handler_target
->remote_serial_quit_handler ();
5435 /* Remove any of the remote.c targets from target stack. Upper targets depend
5436 on it so remove them first. */
5439 remote_unpush_target (void)
5441 pop_all_targets_at_and_above (process_stratum
);
5445 remote_unpush_and_throw (void)
5447 remote_unpush_target ();
5448 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5452 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5454 remote_target
*curr_remote
= get_current_remote_target ();
5457 error (_("To open a remote debug connection, you need to specify what\n"
5458 "serial device is attached to the remote system\n"
5459 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5461 /* If we're connected to a running target, target_preopen will kill it.
5462 Ask this question first, before target_preopen has a chance to kill
5464 if (curr_remote
!= NULL
&& !have_inferiors ())
5467 && !query (_("Already connected to a remote target. Disconnect? ")))
5468 error (_("Still connected."));
5471 /* Here the possibly existing remote target gets unpushed. */
5472 target_preopen (from_tty
);
5474 remote_fileio_reset ();
5475 reopen_exec_file ();
5478 remote_target
*remote
5479 = (extended_p
? new extended_remote_target () : new remote_target ());
5480 target_ops_up
target_holder (remote
);
5482 remote_state
*rs
= remote
->get_remote_state ();
5484 /* See FIXME above. */
5485 if (!target_async_permitted
)
5486 rs
->wait_forever_enabled_p
= 1;
5488 rs
->remote_desc
= remote_serial_open (name
);
5489 if (!rs
->remote_desc
)
5490 perror_with_name (name
);
5492 if (baud_rate
!= -1)
5494 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5496 /* The requested speed could not be set. Error out to
5497 top level after closing remote_desc. Take care to
5498 set remote_desc to NULL to avoid closing remote_desc
5500 serial_close (rs
->remote_desc
);
5501 rs
->remote_desc
= NULL
;
5502 perror_with_name (name
);
5506 serial_setparity (rs
->remote_desc
, serial_parity
);
5507 serial_raw (rs
->remote_desc
);
5509 /* If there is something sitting in the buffer we might take it as a
5510 response to a command, which would be bad. */
5511 serial_flush_input (rs
->remote_desc
);
5515 puts_filtered ("Remote debugging using ");
5516 puts_filtered (name
);
5517 puts_filtered ("\n");
5520 /* Switch to using the remote target now. */
5521 push_target (std::move (target_holder
));
5523 /* Register extra event sources in the event loop. */
5524 rs
->remote_async_inferior_event_token
5525 = create_async_event_handler (remote_async_inferior_event_handler
,
5527 rs
->notif_state
= remote_notif_state_allocate (remote
);
5529 /* Reset the target state; these things will be queried either by
5530 remote_query_supported or as they are needed. */
5531 reset_all_packet_configs_support ();
5532 rs
->cached_wait_status
= 0;
5533 rs
->explicit_packet_size
= 0;
5535 rs
->extended
= extended_p
;
5536 rs
->waiting_for_stop_reply
= 0;
5537 rs
->ctrlc_pending_p
= 0;
5538 rs
->got_ctrlc_during_io
= 0;
5540 rs
->general_thread
= not_sent_ptid
;
5541 rs
->continue_thread
= not_sent_ptid
;
5542 rs
->remote_traceframe_number
= -1;
5544 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5546 /* Probe for ability to use "ThreadInfo" query, as required. */
5547 rs
->use_threadinfo_query
= 1;
5548 rs
->use_threadextra_query
= 1;
5550 rs
->readahead_cache
.invalidate ();
5552 if (target_async_permitted
)
5554 /* FIXME: cagney/1999-09-23: During the initial connection it is
5555 assumed that the target is already ready and able to respond to
5556 requests. Unfortunately remote_start_remote() eventually calls
5557 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5558 around this. Eventually a mechanism that allows
5559 wait_for_inferior() to expect/get timeouts will be
5561 rs
->wait_forever_enabled_p
= 0;
5564 /* First delete any symbols previously loaded from shared libraries. */
5565 no_shared_libraries (NULL
, 0);
5567 /* Start the remote connection. If error() or QUIT, discard this
5568 target (we'd otherwise be in an inconsistent state) and then
5569 propogate the error on up the exception chain. This ensures that
5570 the caller doesn't stumble along blindly assuming that the
5571 function succeeded. The CLI doesn't have this problem but other
5572 UI's, such as MI do.
5574 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5575 this function should return an error indication letting the
5576 caller restore the previous state. Unfortunately the command
5577 ``target remote'' is directly wired to this function making that
5578 impossible. On a positive note, the CLI side of this problem has
5579 been fixed - the function set_cmd_context() makes it possible for
5580 all the ``target ....'' commands to share a common callback
5581 function. See cli-dump.c. */
5586 remote
->start_remote (from_tty
, extended_p
);
5588 catch (const gdb_exception
&ex
)
5590 /* Pop the partially set up target - unless something else did
5591 already before throwing the exception. */
5592 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5593 remote_unpush_target ();
5598 remote_btrace_reset (rs
);
5600 if (target_async_permitted
)
5601 rs
->wait_forever_enabled_p
= 1;
5604 /* Detach the specified process. */
5607 remote_target::remote_detach_pid (int pid
)
5609 struct remote_state
*rs
= get_remote_state ();
5611 /* This should not be necessary, but the handling for D;PID in
5612 GDBserver versions prior to 8.2 incorrectly assumes that the
5613 selected process points to the same process we're detaching,
5614 leading to misbehavior (and possibly GDBserver crashing) when it
5615 does not. Since it's easy and cheap, work around it by forcing
5616 GDBserver to select GDB's current process. */
5617 set_general_process ();
5619 if (remote_multi_process_p (rs
))
5620 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5622 strcpy (rs
->buf
.data (), "D");
5625 getpkt (&rs
->buf
, 0);
5627 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5629 else if (rs
->buf
[0] == '\0')
5630 error (_("Remote doesn't know how to detach"));
5632 error (_("Can't detach process."));
5635 /* This detaches a program to which we previously attached, using
5636 inferior_ptid to identify the process. After this is done, GDB
5637 can be used to debug some other program. We better not have left
5638 any breakpoints in the target program or it'll die when it hits
5642 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5644 int pid
= inferior_ptid
.pid ();
5645 struct remote_state
*rs
= get_remote_state ();
5648 if (!target_has_execution
)
5649 error (_("No process to detach from."));
5651 target_announce_detach (from_tty
);
5653 /* Tell the remote target to detach. */
5654 remote_detach_pid (pid
);
5656 /* Exit only if this is the only active inferior. */
5657 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors () == 1)
5658 puts_filtered (_("Ending remote debugging.\n"));
5660 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
5662 /* Check to see if we are detaching a fork parent. Note that if we
5663 are detaching a fork child, tp == NULL. */
5664 is_fork_parent
= (tp
!= NULL
5665 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5667 /* If doing detach-on-fork, we don't mourn, because that will delete
5668 breakpoints that should be available for the followed inferior. */
5669 if (!is_fork_parent
)
5671 /* Save the pid as a string before mourning, since that will
5672 unpush the remote target, and we need the string after. */
5673 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5675 target_mourn_inferior (inferior_ptid
);
5676 if (print_inferior_events
)
5677 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5678 inf
->num
, infpid
.c_str ());
5682 inferior_ptid
= null_ptid
;
5683 detach_inferior (current_inferior ());
5688 remote_target::detach (inferior
*inf
, int from_tty
)
5690 remote_detach_1 (inf
, from_tty
);
5694 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5696 remote_detach_1 (inf
, from_tty
);
5699 /* Target follow-fork function for remote targets. On entry, and
5700 at return, the current inferior is the fork parent.
5702 Note that although this is currently only used for extended-remote,
5703 it is named remote_follow_fork in anticipation of using it for the
5704 remote target as well. */
5707 remote_target::follow_fork (int follow_child
, int detach_fork
)
5709 struct remote_state
*rs
= get_remote_state ();
5710 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5712 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5713 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5715 /* When following the parent and detaching the child, we detach
5716 the child here. For the case of following the child and
5717 detaching the parent, the detach is done in the target-
5718 independent follow fork code in infrun.c. We can't use
5719 target_detach when detaching an unfollowed child because
5720 the client side doesn't know anything about the child. */
5721 if (detach_fork
&& !follow_child
)
5723 /* Detach the fork child. */
5727 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5728 child_pid
= child_ptid
.pid ();
5730 remote_detach_pid (child_pid
);
5736 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5737 in the program space of the new inferior. On entry and at return the
5738 current inferior is the exec'ing inferior. INF is the new exec'd
5739 inferior, which may be the same as the exec'ing inferior unless
5740 follow-exec-mode is "new". */
5743 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5745 /* We know that this is a target file name, so if it has the "target:"
5746 prefix we strip it off before saving it in the program space. */
5747 if (is_target_filename (execd_pathname
))
5748 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5750 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5753 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5756 remote_target::disconnect (const char *args
, int from_tty
)
5759 error (_("Argument given to \"disconnect\" when remotely debugging."));
5761 /* Make sure we unpush even the extended remote targets. Calling
5762 target_mourn_inferior won't unpush, and remote_mourn won't
5763 unpush if there is more than one inferior left. */
5764 unpush_target (this);
5765 generic_mourn_inferior ();
5768 puts_filtered ("Ending remote debugging.\n");
5771 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5772 be chatty about it. */
5775 extended_remote_target::attach (const char *args
, int from_tty
)
5777 struct remote_state
*rs
= get_remote_state ();
5779 char *wait_status
= NULL
;
5781 pid
= parse_pid_to_attach (args
);
5783 /* Remote PID can be freely equal to getpid, do not check it here the same
5784 way as in other targets. */
5786 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5787 error (_("This target does not support attaching to a process"));
5791 const char *exec_file
= get_exec_file (0);
5794 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5795 target_pid_to_str (ptid_t (pid
)).c_str ());
5797 printf_unfiltered (_("Attaching to %s\n"),
5798 target_pid_to_str (ptid_t (pid
)).c_str ());
5801 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5803 getpkt (&rs
->buf
, 0);
5805 switch (packet_ok (rs
->buf
,
5806 &remote_protocol_packets
[PACKET_vAttach
]))
5809 if (!target_is_non_stop_p ())
5811 /* Save the reply for later. */
5812 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5813 strcpy (wait_status
, rs
->buf
.data ());
5815 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5816 error (_("Attaching to %s failed with: %s"),
5817 target_pid_to_str (ptid_t (pid
)).c_str (),
5820 case PACKET_UNKNOWN
:
5821 error (_("This target does not support attaching to a process"));
5823 error (_("Attaching to %s failed"),
5824 target_pid_to_str (ptid_t (pid
)).c_str ());
5827 set_current_inferior (remote_add_inferior (false, pid
, 1, 0));
5829 inferior_ptid
= ptid_t (pid
);
5831 if (target_is_non_stop_p ())
5833 struct thread_info
*thread
;
5835 /* Get list of threads. */
5836 update_thread_list ();
5838 thread
= first_thread_of_inferior (current_inferior ());
5840 inferior_ptid
= thread
->ptid
;
5842 inferior_ptid
= ptid_t (pid
);
5844 /* Invalidate our notion of the remote current thread. */
5845 record_currthread (rs
, minus_one_ptid
);
5849 /* Now, if we have thread information, update inferior_ptid. */
5850 inferior_ptid
= remote_current_thread (inferior_ptid
);
5852 /* Add the main thread to the thread list. */
5853 thread_info
*thr
= add_thread_silent (inferior_ptid
);
5854 /* Don't consider the thread stopped until we've processed the
5855 saved stop reply. */
5856 set_executing (thr
->ptid
, true);
5859 /* Next, if the target can specify a description, read it. We do
5860 this before anything involving memory or registers. */
5861 target_find_description ();
5863 if (!target_is_non_stop_p ())
5865 /* Use the previously fetched status. */
5866 gdb_assert (wait_status
!= NULL
);
5868 if (target_can_async_p ())
5870 struct notif_event
*reply
5871 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
5873 push_stop_reply ((struct stop_reply
*) reply
);
5879 gdb_assert (wait_status
!= NULL
);
5880 strcpy (rs
->buf
.data (), wait_status
);
5881 rs
->cached_wait_status
= 1;
5885 gdb_assert (wait_status
== NULL
);
5888 /* Implementation of the to_post_attach method. */
5891 extended_remote_target::post_attach (int pid
)
5893 /* Get text, data & bss offsets. */
5896 /* In certain cases GDB might not have had the chance to start
5897 symbol lookup up until now. This could happen if the debugged
5898 binary is not using shared libraries, the vsyscall page is not
5899 present (on Linux) and the binary itself hadn't changed since the
5900 debugging process was started. */
5901 if (symfile_objfile
!= NULL
)
5902 remote_check_symbols();
5906 /* Check for the availability of vCont. This function should also check
5910 remote_target::remote_vcont_probe ()
5912 remote_state
*rs
= get_remote_state ();
5915 strcpy (rs
->buf
.data (), "vCont?");
5917 getpkt (&rs
->buf
, 0);
5918 buf
= rs
->buf
.data ();
5920 /* Make sure that the features we assume are supported. */
5921 if (startswith (buf
, "vCont"))
5924 int support_c
, support_C
;
5926 rs
->supports_vCont
.s
= 0;
5927 rs
->supports_vCont
.S
= 0;
5930 rs
->supports_vCont
.t
= 0;
5931 rs
->supports_vCont
.r
= 0;
5932 while (p
&& *p
== ';')
5935 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5936 rs
->supports_vCont
.s
= 1;
5937 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5938 rs
->supports_vCont
.S
= 1;
5939 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5941 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5943 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5944 rs
->supports_vCont
.t
= 1;
5945 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5946 rs
->supports_vCont
.r
= 1;
5948 p
= strchr (p
, ';');
5951 /* If c, and C are not all supported, we can't use vCont. Clearing
5952 BUF will make packet_ok disable the packet. */
5953 if (!support_c
|| !support_C
)
5957 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
5960 /* Helper function for building "vCont" resumptions. Write a
5961 resumption to P. ENDP points to one-passed-the-end of the buffer
5962 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
5963 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5964 resumed thread should be single-stepped and/or signalled. If PTID
5965 equals minus_one_ptid, then all threads are resumed; if PTID
5966 represents a process, then all threads of the process are resumed;
5967 the thread to be stepped and/or signalled is given in the global
5971 remote_target::append_resumption (char *p
, char *endp
,
5972 ptid_t ptid
, int step
, gdb_signal siggnal
)
5974 struct remote_state
*rs
= get_remote_state ();
5976 if (step
&& siggnal
!= GDB_SIGNAL_0
)
5977 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
5979 /* GDB is willing to range step. */
5980 && use_range_stepping
5981 /* Target supports range stepping. */
5982 && rs
->supports_vCont
.r
5983 /* We don't currently support range stepping multiple
5984 threads with a wildcard (though the protocol allows it,
5985 so stubs shouldn't make an active effort to forbid
5987 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
5989 struct thread_info
*tp
;
5991 if (ptid
== minus_one_ptid
)
5993 /* If we don't know about the target thread's tid, then
5994 we're resuming magic_null_ptid (see caller). */
5995 tp
= find_thread_ptid (magic_null_ptid
);
5998 tp
= find_thread_ptid (ptid
);
5999 gdb_assert (tp
!= NULL
);
6001 if (tp
->control
.may_range_step
)
6003 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6005 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6006 phex_nz (tp
->control
.step_range_start
,
6008 phex_nz (tp
->control
.step_range_end
,
6012 p
+= xsnprintf (p
, endp
- p
, ";s");
6015 p
+= xsnprintf (p
, endp
- p
, ";s");
6016 else if (siggnal
!= GDB_SIGNAL_0
)
6017 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6019 p
+= xsnprintf (p
, endp
- p
, ";c");
6021 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6025 /* All (-1) threads of process. */
6026 nptid
= ptid_t (ptid
.pid (), -1, 0);
6028 p
+= xsnprintf (p
, endp
- p
, ":");
6029 p
= write_ptid (p
, endp
, nptid
);
6031 else if (ptid
!= minus_one_ptid
)
6033 p
+= xsnprintf (p
, endp
- p
, ":");
6034 p
= write_ptid (p
, endp
, ptid
);
6040 /* Clear the thread's private info on resume. */
6043 resume_clear_thread_private_info (struct thread_info
*thread
)
6045 if (thread
->priv
!= NULL
)
6047 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6049 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6050 priv
->watch_data_address
= 0;
6054 /* Append a vCont continue-with-signal action for threads that have a
6055 non-zero stop signal. */
6058 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6061 for (thread_info
*thread
: all_non_exited_threads (ptid
))
6062 if (inferior_ptid
!= thread
->ptid
6063 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6065 p
= append_resumption (p
, endp
, thread
->ptid
,
6066 0, thread
->suspend
.stop_signal
);
6067 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6068 resume_clear_thread_private_info (thread
);
6074 /* Set the target running, using the packets that use Hc
6078 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6081 struct remote_state
*rs
= get_remote_state ();
6084 rs
->last_sent_signal
= siggnal
;
6085 rs
->last_sent_step
= step
;
6087 /* The c/s/C/S resume packets use Hc, so set the continue
6089 if (ptid
== minus_one_ptid
)
6090 set_continue_thread (any_thread_ptid
);
6092 set_continue_thread (ptid
);
6094 for (thread_info
*thread
: all_non_exited_threads ())
6095 resume_clear_thread_private_info (thread
);
6097 buf
= rs
->buf
.data ();
6098 if (::execution_direction
== EXEC_REVERSE
)
6100 /* We don't pass signals to the target in reverse exec mode. */
6101 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6102 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6105 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6106 error (_("Remote reverse-step not supported."));
6107 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6108 error (_("Remote reverse-continue not supported."));
6110 strcpy (buf
, step
? "bs" : "bc");
6112 else if (siggnal
!= GDB_SIGNAL_0
)
6114 buf
[0] = step
? 'S' : 'C';
6115 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6116 buf
[2] = tohex (((int) siggnal
) & 0xf);
6120 strcpy (buf
, step
? "s" : "c");
6125 /* Resume the remote inferior by using a "vCont" packet. The thread
6126 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6127 resumed thread should be single-stepped and/or signalled. If PTID
6128 equals minus_one_ptid, then all threads are resumed; the thread to
6129 be stepped and/or signalled is given in the global INFERIOR_PTID.
6130 This function returns non-zero iff it resumes the inferior.
6132 This function issues a strict subset of all possible vCont commands
6136 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6137 enum gdb_signal siggnal
)
6139 struct remote_state
*rs
= get_remote_state ();
6143 /* No reverse execution actions defined for vCont. */
6144 if (::execution_direction
== EXEC_REVERSE
)
6147 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6148 remote_vcont_probe ();
6150 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6153 p
= rs
->buf
.data ();
6154 endp
= p
+ get_remote_packet_size ();
6156 /* If we could generate a wider range of packets, we'd have to worry
6157 about overflowing BUF. Should there be a generic
6158 "multi-part-packet" packet? */
6160 p
+= xsnprintf (p
, endp
- p
, "vCont");
6162 if (ptid
== magic_null_ptid
)
6164 /* MAGIC_NULL_PTID means that we don't have any active threads,
6165 so we don't have any TID numbers the inferior will
6166 understand. Make sure to only send forms that do not specify
6168 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6170 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6172 /* Resume all threads (of all processes, or of a single
6173 process), with preference for INFERIOR_PTID. This assumes
6174 inferior_ptid belongs to the set of all threads we are about
6176 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6178 /* Step inferior_ptid, with or without signal. */
6179 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6182 /* Also pass down any pending signaled resumption for other
6183 threads not the current. */
6184 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6186 /* And continue others without a signal. */
6187 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6191 /* Scheduler locking; resume only PTID. */
6192 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6195 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6198 if (target_is_non_stop_p ())
6200 /* In non-stop, the stub replies to vCont with "OK". The stop
6201 reply will be reported asynchronously by means of a `%Stop'
6203 getpkt (&rs
->buf
, 0);
6204 if (strcmp (rs
->buf
.data (), "OK") != 0)
6205 error (_("Unexpected vCont reply in non-stop mode: %s"),
6212 /* Tell the remote machine to resume. */
6215 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6217 struct remote_state
*rs
= get_remote_state ();
6219 /* When connected in non-stop mode, the core resumes threads
6220 individually. Resuming remote threads directly in target_resume
6221 would thus result in sending one packet per thread. Instead, to
6222 minimize roundtrip latency, here we just store the resume
6223 request; the actual remote resumption will be done in
6224 target_commit_resume / remote_commit_resume, where we'll be able
6225 to do vCont action coalescing. */
6226 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6228 remote_thread_info
*remote_thr
;
6230 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6231 remote_thr
= get_remote_thread_info (inferior_ptid
);
6233 remote_thr
= get_remote_thread_info (ptid
);
6235 remote_thr
->last_resume_step
= step
;
6236 remote_thr
->last_resume_sig
= siggnal
;
6240 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6241 (explained in remote-notif.c:handle_notification) so
6242 remote_notif_process is not called. We need find a place where
6243 it is safe to start a 'vNotif' sequence. It is good to do it
6244 before resuming inferior, because inferior was stopped and no RSP
6245 traffic at that moment. */
6246 if (!target_is_non_stop_p ())
6247 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6249 rs
->last_resume_exec_dir
= ::execution_direction
;
6251 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6252 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6253 remote_resume_with_hc (ptid
, step
, siggnal
);
6255 /* We are about to start executing the inferior, let's register it
6256 with the event loop. NOTE: this is the one place where all the
6257 execution commands end up. We could alternatively do this in each
6258 of the execution commands in infcmd.c. */
6259 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6260 into infcmd.c in order to allow inferior function calls to work
6261 NOT asynchronously. */
6262 if (target_can_async_p ())
6265 /* We've just told the target to resume. The remote server will
6266 wait for the inferior to stop, and then send a stop reply. In
6267 the mean time, we can't start another command/query ourselves
6268 because the stub wouldn't be ready to process it. This applies
6269 only to the base all-stop protocol, however. In non-stop (which
6270 only supports vCont), the stub replies with an "OK", and is
6271 immediate able to process further serial input. */
6272 if (!target_is_non_stop_p ())
6273 rs
->waiting_for_stop_reply
= 1;
6276 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6278 /* Private per-inferior info for target remote processes. */
6280 struct remote_inferior
: public private_inferior
6282 /* Whether we can send a wildcard vCont for this process. */
6283 bool may_wildcard_vcont
= true;
6286 /* Get the remote private inferior data associated to INF. */
6288 static remote_inferior
*
6289 get_remote_inferior (inferior
*inf
)
6291 if (inf
->priv
== NULL
)
6292 inf
->priv
.reset (new remote_inferior
);
6294 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6297 /* Class used to track the construction of a vCont packet in the
6298 outgoing packet buffer. This is used to send multiple vCont
6299 packets if we have more actions than would fit a single packet. */
6304 explicit vcont_builder (remote_target
*remote
)
6311 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6316 /* The remote target. */
6317 remote_target
*m_remote
;
6319 /* Pointer to the first action. P points here if no action has been
6321 char *m_first_action
;
6323 /* Where the next action will be appended. */
6326 /* The end of the buffer. Must never write past this. */
6330 /* Prepare the outgoing buffer for a new vCont packet. */
6333 vcont_builder::restart ()
6335 struct remote_state
*rs
= m_remote
->get_remote_state ();
6337 m_p
= rs
->buf
.data ();
6338 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6339 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6340 m_first_action
= m_p
;
6343 /* If the vCont packet being built has any action, send it to the
6347 vcont_builder::flush ()
6349 struct remote_state
*rs
;
6351 if (m_p
== m_first_action
)
6354 rs
= m_remote
->get_remote_state ();
6355 m_remote
->putpkt (rs
->buf
);
6356 m_remote
->getpkt (&rs
->buf
, 0);
6357 if (strcmp (rs
->buf
.data (), "OK") != 0)
6358 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6361 /* The largest action is range-stepping, with its two addresses. This
6362 is more than sufficient. If a new, bigger action is created, it'll
6363 quickly trigger a failed assertion in append_resumption (and we'll
6365 #define MAX_ACTION_SIZE 200
6367 /* Append a new vCont action in the outgoing packet being built. If
6368 the action doesn't fit the packet along with previous actions, push
6369 what we've got so far to the remote end and start over a new vCont
6370 packet (with the new action). */
6373 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6375 char buf
[MAX_ACTION_SIZE
+ 1];
6377 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6378 ptid
, step
, siggnal
);
6380 /* Check whether this new action would fit in the vCont packet along
6381 with previous actions. If not, send what we've got so far and
6382 start a new vCont packet. */
6383 size_t rsize
= endp
- buf
;
6384 if (rsize
> m_endp
- m_p
)
6389 /* Should now fit. */
6390 gdb_assert (rsize
<= m_endp
- m_p
);
6393 memcpy (m_p
, buf
, rsize
);
6398 /* to_commit_resume implementation. */
6401 remote_target::commit_resume ()
6403 int any_process_wildcard
;
6404 int may_global_wildcard_vcont
;
6406 /* If connected in all-stop mode, we'd send the remote resume
6407 request directly from remote_resume. Likewise if
6408 reverse-debugging, as there are no defined vCont actions for
6409 reverse execution. */
6410 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6413 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6414 instead of resuming all threads of each process individually.
6415 However, if any thread of a process must remain halted, we can't
6416 send wildcard resumes and must send one action per thread.
6418 Care must be taken to not resume threads/processes the server
6419 side already told us are stopped, but the core doesn't know about
6420 yet, because the events are still in the vStopped notification
6423 #1 => vCont s:p1.1;c
6425 #3 <= %Stopped T05 p1.1
6430 #8 (infrun handles the stop for p1.1 and continues stepping)
6431 #9 => vCont s:p1.1;c
6433 The last vCont above would resume thread p1.2 by mistake, because
6434 the server has no idea that the event for p1.2 had not been
6437 The server side must similarly ignore resume actions for the
6438 thread that has a pending %Stopped notification (and any other
6439 threads with events pending), until GDB acks the notification
6440 with vStopped. Otherwise, e.g., the following case is
6443 #1 => g (or any other packet)
6445 #3 <= %Stopped T05 p1.2
6446 #4 => vCont s:p1.1;c
6449 Above, the server must not resume thread p1.2. GDB can't know
6450 that p1.2 stopped until it acks the %Stopped notification, and
6451 since from GDB's perspective all threads should be running, it
6454 Finally, special care must also be given to handling fork/vfork
6455 events. A (v)fork event actually tells us that two processes
6456 stopped -- the parent and the child. Until we follow the fork,
6457 we must not resume the child. Therefore, if we have a pending
6458 fork follow, we must not send a global wildcard resume action
6459 (vCont;c). We can still send process-wide wildcards though. */
6461 /* Start by assuming a global wildcard (vCont;c) is possible. */
6462 may_global_wildcard_vcont
= 1;
6464 /* And assume every process is individually wildcard-able too. */
6465 for (inferior
*inf
: all_non_exited_inferiors ())
6467 remote_inferior
*priv
= get_remote_inferior (inf
);
6469 priv
->may_wildcard_vcont
= true;
6472 /* Check for any pending events (not reported or processed yet) and
6473 disable process and global wildcard resumes appropriately. */
6474 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6476 for (thread_info
*tp
: all_non_exited_threads ())
6478 /* If a thread of a process is not meant to be resumed, then we
6479 can't wildcard that process. */
6482 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6484 /* And if we can't wildcard a process, we can't wildcard
6485 everything either. */
6486 may_global_wildcard_vcont
= 0;
6490 /* If a thread is the parent of an unfollowed fork, then we
6491 can't do a global wildcard, as that would resume the fork
6493 if (is_pending_fork_parent_thread (tp
))
6494 may_global_wildcard_vcont
= 0;
6497 /* Now let's build the vCont packet(s). Actions must be appended
6498 from narrower to wider scopes (thread -> process -> global). If
6499 we end up with too many actions for a single packet vcont_builder
6500 flushes the current vCont packet to the remote side and starts a
6502 struct vcont_builder
vcont_builder (this);
6504 /* Threads first. */
6505 for (thread_info
*tp
: all_non_exited_threads ())
6507 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6509 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6512 gdb_assert (!thread_is_in_step_over_chain (tp
));
6514 if (!remote_thr
->last_resume_step
6515 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6516 && get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6518 /* We'll send a wildcard resume instead. */
6519 remote_thr
->vcont_resumed
= 1;
6523 vcont_builder
.push_action (tp
->ptid
,
6524 remote_thr
->last_resume_step
,
6525 remote_thr
->last_resume_sig
);
6526 remote_thr
->vcont_resumed
= 1;
6529 /* Now check whether we can send any process-wide wildcard. This is
6530 to avoid sending a global wildcard in the case nothing is
6531 supposed to be resumed. */
6532 any_process_wildcard
= 0;
6534 for (inferior
*inf
: all_non_exited_inferiors ())
6536 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6538 any_process_wildcard
= 1;
6543 if (any_process_wildcard
)
6545 /* If all processes are wildcard-able, then send a single "c"
6546 action, otherwise, send an "all (-1) threads of process"
6547 continue action for each running process, if any. */
6548 if (may_global_wildcard_vcont
)
6550 vcont_builder
.push_action (minus_one_ptid
,
6551 false, GDB_SIGNAL_0
);
6555 for (inferior
*inf
: all_non_exited_inferiors ())
6557 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6559 vcont_builder
.push_action (ptid_t (inf
->pid
),
6560 false, GDB_SIGNAL_0
);
6566 vcont_builder
.flush ();
6571 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6572 thread, all threads of a remote process, or all threads of all
6576 remote_target::remote_stop_ns (ptid_t ptid
)
6578 struct remote_state
*rs
= get_remote_state ();
6579 char *p
= rs
->buf
.data ();
6580 char *endp
= p
+ get_remote_packet_size ();
6582 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6583 remote_vcont_probe ();
6585 if (!rs
->supports_vCont
.t
)
6586 error (_("Remote server does not support stopping threads"));
6588 if (ptid
== minus_one_ptid
6589 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6590 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6595 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6598 /* All (-1) threads of process. */
6599 nptid
= ptid_t (ptid
.pid (), -1, 0);
6602 /* Small optimization: if we already have a stop reply for
6603 this thread, no use in telling the stub we want this
6605 if (peek_stop_reply (ptid
))
6611 write_ptid (p
, endp
, nptid
);
6614 /* In non-stop, we get an immediate OK reply. The stop reply will
6615 come in asynchronously by notification. */
6617 getpkt (&rs
->buf
, 0);
6618 if (strcmp (rs
->buf
.data (), "OK") != 0)
6619 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6623 /* All-stop version of target_interrupt. Sends a break or a ^C to
6624 interrupt the remote target. It is undefined which thread of which
6625 process reports the interrupt. */
6628 remote_target::remote_interrupt_as ()
6630 struct remote_state
*rs
= get_remote_state ();
6632 rs
->ctrlc_pending_p
= 1;
6634 /* If the inferior is stopped already, but the core didn't know
6635 about it yet, just ignore the request. The cached wait status
6636 will be collected in remote_wait. */
6637 if (rs
->cached_wait_status
)
6640 /* Send interrupt_sequence to remote target. */
6641 send_interrupt_sequence ();
6644 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6645 the remote target. It is undefined which thread of which process
6646 reports the interrupt. Throws an error if the packet is not
6647 supported by the server. */
6650 remote_target::remote_interrupt_ns ()
6652 struct remote_state
*rs
= get_remote_state ();
6653 char *p
= rs
->buf
.data ();
6654 char *endp
= p
+ get_remote_packet_size ();
6656 xsnprintf (p
, endp
- p
, "vCtrlC");
6658 /* In non-stop, we get an immediate OK reply. The stop reply will
6659 come in asynchronously by notification. */
6661 getpkt (&rs
->buf
, 0);
6663 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6667 case PACKET_UNKNOWN
:
6668 error (_("No support for interrupting the remote target."));
6670 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6674 /* Implement the to_stop function for the remote targets. */
6677 remote_target::stop (ptid_t ptid
)
6680 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6682 if (target_is_non_stop_p ())
6683 remote_stop_ns (ptid
);
6686 /* We don't currently have a way to transparently pause the
6687 remote target in all-stop mode. Interrupt it instead. */
6688 remote_interrupt_as ();
6692 /* Implement the to_interrupt function for the remote targets. */
6695 remote_target::interrupt ()
6698 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6700 if (target_is_non_stop_p ())
6701 remote_interrupt_ns ();
6703 remote_interrupt_as ();
6706 /* Implement the to_pass_ctrlc function for the remote targets. */
6709 remote_target::pass_ctrlc ()
6711 struct remote_state
*rs
= get_remote_state ();
6714 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6716 /* If we're starting up, we're not fully synced yet. Quit
6718 if (rs
->starting_up
)
6720 /* If ^C has already been sent once, offer to disconnect. */
6721 else if (rs
->ctrlc_pending_p
)
6724 target_interrupt ();
6727 /* Ask the user what to do when an interrupt is received. */
6730 remote_target::interrupt_query ()
6732 struct remote_state
*rs
= get_remote_state ();
6734 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6736 if (query (_("The target is not responding to interrupt requests.\n"
6737 "Stop debugging it? ")))
6739 remote_unpush_target ();
6740 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6745 if (query (_("Interrupted while waiting for the program.\n"
6746 "Give up waiting? ")))
6751 /* Enable/disable target terminal ownership. Most targets can use
6752 terminal groups to control terminal ownership. Remote targets are
6753 different in that explicit transfer of ownership to/from GDB/target
6757 remote_target::terminal_inferior ()
6759 /* NOTE: At this point we could also register our selves as the
6760 recipient of all input. Any characters typed could then be
6761 passed on down to the target. */
6765 remote_target::terminal_ours ()
6770 remote_console_output (const char *msg
)
6774 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6777 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6781 fputs_unfiltered (tb
, gdb_stdtarg
);
6783 gdb_flush (gdb_stdtarg
);
6786 struct stop_reply
: public notif_event
6790 /* The identifier of the thread about this event */
6793 /* The remote state this event is associated with. When the remote
6794 connection, represented by a remote_state object, is closed,
6795 all the associated stop_reply events should be released. */
6796 struct remote_state
*rs
;
6798 struct target_waitstatus ws
;
6800 /* The architecture associated with the expedited registers. */
6803 /* Expedited registers. This makes remote debugging a bit more
6804 efficient for those targets that provide critical registers as
6805 part of their normal status mechanism (as another roundtrip to
6806 fetch them is avoided). */
6807 std::vector
<cached_reg_t
> regcache
;
6809 enum target_stop_reason stop_reason
;
6811 CORE_ADDR watch_data_address
;
6816 /* Return the length of the stop reply queue. */
6819 remote_target::stop_reply_queue_length ()
6821 remote_state
*rs
= get_remote_state ();
6822 return rs
->stop_reply_queue
.size ();
6826 remote_notif_stop_parse (remote_target
*remote
,
6827 struct notif_client
*self
, const char *buf
,
6828 struct notif_event
*event
)
6830 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6834 remote_notif_stop_ack (remote_target
*remote
,
6835 struct notif_client
*self
, const char *buf
,
6836 struct notif_event
*event
)
6838 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6841 putpkt (remote
, self
->ack_command
);
6843 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6845 /* We got an unknown stop reply. */
6846 error (_("Unknown stop reply"));
6849 remote
->push_stop_reply (stop_reply
);
6853 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
6854 struct notif_client
*self
)
6856 /* We can't get pending events in remote_notif_process for
6857 notification stop, and we have to do this in remote_wait_ns
6858 instead. If we fetch all queued events from stub, remote stub
6859 may exit and we have no chance to process them back in
6861 remote_state
*rs
= remote
->get_remote_state ();
6862 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
6866 stop_reply::~stop_reply ()
6868 for (cached_reg_t
®
: regcache
)
6872 static notif_event_up
6873 remote_notif_stop_alloc_reply ()
6875 return notif_event_up (new struct stop_reply ());
6878 /* A client of notification Stop. */
6880 struct notif_client notif_client_stop
=
6884 remote_notif_stop_parse
,
6885 remote_notif_stop_ack
,
6886 remote_notif_stop_can_get_pending_events
,
6887 remote_notif_stop_alloc_reply
,
6891 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6892 the pid of the process that owns the threads we want to check, or
6893 -1 if we want to check all threads. */
6896 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6899 if (ws
->kind
== TARGET_WAITKIND_FORKED
6900 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6902 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
6909 /* Return the thread's pending status used to determine whether the
6910 thread is a fork parent stopped at a fork event. */
6912 static struct target_waitstatus
*
6913 thread_pending_fork_status (struct thread_info
*thread
)
6915 if (thread
->suspend
.waitstatus_pending_p
)
6916 return &thread
->suspend
.waitstatus
;
6918 return &thread
->pending_follow
;
6921 /* Determine if THREAD is a pending fork parent thread. */
6924 is_pending_fork_parent_thread (struct thread_info
*thread
)
6926 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6929 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6932 /* If CONTEXT contains any fork child threads that have not been
6933 reported yet, remove them from the CONTEXT list. If such a
6934 thread exists it is because we are stopped at a fork catchpoint
6935 and have not yet called follow_fork, which will set up the
6936 host-side data structures for the new process. */
6939 remote_target::remove_new_fork_children (threads_listing_context
*context
)
6942 struct notif_client
*notif
= ¬if_client_stop
;
6944 /* For any threads stopped at a fork event, remove the corresponding
6945 fork child threads from the CONTEXT list. */
6946 for (thread_info
*thread
: all_non_exited_threads ())
6948 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6950 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
6951 context
->remove_thread (ws
->value
.related_pid
);
6954 /* Check for any pending fork events (not reported or processed yet)
6955 in process PID and remove those fork child threads from the
6956 CONTEXT list as well. */
6957 remote_notif_get_pending_events (notif
);
6958 for (auto &event
: get_remote_state ()->stop_reply_queue
)
6959 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6960 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
6961 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
6962 context
->remove_thread (event
->ws
.value
.related_pid
);
6965 /* Check whether any event pending in the vStopped queue would prevent
6966 a global or process wildcard vCont action. Clear
6967 *may_global_wildcard if we can't do a global wildcard (vCont;c),
6968 and clear the event inferior's may_wildcard_vcont flag if we can't
6969 do a process-wide wildcard resume (vCont;c:pPID.-1). */
6972 remote_target::check_pending_events_prevent_wildcard_vcont
6973 (int *may_global_wildcard
)
6975 struct notif_client
*notif
= ¬if_client_stop
;
6977 remote_notif_get_pending_events (notif
);
6978 for (auto &event
: get_remote_state ()->stop_reply_queue
)
6980 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
6981 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
6984 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6985 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
6986 *may_global_wildcard
= 0;
6988 struct inferior
*inf
= find_inferior_ptid (event
->ptid
);
6990 /* This may be the first time we heard about this process.
6991 Regardless, we must not do a global wildcard resume, otherwise
6992 we'd resume this process too. */
6993 *may_global_wildcard
= 0;
6995 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
6999 /* Discard all pending stop replies of inferior INF. */
7002 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7004 struct stop_reply
*reply
;
7005 struct remote_state
*rs
= get_remote_state ();
7006 struct remote_notif_state
*rns
= rs
->notif_state
;
7008 /* This function can be notified when an inferior exists. When the
7009 target is not remote, the notification state is NULL. */
7010 if (rs
->remote_desc
== NULL
)
7013 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7015 /* Discard the in-flight notification. */
7016 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7019 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7022 /* Discard the stop replies we have already pulled with
7024 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7025 rs
->stop_reply_queue
.end (),
7026 [=] (const stop_reply_up
&event
)
7028 return event
->ptid
.pid () == inf
->pid
;
7030 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7033 /* Discard the stop replies for RS in stop_reply_queue. */
7036 remote_target::discard_pending_stop_replies_in_queue ()
7038 remote_state
*rs
= get_remote_state ();
7040 /* Discard the stop replies we have already pulled with
7042 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7043 rs
->stop_reply_queue
.end (),
7044 [=] (const stop_reply_up
&event
)
7046 return event
->rs
== rs
;
7048 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7051 /* Remove the first reply in 'stop_reply_queue' which matches
7055 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7057 remote_state
*rs
= get_remote_state ();
7059 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7060 rs
->stop_reply_queue
.end (),
7061 [=] (const stop_reply_up
&event
)
7063 return event
->ptid
.matches (ptid
);
7065 struct stop_reply
*result
;
7066 if (iter
== rs
->stop_reply_queue
.end ())
7070 result
= iter
->release ();
7071 rs
->stop_reply_queue
.erase (iter
);
7075 fprintf_unfiltered (gdb_stdlog
,
7076 "notif: discard queued event: 'Stop' in %s\n",
7077 target_pid_to_str (ptid
).c_str ());
7082 /* Look for a queued stop reply belonging to PTID. If one is found,
7083 remove it from the queue, and return it. Returns NULL if none is
7084 found. If there are still queued events left to process, tell the
7085 event loop to get back to target_wait soon. */
7088 remote_target::queued_stop_reply (ptid_t ptid
)
7090 remote_state
*rs
= get_remote_state ();
7091 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7093 if (!rs
->stop_reply_queue
.empty ())
7095 /* There's still at least an event left. */
7096 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7102 /* Push a fully parsed stop reply in the stop reply queue. Since we
7103 know that we now have at least one queued event left to pass to the
7104 core side, tell the event loop to get back to target_wait soon. */
7107 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7109 remote_state
*rs
= get_remote_state ();
7110 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7113 fprintf_unfiltered (gdb_stdlog
,
7114 "notif: push 'Stop' %s to queue %d\n",
7115 target_pid_to_str (new_event
->ptid
).c_str (),
7116 int (rs
->stop_reply_queue
.size ()));
7118 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7121 /* Returns true if we have a stop reply for PTID. */
7124 remote_target::peek_stop_reply (ptid_t ptid
)
7126 remote_state
*rs
= get_remote_state ();
7127 for (auto &event
: rs
->stop_reply_queue
)
7128 if (ptid
== event
->ptid
7129 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7134 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7135 starting with P and ending with PEND matches PREFIX. */
7138 strprefix (const char *p
, const char *pend
, const char *prefix
)
7140 for ( ; p
< pend
; p
++, prefix
++)
7143 return *prefix
== '\0';
7146 /* Parse the stop reply in BUF. Either the function succeeds, and the
7147 result is stored in EVENT, or throws an error. */
7150 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7152 remote_arch_state
*rsa
= NULL
;
7157 event
->ptid
= null_ptid
;
7158 event
->rs
= get_remote_state ();
7159 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7160 event
->ws
.value
.integer
= 0;
7161 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7162 event
->regcache
.clear ();
7167 case 'T': /* Status with PC, SP, FP, ... */
7168 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7169 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7171 n... = register number
7172 r... = register contents
7175 p
= &buf
[3]; /* after Txx */
7181 p1
= strchr (p
, ':');
7183 error (_("Malformed packet(a) (missing colon): %s\n\
7187 error (_("Malformed packet(a) (missing register number): %s\n\
7191 /* Some "registers" are actually extended stop information.
7192 Note if you're adding a new entry here: GDB 7.9 and
7193 earlier assume that all register "numbers" that start
7194 with an hex digit are real register numbers. Make sure
7195 the server only sends such a packet if it knows the
7196 client understands it. */
7198 if (strprefix (p
, p1
, "thread"))
7199 event
->ptid
= read_ptid (++p1
, &p
);
7200 else if (strprefix (p
, p1
, "syscall_entry"))
7204 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7205 p
= unpack_varlen_hex (++p1
, &sysno
);
7206 event
->ws
.value
.syscall_number
= (int) sysno
;
7208 else if (strprefix (p
, p1
, "syscall_return"))
7212 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7213 p
= unpack_varlen_hex (++p1
, &sysno
);
7214 event
->ws
.value
.syscall_number
= (int) sysno
;
7216 else if (strprefix (p
, p1
, "watch")
7217 || strprefix (p
, p1
, "rwatch")
7218 || strprefix (p
, p1
, "awatch"))
7220 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7221 p
= unpack_varlen_hex (++p1
, &addr
);
7222 event
->watch_data_address
= (CORE_ADDR
) addr
;
7224 else if (strprefix (p
, p1
, "swbreak"))
7226 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7228 /* Make sure the stub doesn't forget to indicate support
7230 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7231 error (_("Unexpected swbreak stop reason"));
7233 /* The value part is documented as "must be empty",
7234 though we ignore it, in case we ever decide to make
7235 use of it in a backward compatible way. */
7236 p
= strchrnul (p1
+ 1, ';');
7238 else if (strprefix (p
, p1
, "hwbreak"))
7240 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7242 /* Make sure the stub doesn't forget to indicate support
7244 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7245 error (_("Unexpected hwbreak stop reason"));
7248 p
= strchrnul (p1
+ 1, ';');
7250 else if (strprefix (p
, p1
, "library"))
7252 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7253 p
= strchrnul (p1
+ 1, ';');
7255 else if (strprefix (p
, p1
, "replaylog"))
7257 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7258 /* p1 will indicate "begin" or "end", but it makes
7259 no difference for now, so ignore it. */
7260 p
= strchrnul (p1
+ 1, ';');
7262 else if (strprefix (p
, p1
, "core"))
7266 p
= unpack_varlen_hex (++p1
, &c
);
7269 else if (strprefix (p
, p1
, "fork"))
7271 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7272 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7274 else if (strprefix (p
, p1
, "vfork"))
7276 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7277 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7279 else if (strprefix (p
, p1
, "vforkdone"))
7281 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7282 p
= strchrnul (p1
+ 1, ';');
7284 else if (strprefix (p
, p1
, "exec"))
7289 /* Determine the length of the execd pathname. */
7290 p
= unpack_varlen_hex (++p1
, &ignored
);
7291 pathlen
= (p
- p1
) / 2;
7293 /* Save the pathname for event reporting and for
7294 the next run command. */
7295 gdb::unique_xmalloc_ptr
<char[]> pathname
7296 ((char *) xmalloc (pathlen
+ 1));
7297 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7298 pathname
[pathlen
] = '\0';
7300 /* This is freed during event handling. */
7301 event
->ws
.value
.execd_pathname
= pathname
.release ();
7302 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7304 /* Skip the registers included in this packet, since
7305 they may be for an architecture different from the
7306 one used by the original program. */
7309 else if (strprefix (p
, p1
, "create"))
7311 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7312 p
= strchrnul (p1
+ 1, ';');
7321 p
= strchrnul (p1
+ 1, ';');
7326 /* Maybe a real ``P'' register number. */
7327 p_temp
= unpack_varlen_hex (p
, &pnum
);
7328 /* If the first invalid character is the colon, we got a
7329 register number. Otherwise, it's an unknown stop
7333 /* If we haven't parsed the event's thread yet, find
7334 it now, in order to find the architecture of the
7335 reported expedited registers. */
7336 if (event
->ptid
== null_ptid
)
7338 const char *thr
= strstr (p1
+ 1, ";thread:");
7340 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7344 /* Either the current thread hasn't changed,
7345 or the inferior is not multi-threaded.
7346 The event must be for the thread we last
7347 set as (or learned as being) current. */
7348 event
->ptid
= event
->rs
->general_thread
;
7354 inferior
*inf
= (event
->ptid
== null_ptid
7356 : find_inferior_ptid (event
->ptid
));
7357 /* If this is the first time we learn anything
7358 about this process, skip the registers
7359 included in this packet, since we don't yet
7360 know which architecture to use to parse them.
7361 We'll determine the architecture later when
7362 we process the stop reply and retrieve the
7363 target description, via
7364 remote_notice_new_inferior ->
7365 post_create_inferior. */
7368 p
= strchrnul (p1
+ 1, ';');
7373 event
->arch
= inf
->gdbarch
;
7374 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7378 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7379 cached_reg_t cached_reg
;
7382 error (_("Remote sent bad register number %s: %s\n\
7384 hex_string (pnum
), p
, buf
);
7386 cached_reg
.num
= reg
->regnum
;
7387 cached_reg
.data
= (gdb_byte
*)
7388 xmalloc (register_size (event
->arch
, reg
->regnum
));
7391 fieldsize
= hex2bin (p
, cached_reg
.data
,
7392 register_size (event
->arch
, reg
->regnum
));
7394 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7395 warning (_("Remote reply is too short: %s"), buf
);
7397 event
->regcache
.push_back (cached_reg
);
7401 /* Not a number. Silently skip unknown optional
7403 p
= strchrnul (p1
+ 1, ';');
7408 error (_("Remote register badly formatted: %s\nhere: %s"),
7413 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7417 case 'S': /* Old style status, just signal only. */
7421 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7422 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7423 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7424 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7426 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7429 case 'w': /* Thread exited. */
7433 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7434 p
= unpack_varlen_hex (&buf
[1], &value
);
7435 event
->ws
.value
.integer
= value
;
7437 error (_("stop reply packet badly formatted: %s"), buf
);
7438 event
->ptid
= read_ptid (++p
, NULL
);
7441 case 'W': /* Target exited. */
7447 /* GDB used to accept only 2 hex chars here. Stubs should
7448 only send more if they detect GDB supports multi-process
7450 p
= unpack_varlen_hex (&buf
[1], &value
);
7454 /* The remote process exited. */
7455 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7456 event
->ws
.value
.integer
= value
;
7460 /* The remote process exited with a signal. */
7461 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7462 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7463 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7465 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7468 /* If no process is specified, assume inferior_ptid. */
7469 pid
= inferior_ptid
.pid ();
7478 else if (startswith (p
, "process:"))
7482 p
+= sizeof ("process:") - 1;
7483 unpack_varlen_hex (p
, &upid
);
7487 error (_("unknown stop reply packet: %s"), buf
);
7490 error (_("unknown stop reply packet: %s"), buf
);
7491 event
->ptid
= ptid_t (pid
);
7495 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7496 event
->ptid
= minus_one_ptid
;
7500 if (target_is_non_stop_p () && event
->ptid
== null_ptid
)
7501 error (_("No process or thread specified in stop reply: %s"), buf
);
7504 /* When the stub wants to tell GDB about a new notification reply, it
7505 sends a notification (%Stop, for example). Those can come it at
7506 any time, hence, we have to make sure that any pending
7507 putpkt/getpkt sequence we're making is finished, before querying
7508 the stub for more events with the corresponding ack command
7509 (vStopped, for example). E.g., if we started a vStopped sequence
7510 immediately upon receiving the notification, something like this
7518 1.6) <-- (registers reply to step #1.3)
7520 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7523 To solve this, whenever we parse a %Stop notification successfully,
7524 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7525 doing whatever we were doing:
7531 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7532 2.5) <-- (registers reply to step #2.3)
7534 Eventually after step #2.5, we return to the event loop, which
7535 notices there's an event on the
7536 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7537 associated callback --- the function below. At this point, we're
7538 always safe to start a vStopped sequence. :
7541 2.7) <-- T05 thread:2
7547 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7549 struct remote_state
*rs
= get_remote_state ();
7551 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7554 fprintf_unfiltered (gdb_stdlog
,
7555 "notif: process: '%s' ack pending event\n",
7559 nc
->ack (this, nc
, rs
->buf
.data (),
7560 rs
->notif_state
->pending_event
[nc
->id
]);
7561 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7565 getpkt (&rs
->buf
, 0);
7566 if (strcmp (rs
->buf
.data (), "OK") == 0)
7569 remote_notif_ack (this, nc
, rs
->buf
.data ());
7575 fprintf_unfiltered (gdb_stdlog
,
7576 "notif: process: '%s' no pending reply\n",
7581 /* Wrapper around remote_target::remote_notif_get_pending_events to
7582 avoid having to export the whole remote_target class. */
7585 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7587 remote
->remote_notif_get_pending_events (nc
);
7590 /* Called when it is decided that STOP_REPLY holds the info of the
7591 event that is to be returned to the core. This function always
7592 destroys STOP_REPLY. */
7595 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7596 struct target_waitstatus
*status
)
7600 *status
= stop_reply
->ws
;
7601 ptid
= stop_reply
->ptid
;
7603 /* If no thread/process was reported by the stub, assume the current
7605 if (ptid
== null_ptid
)
7606 ptid
= inferior_ptid
;
7608 if (status
->kind
!= TARGET_WAITKIND_EXITED
7609 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7610 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7612 /* Expedited registers. */
7613 if (!stop_reply
->regcache
.empty ())
7615 struct regcache
*regcache
7616 = get_thread_arch_regcache (ptid
, stop_reply
->arch
);
7618 for (cached_reg_t
®
: stop_reply
->regcache
)
7620 regcache
->raw_supply (reg
.num
, reg
.data
);
7624 stop_reply
->regcache
.clear ();
7627 remote_notice_new_inferior (ptid
, 0);
7628 remote_thread_info
*remote_thr
= get_remote_thread_info (ptid
);
7629 remote_thr
->core
= stop_reply
->core
;
7630 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7631 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7632 remote_thr
->vcont_resumed
= 0;
7639 /* The non-stop mode version of target_wait. */
7642 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7644 struct remote_state
*rs
= get_remote_state ();
7645 struct stop_reply
*stop_reply
;
7649 /* If in non-stop mode, get out of getpkt even if a
7650 notification is received. */
7652 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7655 if (ret
!= -1 && !is_notif
)
7658 case 'E': /* Error of some sort. */
7659 /* We're out of sync with the target now. Did it continue
7660 or not? We can't tell which thread it was in non-stop,
7661 so just ignore this. */
7662 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7664 case 'O': /* Console output. */
7665 remote_console_output (&rs
->buf
[1]);
7668 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7672 /* Acknowledge a pending stop reply that may have arrived in the
7674 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7675 remote_notif_get_pending_events (¬if_client_stop
);
7677 /* If indeed we noticed a stop reply, we're done. */
7678 stop_reply
= queued_stop_reply (ptid
);
7679 if (stop_reply
!= NULL
)
7680 return process_stop_reply (stop_reply
, status
);
7682 /* Still no event. If we're just polling for an event, then
7683 return to the event loop. */
7684 if (options
& TARGET_WNOHANG
)
7686 status
->kind
= TARGET_WAITKIND_IGNORE
;
7687 return minus_one_ptid
;
7690 /* Otherwise do a blocking wait. */
7691 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7695 /* Return the first resumed thread. */
7698 first_remote_resumed_thread ()
7700 for (thread_info
*tp
: all_non_exited_threads (minus_one_ptid
))
7706 /* Wait until the remote machine stops, then return, storing status in
7707 STATUS just as `wait' would. */
7710 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
, int options
)
7712 struct remote_state
*rs
= get_remote_state ();
7713 ptid_t event_ptid
= null_ptid
;
7715 struct stop_reply
*stop_reply
;
7719 status
->kind
= TARGET_WAITKIND_IGNORE
;
7720 status
->value
.integer
= 0;
7722 stop_reply
= queued_stop_reply (ptid
);
7723 if (stop_reply
!= NULL
)
7724 return process_stop_reply (stop_reply
, status
);
7726 if (rs
->cached_wait_status
)
7727 /* Use the cached wait status, but only once. */
7728 rs
->cached_wait_status
= 0;
7733 int forever
= ((options
& TARGET_WNOHANG
) == 0
7734 && rs
->wait_forever_enabled_p
);
7736 if (!rs
->waiting_for_stop_reply
)
7738 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7739 return minus_one_ptid
;
7742 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7743 _never_ wait for ever -> test on target_is_async_p().
7744 However, before we do that we need to ensure that the caller
7745 knows how to take the target into/out of async mode. */
7746 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
7748 /* GDB gets a notification. Return to core as this event is
7750 if (ret
!= -1 && is_notif
)
7751 return minus_one_ptid
;
7753 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7754 return minus_one_ptid
;
7757 buf
= rs
->buf
.data ();
7759 /* Assume that the target has acknowledged Ctrl-C unless we receive
7760 an 'F' or 'O' packet. */
7761 if (buf
[0] != 'F' && buf
[0] != 'O')
7762 rs
->ctrlc_pending_p
= 0;
7766 case 'E': /* Error of some sort. */
7767 /* We're out of sync with the target now. Did it continue or
7768 not? Not is more likely, so report a stop. */
7769 rs
->waiting_for_stop_reply
= 0;
7771 warning (_("Remote failure reply: %s"), buf
);
7772 status
->kind
= TARGET_WAITKIND_STOPPED
;
7773 status
->value
.sig
= GDB_SIGNAL_0
;
7775 case 'F': /* File-I/O request. */
7776 /* GDB may access the inferior memory while handling the File-I/O
7777 request, but we don't want GDB accessing memory while waiting
7778 for a stop reply. See the comments in putpkt_binary. Set
7779 waiting_for_stop_reply to 0 temporarily. */
7780 rs
->waiting_for_stop_reply
= 0;
7781 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
7782 rs
->ctrlc_pending_p
= 0;
7783 /* GDB handled the File-I/O request, and the target is running
7784 again. Keep waiting for events. */
7785 rs
->waiting_for_stop_reply
= 1;
7787 case 'N': case 'T': case 'S': case 'X': case 'W':
7789 /* There is a stop reply to handle. */
7790 rs
->waiting_for_stop_reply
= 0;
7793 = (struct stop_reply
*) remote_notif_parse (this,
7797 event_ptid
= process_stop_reply (stop_reply
, status
);
7800 case 'O': /* Console output. */
7801 remote_console_output (buf
+ 1);
7804 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7806 /* Zero length reply means that we tried 'S' or 'C' and the
7807 remote system doesn't support it. */
7808 target_terminal::ours_for_output ();
7810 ("Can't send signals to this remote system. %s not sent.\n",
7811 gdb_signal_to_name (rs
->last_sent_signal
));
7812 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7813 target_terminal::inferior ();
7815 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7821 warning (_("Invalid remote reply: %s"), buf
);
7825 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7826 return minus_one_ptid
;
7827 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7829 /* Nothing interesting happened. If we're doing a non-blocking
7830 poll, we're done. Otherwise, go back to waiting. */
7831 if (options
& TARGET_WNOHANG
)
7832 return minus_one_ptid
;
7836 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7837 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7839 if (event_ptid
!= null_ptid
)
7840 record_currthread (rs
, event_ptid
);
7842 event_ptid
= first_remote_resumed_thread ();
7845 /* A process exit. Invalidate our notion of current thread. */
7846 record_currthread (rs
, minus_one_ptid
);
7851 /* Wait until the remote machine stops, then return, storing status in
7852 STATUS just as `wait' would. */
7855 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7859 if (target_is_non_stop_p ())
7860 event_ptid
= wait_ns (ptid
, status
, options
);
7862 event_ptid
= wait_as (ptid
, status
, options
);
7864 if (target_is_async_p ())
7866 remote_state
*rs
= get_remote_state ();
7868 /* If there are are events left in the queue tell the event loop
7870 if (!rs
->stop_reply_queue
.empty ())
7871 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7877 /* Fetch a single register using a 'p' packet. */
7880 remote_target::fetch_register_using_p (struct regcache
*regcache
,
7883 struct gdbarch
*gdbarch
= regcache
->arch ();
7884 struct remote_state
*rs
= get_remote_state ();
7886 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7889 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7892 if (reg
->pnum
== -1)
7895 p
= rs
->buf
.data ();
7897 p
+= hexnumstr (p
, reg
->pnum
);
7900 getpkt (&rs
->buf
, 0);
7902 buf
= rs
->buf
.data ();
7904 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
7908 case PACKET_UNKNOWN
:
7911 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7912 gdbarch_register_name (regcache
->arch (),
7917 /* If this register is unfetchable, tell the regcache. */
7920 regcache
->raw_supply (reg
->regnum
, NULL
);
7924 /* Otherwise, parse and supply the value. */
7930 error (_("fetch_register_using_p: early buf termination"));
7932 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7935 regcache
->raw_supply (reg
->regnum
, regp
);
7939 /* Fetch the registers included in the target's 'g' packet. */
7942 remote_target::send_g_packet ()
7944 struct remote_state
*rs
= get_remote_state ();
7947 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
7949 getpkt (&rs
->buf
, 0);
7950 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
7951 error (_("Could not read registers; remote failure reply '%s'"),
7954 /* We can get out of synch in various cases. If the first character
7955 in the buffer is not a hex character, assume that has happened
7956 and try to fetch another packet to read. */
7957 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
7958 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
7959 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
7960 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
7963 fprintf_unfiltered (gdb_stdlog
,
7964 "Bad register packet; fetching a new packet\n");
7965 getpkt (&rs
->buf
, 0);
7968 buf_len
= strlen (rs
->buf
.data ());
7970 /* Sanity check the received packet. */
7971 if (buf_len
% 2 != 0)
7972 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
7978 remote_target::process_g_packet (struct regcache
*regcache
)
7980 struct gdbarch
*gdbarch
= regcache
->arch ();
7981 struct remote_state
*rs
= get_remote_state ();
7982 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
7987 buf_len
= strlen (rs
->buf
.data ());
7989 /* Further sanity checks, with knowledge of the architecture. */
7990 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
7991 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
7993 rsa
->sizeof_g_packet
, buf_len
/ 2,
7996 /* Save the size of the packet sent to us by the target. It is used
7997 as a heuristic when determining the max size of packets that the
7998 target can safely receive. */
7999 if (rsa
->actual_register_packet_size
== 0)
8000 rsa
->actual_register_packet_size
= buf_len
;
8002 /* If this is smaller than we guessed the 'g' packet would be,
8003 update our records. A 'g' reply that doesn't include a register's
8004 value implies either that the register is not available, or that
8005 the 'p' packet must be used. */
8006 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8008 long sizeof_g_packet
= buf_len
/ 2;
8010 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8012 long offset
= rsa
->regs
[i
].offset
;
8013 long reg_size
= register_size (gdbarch
, i
);
8015 if (rsa
->regs
[i
].pnum
== -1)
8018 if (offset
>= sizeof_g_packet
)
8019 rsa
->regs
[i
].in_g_packet
= 0;
8020 else if (offset
+ reg_size
> sizeof_g_packet
)
8021 error (_("Truncated register %d in remote 'g' packet"), i
);
8023 rsa
->regs
[i
].in_g_packet
= 1;
8026 /* Looks valid enough, we can assume this is the correct length
8027 for a 'g' packet. It's important not to adjust
8028 rsa->sizeof_g_packet if we have truncated registers otherwise
8029 this "if" won't be run the next time the method is called
8030 with a packet of the same size and one of the internal errors
8031 below will trigger instead. */
8032 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8035 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8037 /* Unimplemented registers read as all bits zero. */
8038 memset (regs
, 0, rsa
->sizeof_g_packet
);
8040 /* Reply describes registers byte by byte, each byte encoded as two
8041 hex characters. Suck them all up, then supply them to the
8042 register cacheing/storage mechanism. */
8044 p
= rs
->buf
.data ();
8045 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8047 if (p
[0] == 0 || p
[1] == 0)
8048 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8049 internal_error (__FILE__
, __LINE__
,
8050 _("unexpected end of 'g' packet reply"));
8052 if (p
[0] == 'x' && p
[1] == 'x')
8053 regs
[i
] = 0; /* 'x' */
8055 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8059 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8061 struct packet_reg
*r
= &rsa
->regs
[i
];
8062 long reg_size
= register_size (gdbarch
, i
);
8066 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8067 /* This shouldn't happen - we adjusted in_g_packet above. */
8068 internal_error (__FILE__
, __LINE__
,
8069 _("unexpected end of 'g' packet reply"));
8070 else if (rs
->buf
[r
->offset
* 2] == 'x')
8072 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8073 /* The register isn't available, mark it as such (at
8074 the same time setting the value to zero). */
8075 regcache
->raw_supply (r
->regnum
, NULL
);
8078 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8084 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8087 process_g_packet (regcache
);
8090 /* Make the remote selected traceframe match GDB's selected
8094 remote_target::set_remote_traceframe ()
8097 struct remote_state
*rs
= get_remote_state ();
8099 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8102 /* Avoid recursion, remote_trace_find calls us again. */
8103 rs
->remote_traceframe_number
= get_traceframe_number ();
8105 newnum
= target_trace_find (tfind_number
,
8106 get_traceframe_number (), 0, 0, NULL
);
8108 /* Should not happen. If it does, all bets are off. */
8109 if (newnum
!= get_traceframe_number ())
8110 warning (_("could not set remote traceframe"));
8114 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8116 struct gdbarch
*gdbarch
= regcache
->arch ();
8117 struct remote_state
*rs
= get_remote_state ();
8118 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8121 set_remote_traceframe ();
8122 set_general_thread (regcache
->ptid ());
8126 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8128 gdb_assert (reg
!= NULL
);
8130 /* If this register might be in the 'g' packet, try that first -
8131 we are likely to read more than one register. If this is the
8132 first 'g' packet, we might be overly optimistic about its
8133 contents, so fall back to 'p'. */
8134 if (reg
->in_g_packet
)
8136 fetch_registers_using_g (regcache
);
8137 if (reg
->in_g_packet
)
8141 if (fetch_register_using_p (regcache
, reg
))
8144 /* This register is not available. */
8145 regcache
->raw_supply (reg
->regnum
, NULL
);
8150 fetch_registers_using_g (regcache
);
8152 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8153 if (!rsa
->regs
[i
].in_g_packet
)
8154 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8156 /* This register is not available. */
8157 regcache
->raw_supply (i
, NULL
);
8161 /* Prepare to store registers. Since we may send them all (using a
8162 'G' request), we have to read out the ones we don't want to change
8166 remote_target::prepare_to_store (struct regcache
*regcache
)
8168 struct remote_state
*rs
= get_remote_state ();
8169 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8172 /* Make sure the entire registers array is valid. */
8173 switch (packet_support (PACKET_P
))
8175 case PACKET_DISABLE
:
8176 case PACKET_SUPPORT_UNKNOWN
:
8177 /* Make sure all the necessary registers are cached. */
8178 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8179 if (rsa
->regs
[i
].in_g_packet
)
8180 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8187 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8188 packet was not recognized. */
8191 remote_target::store_register_using_P (const struct regcache
*regcache
,
8194 struct gdbarch
*gdbarch
= regcache
->arch ();
8195 struct remote_state
*rs
= get_remote_state ();
8196 /* Try storing a single register. */
8197 char *buf
= rs
->buf
.data ();
8198 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8201 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8204 if (reg
->pnum
== -1)
8207 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8208 p
= buf
+ strlen (buf
);
8209 regcache
->raw_collect (reg
->regnum
, regp
);
8210 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8212 getpkt (&rs
->buf
, 0);
8214 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8219 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8220 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8221 case PACKET_UNKNOWN
:
8224 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8228 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8229 contents of the register cache buffer. FIXME: ignores errors. */
8232 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8234 struct remote_state
*rs
= get_remote_state ();
8235 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8239 /* Extract all the registers in the regcache copying them into a
8244 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8245 memset (regs
, 0, rsa
->sizeof_g_packet
);
8246 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8248 struct packet_reg
*r
= &rsa
->regs
[i
];
8251 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8255 /* Command describes registers byte by byte,
8256 each byte encoded as two hex characters. */
8257 p
= rs
->buf
.data ();
8259 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8261 getpkt (&rs
->buf
, 0);
8262 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8263 error (_("Could not write registers; remote failure reply '%s'"),
8267 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8268 of the register cache buffer. FIXME: ignores errors. */
8271 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8273 struct gdbarch
*gdbarch
= regcache
->arch ();
8274 struct remote_state
*rs
= get_remote_state ();
8275 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8278 set_remote_traceframe ();
8279 set_general_thread (regcache
->ptid ());
8283 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8285 gdb_assert (reg
!= NULL
);
8287 /* Always prefer to store registers using the 'P' packet if
8288 possible; we often change only a small number of registers.
8289 Sometimes we change a larger number; we'd need help from a
8290 higher layer to know to use 'G'. */
8291 if (store_register_using_P (regcache
, reg
))
8294 /* For now, don't complain if we have no way to write the
8295 register. GDB loses track of unavailable registers too
8296 easily. Some day, this may be an error. We don't have
8297 any way to read the register, either... */
8298 if (!reg
->in_g_packet
)
8301 store_registers_using_G (regcache
);
8305 store_registers_using_G (regcache
);
8307 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8308 if (!rsa
->regs
[i
].in_g_packet
)
8309 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8310 /* See above for why we do not issue an error here. */
8315 /* Return the number of hex digits in num. */
8318 hexnumlen (ULONGEST num
)
8322 for (i
= 0; num
!= 0; i
++)
8325 return std::max (i
, 1);
8328 /* Set BUF to the minimum number of hex digits representing NUM. */
8331 hexnumstr (char *buf
, ULONGEST num
)
8333 int len
= hexnumlen (num
);
8335 return hexnumnstr (buf
, num
, len
);
8339 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8342 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8348 for (i
= width
- 1; i
>= 0; i
--)
8350 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8357 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8360 remote_address_masked (CORE_ADDR addr
)
8362 unsigned int address_size
= remote_address_size
;
8364 /* If "remoteaddresssize" was not set, default to target address size. */
8366 address_size
= gdbarch_addr_bit (target_gdbarch ());
8368 if (address_size
> 0
8369 && address_size
< (sizeof (ULONGEST
) * 8))
8371 /* Only create a mask when that mask can safely be constructed
8372 in a ULONGEST variable. */
8375 mask
= (mask
<< address_size
) - 1;
8381 /* Determine whether the remote target supports binary downloading.
8382 This is accomplished by sending a no-op memory write of zero length
8383 to the target at the specified address. It does not suffice to send
8384 the whole packet, since many stubs strip the eighth bit and
8385 subsequently compute a wrong checksum, which causes real havoc with
8388 NOTE: This can still lose if the serial line is not eight-bit
8389 clean. In cases like this, the user should clear "remote
8393 remote_target::check_binary_download (CORE_ADDR addr
)
8395 struct remote_state
*rs
= get_remote_state ();
8397 switch (packet_support (PACKET_X
))
8399 case PACKET_DISABLE
:
8403 case PACKET_SUPPORT_UNKNOWN
:
8407 p
= rs
->buf
.data ();
8409 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8411 p
+= hexnumstr (p
, (ULONGEST
) 0);
8415 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8416 getpkt (&rs
->buf
, 0);
8418 if (rs
->buf
[0] == '\0')
8421 fprintf_unfiltered (gdb_stdlog
,
8422 "binary downloading NOT "
8423 "supported by target\n");
8424 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8429 fprintf_unfiltered (gdb_stdlog
,
8430 "binary downloading supported by target\n");
8431 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8438 /* Helper function to resize the payload in order to try to get a good
8439 alignment. We try to write an amount of data such that the next write will
8440 start on an address aligned on REMOTE_ALIGN_WRITES. */
8443 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8445 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8448 /* Write memory data directly to the remote machine.
8449 This does not inform the data cache; the data cache uses this.
8450 HEADER is the starting part of the packet.
8451 MEMADDR is the address in the remote memory space.
8452 MYADDR is the address of the buffer in our space.
8453 LEN_UNITS is the number of addressable units to write.
8454 UNIT_SIZE is the length in bytes of an addressable unit.
8455 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8456 should send data as binary ('X'), or hex-encoded ('M').
8458 The function creates packet of the form
8459 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8461 where encoding of <DATA> is terminated by PACKET_FORMAT.
8463 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8466 Return the transferred status, error or OK (an
8467 'enum target_xfer_status' value). Save the number of addressable units
8468 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8470 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8471 exchange between gdb and the stub could look like (?? in place of the
8477 -> $M1000,3:eeeeffffeeee#??
8481 <- eeeeffffeeeedddd */
8484 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8485 const gdb_byte
*myaddr
,
8488 ULONGEST
*xfered_len_units
,
8489 char packet_format
, int use_length
)
8491 struct remote_state
*rs
= get_remote_state ();
8497 int payload_capacity_bytes
;
8498 int payload_length_bytes
;
8500 if (packet_format
!= 'X' && packet_format
!= 'M')
8501 internal_error (__FILE__
, __LINE__
,
8502 _("remote_write_bytes_aux: bad packet format"));
8505 return TARGET_XFER_EOF
;
8507 payload_capacity_bytes
= get_memory_write_packet_size ();
8509 /* The packet buffer will be large enough for the payload;
8510 get_memory_packet_size ensures this. */
8513 /* Compute the size of the actual payload by subtracting out the
8514 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8516 payload_capacity_bytes
-= strlen ("$,:#NN");
8518 /* The comma won't be used. */
8519 payload_capacity_bytes
+= 1;
8520 payload_capacity_bytes
-= strlen (header
);
8521 payload_capacity_bytes
-= hexnumlen (memaddr
);
8523 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8525 strcat (rs
->buf
.data (), header
);
8526 p
= rs
->buf
.data () + strlen (header
);
8528 /* Compute a best guess of the number of bytes actually transfered. */
8529 if (packet_format
== 'X')
8531 /* Best guess at number of bytes that will fit. */
8532 todo_units
= std::min (len_units
,
8533 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8535 payload_capacity_bytes
-= hexnumlen (todo_units
);
8536 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8540 /* Number of bytes that will fit. */
8542 = std::min (len_units
,
8543 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8545 payload_capacity_bytes
-= hexnumlen (todo_units
);
8546 todo_units
= std::min (todo_units
,
8547 (payload_capacity_bytes
/ unit_size
) / 2);
8550 if (todo_units
<= 0)
8551 internal_error (__FILE__
, __LINE__
,
8552 _("minimum packet size too small to write data"));
8554 /* If we already need another packet, then try to align the end
8555 of this packet to a useful boundary. */
8556 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8557 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8559 /* Append "<memaddr>". */
8560 memaddr
= remote_address_masked (memaddr
);
8561 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8568 /* Append the length and retain its location and size. It may need to be
8569 adjusted once the packet body has been created. */
8571 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8579 /* Append the packet body. */
8580 if (packet_format
== 'X')
8582 /* Binary mode. Send target system values byte by byte, in
8583 increasing byte addresses. Only escape certain critical
8585 payload_length_bytes
=
8586 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8587 &units_written
, payload_capacity_bytes
);
8589 /* If not all TODO units fit, then we'll need another packet. Make
8590 a second try to keep the end of the packet aligned. Don't do
8591 this if the packet is tiny. */
8592 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8596 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8598 if (new_todo_units
!= units_written
)
8599 payload_length_bytes
=
8600 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8601 (gdb_byte
*) p
, &units_written
,
8602 payload_capacity_bytes
);
8605 p
+= payload_length_bytes
;
8606 if (use_length
&& units_written
< todo_units
)
8608 /* Escape chars have filled up the buffer prematurely,
8609 and we have actually sent fewer units than planned.
8610 Fix-up the length field of the packet. Use the same
8611 number of characters as before. */
8612 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8614 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8619 /* Normal mode: Send target system values byte by byte, in
8620 increasing byte addresses. Each byte is encoded as a two hex
8622 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8623 units_written
= todo_units
;
8626 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8627 getpkt (&rs
->buf
, 0);
8629 if (rs
->buf
[0] == 'E')
8630 return TARGET_XFER_E_IO
;
8632 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8633 send fewer units than we'd planned. */
8634 *xfered_len_units
= (ULONGEST
) units_written
;
8635 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8638 /* Write memory data directly to the remote machine.
8639 This does not inform the data cache; the data cache uses this.
8640 MEMADDR is the address in the remote memory space.
8641 MYADDR is the address of the buffer in our space.
8642 LEN is the number of bytes.
8644 Return the transferred status, error or OK (an
8645 'enum target_xfer_status' value). Save the number of bytes
8646 transferred in *XFERED_LEN. Only transfer a single packet. */
8649 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8650 ULONGEST len
, int unit_size
,
8651 ULONGEST
*xfered_len
)
8653 const char *packet_format
= NULL
;
8655 /* Check whether the target supports binary download. */
8656 check_binary_download (memaddr
);
8658 switch (packet_support (PACKET_X
))
8661 packet_format
= "X";
8663 case PACKET_DISABLE
:
8664 packet_format
= "M";
8666 case PACKET_SUPPORT_UNKNOWN
:
8667 internal_error (__FILE__
, __LINE__
,
8668 _("remote_write_bytes: bad internal state"));
8670 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8673 return remote_write_bytes_aux (packet_format
,
8674 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8675 packet_format
[0], 1);
8678 /* Read memory data directly from the remote machine.
8679 This does not use the data cache; the data cache uses this.
8680 MEMADDR is the address in the remote memory space.
8681 MYADDR is the address of the buffer in our space.
8682 LEN_UNITS is the number of addressable memory units to read..
8683 UNIT_SIZE is the length in bytes of an addressable unit.
8685 Return the transferred status, error or OK (an
8686 'enum target_xfer_status' value). Save the number of bytes
8687 transferred in *XFERED_LEN_UNITS.
8689 See the comment of remote_write_bytes_aux for an example of
8690 memory read/write exchange between gdb and the stub. */
8693 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8695 int unit_size
, ULONGEST
*xfered_len_units
)
8697 struct remote_state
*rs
= get_remote_state ();
8698 int buf_size_bytes
; /* Max size of packet output buffer. */
8703 buf_size_bytes
= get_memory_read_packet_size ();
8704 /* The packet buffer will be large enough for the payload;
8705 get_memory_packet_size ensures this. */
8707 /* Number of units that will fit. */
8708 todo_units
= std::min (len_units
,
8709 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8711 /* Construct "m"<memaddr>","<len>". */
8712 memaddr
= remote_address_masked (memaddr
);
8713 p
= rs
->buf
.data ();
8715 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8717 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8720 getpkt (&rs
->buf
, 0);
8721 if (rs
->buf
[0] == 'E'
8722 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8723 && rs
->buf
[3] == '\0')
8724 return TARGET_XFER_E_IO
;
8725 /* Reply describes memory byte by byte, each byte encoded as two hex
8727 p
= rs
->buf
.data ();
8728 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8729 /* Return what we have. Let higher layers handle partial reads. */
8730 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8731 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8734 /* Using the set of read-only target sections of remote, read live
8737 For interface/parameters/return description see target.h,
8741 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
8745 ULONGEST
*xfered_len
)
8747 struct target_section
*secp
;
8748 struct target_section_table
*table
;
8750 secp
= target_section_by_addr (this, memaddr
);
8752 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
8754 struct target_section
*p
;
8755 ULONGEST memend
= memaddr
+ len
;
8757 table
= target_get_section_table (this);
8759 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8761 if (memaddr
>= p
->addr
)
8763 if (memend
<= p
->endaddr
)
8765 /* Entire transfer is within this section. */
8766 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8769 else if (memaddr
>= p
->endaddr
)
8771 /* This section ends before the transfer starts. */
8776 /* This section overlaps the transfer. Just do half. */
8777 len
= p
->endaddr
- memaddr
;
8778 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8785 return TARGET_XFER_EOF
;
8788 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8789 first if the requested memory is unavailable in traceframe.
8790 Otherwise, fall back to remote_read_bytes_1. */
8793 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
8794 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8795 ULONGEST
*xfered_len
)
8798 return TARGET_XFER_EOF
;
8800 if (get_traceframe_number () != -1)
8802 std::vector
<mem_range
> available
;
8804 /* If we fail to get the set of available memory, then the
8805 target does not support querying traceframe info, and so we
8806 attempt reading from the traceframe anyway (assuming the
8807 target implements the old QTro packet then). */
8808 if (traceframe_available_memory (&available
, memaddr
, len
))
8810 if (available
.empty () || available
[0].start
!= memaddr
)
8812 enum target_xfer_status res
;
8814 /* Don't read into the traceframe's available
8816 if (!available
.empty ())
8818 LONGEST oldlen
= len
;
8820 len
= available
[0].start
- memaddr
;
8821 gdb_assert (len
<= oldlen
);
8824 /* This goes through the topmost target again. */
8825 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
8826 len
, unit_size
, xfered_len
);
8827 if (res
== TARGET_XFER_OK
)
8828 return TARGET_XFER_OK
;
8831 /* No use trying further, we know some memory starting
8832 at MEMADDR isn't available. */
8834 return (*xfered_len
!= 0) ?
8835 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
8839 /* Don't try to read more than how much is available, in
8840 case the target implements the deprecated QTro packet to
8841 cater for older GDBs (the target's knowledge of read-only
8842 sections may be outdated by now). */
8843 len
= available
[0].length
;
8847 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8852 /* Sends a packet with content determined by the printf format string
8853 FORMAT and the remaining arguments, then gets the reply. Returns
8854 whether the packet was a success, a failure, or unknown. */
8857 remote_target::remote_send_printf (const char *format
, ...)
8859 struct remote_state
*rs
= get_remote_state ();
8860 int max_size
= get_remote_packet_size ();
8863 va_start (ap
, format
);
8866 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
8870 if (size
>= max_size
)
8871 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8873 if (putpkt (rs
->buf
) < 0)
8874 error (_("Communication problem with target."));
8877 getpkt (&rs
->buf
, 0);
8879 return packet_check_result (rs
->buf
);
8882 /* Flash writing can take quite some time. We'll set
8883 effectively infinite timeout for flash operations.
8884 In future, we'll need to decide on a better approach. */
8885 static const int remote_flash_timeout
= 1000;
8888 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
8890 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8891 enum packet_result ret
;
8892 scoped_restore restore_timeout
8893 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8895 ret
= remote_send_printf ("vFlashErase:%s,%s",
8896 phex (address
, addr_size
),
8900 case PACKET_UNKNOWN
:
8901 error (_("Remote target does not support flash erase"));
8903 error (_("Error erasing flash with vFlashErase packet"));
8910 remote_target::remote_flash_write (ULONGEST address
,
8911 ULONGEST length
, ULONGEST
*xfered_len
,
8912 const gdb_byte
*data
)
8914 scoped_restore restore_timeout
8915 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8916 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8921 remote_target::flash_done ()
8925 scoped_restore restore_timeout
8926 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8928 ret
= remote_send_printf ("vFlashDone");
8932 case PACKET_UNKNOWN
:
8933 error (_("Remote target does not support vFlashDone"));
8935 error (_("Error finishing flash operation"));
8942 remote_target::files_info ()
8944 puts_filtered ("Debugging a target over a serial line.\n");
8947 /* Stuff for dealing with the packets which are part of this protocol.
8948 See comment at top of file for details. */
8950 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8951 error to higher layers. Called when a serial error is detected.
8952 The exception message is STRING, followed by a colon and a blank,
8953 the system error message for errno at function entry and final dot
8954 for output compatibility with throw_perror_with_name. */
8957 unpush_and_perror (const char *string
)
8959 int saved_errno
= errno
;
8961 remote_unpush_target ();
8962 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
8963 safe_strerror (saved_errno
));
8966 /* Read a single character from the remote end. The current quit
8967 handler is overridden to avoid quitting in the middle of packet
8968 sequence, as that would break communication with the remote server.
8969 See remote_serial_quit_handler for more detail. */
8972 remote_target::readchar (int timeout
)
8975 struct remote_state
*rs
= get_remote_state ();
8978 scoped_restore restore_quit_target
8979 = make_scoped_restore (&curr_quit_handler_target
, this);
8980 scoped_restore restore_quit
8981 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
8983 rs
->got_ctrlc_during_io
= 0;
8985 ch
= serial_readchar (rs
->remote_desc
, timeout
);
8987 if (rs
->got_ctrlc_during_io
)
8994 switch ((enum serial_rc
) ch
)
8997 remote_unpush_target ();
8998 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9001 unpush_and_perror (_("Remote communication error. "
9002 "Target disconnected."));
9004 case SERIAL_TIMEOUT
:
9010 /* Wrapper for serial_write that closes the target and throws if
9011 writing fails. The current quit handler is overridden to avoid
9012 quitting in the middle of packet sequence, as that would break
9013 communication with the remote server. See
9014 remote_serial_quit_handler for more detail. */
9017 remote_target::remote_serial_write (const char *str
, int len
)
9019 struct remote_state
*rs
= get_remote_state ();
9021 scoped_restore restore_quit_target
9022 = make_scoped_restore (&curr_quit_handler_target
, this);
9023 scoped_restore restore_quit
9024 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9026 rs
->got_ctrlc_during_io
= 0;
9028 if (serial_write (rs
->remote_desc
, str
, len
))
9030 unpush_and_perror (_("Remote communication error. "
9031 "Target disconnected."));
9034 if (rs
->got_ctrlc_during_io
)
9038 /* Return a string representing an escaped version of BUF, of len N.
9039 E.g. \n is converted to \\n, \t to \\t, etc. */
9042 escape_buffer (const char *buf
, int n
)
9046 stb
.putstrn (buf
, n
, '\\');
9047 return std::move (stb
.string ());
9050 /* Display a null-terminated packet on stdout, for debugging, using C
9054 print_packet (const char *buf
)
9056 puts_filtered ("\"");
9057 fputstr_filtered (buf
, '"', gdb_stdout
);
9058 puts_filtered ("\"");
9062 remote_target::putpkt (const char *buf
)
9064 return putpkt_binary (buf
, strlen (buf
));
9067 /* Wrapper around remote_target::putpkt to avoid exporting
9071 putpkt (remote_target
*remote
, const char *buf
)
9073 return remote
->putpkt (buf
);
9076 /* Send a packet to the remote machine, with error checking. The data
9077 of the packet is in BUF. The string in BUF can be at most
9078 get_remote_packet_size () - 5 to account for the $, # and checksum,
9079 and for a possible /0 if we are debugging (remote_debug) and want
9080 to print the sent packet as a string. */
9083 remote_target::putpkt_binary (const char *buf
, int cnt
)
9085 struct remote_state
*rs
= get_remote_state ();
9087 unsigned char csum
= 0;
9088 gdb::def_vector
<char> data (cnt
+ 6);
9089 char *buf2
= data
.data ();
9095 /* Catch cases like trying to read memory or listing threads while
9096 we're waiting for a stop reply. The remote server wouldn't be
9097 ready to handle this request, so we'd hang and timeout. We don't
9098 have to worry about this in synchronous mode, because in that
9099 case it's not possible to issue a command while the target is
9100 running. This is not a problem in non-stop mode, because in that
9101 case, the stub is always ready to process serial input. */
9102 if (!target_is_non_stop_p ()
9103 && target_is_async_p ()
9104 && rs
->waiting_for_stop_reply
)
9106 error (_("Cannot execute this command while the target is running.\n"
9107 "Use the \"interrupt\" command to stop the target\n"
9108 "and then try again."));
9111 /* We're sending out a new packet. Make sure we don't look at a
9112 stale cached response. */
9113 rs
->cached_wait_status
= 0;
9115 /* Copy the packet into buffer BUF2, encapsulating it
9116 and giving it a checksum. */
9121 for (i
= 0; i
< cnt
; i
++)
9127 *p
++ = tohex ((csum
>> 4) & 0xf);
9128 *p
++ = tohex (csum
& 0xf);
9130 /* Send it over and over until we get a positive ack. */
9134 int started_error_output
= 0;
9140 int len
= (int) (p
- buf2
);
9143 if (remote_packet_max_chars
< 0)
9146 max_chars
= remote_packet_max_chars
;
9149 = escape_buffer (buf2
, std::min (len
, max_chars
));
9151 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9153 if (len
> max_chars
)
9154 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9157 fprintf_unfiltered (gdb_stdlog
, "...");
9159 gdb_flush (gdb_stdlog
);
9161 remote_serial_write (buf2
, p
- buf2
);
9163 /* If this is a no acks version of the remote protocol, send the
9164 packet and move on. */
9168 /* Read until either a timeout occurs (-2) or '+' is read.
9169 Handle any notification that arrives in the mean time. */
9172 ch
= readchar (remote_timeout
);
9180 case SERIAL_TIMEOUT
:
9183 if (started_error_output
)
9185 putchar_unfiltered ('\n');
9186 started_error_output
= 0;
9195 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9199 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9201 case SERIAL_TIMEOUT
:
9205 break; /* Retransmit buffer. */
9209 fprintf_unfiltered (gdb_stdlog
,
9210 "Packet instead of Ack, ignoring it\n");
9211 /* It's probably an old response sent because an ACK
9212 was lost. Gobble up the packet and ack it so it
9213 doesn't get retransmitted when we resend this
9216 remote_serial_write ("+", 1);
9217 continue; /* Now, go look for +. */
9224 /* If we got a notification, handle it, and go back to looking
9226 /* We've found the start of a notification. Now
9227 collect the data. */
9228 val
= read_frame (&rs
->buf
);
9233 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9235 fprintf_unfiltered (gdb_stdlog
,
9236 " Notification received: %s\n",
9239 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9240 /* We're in sync now, rewait for the ack. */
9247 if (!started_error_output
)
9249 started_error_output
= 1;
9250 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9252 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9253 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9262 if (!started_error_output
)
9264 started_error_output
= 1;
9265 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9267 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9271 break; /* Here to retransmit. */
9275 /* This is wrong. If doing a long backtrace, the user should be
9276 able to get out next time we call QUIT, without anything as
9277 violent as interrupt_query. If we want to provide a way out of
9278 here without getting to the next QUIT, it should be based on
9279 hitting ^C twice as in remote_wait. */
9291 /* Come here after finding the start of a frame when we expected an
9292 ack. Do our best to discard the rest of this packet. */
9295 remote_target::skip_frame ()
9301 c
= readchar (remote_timeout
);
9304 case SERIAL_TIMEOUT
:
9305 /* Nothing we can do. */
9308 /* Discard the two bytes of checksum and stop. */
9309 c
= readchar (remote_timeout
);
9311 c
= readchar (remote_timeout
);
9314 case '*': /* Run length encoding. */
9315 /* Discard the repeat count. */
9316 c
= readchar (remote_timeout
);
9321 /* A regular character. */
9327 /* Come here after finding the start of the frame. Collect the rest
9328 into *BUF, verifying the checksum, length, and handling run-length
9329 compression. NUL terminate the buffer. If there is not enough room,
9332 Returns -1 on error, number of characters in buffer (ignoring the
9333 trailing NULL) on success. (could be extended to return one of the
9334 SERIAL status indications). */
9337 remote_target::read_frame (gdb::char_vector
*buf_p
)
9342 char *buf
= buf_p
->data ();
9343 struct remote_state
*rs
= get_remote_state ();
9350 c
= readchar (remote_timeout
);
9353 case SERIAL_TIMEOUT
:
9355 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9359 fputs_filtered ("Saw new packet start in middle of old one\n",
9361 return -1; /* Start a new packet, count retries. */
9364 unsigned char pktcsum
;
9370 check_0
= readchar (remote_timeout
);
9372 check_1
= readchar (remote_timeout
);
9374 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9377 fputs_filtered ("Timeout in checksum, retrying\n",
9381 else if (check_0
< 0 || check_1
< 0)
9384 fputs_filtered ("Communication error in checksum\n",
9389 /* Don't recompute the checksum; with no ack packets we
9390 don't have any way to indicate a packet retransmission
9395 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9396 if (csum
== pktcsum
)
9401 std::string str
= escape_buffer (buf
, bc
);
9403 fprintf_unfiltered (gdb_stdlog
,
9404 "Bad checksum, sentsum=0x%x, "
9405 "csum=0x%x, buf=%s\n",
9406 pktcsum
, csum
, str
.c_str ());
9408 /* Number of characters in buffer ignoring trailing
9412 case '*': /* Run length encoding. */
9417 c
= readchar (remote_timeout
);
9419 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9421 /* The character before ``*'' is repeated. */
9423 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9425 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9427 /* Make some more room in the buffer. */
9428 buf_p
->resize (buf_p
->size () + repeat
);
9429 buf
= buf_p
->data ();
9432 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9438 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9442 if (bc
>= buf_p
->size () - 1)
9444 /* Make some more room in the buffer. */
9445 buf_p
->resize (buf_p
->size () * 2);
9446 buf
= buf_p
->data ();
9456 /* Set this to the maximum number of seconds to wait instead of waiting forever
9457 in target_wait(). If this timer times out, then it generates an error and
9458 the command is aborted. This replaces most of the need for timeouts in the
9459 GDB test suite, and makes it possible to distinguish between a hung target
9460 and one with slow communications. */
9462 static int watchdog
= 0;
9464 show_watchdog (struct ui_file
*file
, int from_tty
,
9465 struct cmd_list_element
*c
, const char *value
)
9467 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9470 /* Read a packet from the remote machine, with error checking, and
9471 store it in *BUF. Resize *BUF if necessary to hold the result. If
9472 FOREVER, wait forever rather than timing out; this is used (in
9473 synchronous mode) to wait for a target that is is executing user
9475 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9476 don't have to change all the calls to getpkt to deal with the
9477 return value, because at the moment I don't know what the right
9478 thing to do it for those. */
9481 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9483 getpkt_sane (buf
, forever
);
9487 /* Read a packet from the remote machine, with error checking, and
9488 store it in *BUF. Resize *BUF if necessary to hold the result. If
9489 FOREVER, wait forever rather than timing out; this is used (in
9490 synchronous mode) to wait for a target that is is executing user
9491 code to stop. If FOREVER == 0, this function is allowed to time
9492 out gracefully and return an indication of this to the caller.
9493 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9494 consider receiving a notification enough reason to return to the
9495 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9496 holds a notification or not (a regular packet). */
9499 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9500 int forever
, int expecting_notif
,
9503 struct remote_state
*rs
= get_remote_state ();
9509 /* We're reading a new response. Make sure we don't look at a
9510 previously cached response. */
9511 rs
->cached_wait_status
= 0;
9513 strcpy (buf
->data (), "timeout");
9516 timeout
= watchdog
> 0 ? watchdog
: -1;
9517 else if (expecting_notif
)
9518 timeout
= 0; /* There should already be a char in the buffer. If
9521 timeout
= remote_timeout
;
9525 /* Process any number of notifications, and then return when
9529 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9531 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9533 /* This can loop forever if the remote side sends us
9534 characters continuously, but if it pauses, we'll get
9535 SERIAL_TIMEOUT from readchar because of timeout. Then
9536 we'll count that as a retry.
9538 Note that even when forever is set, we will only wait
9539 forever prior to the start of a packet. After that, we
9540 expect characters to arrive at a brisk pace. They should
9541 show up within remote_timeout intervals. */
9543 c
= readchar (timeout
);
9544 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9546 if (c
== SERIAL_TIMEOUT
)
9548 if (expecting_notif
)
9549 return -1; /* Don't complain, it's normal to not get
9550 anything in this case. */
9552 if (forever
) /* Watchdog went off? Kill the target. */
9554 remote_unpush_target ();
9555 throw_error (TARGET_CLOSE_ERROR
,
9556 _("Watchdog timeout has expired. "
9557 "Target detached."));
9560 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9564 /* We've found the start of a packet or notification.
9565 Now collect the data. */
9566 val
= read_frame (buf
);
9571 remote_serial_write ("-", 1);
9574 if (tries
> MAX_TRIES
)
9576 /* We have tried hard enough, and just can't receive the
9577 packet/notification. Give up. */
9578 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9580 /* Skip the ack char if we're in no-ack mode. */
9581 if (!rs
->noack_mode
)
9582 remote_serial_write ("+", 1);
9586 /* If we got an ordinary packet, return that to our caller. */
9593 if (remote_packet_max_chars
< 0)
9596 max_chars
= remote_packet_max_chars
;
9599 = escape_buffer (buf
->data (),
9600 std::min (val
, max_chars
));
9602 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9605 if (val
> max_chars
)
9606 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9609 fprintf_unfiltered (gdb_stdlog
, "\n");
9612 /* Skip the ack char if we're in no-ack mode. */
9613 if (!rs
->noack_mode
)
9614 remote_serial_write ("+", 1);
9615 if (is_notif
!= NULL
)
9620 /* If we got a notification, handle it, and go back to looking
9624 gdb_assert (c
== '%');
9628 std::string str
= escape_buffer (buf
->data (), val
);
9630 fprintf_unfiltered (gdb_stdlog
,
9631 " Notification received: %s\n",
9634 if (is_notif
!= NULL
)
9637 handle_notification (rs
->notif_state
, buf
->data ());
9639 /* Notifications require no acknowledgement. */
9641 if (expecting_notif
)
9648 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9650 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9654 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9657 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9660 /* Kill any new fork children of process PID that haven't been
9661 processed by follow_fork. */
9664 remote_target::kill_new_fork_children (int pid
)
9666 remote_state
*rs
= get_remote_state ();
9667 struct notif_client
*notif
= ¬if_client_stop
;
9669 /* Kill the fork child threads of any threads in process PID
9670 that are stopped at a fork event. */
9671 for (thread_info
*thread
: all_non_exited_threads ())
9673 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9675 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9677 int child_pid
= ws
->value
.related_pid
.pid ();
9680 res
= remote_vkill (child_pid
);
9682 error (_("Can't kill fork child process %d"), child_pid
);
9686 /* Check for any pending fork events (not reported or processed yet)
9687 in process PID and kill those fork child threads as well. */
9688 remote_notif_get_pending_events (notif
);
9689 for (auto &event
: rs
->stop_reply_queue
)
9690 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9692 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9695 res
= remote_vkill (child_pid
);
9697 error (_("Can't kill fork child process %d"), child_pid
);
9702 /* Target hook to kill the current inferior. */
9705 remote_target::kill ()
9708 int pid
= inferior_ptid
.pid ();
9709 struct remote_state
*rs
= get_remote_state ();
9711 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9713 /* If we're stopped while forking and we haven't followed yet,
9714 kill the child task. We need to do this before killing the
9715 parent task because if this is a vfork then the parent will
9717 kill_new_fork_children (pid
);
9719 res
= remote_vkill (pid
);
9722 target_mourn_inferior (inferior_ptid
);
9727 /* If we are in 'target remote' mode and we are killing the only
9728 inferior, then we will tell gdbserver to exit and unpush the
9730 if (res
== -1 && !remote_multi_process_p (rs
)
9731 && number_of_live_inferiors () == 1)
9735 /* We've killed the remote end, we get to mourn it. If we are
9736 not in extended mode, mourning the inferior also unpushes
9737 remote_ops from the target stack, which closes the remote
9739 target_mourn_inferior (inferior_ptid
);
9744 error (_("Can't kill process"));
9747 /* Send a kill request to the target using the 'vKill' packet. */
9750 remote_target::remote_vkill (int pid
)
9752 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9755 remote_state
*rs
= get_remote_state ();
9757 /* Tell the remote target to detach. */
9758 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
9760 getpkt (&rs
->buf
, 0);
9762 switch (packet_ok (rs
->buf
,
9763 &remote_protocol_packets
[PACKET_vKill
]))
9769 case PACKET_UNKNOWN
:
9772 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9776 /* Send a kill request to the target using the 'k' packet. */
9779 remote_target::remote_kill_k ()
9781 /* Catch errors so the user can quit from gdb even when we
9782 aren't on speaking terms with the remote system. */
9787 catch (const gdb_exception_error
&ex
)
9789 if (ex
.error
== TARGET_CLOSE_ERROR
)
9791 /* If we got an (EOF) error that caused the target
9792 to go away, then we're done, that's what we wanted.
9793 "k" is susceptible to cause a premature EOF, given
9794 that the remote server isn't actually required to
9795 reply to "k", and it can happen that it doesn't
9796 even get to reply ACK to the "k". */
9800 /* Otherwise, something went wrong. We didn't actually kill
9801 the target. Just propagate the exception, and let the
9802 user or higher layers decide what to do. */
9808 remote_target::mourn_inferior ()
9810 struct remote_state
*rs
= get_remote_state ();
9812 /* We're no longer interested in notification events of an inferior
9813 that exited or was killed/detached. */
9814 discard_pending_stop_replies (current_inferior ());
9816 /* In 'target remote' mode with one inferior, we close the connection. */
9817 if (!rs
->extended
&& number_of_live_inferiors () <= 1)
9819 unpush_target (this);
9821 /* remote_close takes care of doing most of the clean up. */
9822 generic_mourn_inferior ();
9826 /* In case we got here due to an error, but we're going to stay
9828 rs
->waiting_for_stop_reply
= 0;
9830 /* If the current general thread belonged to the process we just
9831 detached from or has exited, the remote side current general
9832 thread becomes undefined. Considering a case like this:
9834 - We just got here due to a detach.
9835 - The process that we're detaching from happens to immediately
9836 report a global breakpoint being hit in non-stop mode, in the
9837 same thread we had selected before.
9838 - GDB attaches to this process again.
9839 - This event happens to be the next event we handle.
9841 GDB would consider that the current general thread didn't need to
9842 be set on the stub side (with Hg), since for all it knew,
9843 GENERAL_THREAD hadn't changed.
9845 Notice that although in all-stop mode, the remote server always
9846 sets the current thread to the thread reporting the stop event,
9847 that doesn't happen in non-stop mode; in non-stop, the stub *must
9848 not* change the current thread when reporting a breakpoint hit,
9849 due to the decoupling of event reporting and event handling.
9851 To keep things simple, we always invalidate our notion of the
9853 record_currthread (rs
, minus_one_ptid
);
9855 /* Call common code to mark the inferior as not running. */
9856 generic_mourn_inferior ();
9860 extended_remote_target::supports_disable_randomization ()
9862 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9866 remote_target::extended_remote_disable_randomization (int val
)
9868 struct remote_state
*rs
= get_remote_state ();
9871 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9872 "QDisableRandomization:%x", val
);
9874 reply
= remote_get_noisy_reply ();
9876 error (_("Target does not support QDisableRandomization."));
9877 if (strcmp (reply
, "OK") != 0)
9878 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9882 remote_target::extended_remote_run (const std::string
&args
)
9884 struct remote_state
*rs
= get_remote_state ();
9886 const char *remote_exec_file
= get_remote_exec_file ();
9888 /* If the user has disabled vRun support, or we have detected that
9889 support is not available, do not try it. */
9890 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9893 strcpy (rs
->buf
.data (), "vRun;");
9894 len
= strlen (rs
->buf
.data ());
9896 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9897 error (_("Remote file name too long for run packet"));
9898 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
9899 strlen (remote_exec_file
));
9905 gdb_argv
argv (args
.c_str ());
9906 for (i
= 0; argv
[i
] != NULL
; i
++)
9908 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9909 error (_("Argument list too long for run packet"));
9910 rs
->buf
[len
++] = ';';
9911 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
9916 rs
->buf
[len
++] = '\0';
9919 getpkt (&rs
->buf
, 0);
9921 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9924 /* We have a wait response. All is well. */
9926 case PACKET_UNKNOWN
:
9929 if (remote_exec_file
[0] == '\0')
9930 error (_("Running the default executable on the remote target failed; "
9931 "try \"set remote exec-file\"?"));
9933 error (_("Running \"%s\" on the remote target failed"),
9936 gdb_assert_not_reached (_("bad switch"));
9940 /* Helper function to send set/unset environment packets. ACTION is
9941 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
9942 or "QEnvironmentUnsetVariable". VALUE is the variable to be
9946 remote_target::send_environment_packet (const char *action
,
9950 remote_state
*rs
= get_remote_state ();
9952 /* Convert the environment variable to an hex string, which
9953 is the best format to be transmitted over the wire. */
9954 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
9957 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9958 "%s:%s", packet
, encoded_value
.c_str ());
9961 getpkt (&rs
->buf
, 0);
9962 if (strcmp (rs
->buf
.data (), "OK") != 0)
9963 warning (_("Unable to %s environment variable '%s' on remote."),
9967 /* Helper function to handle the QEnvironment* packets. */
9970 remote_target::extended_remote_environment_support ()
9972 remote_state
*rs
= get_remote_state ();
9974 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
9976 putpkt ("QEnvironmentReset");
9977 getpkt (&rs
->buf
, 0);
9978 if (strcmp (rs
->buf
.data (), "OK") != 0)
9979 warning (_("Unable to reset environment on remote."));
9982 gdb_environ
*e
= ¤t_inferior ()->environment
;
9984 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
9985 for (const std::string
&el
: e
->user_set_env ())
9986 send_environment_packet ("set", "QEnvironmentHexEncoded",
9989 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
9990 for (const std::string
&el
: e
->user_unset_env ())
9991 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
9994 /* Helper function to set the current working directory for the
9995 inferior in the remote target. */
9998 remote_target::extended_remote_set_inferior_cwd ()
10000 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10002 const char *inferior_cwd
= get_inferior_cwd ();
10003 remote_state
*rs
= get_remote_state ();
10005 if (inferior_cwd
!= NULL
)
10007 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10008 strlen (inferior_cwd
));
10010 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10011 "QSetWorkingDir:%s", hexpath
.c_str ());
10015 /* An empty inferior_cwd means that the user wants us to
10016 reset the remote server's inferior's cwd. */
10017 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10018 "QSetWorkingDir:");
10022 getpkt (&rs
->buf
, 0);
10023 if (packet_ok (rs
->buf
,
10024 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10027 Remote replied unexpectedly while setting the inferior's working\n\
10034 /* In the extended protocol we want to be able to do things like
10035 "run" and have them basically work as expected. So we need
10036 a special create_inferior function. We support changing the
10037 executable file and the command line arguments, but not the
10041 extended_remote_target::create_inferior (const char *exec_file
,
10042 const std::string
&args
,
10043 char **env
, int from_tty
)
10047 struct remote_state
*rs
= get_remote_state ();
10048 const char *remote_exec_file
= get_remote_exec_file ();
10050 /* If running asynchronously, register the target file descriptor
10051 with the event loop. */
10052 if (target_can_async_p ())
10055 /* Disable address space randomization if requested (and supported). */
10056 if (supports_disable_randomization ())
10057 extended_remote_disable_randomization (disable_randomization
);
10059 /* If startup-with-shell is on, we inform gdbserver to start the
10060 remote inferior using a shell. */
10061 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10063 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10064 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10066 getpkt (&rs
->buf
, 0);
10067 if (strcmp (rs
->buf
.data (), "OK") != 0)
10069 Remote replied unexpectedly while setting startup-with-shell: %s"),
10073 extended_remote_environment_support ();
10075 extended_remote_set_inferior_cwd ();
10077 /* Now restart the remote server. */
10078 run_worked
= extended_remote_run (args
) != -1;
10081 /* vRun was not supported. Fail if we need it to do what the
10083 if (remote_exec_file
[0])
10084 error (_("Remote target does not support \"set remote exec-file\""));
10085 if (!args
.empty ())
10086 error (_("Remote target does not support \"set args\" or run ARGS"));
10088 /* Fall back to "R". */
10089 extended_remote_restart ();
10092 /* vRun's success return is a stop reply. */
10093 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10094 add_current_inferior_and_thread (stop_reply
);
10096 /* Get updated offsets, if the stub uses qOffsets. */
10101 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10102 the list of conditions (in agent expression bytecode format), if any, the
10103 target needs to evaluate. The output is placed into the packet buffer
10104 started from BUF and ended at BUF_END. */
10107 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10108 struct bp_target_info
*bp_tgt
, char *buf
,
10111 if (bp_tgt
->conditions
.empty ())
10114 buf
+= strlen (buf
);
10115 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10118 /* Send conditions to the target. */
10119 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10121 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10122 buf
+= strlen (buf
);
10123 for (int i
= 0; i
< aexpr
->len
; ++i
)
10124 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10131 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10132 struct bp_target_info
*bp_tgt
, char *buf
)
10134 if (bp_tgt
->tcommands
.empty ())
10137 buf
+= strlen (buf
);
10139 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10140 buf
+= strlen (buf
);
10142 /* Concatenate all the agent expressions that are commands into the
10144 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10146 sprintf (buf
, "X%x,", aexpr
->len
);
10147 buf
+= strlen (buf
);
10148 for (int i
= 0; i
< aexpr
->len
; ++i
)
10149 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10154 /* Insert a breakpoint. On targets that have software breakpoint
10155 support, we ask the remote target to do the work; on targets
10156 which don't, we insert a traditional memory breakpoint. */
10159 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10160 struct bp_target_info
*bp_tgt
)
10162 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10163 If it succeeds, then set the support to PACKET_ENABLE. If it
10164 fails, and the user has explicitly requested the Z support then
10165 report an error, otherwise, mark it disabled and go on. */
10167 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10169 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10170 struct remote_state
*rs
;
10173 /* Make sure the remote is pointing at the right process, if
10175 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10176 set_general_process ();
10178 rs
= get_remote_state ();
10179 p
= rs
->buf
.data ();
10180 endbuf
= p
+ get_remote_packet_size ();
10185 addr
= (ULONGEST
) remote_address_masked (addr
);
10186 p
+= hexnumstr (p
, addr
);
10187 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10189 if (supports_evaluation_of_breakpoint_conditions ())
10190 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10192 if (can_run_breakpoint_commands ())
10193 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10196 getpkt (&rs
->buf
, 0);
10198 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10204 case PACKET_UNKNOWN
:
10209 /* If this breakpoint has target-side commands but this stub doesn't
10210 support Z0 packets, throw error. */
10211 if (!bp_tgt
->tcommands
.empty ())
10212 throw_error (NOT_SUPPORTED_ERROR
, _("\
10213 Target doesn't support breakpoints that have target side commands."));
10215 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10219 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10220 struct bp_target_info
*bp_tgt
,
10221 enum remove_bp_reason reason
)
10223 CORE_ADDR addr
= bp_tgt
->placed_address
;
10224 struct remote_state
*rs
= get_remote_state ();
10226 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10228 char *p
= rs
->buf
.data ();
10229 char *endbuf
= p
+ get_remote_packet_size ();
10231 /* Make sure the remote is pointing at the right process, if
10233 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10234 set_general_process ();
10240 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10241 p
+= hexnumstr (p
, addr
);
10242 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10245 getpkt (&rs
->buf
, 0);
10247 return (rs
->buf
[0] == 'E');
10250 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10253 static enum Z_packet_type
10254 watchpoint_to_Z_packet (int type
)
10259 return Z_PACKET_WRITE_WP
;
10262 return Z_PACKET_READ_WP
;
10265 return Z_PACKET_ACCESS_WP
;
10268 internal_error (__FILE__
, __LINE__
,
10269 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10274 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10275 enum target_hw_bp_type type
, struct expression
*cond
)
10277 struct remote_state
*rs
= get_remote_state ();
10278 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10280 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10282 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10285 /* Make sure the remote is pointing at the right process, if
10287 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10288 set_general_process ();
10290 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10291 p
= strchr (rs
->buf
.data (), '\0');
10292 addr
= remote_address_masked (addr
);
10293 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10294 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10297 getpkt (&rs
->buf
, 0);
10299 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10303 case PACKET_UNKNOWN
:
10308 internal_error (__FILE__
, __LINE__
,
10309 _("remote_insert_watchpoint: reached end of function"));
10313 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10314 CORE_ADDR start
, int length
)
10316 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10318 return diff
< length
;
10323 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10324 enum target_hw_bp_type type
, struct expression
*cond
)
10326 struct remote_state
*rs
= get_remote_state ();
10327 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10329 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10331 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10334 /* Make sure the remote is pointing at the right process, if
10336 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10337 set_general_process ();
10339 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10340 p
= strchr (rs
->buf
.data (), '\0');
10341 addr
= remote_address_masked (addr
);
10342 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10343 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10345 getpkt (&rs
->buf
, 0);
10347 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10350 case PACKET_UNKNOWN
:
10355 internal_error (__FILE__
, __LINE__
,
10356 _("remote_remove_watchpoint: reached end of function"));
10360 static int remote_hw_watchpoint_limit
= -1;
10361 static int remote_hw_watchpoint_length_limit
= -1;
10362 static int remote_hw_breakpoint_limit
= -1;
10365 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10367 if (remote_hw_watchpoint_length_limit
== 0)
10369 else if (remote_hw_watchpoint_length_limit
< 0)
10371 else if (len
<= remote_hw_watchpoint_length_limit
)
10378 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10380 if (type
== bp_hardware_breakpoint
)
10382 if (remote_hw_breakpoint_limit
== 0)
10384 else if (remote_hw_breakpoint_limit
< 0)
10386 else if (cnt
<= remote_hw_breakpoint_limit
)
10391 if (remote_hw_watchpoint_limit
== 0)
10393 else if (remote_hw_watchpoint_limit
< 0)
10397 else if (cnt
<= remote_hw_watchpoint_limit
)
10403 /* The to_stopped_by_sw_breakpoint method of target remote. */
10406 remote_target::stopped_by_sw_breakpoint ()
10408 struct thread_info
*thread
= inferior_thread ();
10410 return (thread
->priv
!= NULL
10411 && (get_remote_thread_info (thread
)->stop_reason
10412 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10415 /* The to_supports_stopped_by_sw_breakpoint method of target
10419 remote_target::supports_stopped_by_sw_breakpoint ()
10421 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10424 /* The to_stopped_by_hw_breakpoint method of target remote. */
10427 remote_target::stopped_by_hw_breakpoint ()
10429 struct thread_info
*thread
= inferior_thread ();
10431 return (thread
->priv
!= NULL
10432 && (get_remote_thread_info (thread
)->stop_reason
10433 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10436 /* The to_supports_stopped_by_hw_breakpoint method of target
10440 remote_target::supports_stopped_by_hw_breakpoint ()
10442 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10446 remote_target::stopped_by_watchpoint ()
10448 struct thread_info
*thread
= inferior_thread ();
10450 return (thread
->priv
!= NULL
10451 && (get_remote_thread_info (thread
)->stop_reason
10452 == TARGET_STOPPED_BY_WATCHPOINT
));
10456 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10458 struct thread_info
*thread
= inferior_thread ();
10460 if (thread
->priv
!= NULL
10461 && (get_remote_thread_info (thread
)->stop_reason
10462 == TARGET_STOPPED_BY_WATCHPOINT
))
10464 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10473 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10474 struct bp_target_info
*bp_tgt
)
10476 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10477 struct remote_state
*rs
;
10481 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10484 /* Make sure the remote is pointing at the right process, if
10486 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10487 set_general_process ();
10489 rs
= get_remote_state ();
10490 p
= rs
->buf
.data ();
10491 endbuf
= p
+ get_remote_packet_size ();
10497 addr
= remote_address_masked (addr
);
10498 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10499 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10501 if (supports_evaluation_of_breakpoint_conditions ())
10502 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10504 if (can_run_breakpoint_commands ())
10505 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10508 getpkt (&rs
->buf
, 0);
10510 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10513 if (rs
->buf
[1] == '.')
10515 message
= strchr (&rs
->buf
[2], '.');
10517 error (_("Remote failure reply: %s"), message
+ 1);
10520 case PACKET_UNKNOWN
:
10525 internal_error (__FILE__
, __LINE__
,
10526 _("remote_insert_hw_breakpoint: reached end of function"));
10531 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10532 struct bp_target_info
*bp_tgt
)
10535 struct remote_state
*rs
= get_remote_state ();
10536 char *p
= rs
->buf
.data ();
10537 char *endbuf
= p
+ get_remote_packet_size ();
10539 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10542 /* Make sure the remote is pointing at the right process, if
10544 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10545 set_general_process ();
10551 addr
= remote_address_masked (bp_tgt
->placed_address
);
10552 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10553 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10556 getpkt (&rs
->buf
, 0);
10558 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10561 case PACKET_UNKNOWN
:
10566 internal_error (__FILE__
, __LINE__
,
10567 _("remote_remove_hw_breakpoint: reached end of function"));
10570 /* Verify memory using the "qCRC:" request. */
10573 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10575 struct remote_state
*rs
= get_remote_state ();
10576 unsigned long host_crc
, target_crc
;
10579 /* It doesn't make sense to use qCRC if the remote target is
10580 connected but not running. */
10581 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10583 enum packet_result result
;
10585 /* Make sure the remote is pointing at the right process. */
10586 set_general_process ();
10588 /* FIXME: assumes lma can fit into long. */
10589 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10590 (long) lma
, (long) size
);
10593 /* Be clever; compute the host_crc before waiting for target
10595 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10597 getpkt (&rs
->buf
, 0);
10599 result
= packet_ok (rs
->buf
,
10600 &remote_protocol_packets
[PACKET_qCRC
]);
10601 if (result
== PACKET_ERROR
)
10603 else if (result
== PACKET_OK
)
10605 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10606 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10608 return (host_crc
== target_crc
);
10612 return simple_verify_memory (this, data
, lma
, size
);
10615 /* compare-sections command
10617 With no arguments, compares each loadable section in the exec bfd
10618 with the same memory range on the target, and reports mismatches.
10619 Useful for verifying the image on the target against the exec file. */
10622 compare_sections_command (const char *args
, int from_tty
)
10625 const char *sectname
;
10626 bfd_size_type size
;
10629 int mismatched
= 0;
10634 error (_("command cannot be used without an exec file"));
10636 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10642 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10644 if (!(s
->flags
& SEC_LOAD
))
10645 continue; /* Skip non-loadable section. */
10647 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10648 continue; /* Skip writeable sections */
10650 size
= bfd_section_size (s
);
10652 continue; /* Skip zero-length section. */
10654 sectname
= bfd_section_name (s
);
10655 if (args
&& strcmp (args
, sectname
) != 0)
10656 continue; /* Not the section selected by user. */
10658 matched
= 1; /* Do this section. */
10661 gdb::byte_vector
sectdata (size
);
10662 bfd_get_section_contents (exec_bfd
, s
, sectdata
.data (), 0, size
);
10664 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10667 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10668 paddress (target_gdbarch (), lma
),
10669 paddress (target_gdbarch (), lma
+ size
));
10671 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10672 paddress (target_gdbarch (), lma
),
10673 paddress (target_gdbarch (), lma
+ size
));
10675 printf_filtered ("matched.\n");
10678 printf_filtered ("MIS-MATCHED!\n");
10682 if (mismatched
> 0)
10683 warning (_("One or more sections of the target image does not match\n\
10684 the loaded file\n"));
10685 if (args
&& !matched
)
10686 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10689 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10690 into remote target. The number of bytes written to the remote
10691 target is returned, or -1 for error. */
10694 remote_target::remote_write_qxfer (const char *object_name
,
10695 const char *annex
, const gdb_byte
*writebuf
,
10696 ULONGEST offset
, LONGEST len
,
10697 ULONGEST
*xfered_len
,
10698 struct packet_config
*packet
)
10702 struct remote_state
*rs
= get_remote_state ();
10703 int max_size
= get_memory_write_packet_size ();
10705 if (packet_config_support (packet
) == PACKET_DISABLE
)
10706 return TARGET_XFER_E_IO
;
10708 /* Insert header. */
10709 i
= snprintf (rs
->buf
.data (), max_size
,
10710 "qXfer:%s:write:%s:%s:",
10711 object_name
, annex
? annex
: "",
10712 phex_nz (offset
, sizeof offset
));
10713 max_size
-= (i
+ 1);
10715 /* Escape as much data as fits into rs->buf. */
10716 buf_len
= remote_escape_output
10717 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10719 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10720 || getpkt_sane (&rs
->buf
, 0) < 0
10721 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10722 return TARGET_XFER_E_IO
;
10724 unpack_varlen_hex (rs
->buf
.data (), &n
);
10727 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10730 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10731 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10732 number of bytes read is returned, or 0 for EOF, or -1 for error.
10733 The number of bytes read may be less than LEN without indicating an
10734 EOF. PACKET is checked and updated to indicate whether the remote
10735 target supports this object. */
10738 remote_target::remote_read_qxfer (const char *object_name
,
10740 gdb_byte
*readbuf
, ULONGEST offset
,
10742 ULONGEST
*xfered_len
,
10743 struct packet_config
*packet
)
10745 struct remote_state
*rs
= get_remote_state ();
10746 LONGEST i
, n
, packet_len
;
10748 if (packet_config_support (packet
) == PACKET_DISABLE
)
10749 return TARGET_XFER_E_IO
;
10751 /* Check whether we've cached an end-of-object packet that matches
10753 if (rs
->finished_object
)
10755 if (strcmp (object_name
, rs
->finished_object
) == 0
10756 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10757 && offset
== rs
->finished_offset
)
10758 return TARGET_XFER_EOF
;
10761 /* Otherwise, we're now reading something different. Discard
10763 xfree (rs
->finished_object
);
10764 xfree (rs
->finished_annex
);
10765 rs
->finished_object
= NULL
;
10766 rs
->finished_annex
= NULL
;
10769 /* Request only enough to fit in a single packet. The actual data
10770 may not, since we don't know how much of it will need to be escaped;
10771 the target is free to respond with slightly less data. We subtract
10772 five to account for the response type and the protocol frame. */
10773 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10774 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
10775 "qXfer:%s:read:%s:%s,%s",
10776 object_name
, annex
? annex
: "",
10777 phex_nz (offset
, sizeof offset
),
10778 phex_nz (n
, sizeof n
));
10779 i
= putpkt (rs
->buf
);
10781 return TARGET_XFER_E_IO
;
10784 packet_len
= getpkt_sane (&rs
->buf
, 0);
10785 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10786 return TARGET_XFER_E_IO
;
10788 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10789 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
10791 /* 'm' means there is (or at least might be) more data after this
10792 batch. That does not make sense unless there's at least one byte
10793 of data in this reply. */
10794 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10795 error (_("Remote qXfer reply contained no data."));
10797 /* Got some data. */
10798 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
10799 packet_len
- 1, readbuf
, n
);
10801 /* 'l' is an EOF marker, possibly including a final block of data,
10802 or possibly empty. If we have the final block of a non-empty
10803 object, record this fact to bypass a subsequent partial read. */
10804 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10806 rs
->finished_object
= xstrdup (object_name
);
10807 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10808 rs
->finished_offset
= offset
+ i
;
10812 return TARGET_XFER_EOF
;
10816 return TARGET_XFER_OK
;
10820 enum target_xfer_status
10821 remote_target::xfer_partial (enum target_object object
,
10822 const char *annex
, gdb_byte
*readbuf
,
10823 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10824 ULONGEST
*xfered_len
)
10826 struct remote_state
*rs
;
10830 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10832 set_remote_traceframe ();
10833 set_general_thread (inferior_ptid
);
10835 rs
= get_remote_state ();
10837 /* Handle memory using the standard memory routines. */
10838 if (object
== TARGET_OBJECT_MEMORY
)
10840 /* If the remote target is connected but not running, we should
10841 pass this request down to a lower stratum (e.g. the executable
10843 if (!target_has_execution
)
10844 return TARGET_XFER_EOF
;
10846 if (writebuf
!= NULL
)
10847 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10850 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
10854 /* Handle extra signal info using qxfer packets. */
10855 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10858 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
10859 xfered_len
, &remote_protocol_packets
10860 [PACKET_qXfer_siginfo_read
]);
10862 return remote_write_qxfer ("siginfo", annex
,
10863 writebuf
, offset
, len
, xfered_len
,
10864 &remote_protocol_packets
10865 [PACKET_qXfer_siginfo_write
]);
10868 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10871 return remote_read_qxfer ("statictrace", annex
,
10872 readbuf
, offset
, len
, xfered_len
,
10873 &remote_protocol_packets
10874 [PACKET_qXfer_statictrace_read
]);
10876 return TARGET_XFER_E_IO
;
10879 /* Only handle flash writes. */
10880 if (writebuf
!= NULL
)
10884 case TARGET_OBJECT_FLASH
:
10885 return remote_flash_write (offset
, len
, xfered_len
,
10889 return TARGET_XFER_E_IO
;
10893 /* Map pre-existing objects onto letters. DO NOT do this for new
10894 objects!!! Instead specify new query packets. */
10897 case TARGET_OBJECT_AVR
:
10901 case TARGET_OBJECT_AUXV
:
10902 gdb_assert (annex
== NULL
);
10903 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
10905 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10907 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10908 return remote_read_qxfer
10909 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
10910 &remote_protocol_packets
[PACKET_qXfer_features
]);
10912 case TARGET_OBJECT_LIBRARIES
:
10913 return remote_read_qxfer
10914 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10915 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10917 case TARGET_OBJECT_LIBRARIES_SVR4
:
10918 return remote_read_qxfer
10919 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10920 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10922 case TARGET_OBJECT_MEMORY_MAP
:
10923 gdb_assert (annex
== NULL
);
10924 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
10926 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10928 case TARGET_OBJECT_OSDATA
:
10929 /* Should only get here if we're connected. */
10930 gdb_assert (rs
->remote_desc
);
10931 return remote_read_qxfer
10932 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
10933 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
10935 case TARGET_OBJECT_THREADS
:
10936 gdb_assert (annex
== NULL
);
10937 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
10939 &remote_protocol_packets
[PACKET_qXfer_threads
]);
10941 case TARGET_OBJECT_TRACEFRAME_INFO
:
10942 gdb_assert (annex
== NULL
);
10943 return remote_read_qxfer
10944 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
10945 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
10947 case TARGET_OBJECT_FDPIC
:
10948 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
10950 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
10952 case TARGET_OBJECT_OPENVMS_UIB
:
10953 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
10955 &remote_protocol_packets
[PACKET_qXfer_uib
]);
10957 case TARGET_OBJECT_BTRACE
:
10958 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
10960 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
10962 case TARGET_OBJECT_BTRACE_CONF
:
10963 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
10965 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
10967 case TARGET_OBJECT_EXEC_FILE
:
10968 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
10970 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
10973 return TARGET_XFER_E_IO
;
10976 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
10977 large enough let the caller deal with it. */
10978 if (len
< get_remote_packet_size ())
10979 return TARGET_XFER_E_IO
;
10980 len
= get_remote_packet_size ();
10982 /* Except for querying the minimum buffer size, target must be open. */
10983 if (!rs
->remote_desc
)
10984 error (_("remote query is only available after target open"));
10986 gdb_assert (annex
!= NULL
);
10987 gdb_assert (readbuf
!= NULL
);
10989 p2
= rs
->buf
.data ();
10991 *p2
++ = query_type
;
10993 /* We used one buffer char for the remote protocol q command and
10994 another for the query type. As the remote protocol encapsulation
10995 uses 4 chars plus one extra in case we are debugging
10996 (remote_debug), we have PBUFZIZ - 7 left to pack the query
10999 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11001 /* Bad caller may have sent forbidden characters. */
11002 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11007 gdb_assert (annex
[i
] == '\0');
11009 i
= putpkt (rs
->buf
);
11011 return TARGET_XFER_E_IO
;
11013 getpkt (&rs
->buf
, 0);
11014 strcpy ((char *) readbuf
, rs
->buf
.data ());
11016 *xfered_len
= strlen ((char *) readbuf
);
11017 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11020 /* Implementation of to_get_memory_xfer_limit. */
11023 remote_target::get_memory_xfer_limit ()
11025 return get_memory_write_packet_size ();
11029 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11030 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11031 CORE_ADDR
*found_addrp
)
11033 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11034 struct remote_state
*rs
= get_remote_state ();
11035 int max_size
= get_memory_write_packet_size ();
11036 struct packet_config
*packet
=
11037 &remote_protocol_packets
[PACKET_qSearch_memory
];
11038 /* Number of packet bytes used to encode the pattern;
11039 this could be more than PATTERN_LEN due to escape characters. */
11040 int escaped_pattern_len
;
11041 /* Amount of pattern that was encodable in the packet. */
11042 int used_pattern_len
;
11045 ULONGEST found_addr
;
11047 /* Don't go to the target if we don't have to. This is done before
11048 checking packet_config_support to avoid the possibility that a
11049 success for this edge case means the facility works in
11051 if (pattern_len
> search_space_len
)
11053 if (pattern_len
== 0)
11055 *found_addrp
= start_addr
;
11059 /* If we already know the packet isn't supported, fall back to the simple
11060 way of searching memory. */
11062 if (packet_config_support (packet
) == PACKET_DISABLE
)
11064 /* Target doesn't provided special support, fall back and use the
11065 standard support (copy memory and do the search here). */
11066 return simple_search_memory (this, start_addr
, search_space_len
,
11067 pattern
, pattern_len
, found_addrp
);
11070 /* Make sure the remote is pointing at the right process. */
11071 set_general_process ();
11073 /* Insert header. */
11074 i
= snprintf (rs
->buf
.data (), max_size
,
11075 "qSearch:memory:%s;%s;",
11076 phex_nz (start_addr
, addr_size
),
11077 phex_nz (search_space_len
, sizeof (search_space_len
)));
11078 max_size
-= (i
+ 1);
11080 /* Escape as much data as fits into rs->buf. */
11081 escaped_pattern_len
=
11082 remote_escape_output (pattern
, pattern_len
, 1,
11083 (gdb_byte
*) rs
->buf
.data () + i
,
11084 &used_pattern_len
, max_size
);
11086 /* Bail if the pattern is too large. */
11087 if (used_pattern_len
!= pattern_len
)
11088 error (_("Pattern is too large to transmit to remote target."));
11090 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11091 || getpkt_sane (&rs
->buf
, 0) < 0
11092 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11094 /* The request may not have worked because the command is not
11095 supported. If so, fall back to the simple way. */
11096 if (packet_config_support (packet
) == PACKET_DISABLE
)
11098 return simple_search_memory (this, start_addr
, search_space_len
,
11099 pattern
, pattern_len
, found_addrp
);
11104 if (rs
->buf
[0] == '0')
11106 else if (rs
->buf
[0] == '1')
11109 if (rs
->buf
[1] != ',')
11110 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11111 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11112 *found_addrp
= found_addr
;
11115 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11121 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11123 struct remote_state
*rs
= get_remote_state ();
11124 char *p
= rs
->buf
.data ();
11126 if (!rs
->remote_desc
)
11127 error (_("remote rcmd is only available after target open"));
11129 /* Send a NULL command across as an empty command. */
11130 if (command
== NULL
)
11133 /* The query prefix. */
11134 strcpy (rs
->buf
.data (), "qRcmd,");
11135 p
= strchr (rs
->buf
.data (), '\0');
11137 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11138 > get_remote_packet_size ())
11139 error (_("\"monitor\" command ``%s'' is too long."), command
);
11141 /* Encode the actual command. */
11142 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11144 if (putpkt (rs
->buf
) < 0)
11145 error (_("Communication problem with target."));
11147 /* get/display the response */
11152 /* XXX - see also remote_get_noisy_reply(). */
11153 QUIT
; /* Allow user to bail out with ^C. */
11155 if (getpkt_sane (&rs
->buf
, 0) == -1)
11157 /* Timeout. Continue to (try to) read responses.
11158 This is better than stopping with an error, assuming the stub
11159 is still executing the (long) monitor command.
11160 If needed, the user can interrupt gdb using C-c, obtaining
11161 an effect similar to stop on timeout. */
11164 buf
= rs
->buf
.data ();
11165 if (buf
[0] == '\0')
11166 error (_("Target does not support this command."));
11167 if (buf
[0] == 'O' && buf
[1] != 'K')
11169 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11172 if (strcmp (buf
, "OK") == 0)
11174 if (strlen (buf
) == 3 && buf
[0] == 'E'
11175 && isdigit (buf
[1]) && isdigit (buf
[2]))
11177 error (_("Protocol error with Rcmd"));
11179 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11181 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11183 fputc_unfiltered (c
, outbuf
);
11189 std::vector
<mem_region
>
11190 remote_target::memory_map ()
11192 std::vector
<mem_region
> result
;
11193 gdb::optional
<gdb::char_vector
> text
11194 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11197 result
= parse_memory_map (text
->data ());
11203 packet_command (const char *args
, int from_tty
)
11205 remote_target
*remote
= get_current_remote_target ();
11207 if (remote
== nullptr)
11208 error (_("command can only be used with remote target"));
11210 remote
->packet_command (args
, from_tty
);
11214 remote_target::packet_command (const char *args
, int from_tty
)
11217 error (_("remote-packet command requires packet text as argument"));
11219 puts_filtered ("sending: ");
11220 print_packet (args
);
11221 puts_filtered ("\n");
11224 remote_state
*rs
= get_remote_state ();
11226 getpkt (&rs
->buf
, 0);
11227 puts_filtered ("received: ");
11228 print_packet (rs
->buf
.data ());
11229 puts_filtered ("\n");
11233 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11235 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11237 static void threadset_test_cmd (char *cmd
, int tty
);
11239 static void threadalive_test (char *cmd
, int tty
);
11241 static void threadlist_test_cmd (char *cmd
, int tty
);
11243 int get_and_display_threadinfo (threadref
*ref
);
11245 static void threadinfo_test_cmd (char *cmd
, int tty
);
11247 static int thread_display_step (threadref
*ref
, void *context
);
11249 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11251 static void init_remote_threadtests (void);
11253 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11256 threadset_test_cmd (const char *cmd
, int tty
)
11258 int sample_thread
= SAMPLE_THREAD
;
11260 printf_filtered (_("Remote threadset test\n"));
11261 set_general_thread (sample_thread
);
11266 threadalive_test (const char *cmd
, int tty
)
11268 int sample_thread
= SAMPLE_THREAD
;
11269 int pid
= inferior_ptid
.pid ();
11270 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11272 if (remote_thread_alive (ptid
))
11273 printf_filtered ("PASS: Thread alive test\n");
11275 printf_filtered ("FAIL: Thread alive test\n");
11278 void output_threadid (char *title
, threadref
*ref
);
11281 output_threadid (char *title
, threadref
*ref
)
11285 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11287 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11291 threadlist_test_cmd (const char *cmd
, int tty
)
11294 threadref nextthread
;
11295 int done
, result_count
;
11296 threadref threadlist
[3];
11298 printf_filtered ("Remote Threadlist test\n");
11299 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11300 &result_count
, &threadlist
[0]))
11301 printf_filtered ("FAIL: threadlist test\n");
11304 threadref
*scan
= threadlist
;
11305 threadref
*limit
= scan
+ result_count
;
11307 while (scan
< limit
)
11308 output_threadid (" thread ", scan
++);
11313 display_thread_info (struct gdb_ext_thread_info
*info
)
11315 output_threadid ("Threadid: ", &info
->threadid
);
11316 printf_filtered ("Name: %s\n ", info
->shortname
);
11317 printf_filtered ("State: %s\n", info
->display
);
11318 printf_filtered ("other: %s\n\n", info
->more_display
);
11322 get_and_display_threadinfo (threadref
*ref
)
11326 struct gdb_ext_thread_info threadinfo
;
11328 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11329 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11330 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11331 display_thread_info (&threadinfo
);
11336 threadinfo_test_cmd (const char *cmd
, int tty
)
11338 int athread
= SAMPLE_THREAD
;
11342 int_to_threadref (&thread
, athread
);
11343 printf_filtered ("Remote Threadinfo test\n");
11344 if (!get_and_display_threadinfo (&thread
))
11345 printf_filtered ("FAIL cannot get thread info\n");
11349 thread_display_step (threadref
*ref
, void *context
)
11351 /* output_threadid(" threadstep ",ref); *//* simple test */
11352 return get_and_display_threadinfo (ref
);
11356 threadlist_update_test_cmd (const char *cmd
, int tty
)
11358 printf_filtered ("Remote Threadlist update test\n");
11359 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11363 init_remote_threadtests (void)
11365 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11366 _("Fetch and print the remote list of "
11367 "thread identifiers, one pkt only."));
11368 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11369 _("Fetch and display info about one thread."));
11370 add_com ("tset", class_obscure
, threadset_test_cmd
,
11371 _("Test setting to a different thread."));
11372 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11373 _("Iterate through updating all remote thread info."));
11374 add_com ("talive", class_obscure
, threadalive_test
,
11375 _("Remote thread alive test."));
11380 /* Convert a thread ID to a string. */
11383 remote_target::pid_to_str (ptid_t ptid
)
11385 struct remote_state
*rs
= get_remote_state ();
11387 if (ptid
== null_ptid
)
11388 return normal_pid_to_str (ptid
);
11389 else if (ptid
.is_pid ())
11391 /* Printing an inferior target id. */
11393 /* When multi-process extensions are off, there's no way in the
11394 remote protocol to know the remote process id, if there's any
11395 at all. There's one exception --- when we're connected with
11396 target extended-remote, and we manually attached to a process
11397 with "attach PID". We don't record anywhere a flag that
11398 allows us to distinguish that case from the case of
11399 connecting with extended-remote and the stub already being
11400 attached to a process, and reporting yes to qAttached, hence
11401 no smart special casing here. */
11402 if (!remote_multi_process_p (rs
))
11403 return "Remote target";
11405 return normal_pid_to_str (ptid
);
11409 if (magic_null_ptid
== ptid
)
11410 return "Thread <main>";
11411 else if (remote_multi_process_p (rs
))
11412 if (ptid
.lwp () == 0)
11413 return normal_pid_to_str (ptid
);
11415 return string_printf ("Thread %d.%ld",
11416 ptid
.pid (), ptid
.lwp ());
11418 return string_printf ("Thread %ld", ptid
.lwp ());
11422 /* Get the address of the thread local variable in OBJFILE which is
11423 stored at OFFSET within the thread local storage for thread PTID. */
11426 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11429 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11431 struct remote_state
*rs
= get_remote_state ();
11432 char *p
= rs
->buf
.data ();
11433 char *endp
= p
+ get_remote_packet_size ();
11434 enum packet_result result
;
11436 strcpy (p
, "qGetTLSAddr:");
11438 p
= write_ptid (p
, endp
, ptid
);
11440 p
+= hexnumstr (p
, offset
);
11442 p
+= hexnumstr (p
, lm
);
11446 getpkt (&rs
->buf
, 0);
11447 result
= packet_ok (rs
->buf
,
11448 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11449 if (result
== PACKET_OK
)
11453 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11456 else if (result
== PACKET_UNKNOWN
)
11457 throw_error (TLS_GENERIC_ERROR
,
11458 _("Remote target doesn't support qGetTLSAddr packet"));
11460 throw_error (TLS_GENERIC_ERROR
,
11461 _("Remote target failed to process qGetTLSAddr request"));
11464 throw_error (TLS_GENERIC_ERROR
,
11465 _("TLS not supported or disabled on this target"));
11470 /* Provide thread local base, i.e. Thread Information Block address.
11471 Returns 1 if ptid is found and thread_local_base is non zero. */
11474 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11476 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11478 struct remote_state
*rs
= get_remote_state ();
11479 char *p
= rs
->buf
.data ();
11480 char *endp
= p
+ get_remote_packet_size ();
11481 enum packet_result result
;
11483 strcpy (p
, "qGetTIBAddr:");
11485 p
= write_ptid (p
, endp
, ptid
);
11489 getpkt (&rs
->buf
, 0);
11490 result
= packet_ok (rs
->buf
,
11491 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11492 if (result
== PACKET_OK
)
11495 unpack_varlen_hex (rs
->buf
.data (), &val
);
11497 *addr
= (CORE_ADDR
) val
;
11500 else if (result
== PACKET_UNKNOWN
)
11501 error (_("Remote target doesn't support qGetTIBAddr packet"));
11503 error (_("Remote target failed to process qGetTIBAddr request"));
11506 error (_("qGetTIBAddr not supported or disabled on this target"));
11511 /* Support for inferring a target description based on the current
11512 architecture and the size of a 'g' packet. While the 'g' packet
11513 can have any size (since optional registers can be left off the
11514 end), some sizes are easily recognizable given knowledge of the
11515 approximate architecture. */
11517 struct remote_g_packet_guess
11519 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11526 const struct target_desc
*tdesc
;
11529 struct remote_g_packet_data
: public allocate_on_obstack
11531 std::vector
<remote_g_packet_guess
> guesses
;
11534 static struct gdbarch_data
*remote_g_packet_data_handle
;
11537 remote_g_packet_data_init (struct obstack
*obstack
)
11539 return new (obstack
) remote_g_packet_data
;
11543 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11544 const struct target_desc
*tdesc
)
11546 struct remote_g_packet_data
*data
11547 = ((struct remote_g_packet_data
*)
11548 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11550 gdb_assert (tdesc
!= NULL
);
11552 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11553 if (guess
.bytes
== bytes
)
11554 internal_error (__FILE__
, __LINE__
,
11555 _("Duplicate g packet description added for size %d"),
11558 data
->guesses
.emplace_back (bytes
, tdesc
);
11561 /* Return true if remote_read_description would do anything on this target
11562 and architecture, false otherwise. */
11565 remote_read_description_p (struct target_ops
*target
)
11567 struct remote_g_packet_data
*data
11568 = ((struct remote_g_packet_data
*)
11569 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11571 return !data
->guesses
.empty ();
11574 const struct target_desc
*
11575 remote_target::read_description ()
11577 struct remote_g_packet_data
*data
11578 = ((struct remote_g_packet_data
*)
11579 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11581 /* Do not try this during initial connection, when we do not know
11582 whether there is a running but stopped thread. */
11583 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
11584 return beneath ()->read_description ();
11586 if (!data
->guesses
.empty ())
11588 int bytes
= send_g_packet ();
11590 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11591 if (guess
.bytes
== bytes
)
11592 return guess
.tdesc
;
11594 /* We discard the g packet. A minor optimization would be to
11595 hold on to it, and fill the register cache once we have selected
11596 an architecture, but it's too tricky to do safely. */
11599 return beneath ()->read_description ();
11602 /* Remote file transfer support. This is host-initiated I/O, not
11603 target-initiated; for target-initiated, see remote-fileio.c. */
11605 /* If *LEFT is at least the length of STRING, copy STRING to
11606 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11607 decrease *LEFT. Otherwise raise an error. */
11610 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11612 int len
= strlen (string
);
11615 error (_("Packet too long for target."));
11617 memcpy (*buffer
, string
, len
);
11621 /* NUL-terminate the buffer as a convenience, if there is
11627 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11628 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11629 decrease *LEFT. Otherwise raise an error. */
11632 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11635 if (2 * len
> *left
)
11636 error (_("Packet too long for target."));
11638 bin2hex (bytes
, *buffer
, len
);
11639 *buffer
+= 2 * len
;
11642 /* NUL-terminate the buffer as a convenience, if there is
11648 /* If *LEFT is large enough, convert VALUE to hex and add it to
11649 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11650 decrease *LEFT. Otherwise raise an error. */
11653 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11655 int len
= hexnumlen (value
);
11658 error (_("Packet too long for target."));
11660 hexnumstr (*buffer
, value
);
11664 /* NUL-terminate the buffer as a convenience, if there is
11670 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11671 value, *REMOTE_ERRNO to the remote error number or zero if none
11672 was included, and *ATTACHMENT to point to the start of the annex
11673 if any. The length of the packet isn't needed here; there may
11674 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11676 Return 0 if the packet could be parsed, -1 if it could not. If
11677 -1 is returned, the other variables may not be initialized. */
11680 remote_hostio_parse_result (char *buffer
, int *retcode
,
11681 int *remote_errno
, char **attachment
)
11686 *attachment
= NULL
;
11688 if (buffer
[0] != 'F')
11692 *retcode
= strtol (&buffer
[1], &p
, 16);
11693 if (errno
!= 0 || p
== &buffer
[1])
11696 /* Check for ",errno". */
11700 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11701 if (errno
!= 0 || p
+ 1 == p2
)
11706 /* Check for ";attachment". If there is no attachment, the
11707 packet should end here. */
11710 *attachment
= p
+ 1;
11713 else if (*p
== '\0')
11719 /* Send a prepared I/O packet to the target and read its response.
11720 The prepared packet is in the global RS->BUF before this function
11721 is called, and the answer is there when we return.
11723 COMMAND_BYTES is the length of the request to send, which may include
11724 binary data. WHICH_PACKET is the packet configuration to check
11725 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11726 is set to the error number and -1 is returned. Otherwise the value
11727 returned by the function is returned.
11729 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11730 attachment is expected; an error will be reported if there's a
11731 mismatch. If one is found, *ATTACHMENT will be set to point into
11732 the packet buffer and *ATTACHMENT_LEN will be set to the
11733 attachment's length. */
11736 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11737 int *remote_errno
, char **attachment
,
11738 int *attachment_len
)
11740 struct remote_state
*rs
= get_remote_state ();
11741 int ret
, bytes_read
;
11742 char *attachment_tmp
;
11744 if (packet_support (which_packet
) == PACKET_DISABLE
)
11746 *remote_errno
= FILEIO_ENOSYS
;
11750 putpkt_binary (rs
->buf
.data (), command_bytes
);
11751 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11753 /* If it timed out, something is wrong. Don't try to parse the
11755 if (bytes_read
< 0)
11757 *remote_errno
= FILEIO_EINVAL
;
11761 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11764 *remote_errno
= FILEIO_EINVAL
;
11766 case PACKET_UNKNOWN
:
11767 *remote_errno
= FILEIO_ENOSYS
;
11773 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
11776 *remote_errno
= FILEIO_EINVAL
;
11780 /* Make sure we saw an attachment if and only if we expected one. */
11781 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11782 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11784 *remote_errno
= FILEIO_EINVAL
;
11788 /* If an attachment was found, it must point into the packet buffer;
11789 work out how many bytes there were. */
11790 if (attachment_tmp
!= NULL
)
11792 *attachment
= attachment_tmp
;
11793 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
11799 /* See declaration.h. */
11802 readahead_cache::invalidate ()
11807 /* See declaration.h. */
11810 readahead_cache::invalidate_fd (int fd
)
11812 if (this->fd
== fd
)
11816 /* Set the filesystem remote_hostio functions that take FILENAME
11817 arguments will use. Return 0 on success, or -1 if an error
11818 occurs (and set *REMOTE_ERRNO). */
11821 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
11824 struct remote_state
*rs
= get_remote_state ();
11825 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11826 char *p
= rs
->buf
.data ();
11827 int left
= get_remote_packet_size () - 1;
11831 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11834 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11837 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11839 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11840 remote_buffer_add_string (&p
, &left
, arg
);
11842 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
11843 remote_errno
, NULL
, NULL
);
11845 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11849 rs
->fs_pid
= required_pid
;
11854 /* Implementation of to_fileio_open. */
11857 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
11858 int flags
, int mode
, int warn_if_slow
,
11861 struct remote_state
*rs
= get_remote_state ();
11862 char *p
= rs
->buf
.data ();
11863 int left
= get_remote_packet_size () - 1;
11867 static int warning_issued
= 0;
11869 printf_unfiltered (_("Reading %s from remote target...\n"),
11872 if (!warning_issued
)
11874 warning (_("File transfers from remote targets can be slow."
11875 " Use \"set sysroot\" to access files locally"
11877 warning_issued
= 1;
11881 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11884 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11886 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11887 strlen (filename
));
11888 remote_buffer_add_string (&p
, &left
, ",");
11890 remote_buffer_add_int (&p
, &left
, flags
);
11891 remote_buffer_add_string (&p
, &left
, ",");
11893 remote_buffer_add_int (&p
, &left
, mode
);
11895 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
11896 remote_errno
, NULL
, NULL
);
11900 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
11901 int flags
, int mode
, int warn_if_slow
,
11904 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
11908 /* Implementation of to_fileio_pwrite. */
11911 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11912 ULONGEST offset
, int *remote_errno
)
11914 struct remote_state
*rs
= get_remote_state ();
11915 char *p
= rs
->buf
.data ();
11916 int left
= get_remote_packet_size ();
11919 rs
->readahead_cache
.invalidate_fd (fd
);
11921 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11923 remote_buffer_add_int (&p
, &left
, fd
);
11924 remote_buffer_add_string (&p
, &left
, ",");
11926 remote_buffer_add_int (&p
, &left
, offset
);
11927 remote_buffer_add_string (&p
, &left
, ",");
11929 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
11930 (get_remote_packet_size ()
11931 - (p
- rs
->buf
.data ())));
11933 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
11934 remote_errno
, NULL
, NULL
);
11938 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11939 ULONGEST offset
, int *remote_errno
)
11941 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
11944 /* Helper for the implementation of to_fileio_pread. Read the file
11945 from the remote side with vFile:pread. */
11948 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
11949 ULONGEST offset
, int *remote_errno
)
11951 struct remote_state
*rs
= get_remote_state ();
11952 char *p
= rs
->buf
.data ();
11954 int left
= get_remote_packet_size ();
11955 int ret
, attachment_len
;
11958 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
11960 remote_buffer_add_int (&p
, &left
, fd
);
11961 remote_buffer_add_string (&p
, &left
, ",");
11963 remote_buffer_add_int (&p
, &left
, len
);
11964 remote_buffer_add_string (&p
, &left
, ",");
11966 remote_buffer_add_int (&p
, &left
, offset
);
11968 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
11969 remote_errno
, &attachment
,
11975 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11977 if (read_len
!= ret
)
11978 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
11983 /* See declaration.h. */
11986 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
11990 && this->offset
<= offset
11991 && offset
< this->offset
+ this->bufsize
)
11993 ULONGEST max
= this->offset
+ this->bufsize
;
11995 if (offset
+ len
> max
)
11996 len
= max
- offset
;
11998 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12005 /* Implementation of to_fileio_pread. */
12008 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12009 ULONGEST offset
, int *remote_errno
)
12012 struct remote_state
*rs
= get_remote_state ();
12013 readahead_cache
*cache
= &rs
->readahead_cache
;
12015 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12018 cache
->hit_count
++;
12021 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12022 pulongest (cache
->hit_count
));
12026 cache
->miss_count
++;
12028 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12029 pulongest (cache
->miss_count
));
12032 cache
->offset
= offset
;
12033 cache
->bufsize
= get_remote_packet_size ();
12034 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12036 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12037 cache
->offset
, remote_errno
);
12040 cache
->invalidate_fd (fd
);
12044 cache
->bufsize
= ret
;
12045 return cache
->pread (fd
, read_buf
, len
, offset
);
12049 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12050 ULONGEST offset
, int *remote_errno
)
12052 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12055 /* Implementation of to_fileio_close. */
12058 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12060 struct remote_state
*rs
= get_remote_state ();
12061 char *p
= rs
->buf
.data ();
12062 int left
= get_remote_packet_size () - 1;
12064 rs
->readahead_cache
.invalidate_fd (fd
);
12066 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12068 remote_buffer_add_int (&p
, &left
, fd
);
12070 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12071 remote_errno
, NULL
, NULL
);
12075 remote_target::fileio_close (int fd
, int *remote_errno
)
12077 return remote_hostio_close (fd
, remote_errno
);
12080 /* Implementation of to_fileio_unlink. */
12083 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12086 struct remote_state
*rs
= get_remote_state ();
12087 char *p
= rs
->buf
.data ();
12088 int left
= get_remote_packet_size () - 1;
12090 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12093 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12095 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12096 strlen (filename
));
12098 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12099 remote_errno
, NULL
, NULL
);
12103 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12106 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12109 /* Implementation of to_fileio_readlink. */
12111 gdb::optional
<std::string
>
12112 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12115 struct remote_state
*rs
= get_remote_state ();
12116 char *p
= rs
->buf
.data ();
12118 int left
= get_remote_packet_size ();
12119 int len
, attachment_len
;
12122 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12125 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12127 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12128 strlen (filename
));
12130 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12131 remote_errno
, &attachment
,
12137 std::string
ret (len
, '\0');
12139 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12140 (gdb_byte
*) &ret
[0], len
);
12141 if (read_len
!= len
)
12142 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12147 /* Implementation of to_fileio_fstat. */
12150 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12152 struct remote_state
*rs
= get_remote_state ();
12153 char *p
= rs
->buf
.data ();
12154 int left
= get_remote_packet_size ();
12155 int attachment_len
, ret
;
12157 struct fio_stat fst
;
12160 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12162 remote_buffer_add_int (&p
, &left
, fd
);
12164 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12165 remote_errno
, &attachment
,
12169 if (*remote_errno
!= FILEIO_ENOSYS
)
12172 /* Strictly we should return -1, ENOSYS here, but when
12173 "set sysroot remote:" was implemented in August 2008
12174 BFD's need for a stat function was sidestepped with
12175 this hack. This was not remedied until March 2015
12176 so we retain the previous behavior to avoid breaking
12179 Note that the memset is a March 2015 addition; older
12180 GDBs set st_size *and nothing else* so the structure
12181 would have garbage in all other fields. This might
12182 break something but retaining the previous behavior
12183 here would be just too wrong. */
12185 memset (st
, 0, sizeof (struct stat
));
12186 st
->st_size
= INT_MAX
;
12190 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12191 (gdb_byte
*) &fst
, sizeof (fst
));
12193 if (read_len
!= ret
)
12194 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12196 if (read_len
!= sizeof (fst
))
12197 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12198 read_len
, (int) sizeof (fst
));
12200 remote_fileio_to_host_stat (&fst
, st
);
12205 /* Implementation of to_filesystem_is_local. */
12208 remote_target::filesystem_is_local ()
12210 /* Valgrind GDB presents itself as a remote target but works
12211 on the local filesystem: it does not implement remote get
12212 and users are not expected to set a sysroot. To handle
12213 this case we treat the remote filesystem as local if the
12214 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12215 does not support vFile:open. */
12216 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12218 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12220 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12222 int fd
, remote_errno
;
12224 /* Try opening a file to probe support. The supplied
12225 filename is irrelevant, we only care about whether
12226 the stub recognizes the packet or not. */
12227 fd
= remote_hostio_open (NULL
, "just probing",
12228 FILEIO_O_RDONLY
, 0700, 0,
12232 remote_hostio_close (fd
, &remote_errno
);
12234 ps
= packet_support (PACKET_vFile_open
);
12237 if (ps
== PACKET_DISABLE
)
12239 static int warning_issued
= 0;
12241 if (!warning_issued
)
12243 warning (_("remote target does not support file"
12244 " transfer, attempting to access files"
12245 " from local filesystem."));
12246 warning_issued
= 1;
12257 remote_fileio_errno_to_host (int errnum
)
12263 case FILEIO_ENOENT
:
12271 case FILEIO_EACCES
:
12273 case FILEIO_EFAULT
:
12277 case FILEIO_EEXIST
:
12279 case FILEIO_ENODEV
:
12281 case FILEIO_ENOTDIR
:
12283 case FILEIO_EISDIR
:
12285 case FILEIO_EINVAL
:
12287 case FILEIO_ENFILE
:
12289 case FILEIO_EMFILE
:
12293 case FILEIO_ENOSPC
:
12295 case FILEIO_ESPIPE
:
12299 case FILEIO_ENOSYS
:
12301 case FILEIO_ENAMETOOLONG
:
12302 return ENAMETOOLONG
;
12308 remote_hostio_error (int errnum
)
12310 int host_error
= remote_fileio_errno_to_host (errnum
);
12312 if (host_error
== -1)
12313 error (_("Unknown remote I/O error %d"), errnum
);
12315 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12318 /* A RAII wrapper around a remote file descriptor. */
12320 class scoped_remote_fd
12323 scoped_remote_fd (remote_target
*remote
, int fd
)
12324 : m_remote (remote
), m_fd (fd
)
12328 ~scoped_remote_fd ()
12335 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12339 /* Swallow exception before it escapes the dtor. If
12340 something goes wrong, likely the connection is gone,
12341 and there's nothing else that can be done. */
12346 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12348 /* Release ownership of the file descriptor, and return it. */
12349 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12356 /* Return the owned file descriptor. */
12357 int get () const noexcept
12363 /* The remote target. */
12364 remote_target
*m_remote
;
12366 /* The owned remote I/O file descriptor. */
12371 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12373 remote_target
*remote
= get_current_remote_target ();
12375 if (remote
== nullptr)
12376 error (_("command can only be used with remote target"));
12378 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12382 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12385 int retcode
, remote_errno
, bytes
, io_size
;
12386 int bytes_in_buffer
;
12390 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12392 perror_with_name (local_file
);
12394 scoped_remote_fd fd
12395 (this, remote_hostio_open (NULL
,
12396 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12398 0700, 0, &remote_errno
));
12399 if (fd
.get () == -1)
12400 remote_hostio_error (remote_errno
);
12402 /* Send up to this many bytes at once. They won't all fit in the
12403 remote packet limit, so we'll transfer slightly fewer. */
12404 io_size
= get_remote_packet_size ();
12405 gdb::byte_vector
buffer (io_size
);
12407 bytes_in_buffer
= 0;
12410 while (bytes_in_buffer
|| !saw_eof
)
12414 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12415 io_size
- bytes_in_buffer
,
12419 if (ferror (file
.get ()))
12420 error (_("Error reading %s."), local_file
);
12423 /* EOF. Unless there is something still in the
12424 buffer from the last iteration, we are done. */
12426 if (bytes_in_buffer
== 0)
12434 bytes
+= bytes_in_buffer
;
12435 bytes_in_buffer
= 0;
12437 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12438 offset
, &remote_errno
);
12441 remote_hostio_error (remote_errno
);
12442 else if (retcode
== 0)
12443 error (_("Remote write of %d bytes returned 0!"), bytes
);
12444 else if (retcode
< bytes
)
12446 /* Short write. Save the rest of the read data for the next
12448 bytes_in_buffer
= bytes
- retcode
;
12449 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12455 if (remote_hostio_close (fd
.release (), &remote_errno
))
12456 remote_hostio_error (remote_errno
);
12459 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12463 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12465 remote_target
*remote
= get_current_remote_target ();
12467 if (remote
== nullptr)
12468 error (_("command can only be used with remote target"));
12470 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12474 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12477 int remote_errno
, bytes
, io_size
;
12480 scoped_remote_fd fd
12481 (this, remote_hostio_open (NULL
,
12482 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12484 if (fd
.get () == -1)
12485 remote_hostio_error (remote_errno
);
12487 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12489 perror_with_name (local_file
);
12491 /* Send up to this many bytes at once. They won't all fit in the
12492 remote packet limit, so we'll transfer slightly fewer. */
12493 io_size
= get_remote_packet_size ();
12494 gdb::byte_vector
buffer (io_size
);
12499 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12502 /* Success, but no bytes, means end-of-file. */
12505 remote_hostio_error (remote_errno
);
12509 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12511 perror_with_name (local_file
);
12514 if (remote_hostio_close (fd
.release (), &remote_errno
))
12515 remote_hostio_error (remote_errno
);
12518 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12522 remote_file_delete (const char *remote_file
, int from_tty
)
12524 remote_target
*remote
= get_current_remote_target ();
12526 if (remote
== nullptr)
12527 error (_("command can only be used with remote target"));
12529 remote
->remote_file_delete (remote_file
, from_tty
);
12533 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12535 int retcode
, remote_errno
;
12537 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12539 remote_hostio_error (remote_errno
);
12542 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12546 remote_put_command (const char *args
, int from_tty
)
12549 error_no_arg (_("file to put"));
12551 gdb_argv
argv (args
);
12552 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12553 error (_("Invalid parameters to remote put"));
12555 remote_file_put (argv
[0], argv
[1], from_tty
);
12559 remote_get_command (const char *args
, int from_tty
)
12562 error_no_arg (_("file to get"));
12564 gdb_argv
argv (args
);
12565 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12566 error (_("Invalid parameters to remote get"));
12568 remote_file_get (argv
[0], argv
[1], from_tty
);
12572 remote_delete_command (const char *args
, int from_tty
)
12575 error_no_arg (_("file to delete"));
12577 gdb_argv
argv (args
);
12578 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12579 error (_("Invalid parameters to remote delete"));
12581 remote_file_delete (argv
[0], from_tty
);
12585 remote_command (const char *args
, int from_tty
)
12587 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12591 remote_target::can_execute_reverse ()
12593 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12594 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12601 remote_target::supports_non_stop ()
12607 remote_target::supports_disable_randomization ()
12609 /* Only supported in extended mode. */
12614 remote_target::supports_multi_process ()
12616 struct remote_state
*rs
= get_remote_state ();
12618 return remote_multi_process_p (rs
);
12622 remote_supports_cond_tracepoints ()
12624 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12628 remote_target::supports_evaluation_of_breakpoint_conditions ()
12630 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12634 remote_supports_fast_tracepoints ()
12636 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12640 remote_supports_static_tracepoints ()
12642 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12646 remote_supports_install_in_trace ()
12648 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12652 remote_target::supports_enable_disable_tracepoint ()
12654 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12659 remote_target::supports_string_tracing ()
12661 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12665 remote_target::can_run_breakpoint_commands ()
12667 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12671 remote_target::trace_init ()
12673 struct remote_state
*rs
= get_remote_state ();
12676 remote_get_noisy_reply ();
12677 if (strcmp (rs
->buf
.data (), "OK") != 0)
12678 error (_("Target does not support this command."));
12681 /* Recursive routine to walk through command list including loops, and
12682 download packets for each command. */
12685 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12686 struct command_line
*cmds
)
12688 struct remote_state
*rs
= get_remote_state ();
12689 struct command_line
*cmd
;
12691 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12693 QUIT
; /* Allow user to bail out with ^C. */
12694 strcpy (rs
->buf
.data (), "QTDPsrc:");
12695 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12696 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12697 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12699 remote_get_noisy_reply ();
12700 if (strcmp (rs
->buf
.data (), "OK"))
12701 warning (_("Target does not support source download."));
12703 if (cmd
->control_type
== while_control
12704 || cmd
->control_type
== while_stepping_control
)
12706 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12708 QUIT
; /* Allow user to bail out with ^C. */
12709 strcpy (rs
->buf
.data (), "QTDPsrc:");
12710 encode_source_string (num
, addr
, "cmd", "end",
12711 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12712 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12714 remote_get_noisy_reply ();
12715 if (strcmp (rs
->buf
.data (), "OK"))
12716 warning (_("Target does not support source download."));
12722 remote_target::download_tracepoint (struct bp_location
*loc
)
12726 std::vector
<std::string
> tdp_actions
;
12727 std::vector
<std::string
> stepping_actions
;
12729 struct breakpoint
*b
= loc
->owner
;
12730 struct tracepoint
*t
= (struct tracepoint
*) b
;
12731 struct remote_state
*rs
= get_remote_state ();
12733 const char *err_msg
= _("Tracepoint packet too large for target.");
12736 /* We use a buffer other than rs->buf because we'll build strings
12737 across multiple statements, and other statements in between could
12739 gdb::char_vector
buf (get_remote_packet_size ());
12741 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12743 tpaddr
= loc
->address
;
12744 sprintf_vma (addrbuf
, tpaddr
);
12745 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12746 b
->number
, addrbuf
, /* address */
12747 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12748 t
->step_count
, t
->pass_count
);
12750 if (ret
< 0 || ret
>= buf
.size ())
12751 error ("%s", err_msg
);
12753 /* Fast tracepoints are mostly handled by the target, but we can
12754 tell the target how big of an instruction block should be moved
12756 if (b
->type
== bp_fast_tracepoint
)
12758 /* Only test for support at download time; we may not know
12759 target capabilities at definition time. */
12760 if (remote_supports_fast_tracepoints ())
12762 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12765 size_left
= buf
.size () - strlen (buf
.data ());
12766 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12768 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12770 if (ret
< 0 || ret
>= size_left
)
12771 error ("%s", err_msg
);
12774 /* If it passed validation at definition but fails now,
12775 something is very wrong. */
12776 internal_error (__FILE__
, __LINE__
,
12777 _("Fast tracepoint not "
12778 "valid during download"));
12781 /* Fast tracepoints are functionally identical to regular
12782 tracepoints, so don't take lack of support as a reason to
12783 give up on the trace run. */
12784 warning (_("Target does not support fast tracepoints, "
12785 "downloading %d as regular tracepoint"), b
->number
);
12787 else if (b
->type
== bp_static_tracepoint
)
12789 /* Only test for support at download time; we may not know
12790 target capabilities at definition time. */
12791 if (remote_supports_static_tracepoints ())
12793 struct static_tracepoint_marker marker
;
12795 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12797 size_left
= buf
.size () - strlen (buf
.data ());
12798 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12801 if (ret
< 0 || ret
>= size_left
)
12802 error ("%s", err_msg
);
12805 error (_("Static tracepoint not valid during download"));
12808 /* Fast tracepoints are functionally identical to regular
12809 tracepoints, so don't take lack of support as a reason
12810 to give up on the trace run. */
12811 error (_("Target does not support static tracepoints"));
12813 /* If the tracepoint has a conditional, make it into an agent
12814 expression and append to the definition. */
12817 /* Only test support at download time, we may not know target
12818 capabilities at definition time. */
12819 if (remote_supports_cond_tracepoints ())
12821 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
12824 size_left
= buf
.size () - strlen (buf
.data ());
12826 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12827 size_left
, ":X%x,", aexpr
->len
);
12829 if (ret
< 0 || ret
>= size_left
)
12830 error ("%s", err_msg
);
12832 size_left
= buf
.size () - strlen (buf
.data ());
12834 /* Two bytes to encode each aexpr byte, plus the terminating
12836 if (aexpr
->len
* 2 + 1 > size_left
)
12837 error ("%s", err_msg
);
12839 pkt
= buf
.data () + strlen (buf
.data ());
12841 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12842 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12846 warning (_("Target does not support conditional tracepoints, "
12847 "ignoring tp %d cond"), b
->number
);
12850 if (b
->commands
|| *default_collect
)
12852 size_left
= buf
.size () - strlen (buf
.data ());
12854 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12857 if (ret
< 0 || ret
>= size_left
)
12858 error ("%s", err_msg
);
12861 putpkt (buf
.data ());
12862 remote_get_noisy_reply ();
12863 if (strcmp (rs
->buf
.data (), "OK"))
12864 error (_("Target does not support tracepoints."));
12866 /* do_single_steps (t); */
12867 for (auto action_it
= tdp_actions
.begin ();
12868 action_it
!= tdp_actions
.end (); action_it
++)
12870 QUIT
; /* Allow user to bail out with ^C. */
12872 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
12873 || !stepping_actions
.empty ());
12875 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
12876 b
->number
, addrbuf
, /* address */
12877 action_it
->c_str (),
12878 has_more
? '-' : 0);
12880 if (ret
< 0 || ret
>= buf
.size ())
12881 error ("%s", err_msg
);
12883 putpkt (buf
.data ());
12884 remote_get_noisy_reply ();
12885 if (strcmp (rs
->buf
.data (), "OK"))
12886 error (_("Error on target while setting tracepoints."));
12889 for (auto action_it
= stepping_actions
.begin ();
12890 action_it
!= stepping_actions
.end (); action_it
++)
12892 QUIT
; /* Allow user to bail out with ^C. */
12894 bool is_first
= action_it
== stepping_actions
.begin ();
12895 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
12897 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
12898 b
->number
, addrbuf
, /* address */
12899 is_first
? "S" : "",
12900 action_it
->c_str (),
12901 has_more
? "-" : "");
12903 if (ret
< 0 || ret
>= buf
.size ())
12904 error ("%s", err_msg
);
12906 putpkt (buf
.data ());
12907 remote_get_noisy_reply ();
12908 if (strcmp (rs
->buf
.data (), "OK"))
12909 error (_("Error on target while setting tracepoints."));
12912 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12914 if (b
->location
!= NULL
)
12916 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12918 if (ret
< 0 || ret
>= buf
.size ())
12919 error ("%s", err_msg
);
12921 encode_source_string (b
->number
, loc
->address
, "at",
12922 event_location_to_string (b
->location
.get ()),
12923 buf
.data () + strlen (buf
.data ()),
12924 buf
.size () - strlen (buf
.data ()));
12925 putpkt (buf
.data ());
12926 remote_get_noisy_reply ();
12927 if (strcmp (rs
->buf
.data (), "OK"))
12928 warning (_("Target does not support source download."));
12930 if (b
->cond_string
)
12932 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12934 if (ret
< 0 || ret
>= buf
.size ())
12935 error ("%s", err_msg
);
12937 encode_source_string (b
->number
, loc
->address
,
12938 "cond", b
->cond_string
,
12939 buf
.data () + strlen (buf
.data ()),
12940 buf
.size () - strlen (buf
.data ()));
12941 putpkt (buf
.data ());
12942 remote_get_noisy_reply ();
12943 if (strcmp (rs
->buf
.data (), "OK"))
12944 warning (_("Target does not support source download."));
12946 remote_download_command_source (b
->number
, loc
->address
,
12947 breakpoint_commands (b
));
12952 remote_target::can_download_tracepoint ()
12954 struct remote_state
*rs
= get_remote_state ();
12955 struct trace_status
*ts
;
12958 /* Don't try to install tracepoints until we've relocated our
12959 symbols, and fetched and merged the target's tracepoint list with
12961 if (rs
->starting_up
)
12964 ts
= current_trace_status ();
12965 status
= get_trace_status (ts
);
12967 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
12970 /* If we are in a tracing experiment, but remote stub doesn't support
12971 installing tracepoint in trace, we have to return. */
12972 if (!remote_supports_install_in_trace ())
12980 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
12982 struct remote_state
*rs
= get_remote_state ();
12985 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
12986 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
12988 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
12989 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
12990 >= get_remote_packet_size ())
12991 error (_("Trace state variable name too long for tsv definition packet"));
12992 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
12995 remote_get_noisy_reply ();
12996 if (rs
->buf
[0] == '\0')
12997 error (_("Target does not support this command."));
12998 if (strcmp (rs
->buf
.data (), "OK") != 0)
12999 error (_("Error on target while downloading trace state variable."));
13003 remote_target::enable_tracepoint (struct bp_location
*location
)
13005 struct remote_state
*rs
= get_remote_state ();
13008 sprintf_vma (addr_buf
, location
->address
);
13009 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13010 location
->owner
->number
, addr_buf
);
13012 remote_get_noisy_reply ();
13013 if (rs
->buf
[0] == '\0')
13014 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13015 if (strcmp (rs
->buf
.data (), "OK") != 0)
13016 error (_("Error on target while enabling tracepoint."));
13020 remote_target::disable_tracepoint (struct bp_location
*location
)
13022 struct remote_state
*rs
= get_remote_state ();
13025 sprintf_vma (addr_buf
, location
->address
);
13026 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13027 location
->owner
->number
, addr_buf
);
13029 remote_get_noisy_reply ();
13030 if (rs
->buf
[0] == '\0')
13031 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13032 if (strcmp (rs
->buf
.data (), "OK") != 0)
13033 error (_("Error on target while disabling tracepoint."));
13037 remote_target::trace_set_readonly_regions ()
13040 bfd_size_type size
;
13046 return; /* No information to give. */
13048 struct remote_state
*rs
= get_remote_state ();
13050 strcpy (rs
->buf
.data (), "QTro");
13051 offset
= strlen (rs
->buf
.data ());
13052 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
13054 char tmp1
[40], tmp2
[40];
13057 if ((s
->flags
& SEC_LOAD
) == 0 ||
13058 /* (s->flags & SEC_CODE) == 0 || */
13059 (s
->flags
& SEC_READONLY
) == 0)
13063 vma
= bfd_section_vma (s
);
13064 size
= bfd_section_size (s
);
13065 sprintf_vma (tmp1
, vma
);
13066 sprintf_vma (tmp2
, vma
+ size
);
13067 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13068 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13070 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13072 Too many sections for read-only sections definition packet."));
13075 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13077 offset
+= sec_length
;
13082 getpkt (&rs
->buf
, 0);
13087 remote_target::trace_start ()
13089 struct remote_state
*rs
= get_remote_state ();
13091 putpkt ("QTStart");
13092 remote_get_noisy_reply ();
13093 if (rs
->buf
[0] == '\0')
13094 error (_("Target does not support this command."));
13095 if (strcmp (rs
->buf
.data (), "OK") != 0)
13096 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13100 remote_target::get_trace_status (struct trace_status
*ts
)
13102 /* Initialize it just to avoid a GCC false warning. */
13104 enum packet_result result
;
13105 struct remote_state
*rs
= get_remote_state ();
13107 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13110 /* FIXME we need to get register block size some other way. */
13111 trace_regblock_size
13112 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13114 putpkt ("qTStatus");
13118 p
= remote_get_noisy_reply ();
13120 catch (const gdb_exception_error
&ex
)
13122 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13124 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13130 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13132 /* If the remote target doesn't do tracing, flag it. */
13133 if (result
== PACKET_UNKNOWN
)
13136 /* We're working with a live target. */
13137 ts
->filename
= NULL
;
13140 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13142 /* Function 'parse_trace_status' sets default value of each field of
13143 'ts' at first, so we don't have to do it here. */
13144 parse_trace_status (p
, ts
);
13146 return ts
->running
;
13150 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13151 struct uploaded_tp
*utp
)
13153 struct remote_state
*rs
= get_remote_state ();
13155 struct bp_location
*loc
;
13156 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13157 size_t size
= get_remote_packet_size ();
13162 tp
->traceframe_usage
= 0;
13163 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13165 /* If the tracepoint was never downloaded, don't go asking for
13167 if (tp
->number_on_target
== 0)
13169 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13170 phex_nz (loc
->address
, 0));
13172 reply
= remote_get_noisy_reply ();
13173 if (reply
&& *reply
)
13176 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13182 utp
->hit_count
= 0;
13183 utp
->traceframe_usage
= 0;
13184 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13185 phex_nz (utp
->addr
, 0));
13187 reply
= remote_get_noisy_reply ();
13188 if (reply
&& *reply
)
13191 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13197 remote_target::trace_stop ()
13199 struct remote_state
*rs
= get_remote_state ();
13202 remote_get_noisy_reply ();
13203 if (rs
->buf
[0] == '\0')
13204 error (_("Target does not support this command."));
13205 if (strcmp (rs
->buf
.data (), "OK") != 0)
13206 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13210 remote_target::trace_find (enum trace_find_type type
, int num
,
13211 CORE_ADDR addr1
, CORE_ADDR addr2
,
13214 struct remote_state
*rs
= get_remote_state ();
13215 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13217 int target_frameno
= -1, target_tracept
= -1;
13219 /* Lookups other than by absolute frame number depend on the current
13220 trace selected, so make sure it is correct on the remote end
13222 if (type
!= tfind_number
)
13223 set_remote_traceframe ();
13225 p
= rs
->buf
.data ();
13226 strcpy (p
, "QTFrame:");
13227 p
= strchr (p
, '\0');
13231 xsnprintf (p
, endbuf
- p
, "%x", num
);
13234 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13237 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13240 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13241 phex_nz (addr2
, 0));
13243 case tfind_outside
:
13244 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13245 phex_nz (addr2
, 0));
13248 error (_("Unknown trace find type %d"), type
);
13252 reply
= remote_get_noisy_reply ();
13253 if (*reply
== '\0')
13254 error (_("Target does not support this command."));
13256 while (reply
&& *reply
)
13261 target_frameno
= (int) strtol (p
, &reply
, 16);
13263 error (_("Unable to parse trace frame number"));
13264 /* Don't update our remote traceframe number cache on failure
13265 to select a remote traceframe. */
13266 if (target_frameno
== -1)
13271 target_tracept
= (int) strtol (p
, &reply
, 16);
13273 error (_("Unable to parse tracepoint number"));
13275 case 'O': /* "OK"? */
13276 if (reply
[1] == 'K' && reply
[2] == '\0')
13279 error (_("Bogus reply from target: %s"), reply
);
13282 error (_("Bogus reply from target: %s"), reply
);
13285 *tpp
= target_tracept
;
13287 rs
->remote_traceframe_number
= target_frameno
;
13288 return target_frameno
;
13292 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13294 struct remote_state
*rs
= get_remote_state ();
13298 set_remote_traceframe ();
13300 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13302 reply
= remote_get_noisy_reply ();
13303 if (reply
&& *reply
)
13307 unpack_varlen_hex (reply
+ 1, &uval
);
13308 *val
= (LONGEST
) uval
;
13316 remote_target::save_trace_data (const char *filename
)
13318 struct remote_state
*rs
= get_remote_state ();
13321 p
= rs
->buf
.data ();
13322 strcpy (p
, "QTSave:");
13324 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13325 >= get_remote_packet_size ())
13326 error (_("Remote file name too long for trace save packet"));
13327 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13330 reply
= remote_get_noisy_reply ();
13331 if (*reply
== '\0')
13332 error (_("Target does not support this command."));
13333 if (strcmp (reply
, "OK") != 0)
13334 error (_("Bogus reply from target: %s"), reply
);
13338 /* This is basically a memory transfer, but needs to be its own packet
13339 because we don't know how the target actually organizes its trace
13340 memory, plus we want to be able to ask for as much as possible, but
13341 not be unhappy if we don't get as much as we ask for. */
13344 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13346 struct remote_state
*rs
= get_remote_state ();
13351 p
= rs
->buf
.data ();
13352 strcpy (p
, "qTBuffer:");
13354 p
+= hexnumstr (p
, offset
);
13356 p
+= hexnumstr (p
, len
);
13360 reply
= remote_get_noisy_reply ();
13361 if (reply
&& *reply
)
13363 /* 'l' by itself means we're at the end of the buffer and
13364 there is nothing more to get. */
13368 /* Convert the reply into binary. Limit the number of bytes to
13369 convert according to our passed-in buffer size, rather than
13370 what was returned in the packet; if the target is
13371 unexpectedly generous and gives us a bigger reply than we
13372 asked for, we don't want to crash. */
13373 rslt
= hex2bin (reply
, buf
, len
);
13377 /* Something went wrong, flag as an error. */
13382 remote_target::set_disconnected_tracing (int val
)
13384 struct remote_state
*rs
= get_remote_state ();
13386 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13390 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13391 "QTDisconnected:%x", val
);
13393 reply
= remote_get_noisy_reply ();
13394 if (*reply
== '\0')
13395 error (_("Target does not support this command."));
13396 if (strcmp (reply
, "OK") != 0)
13397 error (_("Bogus reply from target: %s"), reply
);
13400 warning (_("Target does not support disconnected tracing."));
13404 remote_target::core_of_thread (ptid_t ptid
)
13406 struct thread_info
*info
= find_thread_ptid (ptid
);
13408 if (info
!= NULL
&& info
->priv
!= NULL
)
13409 return get_remote_thread_info (info
)->core
;
13415 remote_target::set_circular_trace_buffer (int val
)
13417 struct remote_state
*rs
= get_remote_state ();
13420 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13421 "QTBuffer:circular:%x", val
);
13423 reply
= remote_get_noisy_reply ();
13424 if (*reply
== '\0')
13425 error (_("Target does not support this command."));
13426 if (strcmp (reply
, "OK") != 0)
13427 error (_("Bogus reply from target: %s"), reply
);
13431 remote_target::traceframe_info ()
13433 gdb::optional
<gdb::char_vector
> text
13434 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13437 return parse_traceframe_info (text
->data ());
13442 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13443 instruction on which a fast tracepoint may be placed. Returns -1
13444 if the packet is not supported, and 0 if the minimum instruction
13445 length is unknown. */
13448 remote_target::get_min_fast_tracepoint_insn_len ()
13450 struct remote_state
*rs
= get_remote_state ();
13453 /* If we're not debugging a process yet, the IPA can't be
13455 if (!target_has_execution
)
13458 /* Make sure the remote is pointing at the right process. */
13459 set_general_process ();
13461 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13463 reply
= remote_get_noisy_reply ();
13464 if (*reply
== '\0')
13468 ULONGEST min_insn_len
;
13470 unpack_varlen_hex (reply
, &min_insn_len
);
13472 return (int) min_insn_len
;
13477 remote_target::set_trace_buffer_size (LONGEST val
)
13479 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13481 struct remote_state
*rs
= get_remote_state ();
13482 char *buf
= rs
->buf
.data ();
13483 char *endbuf
= buf
+ get_remote_packet_size ();
13484 enum packet_result result
;
13486 gdb_assert (val
>= 0 || val
== -1);
13487 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13488 /* Send -1 as literal "-1" to avoid host size dependency. */
13492 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13495 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13498 remote_get_noisy_reply ();
13499 result
= packet_ok (rs
->buf
,
13500 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13502 if (result
!= PACKET_OK
)
13503 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13508 remote_target::set_trace_notes (const char *user
, const char *notes
,
13509 const char *stop_notes
)
13511 struct remote_state
*rs
= get_remote_state ();
13513 char *buf
= rs
->buf
.data ();
13514 char *endbuf
= buf
+ get_remote_packet_size ();
13517 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13520 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13521 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13527 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13528 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13534 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13535 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13539 /* Ensure the buffer is terminated. */
13543 reply
= remote_get_noisy_reply ();
13544 if (*reply
== '\0')
13547 if (strcmp (reply
, "OK") != 0)
13548 error (_("Bogus reply from target: %s"), reply
);
13554 remote_target::use_agent (bool use
)
13556 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13558 struct remote_state
*rs
= get_remote_state ();
13560 /* If the stub supports QAgent. */
13561 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13563 getpkt (&rs
->buf
, 0);
13565 if (strcmp (rs
->buf
.data (), "OK") == 0)
13576 remote_target::can_use_agent ()
13578 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13581 struct btrace_target_info
13583 /* The ptid of the traced thread. */
13586 /* The obtained branch trace configuration. */
13587 struct btrace_config conf
;
13590 /* Reset our idea of our target's btrace configuration. */
13593 remote_btrace_reset (remote_state
*rs
)
13595 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13598 /* Synchronize the configuration with the target. */
13601 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13603 struct packet_config
*packet
;
13604 struct remote_state
*rs
;
13605 char *buf
, *pos
, *endbuf
;
13607 rs
= get_remote_state ();
13608 buf
= rs
->buf
.data ();
13609 endbuf
= buf
+ get_remote_packet_size ();
13611 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13612 if (packet_config_support (packet
) == PACKET_ENABLE
13613 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13616 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13620 getpkt (&rs
->buf
, 0);
13622 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13624 if (buf
[0] == 'E' && buf
[1] == '.')
13625 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13627 error (_("Failed to configure the BTS buffer size."));
13630 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13633 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13634 if (packet_config_support (packet
) == PACKET_ENABLE
13635 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13638 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13642 getpkt (&rs
->buf
, 0);
13644 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13646 if (buf
[0] == 'E' && buf
[1] == '.')
13647 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13649 error (_("Failed to configure the trace buffer size."));
13652 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13656 /* Read the current thread's btrace configuration from the target and
13657 store it into CONF. */
13660 btrace_read_config (struct btrace_config
*conf
)
13662 gdb::optional
<gdb::char_vector
> xml
13663 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13665 parse_xml_btrace_conf (conf
, xml
->data ());
13668 /* Maybe reopen target btrace. */
13671 remote_target::remote_btrace_maybe_reopen ()
13673 struct remote_state
*rs
= get_remote_state ();
13674 int btrace_target_pushed
= 0;
13675 #if !defined (HAVE_LIBIPT)
13679 /* Don't bother walking the entirety of the remote thread list when
13680 we know the feature isn't supported by the remote. */
13681 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13684 scoped_restore_current_thread restore_thread
;
13686 for (thread_info
*tp
: all_non_exited_threads ())
13688 set_general_thread (tp
->ptid
);
13690 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13691 btrace_read_config (&rs
->btrace_config
);
13693 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13696 #if !defined (HAVE_LIBIPT)
13697 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13702 warning (_("Target is recording using Intel Processor Trace "
13703 "but support was disabled at compile time."));
13708 #endif /* !defined (HAVE_LIBIPT) */
13710 /* Push target, once, but before anything else happens. This way our
13711 changes to the threads will be cleaned up by unpushing the target
13712 in case btrace_read_config () throws. */
13713 if (!btrace_target_pushed
)
13715 btrace_target_pushed
= 1;
13716 record_btrace_push_target ();
13717 printf_filtered (_("Target is recording using %s.\n"),
13718 btrace_format_string (rs
->btrace_config
.format
));
13721 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13722 tp
->btrace
.target
->ptid
= tp
->ptid
;
13723 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13727 /* Enable branch tracing. */
13729 struct btrace_target_info
*
13730 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13732 struct btrace_target_info
*tinfo
= NULL
;
13733 struct packet_config
*packet
= NULL
;
13734 struct remote_state
*rs
= get_remote_state ();
13735 char *buf
= rs
->buf
.data ();
13736 char *endbuf
= buf
+ get_remote_packet_size ();
13738 switch (conf
->format
)
13740 case BTRACE_FORMAT_BTS
:
13741 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13744 case BTRACE_FORMAT_PT
:
13745 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13749 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13750 error (_("Target does not support branch tracing."));
13752 btrace_sync_conf (conf
);
13754 set_general_thread (ptid
);
13756 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13758 getpkt (&rs
->buf
, 0);
13760 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13762 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13763 error (_("Could not enable branch tracing for %s: %s"),
13764 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
13766 error (_("Could not enable branch tracing for %s."),
13767 target_pid_to_str (ptid
).c_str ());
13770 tinfo
= XCNEW (struct btrace_target_info
);
13771 tinfo
->ptid
= ptid
;
13773 /* If we fail to read the configuration, we lose some information, but the
13774 tracing itself is not impacted. */
13777 btrace_read_config (&tinfo
->conf
);
13779 catch (const gdb_exception_error
&err
)
13781 if (err
.message
!= NULL
)
13782 warning ("%s", err
.what ());
13788 /* Disable branch tracing. */
13791 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
13793 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13794 struct remote_state
*rs
= get_remote_state ();
13795 char *buf
= rs
->buf
.data ();
13796 char *endbuf
= buf
+ get_remote_packet_size ();
13798 if (packet_config_support (packet
) != PACKET_ENABLE
)
13799 error (_("Target does not support branch tracing."));
13801 set_general_thread (tinfo
->ptid
);
13803 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13805 getpkt (&rs
->buf
, 0);
13807 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13809 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13810 error (_("Could not disable branch tracing for %s: %s"),
13811 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
13813 error (_("Could not disable branch tracing for %s."),
13814 target_pid_to_str (tinfo
->ptid
).c_str ());
13820 /* Teardown branch tracing. */
13823 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
13825 /* We must not talk to the target during teardown. */
13829 /* Read the branch trace. */
13832 remote_target::read_btrace (struct btrace_data
*btrace
,
13833 struct btrace_target_info
*tinfo
,
13834 enum btrace_read_type type
)
13836 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13839 if (packet_config_support (packet
) != PACKET_ENABLE
)
13840 error (_("Target does not support branch tracing."));
13842 #if !defined(HAVE_LIBEXPAT)
13843 error (_("Cannot process branch tracing result. XML parsing not supported."));
13848 case BTRACE_READ_ALL
:
13851 case BTRACE_READ_NEW
:
13854 case BTRACE_READ_DELTA
:
13858 internal_error (__FILE__
, __LINE__
,
13859 _("Bad branch tracing read type: %u."),
13860 (unsigned int) type
);
13863 gdb::optional
<gdb::char_vector
> xml
13864 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
13866 return BTRACE_ERR_UNKNOWN
;
13868 parse_xml_btrace (btrace
, xml
->data ());
13870 return BTRACE_ERR_NONE
;
13873 const struct btrace_config
*
13874 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
13876 return &tinfo
->conf
;
13880 remote_target::augmented_libraries_svr4_read ()
13882 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13886 /* Implementation of to_load. */
13889 remote_target::load (const char *name
, int from_tty
)
13891 generic_load (name
, from_tty
);
13894 /* Accepts an integer PID; returns a string representing a file that
13895 can be opened on the remote side to get the symbols for the child
13896 process. Returns NULL if the operation is not supported. */
13899 remote_target::pid_to_exec_file (int pid
)
13901 static gdb::optional
<gdb::char_vector
> filename
;
13902 struct inferior
*inf
;
13903 char *annex
= NULL
;
13905 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13908 inf
= find_inferior_pid (pid
);
13910 internal_error (__FILE__
, __LINE__
,
13911 _("not currently attached to process %d"), pid
);
13913 if (!inf
->fake_pid_p
)
13915 const int annex_size
= 9;
13917 annex
= (char *) alloca (annex_size
);
13918 xsnprintf (annex
, annex_size
, "%x", pid
);
13921 filename
= target_read_stralloc (current_top_target (),
13922 TARGET_OBJECT_EXEC_FILE
, annex
);
13924 return filename
? filename
->data () : nullptr;
13927 /* Implement the to_can_do_single_step target_ops method. */
13930 remote_target::can_do_single_step ()
13932 /* We can only tell whether target supports single step or not by
13933 supported s and S vCont actions if the stub supports vContSupported
13934 feature. If the stub doesn't support vContSupported feature,
13935 we have conservatively to think target doesn't supports single
13937 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
13939 struct remote_state
*rs
= get_remote_state ();
13941 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13942 remote_vcont_probe ();
13944 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
13950 /* Implementation of the to_execution_direction method for the remote
13953 enum exec_direction_kind
13954 remote_target::execution_direction ()
13956 struct remote_state
*rs
= get_remote_state ();
13958 return rs
->last_resume_exec_dir
;
13961 /* Return pointer to the thread_info struct which corresponds to
13962 THREAD_HANDLE (having length HANDLE_LEN). */
13965 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
13969 for (thread_info
*tp
: all_non_exited_threads ())
13971 remote_thread_info
*priv
= get_remote_thread_info (tp
);
13973 if (tp
->inf
== inf
&& priv
!= NULL
)
13975 if (handle_len
!= priv
->thread_handle
.size ())
13976 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
13977 handle_len
, priv
->thread_handle
.size ());
13978 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
13988 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
13990 remote_thread_info
*priv
= get_remote_thread_info (tp
);
13991 return priv
->thread_handle
;
13995 remote_target::can_async_p ()
13997 struct remote_state
*rs
= get_remote_state ();
13999 /* We don't go async if the user has explicitly prevented it with the
14000 "maint set target-async" command. */
14001 if (!target_async_permitted
)
14004 /* We're async whenever the serial device is. */
14005 return serial_can_async_p (rs
->remote_desc
);
14009 remote_target::is_async_p ()
14011 struct remote_state
*rs
= get_remote_state ();
14013 if (!target_async_permitted
)
14014 /* We only enable async when the user specifically asks for it. */
14017 /* We're async whenever the serial device is. */
14018 return serial_is_async_p (rs
->remote_desc
);
14021 /* Pass the SERIAL event on and up to the client. One day this code
14022 will be able to delay notifying the client of an event until the
14023 point where an entire packet has been received. */
14025 static serial_event_ftype remote_async_serial_handler
;
14028 remote_async_serial_handler (struct serial
*scb
, void *context
)
14030 /* Don't propogate error information up to the client. Instead let
14031 the client find out about the error by querying the target. */
14032 inferior_event_handler (INF_REG_EVENT
, NULL
);
14036 remote_async_inferior_event_handler (gdb_client_data data
)
14038 inferior_event_handler (INF_REG_EVENT
, data
);
14042 remote_target::async (int enable
)
14044 struct remote_state
*rs
= get_remote_state ();
14048 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14050 /* If there are pending events in the stop reply queue tell the
14051 event loop to process them. */
14052 if (!rs
->stop_reply_queue
.empty ())
14053 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14054 /* For simplicity, below we clear the pending events token
14055 without remembering whether it is marked, so here we always
14056 mark it. If there's actually no pending notification to
14057 process, this ends up being a no-op (other than a spurious
14058 event-loop wakeup). */
14059 if (target_is_non_stop_p ())
14060 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14064 serial_async (rs
->remote_desc
, NULL
, NULL
);
14065 /* If the core is disabling async, it doesn't want to be
14066 disturbed with target events. Clear all async event sources
14068 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14069 if (target_is_non_stop_p ())
14070 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14074 /* Implementation of the to_thread_events method. */
14077 remote_target::thread_events (int enable
)
14079 struct remote_state
*rs
= get_remote_state ();
14080 size_t size
= get_remote_packet_size ();
14082 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14085 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14087 getpkt (&rs
->buf
, 0);
14089 switch (packet_ok (rs
->buf
,
14090 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14093 if (strcmp (rs
->buf
.data (), "OK") != 0)
14094 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14097 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14099 case PACKET_UNKNOWN
:
14105 set_remote_cmd (const char *args
, int from_tty
)
14107 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
14111 show_remote_cmd (const char *args
, int from_tty
)
14113 /* We can't just use cmd_show_list here, because we want to skip
14114 the redundant "show remote Z-packet" and the legacy aliases. */
14115 struct cmd_list_element
*list
= remote_show_cmdlist
;
14116 struct ui_out
*uiout
= current_uiout
;
14118 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14119 for (; list
!= NULL
; list
= list
->next
)
14120 if (strcmp (list
->name
, "Z-packet") == 0)
14122 else if (list
->type
== not_set_cmd
)
14123 /* Alias commands are exactly like the original, except they
14124 don't have the normal type. */
14128 ui_out_emit_tuple
option_emitter (uiout
, "option");
14130 uiout
->field_string ("name", list
->name
);
14131 uiout
->text (": ");
14132 if (list
->type
== show_cmd
)
14133 do_show_command (NULL
, from_tty
, list
);
14135 cmd_func (list
, NULL
, from_tty
);
14140 /* Function to be called whenever a new objfile (shlib) is detected. */
14142 remote_new_objfile (struct objfile
*objfile
)
14144 remote_target
*remote
= get_current_remote_target ();
14146 if (remote
!= NULL
) /* Have a remote connection. */
14147 remote
->remote_check_symbols ();
14150 /* Pull all the tracepoints defined on the target and create local
14151 data structures representing them. We don't want to create real
14152 tracepoints yet, we don't want to mess up the user's existing
14156 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14158 struct remote_state
*rs
= get_remote_state ();
14161 /* Ask for a first packet of tracepoint definition. */
14163 getpkt (&rs
->buf
, 0);
14164 p
= rs
->buf
.data ();
14165 while (*p
&& *p
!= 'l')
14167 parse_tracepoint_definition (p
, utpp
);
14168 /* Ask for another packet of tracepoint definition. */
14170 getpkt (&rs
->buf
, 0);
14171 p
= rs
->buf
.data ();
14177 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14179 struct remote_state
*rs
= get_remote_state ();
14182 /* Ask for a first packet of variable definition. */
14184 getpkt (&rs
->buf
, 0);
14185 p
= rs
->buf
.data ();
14186 while (*p
&& *p
!= 'l')
14188 parse_tsv_definition (p
, utsvp
);
14189 /* Ask for another packet of variable definition. */
14191 getpkt (&rs
->buf
, 0);
14192 p
= rs
->buf
.data ();
14197 /* The "set/show range-stepping" show hook. */
14200 show_range_stepping (struct ui_file
*file
, int from_tty
,
14201 struct cmd_list_element
*c
,
14204 fprintf_filtered (file
,
14205 _("Debugger's willingness to use range stepping "
14206 "is %s.\n"), value
);
14209 /* Return true if the vCont;r action is supported by the remote
14213 remote_target::vcont_r_supported ()
14215 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14216 remote_vcont_probe ();
14218 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14219 && get_remote_state ()->supports_vCont
.r
);
14222 /* The "set/show range-stepping" set hook. */
14225 set_range_stepping (const char *ignore_args
, int from_tty
,
14226 struct cmd_list_element
*c
)
14228 /* When enabling, check whether range stepping is actually supported
14229 by the target, and warn if not. */
14230 if (use_range_stepping
)
14232 remote_target
*remote
= get_current_remote_target ();
14234 || !remote
->vcont_r_supported ())
14235 warning (_("Range stepping is not supported by the current target"));
14240 _initialize_remote (void)
14242 struct cmd_list_element
*cmd
;
14243 const char *cmd_name
;
14245 /* architecture specific data */
14246 remote_g_packet_data_handle
=
14247 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14249 add_target (remote_target_info
, remote_target::open
);
14250 add_target (extended_remote_target_info
, extended_remote_target::open
);
14252 /* Hook into new objfile notification. */
14253 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14256 init_remote_threadtests ();
14259 /* set/show remote ... */
14261 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14262 Remote protocol specific variables.\n\
14263 Configure various remote-protocol specific variables such as\n\
14264 the packets being used."),
14265 &remote_set_cmdlist
, "set remote ",
14266 0 /* allow-unknown */, &setlist
);
14267 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14268 Remote protocol specific variables.\n\
14269 Configure various remote-protocol specific variables such as\n\
14270 the packets being used."),
14271 &remote_show_cmdlist
, "show remote ",
14272 0 /* allow-unknown */, &showlist
);
14274 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14275 Compare section data on target to the exec file.\n\
14276 Argument is a single section name (default: all loaded sections).\n\
14277 To compare only read-only loaded sections, specify the -r option."),
14280 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14281 Send an arbitrary packet to a remote target.\n\
14282 maintenance packet TEXT\n\
14283 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14284 this command sends the string TEXT to the inferior, and displays the\n\
14285 response packet. GDB supplies the initial `$' character, and the\n\
14286 terminating `#' character and checksum."),
14289 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14290 Set whether to send break if interrupted."), _("\
14291 Show whether to send break if interrupted."), _("\
14292 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14293 set_remotebreak
, show_remotebreak
,
14294 &setlist
, &showlist
);
14295 cmd_name
= "remotebreak";
14296 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14297 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14298 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14299 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14300 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14302 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14303 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14305 Set interrupt sequence to remote target."), _("\
14306 Show interrupt sequence to remote target."), _("\
14307 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14308 NULL
, show_interrupt_sequence
,
14309 &remote_set_cmdlist
,
14310 &remote_show_cmdlist
);
14312 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14313 &interrupt_on_connect
, _("\
14314 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14315 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14316 If set, interrupt sequence is sent to remote target."),
14318 &remote_set_cmdlist
, &remote_show_cmdlist
);
14320 /* Install commands for configuring memory read/write packets. */
14322 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14323 Set the maximum number of bytes per memory write packet (deprecated)."),
14325 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14326 Show the maximum number of bytes per memory write packet (deprecated)."),
14328 add_cmd ("memory-write-packet-size", no_class
,
14329 set_memory_write_packet_size
, _("\
14330 Set the maximum number of bytes per memory-write packet.\n\
14331 Specify the number of bytes in a packet or 0 (zero) for the\n\
14332 default packet size. The actual limit is further reduced\n\
14333 dependent on the target. Specify ``fixed'' to disable the\n\
14334 further restriction and ``limit'' to enable that restriction."),
14335 &remote_set_cmdlist
);
14336 add_cmd ("memory-read-packet-size", no_class
,
14337 set_memory_read_packet_size
, _("\
14338 Set the maximum number of bytes per memory-read packet.\n\
14339 Specify the number of bytes in a packet or 0 (zero) for the\n\
14340 default packet size. The actual limit is further reduced\n\
14341 dependent on the target. Specify ``fixed'' to disable the\n\
14342 further restriction and ``limit'' to enable that restriction."),
14343 &remote_set_cmdlist
);
14344 add_cmd ("memory-write-packet-size", no_class
,
14345 show_memory_write_packet_size
,
14346 _("Show the maximum number of bytes per memory-write packet."),
14347 &remote_show_cmdlist
);
14348 add_cmd ("memory-read-packet-size", no_class
,
14349 show_memory_read_packet_size
,
14350 _("Show the maximum number of bytes per memory-read packet."),
14351 &remote_show_cmdlist
);
14353 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14354 &remote_hw_watchpoint_limit
, _("\
14355 Set the maximum number of target hardware watchpoints."), _("\
14356 Show the maximum number of target hardware watchpoints."), _("\
14357 Specify \"unlimited\" for unlimited hardware watchpoints."),
14358 NULL
, show_hardware_watchpoint_limit
,
14359 &remote_set_cmdlist
,
14360 &remote_show_cmdlist
);
14361 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14363 &remote_hw_watchpoint_length_limit
, _("\
14364 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14365 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14366 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14367 NULL
, show_hardware_watchpoint_length_limit
,
14368 &remote_set_cmdlist
, &remote_show_cmdlist
);
14369 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14370 &remote_hw_breakpoint_limit
, _("\
14371 Set the maximum number of target hardware breakpoints."), _("\
14372 Show the maximum number of target hardware breakpoints."), _("\
14373 Specify \"unlimited\" for unlimited hardware breakpoints."),
14374 NULL
, show_hardware_breakpoint_limit
,
14375 &remote_set_cmdlist
, &remote_show_cmdlist
);
14377 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14378 &remote_address_size
, _("\
14379 Set the maximum size of the address (in bits) in a memory packet."), _("\
14380 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14382 NULL
, /* FIXME: i18n: */
14383 &setlist
, &showlist
);
14385 init_all_packet_configs ();
14387 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14388 "X", "binary-download", 1);
14390 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14391 "vCont", "verbose-resume", 0);
14393 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14394 "QPassSignals", "pass-signals", 0);
14396 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14397 "QCatchSyscalls", "catch-syscalls", 0);
14399 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14400 "QProgramSignals", "program-signals", 0);
14402 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14403 "QSetWorkingDir", "set-working-dir", 0);
14405 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14406 "QStartupWithShell", "startup-with-shell", 0);
14408 add_packet_config_cmd (&remote_protocol_packets
14409 [PACKET_QEnvironmentHexEncoded
],
14410 "QEnvironmentHexEncoded", "environment-hex-encoded",
14413 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14414 "QEnvironmentReset", "environment-reset",
14417 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14418 "QEnvironmentUnset", "environment-unset",
14421 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14422 "qSymbol", "symbol-lookup", 0);
14424 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14425 "P", "set-register", 1);
14427 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14428 "p", "fetch-register", 1);
14430 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14431 "Z0", "software-breakpoint", 0);
14433 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14434 "Z1", "hardware-breakpoint", 0);
14436 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14437 "Z2", "write-watchpoint", 0);
14439 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14440 "Z3", "read-watchpoint", 0);
14442 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14443 "Z4", "access-watchpoint", 0);
14445 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14446 "qXfer:auxv:read", "read-aux-vector", 0);
14448 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14449 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14451 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14452 "qXfer:features:read", "target-features", 0);
14454 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14455 "qXfer:libraries:read", "library-info", 0);
14457 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14458 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14460 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14461 "qXfer:memory-map:read", "memory-map", 0);
14463 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14464 "qXfer:osdata:read", "osdata", 0);
14466 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14467 "qXfer:threads:read", "threads", 0);
14469 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14470 "qXfer:siginfo:read", "read-siginfo-object", 0);
14472 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14473 "qXfer:siginfo:write", "write-siginfo-object", 0);
14475 add_packet_config_cmd
14476 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14477 "qXfer:traceframe-info:read", "traceframe-info", 0);
14479 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14480 "qXfer:uib:read", "unwind-info-block", 0);
14482 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14483 "qGetTLSAddr", "get-thread-local-storage-address",
14486 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14487 "qGetTIBAddr", "get-thread-information-block-address",
14490 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14491 "bc", "reverse-continue", 0);
14493 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14494 "bs", "reverse-step", 0);
14496 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14497 "qSupported", "supported-packets", 0);
14499 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14500 "qSearch:memory", "search-memory", 0);
14502 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14503 "qTStatus", "trace-status", 0);
14505 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14506 "vFile:setfs", "hostio-setfs", 0);
14508 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14509 "vFile:open", "hostio-open", 0);
14511 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14512 "vFile:pread", "hostio-pread", 0);
14514 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14515 "vFile:pwrite", "hostio-pwrite", 0);
14517 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14518 "vFile:close", "hostio-close", 0);
14520 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14521 "vFile:unlink", "hostio-unlink", 0);
14523 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14524 "vFile:readlink", "hostio-readlink", 0);
14526 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14527 "vFile:fstat", "hostio-fstat", 0);
14529 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14530 "vAttach", "attach", 0);
14532 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14535 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14536 "QStartNoAckMode", "noack", 0);
14538 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14539 "vKill", "kill", 0);
14541 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14542 "qAttached", "query-attached", 0);
14544 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14545 "ConditionalTracepoints",
14546 "conditional-tracepoints", 0);
14548 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14549 "ConditionalBreakpoints",
14550 "conditional-breakpoints", 0);
14552 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14553 "BreakpointCommands",
14554 "breakpoint-commands", 0);
14556 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14557 "FastTracepoints", "fast-tracepoints", 0);
14559 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14560 "TracepointSource", "TracepointSource", 0);
14562 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14563 "QAllow", "allow", 0);
14565 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14566 "StaticTracepoints", "static-tracepoints", 0);
14568 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14569 "InstallInTrace", "install-in-trace", 0);
14571 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14572 "qXfer:statictrace:read", "read-sdata-object", 0);
14574 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14575 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14577 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14578 "QDisableRandomization", "disable-randomization", 0);
14580 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14581 "QAgent", "agent", 0);
14583 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14584 "QTBuffer:size", "trace-buffer-size", 0);
14586 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14587 "Qbtrace:off", "disable-btrace", 0);
14589 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14590 "Qbtrace:bts", "enable-btrace-bts", 0);
14592 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14593 "Qbtrace:pt", "enable-btrace-pt", 0);
14595 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14596 "qXfer:btrace", "read-btrace", 0);
14598 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14599 "qXfer:btrace-conf", "read-btrace-conf", 0);
14601 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14602 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14604 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14605 "multiprocess-feature", "multiprocess-feature", 0);
14607 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14608 "swbreak-feature", "swbreak-feature", 0);
14610 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14611 "hwbreak-feature", "hwbreak-feature", 0);
14613 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14614 "fork-event-feature", "fork-event-feature", 0);
14616 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14617 "vfork-event-feature", "vfork-event-feature", 0);
14619 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14620 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14622 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14623 "vContSupported", "verbose-resume-supported", 0);
14625 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14626 "exec-event-feature", "exec-event-feature", 0);
14628 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14629 "vCtrlC", "ctrl-c", 0);
14631 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14632 "QThreadEvents", "thread-events", 0);
14634 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14635 "N stop reply", "no-resumed-stop-reply", 0);
14637 /* Assert that we've registered "set remote foo-packet" commands
14638 for all packet configs. */
14642 for (i
= 0; i
< PACKET_MAX
; i
++)
14644 /* Ideally all configs would have a command associated. Some
14645 still don't though. */
14650 case PACKET_QNonStop
:
14651 case PACKET_EnableDisableTracepoints_feature
:
14652 case PACKET_tracenz_feature
:
14653 case PACKET_DisconnectedTracing_feature
:
14654 case PACKET_augmented_libraries_svr4_read_feature
:
14656 /* Additions to this list need to be well justified:
14657 pre-existing packets are OK; new packets are not. */
14665 /* This catches both forgetting to add a config command, and
14666 forgetting to remove a packet from the exception list. */
14667 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14671 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14672 Z sub-packet has its own set and show commands, but users may
14673 have sets to this variable in their .gdbinit files (or in their
14675 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14676 &remote_Z_packet_detect
, _("\
14677 Set use of remote protocol `Z' packets."), _("\
14678 Show use of remote protocol `Z' packets."), _("\
14679 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14681 set_remote_protocol_Z_packet_cmd
,
14682 show_remote_protocol_Z_packet_cmd
,
14683 /* FIXME: i18n: Use of remote protocol
14684 `Z' packets is %s. */
14685 &remote_set_cmdlist
, &remote_show_cmdlist
);
14687 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14688 Manipulate files on the remote system.\n\
14689 Transfer files to and from the remote target system."),
14690 &remote_cmdlist
, "remote ",
14691 0 /* allow-unknown */, &cmdlist
);
14693 add_cmd ("put", class_files
, remote_put_command
,
14694 _("Copy a local file to the remote system."),
14697 add_cmd ("get", class_files
, remote_get_command
,
14698 _("Copy a remote file to the local system."),
14701 add_cmd ("delete", class_files
, remote_delete_command
,
14702 _("Delete a remote file."),
14705 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14706 &remote_exec_file_var
, _("\
14707 Set the remote pathname for \"run\"."), _("\
14708 Show the remote pathname for \"run\"."), NULL
,
14709 set_remote_exec_file
,
14710 show_remote_exec_file
,
14711 &remote_set_cmdlist
,
14712 &remote_show_cmdlist
);
14714 add_setshow_boolean_cmd ("range-stepping", class_run
,
14715 &use_range_stepping
, _("\
14716 Enable or disable range stepping."), _("\
14717 Show whether target-assisted range stepping is enabled."), _("\
14718 If on, and the target supports it, when stepping a source line, GDB\n\
14719 tells the target to step the corresponding range of addresses itself instead\n\
14720 of issuing multiple single-steps. This speeds up source level\n\
14721 stepping. If off, GDB always issues single-steps, even if range\n\
14722 stepping is supported by the target. The default is on."),
14723 set_range_stepping
,
14724 show_range_stepping
,
14728 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
14729 Set watchdog timer."), _("\
14730 Show watchdog timer."), _("\
14731 When non-zero, this timeout is used instead of waiting forever for a target\n\
14732 to finish a low-level step or continue operation. If the specified amount\n\
14733 of time passes without a response from the target, an error occurs."),
14736 &setlist
, &showlist
);
14738 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
14739 &remote_packet_max_chars
, _("\
14740 Set the maximum number of characters to display for each remote packet."), _("\
14741 Show the maximum number of characters to display for each remote packet."), _("\
14742 Specify \"unlimited\" to display all the characters."),
14743 NULL
, show_remote_packet_max_chars
,
14744 &setdebuglist
, &showdebuglist
);
14746 /* Eventually initialize fileio. See fileio.c */
14747 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);