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 ();
2371 /* However, if the current inferior is already bound to a
2372 process, find some other empty inferior. */
2376 for (inferior
*it
: all_inferiors ())
2385 /* Since all inferiors were already bound to a process, add
2387 inf
= add_inferior_with_spaces ();
2389 switch_to_inferior_no_thread (inf
);
2390 inferior_appeared (inf
, pid
);
2393 inf
->attach_flag
= attached
;
2394 inf
->fake_pid_p
= fake_pid_p
;
2396 /* If no main executable is currently open then attempt to
2397 open the file that was executed to create this inferior. */
2398 if (try_open_exec
&& get_exec_file (0) == NULL
)
2399 exec_file_locate_attach (pid
, 0, 1);
2404 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2405 static remote_thread_info
*get_remote_thread_info (ptid_t ptid
);
2407 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2408 according to RUNNING. */
2411 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
)
2413 struct remote_state
*rs
= get_remote_state ();
2414 struct thread_info
*thread
;
2416 /* GDB historically didn't pull threads in the initial connection
2417 setup. If the remote target doesn't even have a concept of
2418 threads (e.g., a bare-metal target), even if internally we
2419 consider that a single-threaded target, mentioning a new thread
2420 might be confusing to the user. Be silent then, preserving the
2421 age old behavior. */
2422 if (rs
->starting_up
)
2423 thread
= add_thread_silent (ptid
);
2425 thread
= add_thread (ptid
);
2427 get_remote_thread_info (thread
)->vcont_resumed
= executing
;
2428 set_executing (ptid
, executing
);
2429 set_running (ptid
, running
);
2434 /* Come here when we learn about a thread id from the remote target.
2435 It may be the first time we hear about such thread, so take the
2436 opportunity to add it to GDB's thread list. In case this is the
2437 first time we're noticing its corresponding inferior, add it to
2438 GDB's inferior list as well. EXECUTING indicates whether the
2439 thread is (internally) executing or stopped. */
2442 remote_target::remote_notice_new_inferior (ptid_t currthread
, int executing
)
2444 /* In non-stop mode, we assume new found threads are (externally)
2445 running until proven otherwise with a stop reply. In all-stop,
2446 we can only get here if all threads are stopped. */
2447 int running
= target_is_non_stop_p () ? 1 : 0;
2449 /* If this is a new thread, add it to GDB's thread list.
2450 If we leave it up to WFI to do this, bad things will happen. */
2452 thread_info
*tp
= find_thread_ptid (currthread
);
2453 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2455 /* We're seeing an event on a thread id we knew had exited.
2456 This has to be a new thread reusing the old id. Add it. */
2457 remote_add_thread (currthread
, running
, executing
);
2461 if (!in_thread_list (currthread
))
2463 struct inferior
*inf
= NULL
;
2464 int pid
= currthread
.pid ();
2466 if (inferior_ptid
.is_pid ()
2467 && pid
== inferior_ptid
.pid ())
2469 /* inferior_ptid has no thread member yet. This can happen
2470 with the vAttach -> remote_wait,"TAAthread:" path if the
2471 stub doesn't support qC. This is the first stop reported
2472 after an attach, so this is the main thread. Update the
2473 ptid in the thread list. */
2474 if (in_thread_list (ptid_t (pid
)))
2475 thread_change_ptid (inferior_ptid
, currthread
);
2478 remote_add_thread (currthread
, running
, executing
);
2479 inferior_ptid
= currthread
;
2484 if (magic_null_ptid
== inferior_ptid
)
2486 /* inferior_ptid is not set yet. This can happen with the
2487 vRun -> remote_wait,"TAAthread:" path if the stub
2488 doesn't support qC. This is the first stop reported
2489 after an attach, so this is the main thread. Update the
2490 ptid in the thread list. */
2491 thread_change_ptid (inferior_ptid
, currthread
);
2495 /* When connecting to a target remote, or to a target
2496 extended-remote which already was debugging an inferior, we
2497 may not know about it yet. Add it before adding its child
2498 thread, so notifications are emitted in a sensible order. */
2499 if (find_inferior_pid (currthread
.pid ()) == NULL
)
2501 struct remote_state
*rs
= get_remote_state ();
2502 bool fake_pid_p
= !remote_multi_process_p (rs
);
2504 inf
= remote_add_inferior (fake_pid_p
,
2505 currthread
.pid (), -1, 1);
2508 /* This is really a new thread. Add it. */
2509 thread_info
*new_thr
2510 = remote_add_thread (currthread
, running
, executing
);
2512 /* If we found a new inferior, let the common code do whatever
2513 it needs to with it (e.g., read shared libraries, insert
2514 breakpoints), unless we're just setting up an all-stop
2518 struct remote_state
*rs
= get_remote_state ();
2520 if (!rs
->starting_up
)
2521 notice_new_inferior (new_thr
, executing
, 0);
2526 /* Return THREAD's private thread data, creating it if necessary. */
2528 static remote_thread_info
*
2529 get_remote_thread_info (thread_info
*thread
)
2531 gdb_assert (thread
!= NULL
);
2533 if (thread
->priv
== NULL
)
2534 thread
->priv
.reset (new remote_thread_info
);
2536 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2539 static remote_thread_info
*
2540 get_remote_thread_info (ptid_t ptid
)
2542 thread_info
*thr
= find_thread_ptid (ptid
);
2543 return get_remote_thread_info (thr
);
2546 /* Call this function as a result of
2547 1) A halt indication (T packet) containing a thread id
2548 2) A direct query of currthread
2549 3) Successful execution of set thread */
2552 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2554 rs
->general_thread
= currthread
;
2557 /* If 'QPassSignals' is supported, tell the remote stub what signals
2558 it can simply pass through to the inferior without reporting. */
2561 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2563 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2565 char *pass_packet
, *p
;
2567 struct remote_state
*rs
= get_remote_state ();
2569 gdb_assert (pass_signals
.size () < 256);
2570 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2572 if (pass_signals
[i
])
2575 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2576 strcpy (pass_packet
, "QPassSignals:");
2577 p
= pass_packet
+ strlen (pass_packet
);
2578 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2580 if (pass_signals
[i
])
2583 *p
++ = tohex (i
>> 4);
2584 *p
++ = tohex (i
& 15);
2593 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2595 putpkt (pass_packet
);
2596 getpkt (&rs
->buf
, 0);
2597 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2598 if (rs
->last_pass_packet
)
2599 xfree (rs
->last_pass_packet
);
2600 rs
->last_pass_packet
= pass_packet
;
2603 xfree (pass_packet
);
2607 /* If 'QCatchSyscalls' is supported, tell the remote stub
2608 to report syscalls to GDB. */
2611 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2612 gdb::array_view
<const int> syscall_counts
)
2614 const char *catch_packet
;
2615 enum packet_result result
;
2618 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2620 /* Not supported. */
2624 if (needed
&& any_count
== 0)
2626 /* Count how many syscalls are to be caught. */
2627 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2629 if (syscall_counts
[i
] != 0)
2636 fprintf_unfiltered (gdb_stdlog
,
2637 "remote_set_syscall_catchpoint "
2638 "pid %d needed %d any_count %d n_sysno %d\n",
2639 pid
, needed
, any_count
, n_sysno
);
2642 std::string built_packet
;
2645 /* Prepare a packet with the sysno list, assuming max 8+1
2646 characters for a sysno. If the resulting packet size is too
2647 big, fallback on the non-selective packet. */
2648 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2649 built_packet
.reserve (maxpktsz
);
2650 built_packet
= "QCatchSyscalls:1";
2653 /* Add in each syscall to be caught. */
2654 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2656 if (syscall_counts
[i
] != 0)
2657 string_appendf (built_packet
, ";%zx", i
);
2660 if (built_packet
.size () > get_remote_packet_size ())
2662 /* catch_packet too big. Fallback to less efficient
2663 non selective mode, with GDB doing the filtering. */
2664 catch_packet
= "QCatchSyscalls:1";
2667 catch_packet
= built_packet
.c_str ();
2670 catch_packet
= "QCatchSyscalls:0";
2672 struct remote_state
*rs
= get_remote_state ();
2674 putpkt (catch_packet
);
2675 getpkt (&rs
->buf
, 0);
2676 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2677 if (result
== PACKET_OK
)
2683 /* If 'QProgramSignals' is supported, tell the remote stub what
2684 signals it should pass through to the inferior when detaching. */
2687 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2689 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2693 struct remote_state
*rs
= get_remote_state ();
2695 gdb_assert (signals
.size () < 256);
2696 for (size_t i
= 0; i
< signals
.size (); i
++)
2701 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2702 strcpy (packet
, "QProgramSignals:");
2703 p
= packet
+ strlen (packet
);
2704 for (size_t i
= 0; i
< signals
.size (); i
++)
2706 if (signal_pass_state (i
))
2709 *p
++ = tohex (i
>> 4);
2710 *p
++ = tohex (i
& 15);
2719 if (!rs
->last_program_signals_packet
2720 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2723 getpkt (&rs
->buf
, 0);
2724 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2725 xfree (rs
->last_program_signals_packet
);
2726 rs
->last_program_signals_packet
= packet
;
2733 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2734 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2735 thread. If GEN is set, set the general thread, if not, then set
2736 the step/continue thread. */
2738 remote_target::set_thread (ptid_t ptid
, int gen
)
2740 struct remote_state
*rs
= get_remote_state ();
2741 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2742 char *buf
= rs
->buf
.data ();
2743 char *endbuf
= buf
+ get_remote_packet_size ();
2749 *buf
++ = gen
? 'g' : 'c';
2750 if (ptid
== magic_null_ptid
)
2751 xsnprintf (buf
, endbuf
- buf
, "0");
2752 else if (ptid
== any_thread_ptid
)
2753 xsnprintf (buf
, endbuf
- buf
, "0");
2754 else if (ptid
== minus_one_ptid
)
2755 xsnprintf (buf
, endbuf
- buf
, "-1");
2757 write_ptid (buf
, endbuf
, ptid
);
2759 getpkt (&rs
->buf
, 0);
2761 rs
->general_thread
= ptid
;
2763 rs
->continue_thread
= ptid
;
2767 remote_target::set_general_thread (ptid_t ptid
)
2769 set_thread (ptid
, 1);
2773 remote_target::set_continue_thread (ptid_t ptid
)
2775 set_thread (ptid
, 0);
2778 /* Change the remote current process. Which thread within the process
2779 ends up selected isn't important, as long as it is the same process
2780 as what INFERIOR_PTID points to.
2782 This comes from that fact that there is no explicit notion of
2783 "selected process" in the protocol. The selected process for
2784 general operations is the process the selected general thread
2788 remote_target::set_general_process ()
2790 struct remote_state
*rs
= get_remote_state ();
2792 /* If the remote can't handle multiple processes, don't bother. */
2793 if (!remote_multi_process_p (rs
))
2796 /* We only need to change the remote current thread if it's pointing
2797 at some other process. */
2798 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2799 set_general_thread (inferior_ptid
);
2803 /* Return nonzero if this is the main thread that we made up ourselves
2804 to model non-threaded targets as single-threaded. */
2807 remote_thread_always_alive (ptid_t ptid
)
2809 if (ptid
== magic_null_ptid
)
2810 /* The main thread is always alive. */
2813 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2814 /* The main thread is always alive. This can happen after a
2815 vAttach, if the remote side doesn't support
2822 /* Return nonzero if the thread PTID is still alive on the remote
2826 remote_target::thread_alive (ptid_t ptid
)
2828 struct remote_state
*rs
= get_remote_state ();
2831 /* Check if this is a thread that we made up ourselves to model
2832 non-threaded targets as single-threaded. */
2833 if (remote_thread_always_alive (ptid
))
2836 p
= rs
->buf
.data ();
2837 endp
= p
+ get_remote_packet_size ();
2840 write_ptid (p
, endp
, ptid
);
2843 getpkt (&rs
->buf
, 0);
2844 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2847 /* Return a pointer to a thread name if we know it and NULL otherwise.
2848 The thread_info object owns the memory for the name. */
2851 remote_target::thread_name (struct thread_info
*info
)
2853 if (info
->priv
!= NULL
)
2855 const std::string
&name
= get_remote_thread_info (info
)->name
;
2856 return !name
.empty () ? name
.c_str () : NULL
;
2862 /* About these extended threadlist and threadinfo packets. They are
2863 variable length packets but, the fields within them are often fixed
2864 length. They are redundant enough to send over UDP as is the
2865 remote protocol in general. There is a matching unit test module
2868 /* WARNING: This threadref data structure comes from the remote O.S.,
2869 libstub protocol encoding, and remote.c. It is not particularly
2872 /* Right now, the internal structure is int. We want it to be bigger.
2873 Plan to fix this. */
2875 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2877 /* gdb_ext_thread_info is an internal GDB data structure which is
2878 equivalent to the reply of the remote threadinfo packet. */
2880 struct gdb_ext_thread_info
2882 threadref threadid
; /* External form of thread reference. */
2883 int active
; /* Has state interesting to GDB?
2885 char display
[256]; /* Brief state display, name,
2886 blocked/suspended. */
2887 char shortname
[32]; /* To be used to name threads. */
2888 char more_display
[256]; /* Long info, statistics, queue depth,
2892 /* The volume of remote transfers can be limited by submitting
2893 a mask containing bits specifying the desired information.
2894 Use a union of these values as the 'selection' parameter to
2895 get_thread_info. FIXME: Make these TAG names more thread specific. */
2897 #define TAG_THREADID 1
2898 #define TAG_EXISTS 2
2899 #define TAG_DISPLAY 4
2900 #define TAG_THREADNAME 8
2901 #define TAG_MOREDISPLAY 16
2903 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2905 static char *unpack_nibble (char *buf
, int *val
);
2907 static char *unpack_byte (char *buf
, int *value
);
2909 static char *pack_int (char *buf
, int value
);
2911 static char *unpack_int (char *buf
, int *value
);
2913 static char *unpack_string (char *src
, char *dest
, int length
);
2915 static char *pack_threadid (char *pkt
, threadref
*id
);
2917 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2919 void int_to_threadref (threadref
*id
, int value
);
2921 static int threadref_to_int (threadref
*ref
);
2923 static void copy_threadref (threadref
*dest
, threadref
*src
);
2925 static int threadmatch (threadref
*dest
, threadref
*src
);
2927 static char *pack_threadinfo_request (char *pkt
, int mode
,
2930 static char *pack_threadlist_request (char *pkt
, int startflag
,
2932 threadref
*nextthread
);
2934 static int remote_newthread_step (threadref
*ref
, void *context
);
2937 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2938 buffer we're allowed to write to. Returns
2939 BUF+CHARACTERS_WRITTEN. */
2942 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2945 struct remote_state
*rs
= get_remote_state ();
2947 if (remote_multi_process_p (rs
))
2951 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2953 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2957 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2959 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2964 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2965 last parsed char. Returns null_ptid if no thread id is found, and
2966 throws an error if the thread id has an invalid format. */
2969 read_ptid (const char *buf
, const char **obuf
)
2971 const char *p
= buf
;
2973 ULONGEST pid
= 0, tid
= 0;
2977 /* Multi-process ptid. */
2978 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2980 error (_("invalid remote ptid: %s"), p
);
2983 pp
= unpack_varlen_hex (p
+ 1, &tid
);
2986 return ptid_t (pid
, tid
, 0);
2989 /* No multi-process. Just a tid. */
2990 pp
= unpack_varlen_hex (p
, &tid
);
2992 /* Return null_ptid when no thread id is found. */
3000 /* Since the stub is not sending a process id, then default to
3001 what's in inferior_ptid, unless it's null at this point. If so,
3002 then since there's no way to know the pid of the reported
3003 threads, use the magic number. */
3004 if (inferior_ptid
== null_ptid
)
3005 pid
= magic_null_ptid
.pid ();
3007 pid
= inferior_ptid
.pid ();
3011 return ptid_t (pid
, tid
, 0);
3017 if (ch
>= 'a' && ch
<= 'f')
3018 return ch
- 'a' + 10;
3019 if (ch
>= '0' && ch
<= '9')
3021 if (ch
>= 'A' && ch
<= 'F')
3022 return ch
- 'A' + 10;
3027 stub_unpack_int (char *buff
, int fieldlength
)
3034 nibble
= stubhex (*buff
++);
3038 retval
= retval
<< 4;
3044 unpack_nibble (char *buf
, int *val
)
3046 *val
= fromhex (*buf
++);
3051 unpack_byte (char *buf
, int *value
)
3053 *value
= stub_unpack_int (buf
, 2);
3058 pack_int (char *buf
, int value
)
3060 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3061 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3062 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3063 buf
= pack_hex_byte (buf
, (value
& 0xff));
3068 unpack_int (char *buf
, int *value
)
3070 *value
= stub_unpack_int (buf
, 8);
3074 #if 0 /* Currently unused, uncomment when needed. */
3075 static char *pack_string (char *pkt
, char *string
);
3078 pack_string (char *pkt
, char *string
)
3083 len
= strlen (string
);
3085 len
= 200; /* Bigger than most GDB packets, junk??? */
3086 pkt
= pack_hex_byte (pkt
, len
);
3090 if ((ch
== '\0') || (ch
== '#'))
3091 ch
= '*'; /* Protect encapsulation. */
3096 #endif /* 0 (unused) */
3099 unpack_string (char *src
, char *dest
, int length
)
3108 pack_threadid (char *pkt
, threadref
*id
)
3111 unsigned char *altid
;
3113 altid
= (unsigned char *) id
;
3114 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3116 pkt
= pack_hex_byte (pkt
, *altid
++);
3122 unpack_threadid (char *inbuf
, threadref
*id
)
3125 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3128 altref
= (char *) id
;
3130 while (inbuf
< limit
)
3132 x
= stubhex (*inbuf
++);
3133 y
= stubhex (*inbuf
++);
3134 *altref
++ = (x
<< 4) | y
;
3139 /* Externally, threadrefs are 64 bits but internally, they are still
3140 ints. This is due to a mismatch of specifications. We would like
3141 to use 64bit thread references internally. This is an adapter
3145 int_to_threadref (threadref
*id
, int value
)
3147 unsigned char *scan
;
3149 scan
= (unsigned char *) id
;
3155 *scan
++ = (value
>> 24) & 0xff;
3156 *scan
++ = (value
>> 16) & 0xff;
3157 *scan
++ = (value
>> 8) & 0xff;
3158 *scan
++ = (value
& 0xff);
3162 threadref_to_int (threadref
*ref
)
3165 unsigned char *scan
;
3171 value
= (value
<< 8) | ((*scan
++) & 0xff);
3176 copy_threadref (threadref
*dest
, threadref
*src
)
3179 unsigned char *csrc
, *cdest
;
3181 csrc
= (unsigned char *) src
;
3182 cdest
= (unsigned char *) dest
;
3189 threadmatch (threadref
*dest
, threadref
*src
)
3191 /* Things are broken right now, so just assume we got a match. */
3193 unsigned char *srcp
, *destp
;
3195 srcp
= (char *) src
;
3196 destp
= (char *) dest
;
3200 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3207 threadid:1, # always request threadid
3214 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3217 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3219 *pkt
++ = 'q'; /* Info Query */
3220 *pkt
++ = 'P'; /* process or thread info */
3221 pkt
= pack_int (pkt
, mode
); /* mode */
3222 pkt
= pack_threadid (pkt
, id
); /* threadid */
3223 *pkt
= '\0'; /* terminate */
3227 /* These values tag the fields in a thread info response packet. */
3228 /* Tagging the fields allows us to request specific fields and to
3229 add more fields as time goes by. */
3231 #define TAG_THREADID 1 /* Echo the thread identifier. */
3232 #define TAG_EXISTS 2 /* Is this process defined enough to
3233 fetch registers and its stack? */
3234 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3235 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3236 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3240 remote_target::remote_unpack_thread_info_response (char *pkt
,
3241 threadref
*expectedref
,
3242 gdb_ext_thread_info
*info
)
3244 struct remote_state
*rs
= get_remote_state ();
3248 char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3251 /* info->threadid = 0; FIXME: implement zero_threadref. */
3253 info
->display
[0] = '\0';
3254 info
->shortname
[0] = '\0';
3255 info
->more_display
[0] = '\0';
3257 /* Assume the characters indicating the packet type have been
3259 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3260 pkt
= unpack_threadid (pkt
, &ref
);
3263 warning (_("Incomplete response to threadinfo request."));
3264 if (!threadmatch (&ref
, expectedref
))
3265 { /* This is an answer to a different request. */
3266 warning (_("ERROR RMT Thread info mismatch."));
3269 copy_threadref (&info
->threadid
, &ref
);
3271 /* Loop on tagged fields , try to bail if something goes wrong. */
3273 /* Packets are terminated with nulls. */
3274 while ((pkt
< limit
) && mask
&& *pkt
)
3276 pkt
= unpack_int (pkt
, &tag
); /* tag */
3277 pkt
= unpack_byte (pkt
, &length
); /* length */
3278 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3280 warning (_("ERROR RMT: threadinfo tag mismatch."));
3284 if (tag
== TAG_THREADID
)
3288 warning (_("ERROR RMT: length of threadid is not 16."));
3292 pkt
= unpack_threadid (pkt
, &ref
);
3293 mask
= mask
& ~TAG_THREADID
;
3296 if (tag
== TAG_EXISTS
)
3298 info
->active
= stub_unpack_int (pkt
, length
);
3300 mask
= mask
& ~(TAG_EXISTS
);
3303 warning (_("ERROR RMT: 'exists' length too long."));
3309 if (tag
== TAG_THREADNAME
)
3311 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3312 mask
= mask
& ~TAG_THREADNAME
;
3315 if (tag
== TAG_DISPLAY
)
3317 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3318 mask
= mask
& ~TAG_DISPLAY
;
3321 if (tag
== TAG_MOREDISPLAY
)
3323 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3324 mask
= mask
& ~TAG_MOREDISPLAY
;
3327 warning (_("ERROR RMT: unknown thread info tag."));
3328 break; /* Not a tag we know about. */
3334 remote_target::remote_get_threadinfo (threadref
*threadid
,
3336 gdb_ext_thread_info
*info
)
3338 struct remote_state
*rs
= get_remote_state ();
3341 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3343 getpkt (&rs
->buf
, 0);
3345 if (rs
->buf
[0] == '\0')
3348 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3353 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3356 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3357 threadref
*nextthread
)
3359 *pkt
++ = 'q'; /* info query packet */
3360 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3361 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3362 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3363 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3368 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3371 remote_target::parse_threadlist_response (char *pkt
, int result_limit
,
3372 threadref
*original_echo
,
3373 threadref
*resultlist
,
3376 struct remote_state
*rs
= get_remote_state ();
3378 int count
, resultcount
, done
;
3381 /* Assume the 'q' and 'M chars have been stripped. */
3382 limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3383 /* done parse past here */
3384 pkt
= unpack_byte (pkt
, &count
); /* count field */
3385 pkt
= unpack_nibble (pkt
, &done
);
3386 /* The first threadid is the argument threadid. */
3387 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3388 while ((count
-- > 0) && (pkt
< limit
))
3390 pkt
= unpack_threadid (pkt
, resultlist
++);
3391 if (resultcount
++ >= result_limit
)
3399 /* Fetch the next batch of threads from the remote. Returns -1 if the
3400 qL packet is not supported, 0 on error and 1 on success. */
3403 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3404 int result_limit
, int *done
, int *result_count
,
3405 threadref
*threadlist
)
3407 struct remote_state
*rs
= get_remote_state ();
3410 /* Truncate result limit to be smaller than the packet size. */
3411 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3412 >= get_remote_packet_size ())
3413 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3415 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3418 getpkt (&rs
->buf
, 0);
3419 if (rs
->buf
[0] == '\0')
3421 /* Packet not supported. */
3426 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3427 &rs
->echo_nextthread
, threadlist
, done
);
3429 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3431 /* FIXME: This is a good reason to drop the packet. */
3432 /* Possibly, there is a duplicate response. */
3434 retransmit immediatly - race conditions
3435 retransmit after timeout - yes
3437 wait for packet, then exit
3439 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3440 return 0; /* I choose simply exiting. */
3442 if (*result_count
<= 0)
3446 warning (_("RMT ERROR : failed to get remote thread list."));
3449 return result
; /* break; */
3451 if (*result_count
> result_limit
)
3454 warning (_("RMT ERROR: threadlist response longer than requested."));
3460 /* Fetch the list of remote threads, with the qL packet, and call
3461 STEPFUNCTION for each thread found. Stops iterating and returns 1
3462 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3463 STEPFUNCTION returns false. If the packet is not supported,
3467 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3468 void *context
, int looplimit
)
3470 struct remote_state
*rs
= get_remote_state ();
3471 int done
, i
, result_count
;
3479 if (loopcount
++ > looplimit
)
3482 warning (_("Remote fetch threadlist -infinite loop-."));
3485 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3486 MAXTHREADLISTRESULTS
,
3487 &done
, &result_count
,
3488 rs
->resultthreadlist
);
3491 /* Clear for later iterations. */
3493 /* Setup to resume next batch of thread references, set nextthread. */
3494 if (result_count
>= 1)
3495 copy_threadref (&rs
->nextthread
,
3496 &rs
->resultthreadlist
[result_count
- 1]);
3498 while (result_count
--)
3500 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3510 /* A thread found on the remote target. */
3514 explicit thread_item (ptid_t ptid_
)
3518 thread_item (thread_item
&&other
) = default;
3519 thread_item
&operator= (thread_item
&&other
) = default;
3521 DISABLE_COPY_AND_ASSIGN (thread_item
);
3523 /* The thread's PTID. */
3526 /* The thread's extra info. */
3529 /* The thread's name. */
3532 /* The core the thread was running on. -1 if not known. */
3535 /* The thread handle associated with the thread. */
3536 gdb::byte_vector thread_handle
;
3539 /* Context passed around to the various methods listing remote
3540 threads. As new threads are found, they're added to the ITEMS
3543 struct threads_listing_context
3545 /* Return true if this object contains an entry for a thread with ptid
3548 bool contains_thread (ptid_t ptid
) const
3550 auto match_ptid
= [&] (const thread_item
&item
)
3552 return item
.ptid
== ptid
;
3555 auto it
= std::find_if (this->items
.begin (),
3559 return it
!= this->items
.end ();
3562 /* Remove the thread with ptid PTID. */
3564 void remove_thread (ptid_t ptid
)
3566 auto match_ptid
= [&] (const thread_item
&item
)
3568 return item
.ptid
== ptid
;
3571 auto it
= std::remove_if (this->items
.begin (),
3575 if (it
!= this->items
.end ())
3576 this->items
.erase (it
);
3579 /* The threads found on the remote target. */
3580 std::vector
<thread_item
> items
;
3584 remote_newthread_step (threadref
*ref
, void *data
)
3586 struct threads_listing_context
*context
3587 = (struct threads_listing_context
*) data
;
3588 int pid
= inferior_ptid
.pid ();
3589 int lwp
= threadref_to_int (ref
);
3590 ptid_t
ptid (pid
, lwp
);
3592 context
->items
.emplace_back (ptid
);
3594 return 1; /* continue iterator */
3597 #define CRAZY_MAX_THREADS 1000
3600 remote_target::remote_current_thread (ptid_t oldpid
)
3602 struct remote_state
*rs
= get_remote_state ();
3605 getpkt (&rs
->buf
, 0);
3606 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3611 result
= read_ptid (&rs
->buf
[2], &obuf
);
3612 if (*obuf
!= '\0' && remote_debug
)
3613 fprintf_unfiltered (gdb_stdlog
,
3614 "warning: garbage in qC reply\n");
3622 /* List remote threads using the deprecated qL packet. */
3625 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3627 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3628 CRAZY_MAX_THREADS
) >= 0)
3634 #if defined(HAVE_LIBEXPAT)
3637 start_thread (struct gdb_xml_parser
*parser
,
3638 const struct gdb_xml_element
*element
,
3640 std::vector
<gdb_xml_value
> &attributes
)
3642 struct threads_listing_context
*data
3643 = (struct threads_listing_context
*) user_data
;
3644 struct gdb_xml_value
*attr
;
3646 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3647 ptid_t ptid
= read_ptid (id
, NULL
);
3649 data
->items
.emplace_back (ptid
);
3650 thread_item
&item
= data
->items
.back ();
3652 attr
= xml_find_attribute (attributes
, "core");
3654 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3656 attr
= xml_find_attribute (attributes
, "name");
3658 item
.name
= (const char *) attr
->value
.get ();
3660 attr
= xml_find_attribute (attributes
, "handle");
3662 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3666 end_thread (struct gdb_xml_parser
*parser
,
3667 const struct gdb_xml_element
*element
,
3668 void *user_data
, const char *body_text
)
3670 struct threads_listing_context
*data
3671 = (struct threads_listing_context
*) user_data
;
3673 if (body_text
!= NULL
&& *body_text
!= '\0')
3674 data
->items
.back ().extra
= body_text
;
3677 const struct gdb_xml_attribute thread_attributes
[] = {
3678 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3679 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3680 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3681 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3682 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3685 const struct gdb_xml_element thread_children
[] = {
3686 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3689 const struct gdb_xml_element threads_children
[] = {
3690 { "thread", thread_attributes
, thread_children
,
3691 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3692 start_thread
, end_thread
},
3693 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3696 const struct gdb_xml_element threads_elements
[] = {
3697 { "threads", NULL
, threads_children
,
3698 GDB_XML_EF_NONE
, NULL
, NULL
},
3699 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3704 /* List remote threads using qXfer:threads:read. */
3707 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3709 #if defined(HAVE_LIBEXPAT)
3710 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3712 gdb::optional
<gdb::char_vector
> xml
3713 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3715 if (xml
&& (*xml
)[0] != '\0')
3717 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3718 threads_elements
, xml
->data (), context
);
3728 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3731 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3733 struct remote_state
*rs
= get_remote_state ();
3735 if (rs
->use_threadinfo_query
)
3739 putpkt ("qfThreadInfo");
3740 getpkt (&rs
->buf
, 0);
3741 bufp
= rs
->buf
.data ();
3742 if (bufp
[0] != '\0') /* q packet recognized */
3744 while (*bufp
++ == 'm') /* reply contains one or more TID */
3748 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3749 context
->items
.emplace_back (ptid
);
3751 while (*bufp
++ == ','); /* comma-separated list */
3752 putpkt ("qsThreadInfo");
3753 getpkt (&rs
->buf
, 0);
3754 bufp
= rs
->buf
.data ();
3760 /* Packet not recognized. */
3761 rs
->use_threadinfo_query
= 0;
3768 /* Implement the to_update_thread_list function for the remote
3772 remote_target::update_thread_list ()
3774 struct threads_listing_context context
;
3777 /* We have a few different mechanisms to fetch the thread list. Try
3778 them all, starting with the most preferred one first, falling
3779 back to older methods. */
3780 if (remote_get_threads_with_qxfer (&context
)
3781 || remote_get_threads_with_qthreadinfo (&context
)
3782 || remote_get_threads_with_ql (&context
))
3786 if (context
.items
.empty ()
3787 && remote_thread_always_alive (inferior_ptid
))
3789 /* Some targets don't really support threads, but still
3790 reply an (empty) thread list in response to the thread
3791 listing packets, instead of replying "packet not
3792 supported". Exit early so we don't delete the main
3797 /* CONTEXT now holds the current thread list on the remote
3798 target end. Delete GDB-side threads no longer found on the
3800 for (thread_info
*tp
: all_threads_safe ())
3802 if (!context
.contains_thread (tp
->ptid
))
3809 /* Remove any unreported fork child threads from CONTEXT so
3810 that we don't interfere with follow fork, which is where
3811 creation of such threads is handled. */
3812 remove_new_fork_children (&context
);
3814 /* And now add threads we don't know about yet to our list. */
3815 for (thread_item
&item
: context
.items
)
3817 if (item
.ptid
!= null_ptid
)
3819 /* In non-stop mode, we assume new found threads are
3820 executing until proven otherwise with a stop reply.
3821 In all-stop, we can only get here if all threads are
3823 int executing
= target_is_non_stop_p () ? 1 : 0;
3825 remote_notice_new_inferior (item
.ptid
, executing
);
3827 thread_info
*tp
= find_thread_ptid (item
.ptid
);
3828 remote_thread_info
*info
= get_remote_thread_info (tp
);
3829 info
->core
= item
.core
;
3830 info
->extra
= std::move (item
.extra
);
3831 info
->name
= std::move (item
.name
);
3832 info
->thread_handle
= std::move (item
.thread_handle
);
3839 /* If no thread listing method is supported, then query whether
3840 each known thread is alive, one by one, with the T packet.
3841 If the target doesn't support threads at all, then this is a
3842 no-op. See remote_thread_alive. */
3848 * Collect a descriptive string about the given thread.
3849 * The target may say anything it wants to about the thread
3850 * (typically info about its blocked / runnable state, name, etc.).
3851 * This string will appear in the info threads display.
3853 * Optional: targets are not required to implement this function.
3857 remote_target::extra_thread_info (thread_info
*tp
)
3859 struct remote_state
*rs
= get_remote_state ();
3862 struct gdb_ext_thread_info threadinfo
;
3864 if (rs
->remote_desc
== 0) /* paranoia */
3865 internal_error (__FILE__
, __LINE__
,
3866 _("remote_threads_extra_info"));
3868 if (tp
->ptid
== magic_null_ptid
3869 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
3870 /* This is the main thread which was added by GDB. The remote
3871 server doesn't know about it. */
3874 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
3876 /* If already have cached info, use it. */
3877 if (!extra
.empty ())
3878 return extra
.c_str ();
3880 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3882 /* If we're using qXfer:threads:read, then the extra info is
3883 included in the XML. So if we didn't have anything cached,
3884 it's because there's really no extra info. */
3888 if (rs
->use_threadextra_query
)
3890 char *b
= rs
->buf
.data ();
3891 char *endb
= b
+ get_remote_packet_size ();
3893 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3895 write_ptid (b
, endb
, tp
->ptid
);
3898 getpkt (&rs
->buf
, 0);
3899 if (rs
->buf
[0] != 0)
3901 extra
.resize (strlen (rs
->buf
.data ()) / 2);
3902 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
3903 return extra
.c_str ();
3907 /* If the above query fails, fall back to the old method. */
3908 rs
->use_threadextra_query
= 0;
3909 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3910 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3911 int_to_threadref (&id
, tp
->ptid
.lwp ());
3912 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3913 if (threadinfo
.active
)
3915 if (*threadinfo
.shortname
)
3916 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
3917 if (*threadinfo
.display
)
3919 if (!extra
.empty ())
3921 string_appendf (extra
, " State: %s", threadinfo
.display
);
3923 if (*threadinfo
.more_display
)
3925 if (!extra
.empty ())
3927 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
3929 return extra
.c_str ();
3936 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
3937 struct static_tracepoint_marker
*marker
)
3939 struct remote_state
*rs
= get_remote_state ();
3940 char *p
= rs
->buf
.data ();
3942 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3944 p
+= hexnumstr (p
, addr
);
3946 getpkt (&rs
->buf
, 0);
3947 p
= rs
->buf
.data ();
3950 error (_("Remote failure reply: %s"), p
);
3954 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
3961 std::vector
<static_tracepoint_marker
>
3962 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
3964 struct remote_state
*rs
= get_remote_state ();
3965 std::vector
<static_tracepoint_marker
> markers
;
3967 static_tracepoint_marker marker
;
3969 /* Ask for a first packet of static tracepoint marker
3972 getpkt (&rs
->buf
, 0);
3973 p
= rs
->buf
.data ();
3975 error (_("Remote failure reply: %s"), p
);
3981 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
3983 if (strid
== NULL
|| marker
.str_id
== strid
)
3984 markers
.push_back (std::move (marker
));
3986 while (*p
++ == ','); /* comma-separated list */
3987 /* Ask for another packet of static tracepoint definition. */
3989 getpkt (&rs
->buf
, 0);
3990 p
= rs
->buf
.data ();
3997 /* Implement the to_get_ada_task_ptid function for the remote targets. */
4000 remote_target::get_ada_task_ptid (long lwp
, long thread
)
4002 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
4006 /* Restart the remote side; this is an extended protocol operation. */
4009 remote_target::extended_remote_restart ()
4011 struct remote_state
*rs
= get_remote_state ();
4013 /* Send the restart command; for reasons I don't understand the
4014 remote side really expects a number after the "R". */
4015 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
4018 remote_fileio_reset ();
4021 /* Clean up connection to a remote debugger. */
4024 remote_target::close ()
4026 /* Make sure we leave stdin registered in the event loop. */
4029 /* We don't have a connection to the remote stub anymore. Get rid
4030 of all the inferiors and their threads we were controlling.
4031 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
4032 will be unable to find the thread corresponding to (pid, 0, 0). */
4033 inferior_ptid
= null_ptid
;
4034 discard_all_inferiors ();
4036 trace_reset_local_state ();
4041 remote_target::~remote_target ()
4043 struct remote_state
*rs
= get_remote_state ();
4045 /* Check for NULL because we may get here with a partially
4046 constructed target/connection. */
4047 if (rs
->remote_desc
== nullptr)
4050 serial_close (rs
->remote_desc
);
4052 /* We are destroying the remote target, so we should discard
4053 everything of this target. */
4054 discard_pending_stop_replies_in_queue ();
4056 if (rs
->remote_async_inferior_event_token
)
4057 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4059 delete rs
->notif_state
;
4062 /* Query the remote side for the text, data and bss offsets. */
4065 remote_target::get_offsets ()
4067 struct remote_state
*rs
= get_remote_state ();
4070 int lose
, num_segments
= 0, do_sections
, do_segments
;
4071 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4072 struct symfile_segment_data
*data
;
4074 if (symfile_objfile
== NULL
)
4077 putpkt ("qOffsets");
4078 getpkt (&rs
->buf
, 0);
4079 buf
= rs
->buf
.data ();
4081 if (buf
[0] == '\000')
4082 return; /* Return silently. Stub doesn't support
4086 warning (_("Remote failure reply: %s"), buf
);
4090 /* Pick up each field in turn. This used to be done with scanf, but
4091 scanf will make trouble if CORE_ADDR size doesn't match
4092 conversion directives correctly. The following code will work
4093 with any size of CORE_ADDR. */
4094 text_addr
= data_addr
= bss_addr
= 0;
4098 if (startswith (ptr
, "Text="))
4101 /* Don't use strtol, could lose on big values. */
4102 while (*ptr
&& *ptr
!= ';')
4103 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4105 if (startswith (ptr
, ";Data="))
4108 while (*ptr
&& *ptr
!= ';')
4109 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4114 if (!lose
&& startswith (ptr
, ";Bss="))
4117 while (*ptr
&& *ptr
!= ';')
4118 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4120 if (bss_addr
!= data_addr
)
4121 warning (_("Target reported unsupported offsets: %s"), buf
);
4126 else if (startswith (ptr
, "TextSeg="))
4129 /* Don't use strtol, could lose on big values. */
4130 while (*ptr
&& *ptr
!= ';')
4131 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4134 if (startswith (ptr
, ";DataSeg="))
4137 while (*ptr
&& *ptr
!= ';')
4138 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4146 error (_("Malformed response to offset query, %s"), buf
);
4147 else if (*ptr
!= '\0')
4148 warning (_("Target reported unsupported offsets: %s"), buf
);
4150 section_offsets offs
= symfile_objfile
->section_offsets
;
4152 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
4153 do_segments
= (data
!= NULL
);
4154 do_sections
= num_segments
== 0;
4156 if (num_segments
> 0)
4158 segments
[0] = text_addr
;
4159 segments
[1] = data_addr
;
4161 /* If we have two segments, we can still try to relocate everything
4162 by assuming that the .text and .data offsets apply to the whole
4163 text and data segments. Convert the offsets given in the packet
4164 to base addresses for symfile_map_offsets_to_segments. */
4165 else if (data
&& data
->num_segments
== 2)
4167 segments
[0] = data
->segment_bases
[0] + text_addr
;
4168 segments
[1] = data
->segment_bases
[1] + data_addr
;
4171 /* If the object file has only one segment, assume that it is text
4172 rather than data; main programs with no writable data are rare,
4173 but programs with no code are useless. Of course the code might
4174 have ended up in the data segment... to detect that we would need
4175 the permissions here. */
4176 else if (data
&& data
->num_segments
== 1)
4178 segments
[0] = data
->segment_bases
[0] + text_addr
;
4181 /* There's no way to relocate by segment. */
4187 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
4188 offs
, num_segments
, segments
);
4190 if (ret
== 0 && !do_sections
)
4191 error (_("Can not handle qOffsets TextSeg "
4192 "response with this symbol file"));
4199 free_symfile_segment_data (data
);
4203 offs
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
4205 /* This is a temporary kludge to force data and bss to use the
4206 same offsets because that's what nlmconv does now. The real
4207 solution requires changes to the stub and remote.c that I
4208 don't have time to do right now. */
4210 offs
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
4211 offs
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
4214 objfile_relocate (symfile_objfile
, offs
);
4217 /* Send interrupt_sequence to remote target. */
4220 remote_target::send_interrupt_sequence ()
4222 struct remote_state
*rs
= get_remote_state ();
4224 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4225 remote_serial_write ("\x03", 1);
4226 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4227 serial_send_break (rs
->remote_desc
);
4228 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4230 serial_send_break (rs
->remote_desc
);
4231 remote_serial_write ("g", 1);
4234 internal_error (__FILE__
, __LINE__
,
4235 _("Invalid value for interrupt_sequence_mode: %s."),
4236 interrupt_sequence_mode
);
4240 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4241 and extract the PTID. Returns NULL_PTID if not found. */
4244 stop_reply_extract_thread (char *stop_reply
)
4246 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4250 /* Txx r:val ; r:val (...) */
4253 /* Look for "register" named "thread". */
4258 p1
= strchr (p
, ':');
4262 if (strncmp (p
, "thread", p1
- p
) == 0)
4263 return read_ptid (++p1
, &p
);
4265 p1
= strchr (p
, ';');
4277 /* Determine the remote side's current thread. If we have a stop
4278 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4279 "thread" register we can extract the current thread from. If not,
4280 ask the remote which is the current thread with qC. The former
4281 method avoids a roundtrip. */
4284 remote_target::get_current_thread (char *wait_status
)
4286 ptid_t ptid
= null_ptid
;
4288 /* Note we don't use remote_parse_stop_reply as that makes use of
4289 the target architecture, which we haven't yet fully determined at
4291 if (wait_status
!= NULL
)
4292 ptid
= stop_reply_extract_thread (wait_status
);
4293 if (ptid
== null_ptid
)
4294 ptid
= remote_current_thread (inferior_ptid
);
4299 /* Query the remote target for which is the current thread/process,
4300 add it to our tables, and update INFERIOR_PTID. The caller is
4301 responsible for setting the state such that the remote end is ready
4302 to return the current thread.
4304 This function is called after handling the '?' or 'vRun' packets,
4305 whose response is a stop reply from which we can also try
4306 extracting the thread. If the target doesn't support the explicit
4307 qC query, we infer the current thread from that stop reply, passed
4308 in in WAIT_STATUS, which may be NULL. */
4311 remote_target::add_current_inferior_and_thread (char *wait_status
)
4313 struct remote_state
*rs
= get_remote_state ();
4314 bool fake_pid_p
= false;
4316 inferior_ptid
= null_ptid
;
4318 /* Now, if we have thread information, update inferior_ptid. */
4319 ptid_t curr_ptid
= get_current_thread (wait_status
);
4321 if (curr_ptid
!= null_ptid
)
4323 if (!remote_multi_process_p (rs
))
4328 /* Without this, some commands which require an active target
4329 (such as kill) won't work. This variable serves (at least)
4330 double duty as both the pid of the target process (if it has
4331 such), and as a flag indicating that a target is active. */
4332 curr_ptid
= magic_null_ptid
;
4336 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4338 /* Add the main thread and switch to it. Don't try reading
4339 registers yet, since we haven't fetched the target description
4341 thread_info
*tp
= add_thread_silent (curr_ptid
);
4342 switch_to_thread_no_regs (tp
);
4345 /* Print info about a thread that was found already stopped on
4349 print_one_stopped_thread (struct thread_info
*thread
)
4351 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4353 switch_to_thread (thread
);
4354 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4355 set_current_sal_from_frame (get_current_frame ());
4357 thread
->suspend
.waitstatus_pending_p
= 0;
4359 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4361 enum gdb_signal sig
= ws
->value
.sig
;
4363 if (signal_print_state (sig
))
4364 gdb::observers::signal_received
.notify (sig
);
4366 gdb::observers::normal_stop
.notify (NULL
, 1);
4369 /* Process all initial stop replies the remote side sent in response
4370 to the ? packet. These indicate threads that were already stopped
4371 on initial connection. We mark these threads as stopped and print
4372 their current frame before giving the user the prompt. */
4375 remote_target::process_initial_stop_replies (int from_tty
)
4377 int pending_stop_replies
= stop_reply_queue_length ();
4378 struct thread_info
*selected
= NULL
;
4379 struct thread_info
*lowest_stopped
= NULL
;
4380 struct thread_info
*first
= NULL
;
4382 /* Consume the initial pending events. */
4383 while (pending_stop_replies
-- > 0)
4385 ptid_t waiton_ptid
= minus_one_ptid
;
4387 struct target_waitstatus ws
;
4388 int ignore_event
= 0;
4390 memset (&ws
, 0, sizeof (ws
));
4391 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4393 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4397 case TARGET_WAITKIND_IGNORE
:
4398 case TARGET_WAITKIND_NO_RESUMED
:
4399 case TARGET_WAITKIND_SIGNALLED
:
4400 case TARGET_WAITKIND_EXITED
:
4401 /* We shouldn't see these, but if we do, just ignore. */
4403 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
4407 case TARGET_WAITKIND_EXECD
:
4408 xfree (ws
.value
.execd_pathname
);
4417 struct thread_info
*evthread
= find_thread_ptid (event_ptid
);
4419 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4421 enum gdb_signal sig
= ws
.value
.sig
;
4423 /* Stubs traditionally report SIGTRAP as initial signal,
4424 instead of signal 0. Suppress it. */
4425 if (sig
== GDB_SIGNAL_TRAP
)
4427 evthread
->suspend
.stop_signal
= sig
;
4431 evthread
->suspend
.waitstatus
= ws
;
4433 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4434 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4435 evthread
->suspend
.waitstatus_pending_p
= 1;
4437 set_executing (event_ptid
, 0);
4438 set_running (event_ptid
, 0);
4439 get_remote_thread_info (evthread
)->vcont_resumed
= 0;
4442 /* "Notice" the new inferiors before anything related to
4443 registers/memory. */
4444 for (inferior
*inf
: all_non_exited_inferiors ())
4446 inf
->needs_setup
= 1;
4450 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4451 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4456 /* If all-stop on top of non-stop, pause all threads. Note this
4457 records the threads' stop pc, so must be done after "noticing"
4461 stop_all_threads ();
4463 /* If all threads of an inferior were already stopped, we
4464 haven't setup the inferior yet. */
4465 for (inferior
*inf
: all_non_exited_inferiors ())
4467 if (inf
->needs_setup
)
4469 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4470 switch_to_thread_no_regs (thread
);
4476 /* Now go over all threads that are stopped, and print their current
4477 frame. If all-stop, then if there's a signalled thread, pick
4479 for (thread_info
*thread
: all_non_exited_threads ())
4485 thread
->set_running (false);
4486 else if (thread
->state
!= THREAD_STOPPED
)
4489 if (selected
== NULL
4490 && thread
->suspend
.waitstatus_pending_p
)
4493 if (lowest_stopped
== NULL
4494 || thread
->inf
->num
< lowest_stopped
->inf
->num
4495 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4496 lowest_stopped
= thread
;
4499 print_one_stopped_thread (thread
);
4502 /* In all-stop, we only print the status of one thread, and leave
4503 others with their status pending. */
4506 thread_info
*thread
= selected
;
4508 thread
= lowest_stopped
;
4512 print_one_stopped_thread (thread
);
4515 /* For "info program". */
4516 thread_info
*thread
= inferior_thread ();
4517 if (thread
->state
== THREAD_STOPPED
)
4518 set_last_target_status (inferior_ptid
, thread
->suspend
.waitstatus
);
4521 /* Start the remote connection and sync state. */
4524 remote_target::start_remote (int from_tty
, int extended_p
)
4526 struct remote_state
*rs
= get_remote_state ();
4527 struct packet_config
*noack_config
;
4528 char *wait_status
= NULL
;
4530 /* Signal other parts that we're going through the initial setup,
4531 and so things may not be stable yet. E.g., we don't try to
4532 install tracepoints until we've relocated symbols. Also, a
4533 Ctrl-C before we're connected and synced up can't interrupt the
4534 target. Instead, it offers to drop the (potentially wedged)
4536 rs
->starting_up
= 1;
4540 if (interrupt_on_connect
)
4541 send_interrupt_sequence ();
4543 /* Ack any packet which the remote side has already sent. */
4544 remote_serial_write ("+", 1);
4546 /* The first packet we send to the target is the optional "supported
4547 packets" request. If the target can answer this, it will tell us
4548 which later probes to skip. */
4549 remote_query_supported ();
4551 /* If the stub wants to get a QAllow, compose one and send it. */
4552 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4555 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4556 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4557 as a reply to known packet. For packet "vFile:setfs:" it is an
4558 invalid reply and GDB would return error in
4559 remote_hostio_set_filesystem, making remote files access impossible.
4560 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4561 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4563 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4565 putpkt (v_mustreplyempty
);
4566 getpkt (&rs
->buf
, 0);
4567 if (strcmp (rs
->buf
.data (), "OK") == 0)
4568 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4569 else if (strcmp (rs
->buf
.data (), "") != 0)
4570 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4574 /* Next, we possibly activate noack mode.
4576 If the QStartNoAckMode packet configuration is set to AUTO,
4577 enable noack mode if the stub reported a wish for it with
4580 If set to TRUE, then enable noack mode even if the stub didn't
4581 report it in qSupported. If the stub doesn't reply OK, the
4582 session ends with an error.
4584 If FALSE, then don't activate noack mode, regardless of what the
4585 stub claimed should be the default with qSupported. */
4587 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4588 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4590 putpkt ("QStartNoAckMode");
4591 getpkt (&rs
->buf
, 0);
4592 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4598 /* Tell the remote that we are using the extended protocol. */
4600 getpkt (&rs
->buf
, 0);
4603 /* Let the target know which signals it is allowed to pass down to
4605 update_signals_program_target ();
4607 /* Next, if the target can specify a description, read it. We do
4608 this before anything involving memory or registers. */
4609 target_find_description ();
4611 /* Next, now that we know something about the target, update the
4612 address spaces in the program spaces. */
4613 update_address_spaces ();
4615 /* On OSs where the list of libraries is global to all
4616 processes, we fetch them early. */
4617 if (gdbarch_has_global_solist (target_gdbarch ()))
4618 solib_add (NULL
, from_tty
, auto_solib_add
);
4620 if (target_is_non_stop_p ())
4622 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4623 error (_("Non-stop mode requested, but remote "
4624 "does not support non-stop"));
4626 putpkt ("QNonStop:1");
4627 getpkt (&rs
->buf
, 0);
4629 if (strcmp (rs
->buf
.data (), "OK") != 0)
4630 error (_("Remote refused setting non-stop mode with: %s"),
4633 /* Find about threads and processes the stub is already
4634 controlling. We default to adding them in the running state.
4635 The '?' query below will then tell us about which threads are
4637 this->update_thread_list ();
4639 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4641 /* Don't assume that the stub can operate in all-stop mode.
4642 Request it explicitly. */
4643 putpkt ("QNonStop:0");
4644 getpkt (&rs
->buf
, 0);
4646 if (strcmp (rs
->buf
.data (), "OK") != 0)
4647 error (_("Remote refused setting all-stop mode with: %s"),
4651 /* Upload TSVs regardless of whether the target is running or not. The
4652 remote stub, such as GDBserver, may have some predefined or builtin
4653 TSVs, even if the target is not running. */
4654 if (get_trace_status (current_trace_status ()) != -1)
4656 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4658 upload_trace_state_variables (&uploaded_tsvs
);
4659 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4662 /* Check whether the target is running now. */
4664 getpkt (&rs
->buf
, 0);
4666 if (!target_is_non_stop_p ())
4668 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4671 error (_("The target is not running (try extended-remote?)"));
4673 /* We're connected, but not running. Drop out before we
4674 call start_remote. */
4675 rs
->starting_up
= 0;
4680 /* Save the reply for later. */
4681 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4682 strcpy (wait_status
, rs
->buf
.data ());
4685 /* Fetch thread list. */
4686 target_update_thread_list ();
4688 /* Let the stub know that we want it to return the thread. */
4689 set_continue_thread (minus_one_ptid
);
4691 if (thread_count () == 0)
4693 /* Target has no concept of threads at all. GDB treats
4694 non-threaded target as single-threaded; add a main
4696 add_current_inferior_and_thread (wait_status
);
4700 /* We have thread information; select the thread the target
4701 says should be current. If we're reconnecting to a
4702 multi-threaded program, this will ideally be the thread
4703 that last reported an event before GDB disconnected. */
4704 ptid_t curr_thread
= get_current_thread (wait_status
);
4705 if (curr_thread
== null_ptid
)
4707 /* Odd... The target was able to list threads, but not
4708 tell us which thread was current (no "thread"
4709 register in T stop reply?). Just pick the first
4710 thread in the thread list then. */
4713 fprintf_unfiltered (gdb_stdlog
,
4714 "warning: couldn't determine remote "
4715 "current thread; picking first in list.\n");
4717 for (thread_info
*tp
: all_non_exited_threads ())
4719 switch_to_thread (tp
);
4724 switch_to_thread (find_thread_ptid (curr_thread
));
4727 /* init_wait_for_inferior should be called before get_offsets in order
4728 to manage `inserted' flag in bp loc in a correct state.
4729 breakpoint_init_inferior, called from init_wait_for_inferior, set
4730 `inserted' flag to 0, while before breakpoint_re_set, called from
4731 start_remote, set `inserted' flag to 1. In the initialization of
4732 inferior, breakpoint_init_inferior should be called first, and then
4733 breakpoint_re_set can be called. If this order is broken, state of
4734 `inserted' flag is wrong, and cause some problems on breakpoint
4736 init_wait_for_inferior ();
4738 get_offsets (); /* Get text, data & bss offsets. */
4740 /* If we could not find a description using qXfer, and we know
4741 how to do it some other way, try again. This is not
4742 supported for non-stop; it could be, but it is tricky if
4743 there are no stopped threads when we connect. */
4744 if (remote_read_description_p (this)
4745 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4747 target_clear_description ();
4748 target_find_description ();
4751 /* Use the previously fetched status. */
4752 gdb_assert (wait_status
!= NULL
);
4753 strcpy (rs
->buf
.data (), wait_status
);
4754 rs
->cached_wait_status
= 1;
4756 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4760 /* Clear WFI global state. Do this before finding about new
4761 threads and inferiors, and setting the current inferior.
4762 Otherwise we would clear the proceed status of the current
4763 inferior when we want its stop_soon state to be preserved
4764 (see notice_new_inferior). */
4765 init_wait_for_inferior ();
4767 /* In non-stop, we will either get an "OK", meaning that there
4768 are no stopped threads at this time; or, a regular stop
4769 reply. In the latter case, there may be more than one thread
4770 stopped --- we pull them all out using the vStopped
4772 if (strcmp (rs
->buf
.data (), "OK") != 0)
4774 struct notif_client
*notif
= ¬if_client_stop
;
4776 /* remote_notif_get_pending_replies acks this one, and gets
4778 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4779 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4780 remote_notif_get_pending_events (notif
);
4783 if (thread_count () == 0)
4786 error (_("The target is not running (try extended-remote?)"));
4788 /* We're connected, but not running. Drop out before we
4789 call start_remote. */
4790 rs
->starting_up
= 0;
4794 /* In non-stop mode, any cached wait status will be stored in
4795 the stop reply queue. */
4796 gdb_assert (wait_status
== NULL
);
4798 /* Report all signals during attach/startup. */
4801 /* If there are already stopped threads, mark them stopped and
4802 report their stops before giving the prompt to the user. */
4803 process_initial_stop_replies (from_tty
);
4805 if (target_can_async_p ())
4809 /* If we connected to a live target, do some additional setup. */
4810 if (target_has_execution
)
4812 if (symfile_objfile
) /* No use without a symbol-file. */
4813 remote_check_symbols ();
4816 /* Possibly the target has been engaged in a trace run started
4817 previously; find out where things are at. */
4818 if (get_trace_status (current_trace_status ()) != -1)
4820 struct uploaded_tp
*uploaded_tps
= NULL
;
4822 if (current_trace_status ()->running
)
4823 printf_filtered (_("Trace is already running on the target.\n"));
4825 upload_tracepoints (&uploaded_tps
);
4827 merge_uploaded_tracepoints (&uploaded_tps
);
4830 /* Possibly the target has been engaged in a btrace record started
4831 previously; find out where things are at. */
4832 remote_btrace_maybe_reopen ();
4834 /* The thread and inferior lists are now synchronized with the
4835 target, our symbols have been relocated, and we're merged the
4836 target's tracepoints with ours. We're done with basic start
4838 rs
->starting_up
= 0;
4840 /* Maybe breakpoints are global and need to be inserted now. */
4841 if (breakpoints_should_be_inserted_now ())
4842 insert_breakpoints ();
4845 /* Open a connection to a remote debugger.
4846 NAME is the filename used for communication. */
4849 remote_target::open (const char *name
, int from_tty
)
4851 open_1 (name
, from_tty
, 0);
4854 /* Open a connection to a remote debugger using the extended
4855 remote gdb protocol. NAME is the filename used for communication. */
4858 extended_remote_target::open (const char *name
, int from_tty
)
4860 open_1 (name
, from_tty
, 1 /*extended_p */);
4863 /* Reset all packets back to "unknown support". Called when opening a
4864 new connection to a remote target. */
4867 reset_all_packet_configs_support (void)
4871 for (i
= 0; i
< PACKET_MAX
; i
++)
4872 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4875 /* Initialize all packet configs. */
4878 init_all_packet_configs (void)
4882 for (i
= 0; i
< PACKET_MAX
; i
++)
4884 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4885 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4889 /* Symbol look-up. */
4892 remote_target::remote_check_symbols ()
4897 /* The remote side has no concept of inferiors that aren't running
4898 yet, it only knows about running processes. If we're connected
4899 but our current inferior is not running, we should not invite the
4900 remote target to request symbol lookups related to its
4901 (unrelated) current process. */
4902 if (!target_has_execution
)
4905 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4908 /* Make sure the remote is pointing at the right process. Note
4909 there's no way to select "no process". */
4910 set_general_process ();
4912 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4913 because we need both at the same time. */
4914 gdb::char_vector
msg (get_remote_packet_size ());
4915 gdb::char_vector
reply (get_remote_packet_size ());
4917 /* Invite target to request symbol lookups. */
4919 putpkt ("qSymbol::");
4921 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4923 while (startswith (reply
.data (), "qSymbol:"))
4925 struct bound_minimal_symbol sym
;
4928 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
4931 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
4932 if (sym
.minsym
== NULL
)
4933 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
4937 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4938 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4940 /* If this is a function address, return the start of code
4941 instead of any data function descriptor. */
4942 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4944 current_top_target ());
4946 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4947 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4950 putpkt (msg
.data ());
4955 static struct serial
*
4956 remote_serial_open (const char *name
)
4958 static int udp_warning
= 0;
4960 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4961 of in ser-tcp.c, because it is the remote protocol assuming that the
4962 serial connection is reliable and not the serial connection promising
4964 if (!udp_warning
&& startswith (name
, "udp:"))
4966 warning (_("The remote protocol may be unreliable over UDP.\n"
4967 "Some events may be lost, rendering further debugging "
4972 return serial_open (name
);
4975 /* Inform the target of our permission settings. The permission flags
4976 work without this, but if the target knows the settings, it can do
4977 a couple things. First, it can add its own check, to catch cases
4978 that somehow manage to get by the permissions checks in target
4979 methods. Second, if the target is wired to disallow particular
4980 settings (for instance, a system in the field that is not set up to
4981 be able to stop at a breakpoint), it can object to any unavailable
4985 remote_target::set_permissions ()
4987 struct remote_state
*rs
= get_remote_state ();
4989 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
4990 "WriteReg:%x;WriteMem:%x;"
4991 "InsertBreak:%x;InsertTrace:%x;"
4992 "InsertFastTrace:%x;Stop:%x",
4993 may_write_registers
, may_write_memory
,
4994 may_insert_breakpoints
, may_insert_tracepoints
,
4995 may_insert_fast_tracepoints
, may_stop
);
4997 getpkt (&rs
->buf
, 0);
4999 /* If the target didn't like the packet, warn the user. Do not try
5000 to undo the user's settings, that would just be maddening. */
5001 if (strcmp (rs
->buf
.data (), "OK") != 0)
5002 warning (_("Remote refused setting permissions with: %s"),
5006 /* This type describes each known response to the qSupported
5008 struct protocol_feature
5010 /* The name of this protocol feature. */
5013 /* The default for this protocol feature. */
5014 enum packet_support default_support
;
5016 /* The function to call when this feature is reported, or after
5017 qSupported processing if the feature is not supported.
5018 The first argument points to this structure. The second
5019 argument indicates whether the packet requested support be
5020 enabled, disabled, or probed (or the default, if this function
5021 is being called at the end of processing and this feature was
5022 not reported). The third argument may be NULL; if not NULL, it
5023 is a NUL-terminated string taken from the packet following
5024 this feature's name and an equals sign. */
5025 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5026 enum packet_support
, const char *);
5028 /* The corresponding packet for this feature. Only used if
5029 FUNC is remote_supported_packet. */
5034 remote_supported_packet (remote_target
*remote
,
5035 const struct protocol_feature
*feature
,
5036 enum packet_support support
,
5037 const char *argument
)
5041 warning (_("Remote qSupported response supplied an unexpected value for"
5042 " \"%s\"."), feature
->name
);
5046 remote_protocol_packets
[feature
->packet
].support
= support
;
5050 remote_target::remote_packet_size (const protocol_feature
*feature
,
5051 enum packet_support support
, const char *value
)
5053 struct remote_state
*rs
= get_remote_state ();
5058 if (support
!= PACKET_ENABLE
)
5061 if (value
== NULL
|| *value
== '\0')
5063 warning (_("Remote target reported \"%s\" without a size."),
5069 packet_size
= strtol (value
, &value_end
, 16);
5070 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5072 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5073 feature
->name
, value
);
5077 /* Record the new maximum packet size. */
5078 rs
->explicit_packet_size
= packet_size
;
5082 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5083 enum packet_support support
, const char *value
)
5085 remote
->remote_packet_size (feature
, support
, value
);
5088 static const struct protocol_feature remote_protocol_features
[] = {
5089 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5090 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5091 PACKET_qXfer_auxv
},
5092 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5093 PACKET_qXfer_exec_file
},
5094 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5095 PACKET_qXfer_features
},
5096 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5097 PACKET_qXfer_libraries
},
5098 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5099 PACKET_qXfer_libraries_svr4
},
5100 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5101 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5102 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5103 PACKET_qXfer_memory_map
},
5104 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5105 PACKET_qXfer_osdata
},
5106 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5107 PACKET_qXfer_threads
},
5108 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5109 PACKET_qXfer_traceframe_info
},
5110 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5111 PACKET_QPassSignals
},
5112 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5113 PACKET_QCatchSyscalls
},
5114 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5115 PACKET_QProgramSignals
},
5116 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5117 PACKET_QSetWorkingDir
},
5118 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5119 PACKET_QStartupWithShell
},
5120 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5121 PACKET_QEnvironmentHexEncoded
},
5122 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5123 PACKET_QEnvironmentReset
},
5124 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5125 PACKET_QEnvironmentUnset
},
5126 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5127 PACKET_QStartNoAckMode
},
5128 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5129 PACKET_multiprocess_feature
},
5130 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5131 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5132 PACKET_qXfer_siginfo_read
},
5133 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5134 PACKET_qXfer_siginfo_write
},
5135 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5136 PACKET_ConditionalTracepoints
},
5137 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5138 PACKET_ConditionalBreakpoints
},
5139 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5140 PACKET_BreakpointCommands
},
5141 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5142 PACKET_FastTracepoints
},
5143 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5144 PACKET_StaticTracepoints
},
5145 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5146 PACKET_InstallInTrace
},
5147 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5148 PACKET_DisconnectedTracing_feature
},
5149 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5151 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5153 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5154 PACKET_TracepointSource
},
5155 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5157 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5158 PACKET_EnableDisableTracepoints_feature
},
5159 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5160 PACKET_qXfer_fdpic
},
5161 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5163 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5164 PACKET_QDisableRandomization
},
5165 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5166 { "QTBuffer:size", PACKET_DISABLE
,
5167 remote_supported_packet
, PACKET_QTBuffer_size
},
5168 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5169 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5170 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5171 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5172 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5173 PACKET_qXfer_btrace
},
5174 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5175 PACKET_qXfer_btrace_conf
},
5176 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5177 PACKET_Qbtrace_conf_bts_size
},
5178 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5179 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5180 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5181 PACKET_fork_event_feature
},
5182 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5183 PACKET_vfork_event_feature
},
5184 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5185 PACKET_exec_event_feature
},
5186 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5187 PACKET_Qbtrace_conf_pt_size
},
5188 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5189 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5190 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5193 static char *remote_support_xml
;
5195 /* Register string appended to "xmlRegisters=" in qSupported query. */
5198 register_remote_support_xml (const char *xml
)
5200 #if defined(HAVE_LIBEXPAT)
5201 if (remote_support_xml
== NULL
)
5202 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5205 char *copy
= xstrdup (remote_support_xml
+ 13);
5207 char *p
= strtok_r (copy
, ",", &saveptr
);
5211 if (strcmp (p
, xml
) == 0)
5218 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5221 remote_support_xml
= reconcat (remote_support_xml
,
5222 remote_support_xml
, ",", xml
,
5229 remote_query_supported_append (std::string
*msg
, const char *append
)
5233 msg
->append (append
);
5237 remote_target::remote_query_supported ()
5239 struct remote_state
*rs
= get_remote_state ();
5242 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5244 /* The packet support flags are handled differently for this packet
5245 than for most others. We treat an error, a disabled packet, and
5246 an empty response identically: any features which must be reported
5247 to be used will be automatically disabled. An empty buffer
5248 accomplishes this, since that is also the representation for a list
5249 containing no features. */
5252 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5256 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5257 remote_query_supported_append (&q
, "multiprocess+");
5259 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5260 remote_query_supported_append (&q
, "swbreak+");
5261 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5262 remote_query_supported_append (&q
, "hwbreak+");
5264 remote_query_supported_append (&q
, "qRelocInsn+");
5266 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5267 != AUTO_BOOLEAN_FALSE
)
5268 remote_query_supported_append (&q
, "fork-events+");
5269 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5270 != AUTO_BOOLEAN_FALSE
)
5271 remote_query_supported_append (&q
, "vfork-events+");
5272 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5273 != AUTO_BOOLEAN_FALSE
)
5274 remote_query_supported_append (&q
, "exec-events+");
5276 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5277 remote_query_supported_append (&q
, "vContSupported+");
5279 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5280 remote_query_supported_append (&q
, "QThreadEvents+");
5282 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5283 remote_query_supported_append (&q
, "no-resumed+");
5285 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5286 the qSupported:xmlRegisters=i386 handling. */
5287 if (remote_support_xml
!= NULL
5288 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5289 remote_query_supported_append (&q
, remote_support_xml
);
5291 q
= "qSupported:" + q
;
5292 putpkt (q
.c_str ());
5294 getpkt (&rs
->buf
, 0);
5296 /* If an error occured, warn, but do not return - just reset the
5297 buffer to empty and go on to disable features. */
5298 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5301 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5306 memset (seen
, 0, sizeof (seen
));
5308 next
= rs
->buf
.data ();
5311 enum packet_support is_supported
;
5312 char *p
, *end
, *name_end
, *value
;
5314 /* First separate out this item from the rest of the packet. If
5315 there's another item after this, we overwrite the separator
5316 (terminated strings are much easier to work with). */
5318 end
= strchr (p
, ';');
5321 end
= p
+ strlen (p
);
5331 warning (_("empty item in \"qSupported\" response"));
5336 name_end
= strchr (p
, '=');
5339 /* This is a name=value entry. */
5340 is_supported
= PACKET_ENABLE
;
5341 value
= name_end
+ 1;
5350 is_supported
= PACKET_ENABLE
;
5354 is_supported
= PACKET_DISABLE
;
5358 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5362 warning (_("unrecognized item \"%s\" "
5363 "in \"qSupported\" response"), p
);
5369 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5370 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5372 const struct protocol_feature
*feature
;
5375 feature
= &remote_protocol_features
[i
];
5376 feature
->func (this, feature
, is_supported
, value
);
5381 /* If we increased the packet size, make sure to increase the global
5382 buffer size also. We delay this until after parsing the entire
5383 qSupported packet, because this is the same buffer we were
5385 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5386 rs
->buf
.resize (rs
->explicit_packet_size
);
5388 /* Handle the defaults for unmentioned features. */
5389 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5392 const struct protocol_feature
*feature
;
5394 feature
= &remote_protocol_features
[i
];
5395 feature
->func (this, feature
, feature
->default_support
, NULL
);
5399 /* Serial QUIT handler for the remote serial descriptor.
5401 Defers handling a Ctrl-C until we're done with the current
5402 command/response packet sequence, unless:
5404 - We're setting up the connection. Don't send a remote interrupt
5405 request, as we're not fully synced yet. Quit immediately
5408 - The target has been resumed in the foreground
5409 (target_terminal::is_ours is false) with a synchronous resume
5410 packet, and we're blocked waiting for the stop reply, thus a
5411 Ctrl-C should be immediately sent to the target.
5413 - We get a second Ctrl-C while still within the same serial read or
5414 write. In that case the serial is seemingly wedged --- offer to
5417 - We see a second Ctrl-C without target response, after having
5418 previously interrupted the target. In that case the target/stub
5419 is probably wedged --- offer to quit/disconnect.
5423 remote_target::remote_serial_quit_handler ()
5425 struct remote_state
*rs
= get_remote_state ();
5427 if (check_quit_flag ())
5429 /* If we're starting up, we're not fully synced yet. Quit
5431 if (rs
->starting_up
)
5433 else if (rs
->got_ctrlc_during_io
)
5435 if (query (_("The target is not responding to GDB commands.\n"
5436 "Stop debugging it? ")))
5437 remote_unpush_and_throw ();
5439 /* If ^C has already been sent once, offer to disconnect. */
5440 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5442 /* All-stop protocol, and blocked waiting for stop reply. Send
5443 an interrupt request. */
5444 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5445 target_interrupt ();
5447 rs
->got_ctrlc_during_io
= 1;
5451 /* The remote_target that is current while the quit handler is
5452 overridden with remote_serial_quit_handler. */
5453 static remote_target
*curr_quit_handler_target
;
5456 remote_serial_quit_handler ()
5458 curr_quit_handler_target
->remote_serial_quit_handler ();
5461 /* Remove any of the remote.c targets from target stack. Upper targets depend
5462 on it so remove them first. */
5465 remote_unpush_target (void)
5467 pop_all_targets_at_and_above (process_stratum
);
5471 remote_unpush_and_throw (void)
5473 remote_unpush_target ();
5474 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5478 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5480 remote_target
*curr_remote
= get_current_remote_target ();
5483 error (_("To open a remote debug connection, you need to specify what\n"
5484 "serial device is attached to the remote system\n"
5485 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5487 /* If we're connected to a running target, target_preopen will kill it.
5488 Ask this question first, before target_preopen has a chance to kill
5490 if (curr_remote
!= NULL
&& !have_inferiors ())
5493 && !query (_("Already connected to a remote target. Disconnect? ")))
5494 error (_("Still connected."));
5497 /* Here the possibly existing remote target gets unpushed. */
5498 target_preopen (from_tty
);
5500 remote_fileio_reset ();
5501 reopen_exec_file ();
5504 remote_target
*remote
5505 = (extended_p
? new extended_remote_target () : new remote_target ());
5506 target_ops_up
target_holder (remote
);
5508 remote_state
*rs
= remote
->get_remote_state ();
5510 /* See FIXME above. */
5511 if (!target_async_permitted
)
5512 rs
->wait_forever_enabled_p
= 1;
5514 rs
->remote_desc
= remote_serial_open (name
);
5515 if (!rs
->remote_desc
)
5516 perror_with_name (name
);
5518 if (baud_rate
!= -1)
5520 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5522 /* The requested speed could not be set. Error out to
5523 top level after closing remote_desc. Take care to
5524 set remote_desc to NULL to avoid closing remote_desc
5526 serial_close (rs
->remote_desc
);
5527 rs
->remote_desc
= NULL
;
5528 perror_with_name (name
);
5532 serial_setparity (rs
->remote_desc
, serial_parity
);
5533 serial_raw (rs
->remote_desc
);
5535 /* If there is something sitting in the buffer we might take it as a
5536 response to a command, which would be bad. */
5537 serial_flush_input (rs
->remote_desc
);
5541 puts_filtered ("Remote debugging using ");
5542 puts_filtered (name
);
5543 puts_filtered ("\n");
5546 /* Switch to using the remote target now. */
5547 push_target (std::move (target_holder
));
5549 /* Register extra event sources in the event loop. */
5550 rs
->remote_async_inferior_event_token
5551 = create_async_event_handler (remote_async_inferior_event_handler
,
5553 rs
->notif_state
= remote_notif_state_allocate (remote
);
5555 /* Reset the target state; these things will be queried either by
5556 remote_query_supported or as they are needed. */
5557 reset_all_packet_configs_support ();
5558 rs
->cached_wait_status
= 0;
5559 rs
->explicit_packet_size
= 0;
5561 rs
->extended
= extended_p
;
5562 rs
->waiting_for_stop_reply
= 0;
5563 rs
->ctrlc_pending_p
= 0;
5564 rs
->got_ctrlc_during_io
= 0;
5566 rs
->general_thread
= not_sent_ptid
;
5567 rs
->continue_thread
= not_sent_ptid
;
5568 rs
->remote_traceframe_number
= -1;
5570 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5572 /* Probe for ability to use "ThreadInfo" query, as required. */
5573 rs
->use_threadinfo_query
= 1;
5574 rs
->use_threadextra_query
= 1;
5576 rs
->readahead_cache
.invalidate ();
5578 if (target_async_permitted
)
5580 /* FIXME: cagney/1999-09-23: During the initial connection it is
5581 assumed that the target is already ready and able to respond to
5582 requests. Unfortunately remote_start_remote() eventually calls
5583 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5584 around this. Eventually a mechanism that allows
5585 wait_for_inferior() to expect/get timeouts will be
5587 rs
->wait_forever_enabled_p
= 0;
5590 /* First delete any symbols previously loaded from shared libraries. */
5591 no_shared_libraries (NULL
, 0);
5593 /* Start the remote connection. If error() or QUIT, discard this
5594 target (we'd otherwise be in an inconsistent state) and then
5595 propogate the error on up the exception chain. This ensures that
5596 the caller doesn't stumble along blindly assuming that the
5597 function succeeded. The CLI doesn't have this problem but other
5598 UI's, such as MI do.
5600 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5601 this function should return an error indication letting the
5602 caller restore the previous state. Unfortunately the command
5603 ``target remote'' is directly wired to this function making that
5604 impossible. On a positive note, the CLI side of this problem has
5605 been fixed - the function set_cmd_context() makes it possible for
5606 all the ``target ....'' commands to share a common callback
5607 function. See cli-dump.c. */
5612 remote
->start_remote (from_tty
, extended_p
);
5614 catch (const gdb_exception
&ex
)
5616 /* Pop the partially set up target - unless something else did
5617 already before throwing the exception. */
5618 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5619 remote_unpush_target ();
5624 remote_btrace_reset (rs
);
5626 if (target_async_permitted
)
5627 rs
->wait_forever_enabled_p
= 1;
5630 /* Detach the specified process. */
5633 remote_target::remote_detach_pid (int pid
)
5635 struct remote_state
*rs
= get_remote_state ();
5637 /* This should not be necessary, but the handling for D;PID in
5638 GDBserver versions prior to 8.2 incorrectly assumes that the
5639 selected process points to the same process we're detaching,
5640 leading to misbehavior (and possibly GDBserver crashing) when it
5641 does not. Since it's easy and cheap, work around it by forcing
5642 GDBserver to select GDB's current process. */
5643 set_general_process ();
5645 if (remote_multi_process_p (rs
))
5646 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5648 strcpy (rs
->buf
.data (), "D");
5651 getpkt (&rs
->buf
, 0);
5653 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5655 else if (rs
->buf
[0] == '\0')
5656 error (_("Remote doesn't know how to detach"));
5658 error (_("Can't detach process."));
5661 /* This detaches a program to which we previously attached, using
5662 inferior_ptid to identify the process. After this is done, GDB
5663 can be used to debug some other program. We better not have left
5664 any breakpoints in the target program or it'll die when it hits
5668 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5670 int pid
= inferior_ptid
.pid ();
5671 struct remote_state
*rs
= get_remote_state ();
5674 if (!target_has_execution
)
5675 error (_("No process to detach from."));
5677 target_announce_detach (from_tty
);
5679 /* Tell the remote target to detach. */
5680 remote_detach_pid (pid
);
5682 /* Exit only if this is the only active inferior. */
5683 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors () == 1)
5684 puts_filtered (_("Ending remote debugging.\n"));
5686 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
5688 /* Check to see if we are detaching a fork parent. Note that if we
5689 are detaching a fork child, tp == NULL. */
5690 is_fork_parent
= (tp
!= NULL
5691 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5693 /* If doing detach-on-fork, we don't mourn, because that will delete
5694 breakpoints that should be available for the followed inferior. */
5695 if (!is_fork_parent
)
5697 /* Save the pid as a string before mourning, since that will
5698 unpush the remote target, and we need the string after. */
5699 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5701 target_mourn_inferior (inferior_ptid
);
5702 if (print_inferior_events
)
5703 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5704 inf
->num
, infpid
.c_str ());
5708 inferior_ptid
= null_ptid
;
5709 detach_inferior (current_inferior ());
5714 remote_target::detach (inferior
*inf
, int from_tty
)
5716 remote_detach_1 (inf
, from_tty
);
5720 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5722 remote_detach_1 (inf
, from_tty
);
5725 /* Target follow-fork function for remote targets. On entry, and
5726 at return, the current inferior is the fork parent.
5728 Note that although this is currently only used for extended-remote,
5729 it is named remote_follow_fork in anticipation of using it for the
5730 remote target as well. */
5733 remote_target::follow_fork (int follow_child
, int detach_fork
)
5735 struct remote_state
*rs
= get_remote_state ();
5736 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5738 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5739 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5741 /* When following the parent and detaching the child, we detach
5742 the child here. For the case of following the child and
5743 detaching the parent, the detach is done in the target-
5744 independent follow fork code in infrun.c. We can't use
5745 target_detach when detaching an unfollowed child because
5746 the client side doesn't know anything about the child. */
5747 if (detach_fork
&& !follow_child
)
5749 /* Detach the fork child. */
5753 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5754 child_pid
= child_ptid
.pid ();
5756 remote_detach_pid (child_pid
);
5762 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5763 in the program space of the new inferior. On entry and at return the
5764 current inferior is the exec'ing inferior. INF is the new exec'd
5765 inferior, which may be the same as the exec'ing inferior unless
5766 follow-exec-mode is "new". */
5769 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5771 /* We know that this is a target file name, so if it has the "target:"
5772 prefix we strip it off before saving it in the program space. */
5773 if (is_target_filename (execd_pathname
))
5774 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5776 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5779 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5782 remote_target::disconnect (const char *args
, int from_tty
)
5785 error (_("Argument given to \"disconnect\" when remotely debugging."));
5787 /* Make sure we unpush even the extended remote targets. Calling
5788 target_mourn_inferior won't unpush, and remote_mourn won't
5789 unpush if there is more than one inferior left. */
5790 unpush_target (this);
5791 generic_mourn_inferior ();
5794 puts_filtered ("Ending remote debugging.\n");
5797 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5798 be chatty about it. */
5801 extended_remote_target::attach (const char *args
, int from_tty
)
5803 struct remote_state
*rs
= get_remote_state ();
5805 char *wait_status
= NULL
;
5807 pid
= parse_pid_to_attach (args
);
5809 /* Remote PID can be freely equal to getpid, do not check it here the same
5810 way as in other targets. */
5812 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5813 error (_("This target does not support attaching to a process"));
5817 const char *exec_file
= get_exec_file (0);
5820 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5821 target_pid_to_str (ptid_t (pid
)).c_str ());
5823 printf_unfiltered (_("Attaching to %s\n"),
5824 target_pid_to_str (ptid_t (pid
)).c_str ());
5827 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5829 getpkt (&rs
->buf
, 0);
5831 switch (packet_ok (rs
->buf
,
5832 &remote_protocol_packets
[PACKET_vAttach
]))
5835 if (!target_is_non_stop_p ())
5837 /* Save the reply for later. */
5838 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5839 strcpy (wait_status
, rs
->buf
.data ());
5841 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5842 error (_("Attaching to %s failed with: %s"),
5843 target_pid_to_str (ptid_t (pid
)).c_str (),
5846 case PACKET_UNKNOWN
:
5847 error (_("This target does not support attaching to a process"));
5849 error (_("Attaching to %s failed"),
5850 target_pid_to_str (ptid_t (pid
)).c_str ());
5853 set_current_inferior (remote_add_inferior (false, pid
, 1, 0));
5855 inferior_ptid
= ptid_t (pid
);
5857 if (target_is_non_stop_p ())
5859 struct thread_info
*thread
;
5861 /* Get list of threads. */
5862 update_thread_list ();
5864 thread
= first_thread_of_inferior (current_inferior ());
5866 inferior_ptid
= thread
->ptid
;
5868 inferior_ptid
= ptid_t (pid
);
5870 /* Invalidate our notion of the remote current thread. */
5871 record_currthread (rs
, minus_one_ptid
);
5875 /* Now, if we have thread information, update inferior_ptid. */
5876 inferior_ptid
= remote_current_thread (inferior_ptid
);
5878 /* Add the main thread to the thread list. */
5879 thread_info
*thr
= add_thread_silent (inferior_ptid
);
5880 /* Don't consider the thread stopped until we've processed the
5881 saved stop reply. */
5882 set_executing (thr
->ptid
, true);
5885 /* Next, if the target can specify a description, read it. We do
5886 this before anything involving memory or registers. */
5887 target_find_description ();
5889 if (!target_is_non_stop_p ())
5891 /* Use the previously fetched status. */
5892 gdb_assert (wait_status
!= NULL
);
5894 if (target_can_async_p ())
5896 struct notif_event
*reply
5897 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
5899 push_stop_reply ((struct stop_reply
*) reply
);
5905 gdb_assert (wait_status
!= NULL
);
5906 strcpy (rs
->buf
.data (), wait_status
);
5907 rs
->cached_wait_status
= 1;
5911 gdb_assert (wait_status
== NULL
);
5914 /* Implementation of the to_post_attach method. */
5917 extended_remote_target::post_attach (int pid
)
5919 /* Get text, data & bss offsets. */
5922 /* In certain cases GDB might not have had the chance to start
5923 symbol lookup up until now. This could happen if the debugged
5924 binary is not using shared libraries, the vsyscall page is not
5925 present (on Linux) and the binary itself hadn't changed since the
5926 debugging process was started. */
5927 if (symfile_objfile
!= NULL
)
5928 remote_check_symbols();
5932 /* Check for the availability of vCont. This function should also check
5936 remote_target::remote_vcont_probe ()
5938 remote_state
*rs
= get_remote_state ();
5941 strcpy (rs
->buf
.data (), "vCont?");
5943 getpkt (&rs
->buf
, 0);
5944 buf
= rs
->buf
.data ();
5946 /* Make sure that the features we assume are supported. */
5947 if (startswith (buf
, "vCont"))
5950 int support_c
, support_C
;
5952 rs
->supports_vCont
.s
= 0;
5953 rs
->supports_vCont
.S
= 0;
5956 rs
->supports_vCont
.t
= 0;
5957 rs
->supports_vCont
.r
= 0;
5958 while (p
&& *p
== ';')
5961 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5962 rs
->supports_vCont
.s
= 1;
5963 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5964 rs
->supports_vCont
.S
= 1;
5965 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5967 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5969 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5970 rs
->supports_vCont
.t
= 1;
5971 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5972 rs
->supports_vCont
.r
= 1;
5974 p
= strchr (p
, ';');
5977 /* If c, and C are not all supported, we can't use vCont. Clearing
5978 BUF will make packet_ok disable the packet. */
5979 if (!support_c
|| !support_C
)
5983 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
5986 /* Helper function for building "vCont" resumptions. Write a
5987 resumption to P. ENDP points to one-passed-the-end of the buffer
5988 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
5989 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5990 resumed thread should be single-stepped and/or signalled. If PTID
5991 equals minus_one_ptid, then all threads are resumed; if PTID
5992 represents a process, then all threads of the process are resumed;
5993 the thread to be stepped and/or signalled is given in the global
5997 remote_target::append_resumption (char *p
, char *endp
,
5998 ptid_t ptid
, int step
, gdb_signal siggnal
)
6000 struct remote_state
*rs
= get_remote_state ();
6002 if (step
&& siggnal
!= GDB_SIGNAL_0
)
6003 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
6005 /* GDB is willing to range step. */
6006 && use_range_stepping
6007 /* Target supports range stepping. */
6008 && rs
->supports_vCont
.r
6009 /* We don't currently support range stepping multiple
6010 threads with a wildcard (though the protocol allows it,
6011 so stubs shouldn't make an active effort to forbid
6013 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6015 struct thread_info
*tp
;
6017 if (ptid
== minus_one_ptid
)
6019 /* If we don't know about the target thread's tid, then
6020 we're resuming magic_null_ptid (see caller). */
6021 tp
= find_thread_ptid (magic_null_ptid
);
6024 tp
= find_thread_ptid (ptid
);
6025 gdb_assert (tp
!= NULL
);
6027 if (tp
->control
.may_range_step
)
6029 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6031 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6032 phex_nz (tp
->control
.step_range_start
,
6034 phex_nz (tp
->control
.step_range_end
,
6038 p
+= xsnprintf (p
, endp
- p
, ";s");
6041 p
+= xsnprintf (p
, endp
- p
, ";s");
6042 else if (siggnal
!= GDB_SIGNAL_0
)
6043 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6045 p
+= xsnprintf (p
, endp
- p
, ";c");
6047 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6051 /* All (-1) threads of process. */
6052 nptid
= ptid_t (ptid
.pid (), -1, 0);
6054 p
+= xsnprintf (p
, endp
- p
, ":");
6055 p
= write_ptid (p
, endp
, nptid
);
6057 else if (ptid
!= minus_one_ptid
)
6059 p
+= xsnprintf (p
, endp
- p
, ":");
6060 p
= write_ptid (p
, endp
, ptid
);
6066 /* Clear the thread's private info on resume. */
6069 resume_clear_thread_private_info (struct thread_info
*thread
)
6071 if (thread
->priv
!= NULL
)
6073 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6075 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6076 priv
->watch_data_address
= 0;
6080 /* Append a vCont continue-with-signal action for threads that have a
6081 non-zero stop signal. */
6084 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6087 for (thread_info
*thread
: all_non_exited_threads (ptid
))
6088 if (inferior_ptid
!= thread
->ptid
6089 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6091 p
= append_resumption (p
, endp
, thread
->ptid
,
6092 0, thread
->suspend
.stop_signal
);
6093 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6094 resume_clear_thread_private_info (thread
);
6100 /* Set the target running, using the packets that use Hc
6104 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6107 struct remote_state
*rs
= get_remote_state ();
6110 rs
->last_sent_signal
= siggnal
;
6111 rs
->last_sent_step
= step
;
6113 /* The c/s/C/S resume packets use Hc, so set the continue
6115 if (ptid
== minus_one_ptid
)
6116 set_continue_thread (any_thread_ptid
);
6118 set_continue_thread (ptid
);
6120 for (thread_info
*thread
: all_non_exited_threads ())
6121 resume_clear_thread_private_info (thread
);
6123 buf
= rs
->buf
.data ();
6124 if (::execution_direction
== EXEC_REVERSE
)
6126 /* We don't pass signals to the target in reverse exec mode. */
6127 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6128 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6131 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6132 error (_("Remote reverse-step not supported."));
6133 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6134 error (_("Remote reverse-continue not supported."));
6136 strcpy (buf
, step
? "bs" : "bc");
6138 else if (siggnal
!= GDB_SIGNAL_0
)
6140 buf
[0] = step
? 'S' : 'C';
6141 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6142 buf
[2] = tohex (((int) siggnal
) & 0xf);
6146 strcpy (buf
, step
? "s" : "c");
6151 /* Resume the remote inferior by using a "vCont" packet. The thread
6152 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6153 resumed thread should be single-stepped and/or signalled. If PTID
6154 equals minus_one_ptid, then all threads are resumed; the thread to
6155 be stepped and/or signalled is given in the global INFERIOR_PTID.
6156 This function returns non-zero iff it resumes the inferior.
6158 This function issues a strict subset of all possible vCont commands
6162 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6163 enum gdb_signal siggnal
)
6165 struct remote_state
*rs
= get_remote_state ();
6169 /* No reverse execution actions defined for vCont. */
6170 if (::execution_direction
== EXEC_REVERSE
)
6173 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6174 remote_vcont_probe ();
6176 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6179 p
= rs
->buf
.data ();
6180 endp
= p
+ get_remote_packet_size ();
6182 /* If we could generate a wider range of packets, we'd have to worry
6183 about overflowing BUF. Should there be a generic
6184 "multi-part-packet" packet? */
6186 p
+= xsnprintf (p
, endp
- p
, "vCont");
6188 if (ptid
== magic_null_ptid
)
6190 /* MAGIC_NULL_PTID means that we don't have any active threads,
6191 so we don't have any TID numbers the inferior will
6192 understand. Make sure to only send forms that do not specify
6194 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6196 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6198 /* Resume all threads (of all processes, or of a single
6199 process), with preference for INFERIOR_PTID. This assumes
6200 inferior_ptid belongs to the set of all threads we are about
6202 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6204 /* Step inferior_ptid, with or without signal. */
6205 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6208 /* Also pass down any pending signaled resumption for other
6209 threads not the current. */
6210 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6212 /* And continue others without a signal. */
6213 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6217 /* Scheduler locking; resume only PTID. */
6218 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6221 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6224 if (target_is_non_stop_p ())
6226 /* In non-stop, the stub replies to vCont with "OK". The stop
6227 reply will be reported asynchronously by means of a `%Stop'
6229 getpkt (&rs
->buf
, 0);
6230 if (strcmp (rs
->buf
.data (), "OK") != 0)
6231 error (_("Unexpected vCont reply in non-stop mode: %s"),
6238 /* Tell the remote machine to resume. */
6241 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6243 struct remote_state
*rs
= get_remote_state ();
6245 /* When connected in non-stop mode, the core resumes threads
6246 individually. Resuming remote threads directly in target_resume
6247 would thus result in sending one packet per thread. Instead, to
6248 minimize roundtrip latency, here we just store the resume
6249 request; the actual remote resumption will be done in
6250 target_commit_resume / remote_commit_resume, where we'll be able
6251 to do vCont action coalescing. */
6252 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6254 remote_thread_info
*remote_thr
;
6256 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6257 remote_thr
= get_remote_thread_info (inferior_ptid
);
6259 remote_thr
= get_remote_thread_info (ptid
);
6261 remote_thr
->last_resume_step
= step
;
6262 remote_thr
->last_resume_sig
= siggnal
;
6266 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6267 (explained in remote-notif.c:handle_notification) so
6268 remote_notif_process is not called. We need find a place where
6269 it is safe to start a 'vNotif' sequence. It is good to do it
6270 before resuming inferior, because inferior was stopped and no RSP
6271 traffic at that moment. */
6272 if (!target_is_non_stop_p ())
6273 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6275 rs
->last_resume_exec_dir
= ::execution_direction
;
6277 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6278 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6279 remote_resume_with_hc (ptid
, step
, siggnal
);
6281 /* We are about to start executing the inferior, let's register it
6282 with the event loop. NOTE: this is the one place where all the
6283 execution commands end up. We could alternatively do this in each
6284 of the execution commands in infcmd.c. */
6285 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6286 into infcmd.c in order to allow inferior function calls to work
6287 NOT asynchronously. */
6288 if (target_can_async_p ())
6291 /* We've just told the target to resume. The remote server will
6292 wait for the inferior to stop, and then send a stop reply. In
6293 the mean time, we can't start another command/query ourselves
6294 because the stub wouldn't be ready to process it. This applies
6295 only to the base all-stop protocol, however. In non-stop (which
6296 only supports vCont), the stub replies with an "OK", and is
6297 immediate able to process further serial input. */
6298 if (!target_is_non_stop_p ())
6299 rs
->waiting_for_stop_reply
= 1;
6302 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6304 /* Private per-inferior info for target remote processes. */
6306 struct remote_inferior
: public private_inferior
6308 /* Whether we can send a wildcard vCont for this process. */
6309 bool may_wildcard_vcont
= true;
6312 /* Get the remote private inferior data associated to INF. */
6314 static remote_inferior
*
6315 get_remote_inferior (inferior
*inf
)
6317 if (inf
->priv
== NULL
)
6318 inf
->priv
.reset (new remote_inferior
);
6320 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6323 /* Class used to track the construction of a vCont packet in the
6324 outgoing packet buffer. This is used to send multiple vCont
6325 packets if we have more actions than would fit a single packet. */
6330 explicit vcont_builder (remote_target
*remote
)
6337 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6342 /* The remote target. */
6343 remote_target
*m_remote
;
6345 /* Pointer to the first action. P points here if no action has been
6347 char *m_first_action
;
6349 /* Where the next action will be appended. */
6352 /* The end of the buffer. Must never write past this. */
6356 /* Prepare the outgoing buffer for a new vCont packet. */
6359 vcont_builder::restart ()
6361 struct remote_state
*rs
= m_remote
->get_remote_state ();
6363 m_p
= rs
->buf
.data ();
6364 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6365 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6366 m_first_action
= m_p
;
6369 /* If the vCont packet being built has any action, send it to the
6373 vcont_builder::flush ()
6375 struct remote_state
*rs
;
6377 if (m_p
== m_first_action
)
6380 rs
= m_remote
->get_remote_state ();
6381 m_remote
->putpkt (rs
->buf
);
6382 m_remote
->getpkt (&rs
->buf
, 0);
6383 if (strcmp (rs
->buf
.data (), "OK") != 0)
6384 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6387 /* The largest action is range-stepping, with its two addresses. This
6388 is more than sufficient. If a new, bigger action is created, it'll
6389 quickly trigger a failed assertion in append_resumption (and we'll
6391 #define MAX_ACTION_SIZE 200
6393 /* Append a new vCont action in the outgoing packet being built. If
6394 the action doesn't fit the packet along with previous actions, push
6395 what we've got so far to the remote end and start over a new vCont
6396 packet (with the new action). */
6399 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6401 char buf
[MAX_ACTION_SIZE
+ 1];
6403 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6404 ptid
, step
, siggnal
);
6406 /* Check whether this new action would fit in the vCont packet along
6407 with previous actions. If not, send what we've got so far and
6408 start a new vCont packet. */
6409 size_t rsize
= endp
- buf
;
6410 if (rsize
> m_endp
- m_p
)
6415 /* Should now fit. */
6416 gdb_assert (rsize
<= m_endp
- m_p
);
6419 memcpy (m_p
, buf
, rsize
);
6424 /* to_commit_resume implementation. */
6427 remote_target::commit_resume ()
6429 int any_process_wildcard
;
6430 int may_global_wildcard_vcont
;
6432 /* If connected in all-stop mode, we'd send the remote resume
6433 request directly from remote_resume. Likewise if
6434 reverse-debugging, as there are no defined vCont actions for
6435 reverse execution. */
6436 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6439 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6440 instead of resuming all threads of each process individually.
6441 However, if any thread of a process must remain halted, we can't
6442 send wildcard resumes and must send one action per thread.
6444 Care must be taken to not resume threads/processes the server
6445 side already told us are stopped, but the core doesn't know about
6446 yet, because the events are still in the vStopped notification
6449 #1 => vCont s:p1.1;c
6451 #3 <= %Stopped T05 p1.1
6456 #8 (infrun handles the stop for p1.1 and continues stepping)
6457 #9 => vCont s:p1.1;c
6459 The last vCont above would resume thread p1.2 by mistake, because
6460 the server has no idea that the event for p1.2 had not been
6463 The server side must similarly ignore resume actions for the
6464 thread that has a pending %Stopped notification (and any other
6465 threads with events pending), until GDB acks the notification
6466 with vStopped. Otherwise, e.g., the following case is
6469 #1 => g (or any other packet)
6471 #3 <= %Stopped T05 p1.2
6472 #4 => vCont s:p1.1;c
6475 Above, the server must not resume thread p1.2. GDB can't know
6476 that p1.2 stopped until it acks the %Stopped notification, and
6477 since from GDB's perspective all threads should be running, it
6480 Finally, special care must also be given to handling fork/vfork
6481 events. A (v)fork event actually tells us that two processes
6482 stopped -- the parent and the child. Until we follow the fork,
6483 we must not resume the child. Therefore, if we have a pending
6484 fork follow, we must not send a global wildcard resume action
6485 (vCont;c). We can still send process-wide wildcards though. */
6487 /* Start by assuming a global wildcard (vCont;c) is possible. */
6488 may_global_wildcard_vcont
= 1;
6490 /* And assume every process is individually wildcard-able too. */
6491 for (inferior
*inf
: all_non_exited_inferiors ())
6493 remote_inferior
*priv
= get_remote_inferior (inf
);
6495 priv
->may_wildcard_vcont
= true;
6498 /* Check for any pending events (not reported or processed yet) and
6499 disable process and global wildcard resumes appropriately. */
6500 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6502 for (thread_info
*tp
: all_non_exited_threads ())
6504 /* If a thread of a process is not meant to be resumed, then we
6505 can't wildcard that process. */
6508 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6510 /* And if we can't wildcard a process, we can't wildcard
6511 everything either. */
6512 may_global_wildcard_vcont
= 0;
6516 /* If a thread is the parent of an unfollowed fork, then we
6517 can't do a global wildcard, as that would resume the fork
6519 if (is_pending_fork_parent_thread (tp
))
6520 may_global_wildcard_vcont
= 0;
6523 /* Now let's build the vCont packet(s). Actions must be appended
6524 from narrower to wider scopes (thread -> process -> global). If
6525 we end up with too many actions for a single packet vcont_builder
6526 flushes the current vCont packet to the remote side and starts a
6528 struct vcont_builder
vcont_builder (this);
6530 /* Threads first. */
6531 for (thread_info
*tp
: all_non_exited_threads ())
6533 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6535 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6538 gdb_assert (!thread_is_in_step_over_chain (tp
));
6540 if (!remote_thr
->last_resume_step
6541 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6542 && get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6544 /* We'll send a wildcard resume instead. */
6545 remote_thr
->vcont_resumed
= 1;
6549 vcont_builder
.push_action (tp
->ptid
,
6550 remote_thr
->last_resume_step
,
6551 remote_thr
->last_resume_sig
);
6552 remote_thr
->vcont_resumed
= 1;
6555 /* Now check whether we can send any process-wide wildcard. This is
6556 to avoid sending a global wildcard in the case nothing is
6557 supposed to be resumed. */
6558 any_process_wildcard
= 0;
6560 for (inferior
*inf
: all_non_exited_inferiors ())
6562 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6564 any_process_wildcard
= 1;
6569 if (any_process_wildcard
)
6571 /* If all processes are wildcard-able, then send a single "c"
6572 action, otherwise, send an "all (-1) threads of process"
6573 continue action for each running process, if any. */
6574 if (may_global_wildcard_vcont
)
6576 vcont_builder
.push_action (minus_one_ptid
,
6577 false, GDB_SIGNAL_0
);
6581 for (inferior
*inf
: all_non_exited_inferiors ())
6583 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6585 vcont_builder
.push_action (ptid_t (inf
->pid
),
6586 false, GDB_SIGNAL_0
);
6592 vcont_builder
.flush ();
6597 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6598 thread, all threads of a remote process, or all threads of all
6602 remote_target::remote_stop_ns (ptid_t ptid
)
6604 struct remote_state
*rs
= get_remote_state ();
6605 char *p
= rs
->buf
.data ();
6606 char *endp
= p
+ get_remote_packet_size ();
6608 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6609 remote_vcont_probe ();
6611 if (!rs
->supports_vCont
.t
)
6612 error (_("Remote server does not support stopping threads"));
6614 if (ptid
== minus_one_ptid
6615 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6616 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6621 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6624 /* All (-1) threads of process. */
6625 nptid
= ptid_t (ptid
.pid (), -1, 0);
6628 /* Small optimization: if we already have a stop reply for
6629 this thread, no use in telling the stub we want this
6631 if (peek_stop_reply (ptid
))
6637 write_ptid (p
, endp
, nptid
);
6640 /* In non-stop, we get an immediate OK reply. The stop reply will
6641 come in asynchronously by notification. */
6643 getpkt (&rs
->buf
, 0);
6644 if (strcmp (rs
->buf
.data (), "OK") != 0)
6645 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6649 /* All-stop version of target_interrupt. Sends a break or a ^C to
6650 interrupt the remote target. It is undefined which thread of which
6651 process reports the interrupt. */
6654 remote_target::remote_interrupt_as ()
6656 struct remote_state
*rs
= get_remote_state ();
6658 rs
->ctrlc_pending_p
= 1;
6660 /* If the inferior is stopped already, but the core didn't know
6661 about it yet, just ignore the request. The cached wait status
6662 will be collected in remote_wait. */
6663 if (rs
->cached_wait_status
)
6666 /* Send interrupt_sequence to remote target. */
6667 send_interrupt_sequence ();
6670 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6671 the remote target. It is undefined which thread of which process
6672 reports the interrupt. Throws an error if the packet is not
6673 supported by the server. */
6676 remote_target::remote_interrupt_ns ()
6678 struct remote_state
*rs
= get_remote_state ();
6679 char *p
= rs
->buf
.data ();
6680 char *endp
= p
+ get_remote_packet_size ();
6682 xsnprintf (p
, endp
- p
, "vCtrlC");
6684 /* In non-stop, we get an immediate OK reply. The stop reply will
6685 come in asynchronously by notification. */
6687 getpkt (&rs
->buf
, 0);
6689 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6693 case PACKET_UNKNOWN
:
6694 error (_("No support for interrupting the remote target."));
6696 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6700 /* Implement the to_stop function for the remote targets. */
6703 remote_target::stop (ptid_t ptid
)
6706 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6708 if (target_is_non_stop_p ())
6709 remote_stop_ns (ptid
);
6712 /* We don't currently have a way to transparently pause the
6713 remote target in all-stop mode. Interrupt it instead. */
6714 remote_interrupt_as ();
6718 /* Implement the to_interrupt function for the remote targets. */
6721 remote_target::interrupt ()
6724 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6726 if (target_is_non_stop_p ())
6727 remote_interrupt_ns ();
6729 remote_interrupt_as ();
6732 /* Implement the to_pass_ctrlc function for the remote targets. */
6735 remote_target::pass_ctrlc ()
6737 struct remote_state
*rs
= get_remote_state ();
6740 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6742 /* If we're starting up, we're not fully synced yet. Quit
6744 if (rs
->starting_up
)
6746 /* If ^C has already been sent once, offer to disconnect. */
6747 else if (rs
->ctrlc_pending_p
)
6750 target_interrupt ();
6753 /* Ask the user what to do when an interrupt is received. */
6756 remote_target::interrupt_query ()
6758 struct remote_state
*rs
= get_remote_state ();
6760 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6762 if (query (_("The target is not responding to interrupt requests.\n"
6763 "Stop debugging it? ")))
6765 remote_unpush_target ();
6766 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6771 if (query (_("Interrupted while waiting for the program.\n"
6772 "Give up waiting? ")))
6777 /* Enable/disable target terminal ownership. Most targets can use
6778 terminal groups to control terminal ownership. Remote targets are
6779 different in that explicit transfer of ownership to/from GDB/target
6783 remote_target::terminal_inferior ()
6785 /* NOTE: At this point we could also register our selves as the
6786 recipient of all input. Any characters typed could then be
6787 passed on down to the target. */
6791 remote_target::terminal_ours ()
6796 remote_console_output (const char *msg
)
6800 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6803 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6807 fputs_unfiltered (tb
, gdb_stdtarg
);
6809 gdb_flush (gdb_stdtarg
);
6812 struct stop_reply
: public notif_event
6816 /* The identifier of the thread about this event */
6819 /* The remote state this event is associated with. When the remote
6820 connection, represented by a remote_state object, is closed,
6821 all the associated stop_reply events should be released. */
6822 struct remote_state
*rs
;
6824 struct target_waitstatus ws
;
6826 /* The architecture associated with the expedited registers. */
6829 /* Expedited registers. This makes remote debugging a bit more
6830 efficient for those targets that provide critical registers as
6831 part of their normal status mechanism (as another roundtrip to
6832 fetch them is avoided). */
6833 std::vector
<cached_reg_t
> regcache
;
6835 enum target_stop_reason stop_reason
;
6837 CORE_ADDR watch_data_address
;
6842 /* Return the length of the stop reply queue. */
6845 remote_target::stop_reply_queue_length ()
6847 remote_state
*rs
= get_remote_state ();
6848 return rs
->stop_reply_queue
.size ();
6852 remote_notif_stop_parse (remote_target
*remote
,
6853 struct notif_client
*self
, const char *buf
,
6854 struct notif_event
*event
)
6856 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6860 remote_notif_stop_ack (remote_target
*remote
,
6861 struct notif_client
*self
, const char *buf
,
6862 struct notif_event
*event
)
6864 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6867 putpkt (remote
, self
->ack_command
);
6869 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6871 /* We got an unknown stop reply. */
6872 error (_("Unknown stop reply"));
6875 remote
->push_stop_reply (stop_reply
);
6879 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
6880 struct notif_client
*self
)
6882 /* We can't get pending events in remote_notif_process for
6883 notification stop, and we have to do this in remote_wait_ns
6884 instead. If we fetch all queued events from stub, remote stub
6885 may exit and we have no chance to process them back in
6887 remote_state
*rs
= remote
->get_remote_state ();
6888 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
6892 stop_reply::~stop_reply ()
6894 for (cached_reg_t
®
: regcache
)
6898 static notif_event_up
6899 remote_notif_stop_alloc_reply ()
6901 return notif_event_up (new struct stop_reply ());
6904 /* A client of notification Stop. */
6906 struct notif_client notif_client_stop
=
6910 remote_notif_stop_parse
,
6911 remote_notif_stop_ack
,
6912 remote_notif_stop_can_get_pending_events
,
6913 remote_notif_stop_alloc_reply
,
6917 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6918 the pid of the process that owns the threads we want to check, or
6919 -1 if we want to check all threads. */
6922 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6925 if (ws
->kind
== TARGET_WAITKIND_FORKED
6926 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6928 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
6935 /* Return the thread's pending status used to determine whether the
6936 thread is a fork parent stopped at a fork event. */
6938 static struct target_waitstatus
*
6939 thread_pending_fork_status (struct thread_info
*thread
)
6941 if (thread
->suspend
.waitstatus_pending_p
)
6942 return &thread
->suspend
.waitstatus
;
6944 return &thread
->pending_follow
;
6947 /* Determine if THREAD is a pending fork parent thread. */
6950 is_pending_fork_parent_thread (struct thread_info
*thread
)
6952 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6955 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6958 /* If CONTEXT contains any fork child threads that have not been
6959 reported yet, remove them from the CONTEXT list. If such a
6960 thread exists it is because we are stopped at a fork catchpoint
6961 and have not yet called follow_fork, which will set up the
6962 host-side data structures for the new process. */
6965 remote_target::remove_new_fork_children (threads_listing_context
*context
)
6968 struct notif_client
*notif
= ¬if_client_stop
;
6970 /* For any threads stopped at a fork event, remove the corresponding
6971 fork child threads from the CONTEXT list. */
6972 for (thread_info
*thread
: all_non_exited_threads ())
6974 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6976 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
6977 context
->remove_thread (ws
->value
.related_pid
);
6980 /* Check for any pending fork events (not reported or processed yet)
6981 in process PID and remove those fork child threads from the
6982 CONTEXT list as well. */
6983 remote_notif_get_pending_events (notif
);
6984 for (auto &event
: get_remote_state ()->stop_reply_queue
)
6985 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6986 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
6987 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
6988 context
->remove_thread (event
->ws
.value
.related_pid
);
6991 /* Check whether any event pending in the vStopped queue would prevent
6992 a global or process wildcard vCont action. Clear
6993 *may_global_wildcard if we can't do a global wildcard (vCont;c),
6994 and clear the event inferior's may_wildcard_vcont flag if we can't
6995 do a process-wide wildcard resume (vCont;c:pPID.-1). */
6998 remote_target::check_pending_events_prevent_wildcard_vcont
6999 (int *may_global_wildcard
)
7001 struct notif_client
*notif
= ¬if_client_stop
;
7003 remote_notif_get_pending_events (notif
);
7004 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7006 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
7007 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
7010 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7011 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
7012 *may_global_wildcard
= 0;
7014 struct inferior
*inf
= find_inferior_ptid (event
->ptid
);
7016 /* This may be the first time we heard about this process.
7017 Regardless, we must not do a global wildcard resume, otherwise
7018 we'd resume this process too. */
7019 *may_global_wildcard
= 0;
7021 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7025 /* Discard all pending stop replies of inferior INF. */
7028 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7030 struct stop_reply
*reply
;
7031 struct remote_state
*rs
= get_remote_state ();
7032 struct remote_notif_state
*rns
= rs
->notif_state
;
7034 /* This function can be notified when an inferior exists. When the
7035 target is not remote, the notification state is NULL. */
7036 if (rs
->remote_desc
== NULL
)
7039 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7041 /* Discard the in-flight notification. */
7042 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7045 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7048 /* Discard the stop replies we have already pulled with
7050 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7051 rs
->stop_reply_queue
.end (),
7052 [=] (const stop_reply_up
&event
)
7054 return event
->ptid
.pid () == inf
->pid
;
7056 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7059 /* Discard the stop replies for RS in stop_reply_queue. */
7062 remote_target::discard_pending_stop_replies_in_queue ()
7064 remote_state
*rs
= get_remote_state ();
7066 /* Discard the stop replies we have already pulled with
7068 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7069 rs
->stop_reply_queue
.end (),
7070 [=] (const stop_reply_up
&event
)
7072 return event
->rs
== rs
;
7074 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7077 /* Remove the first reply in 'stop_reply_queue' which matches
7081 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7083 remote_state
*rs
= get_remote_state ();
7085 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7086 rs
->stop_reply_queue
.end (),
7087 [=] (const stop_reply_up
&event
)
7089 return event
->ptid
.matches (ptid
);
7091 struct stop_reply
*result
;
7092 if (iter
== rs
->stop_reply_queue
.end ())
7096 result
= iter
->release ();
7097 rs
->stop_reply_queue
.erase (iter
);
7101 fprintf_unfiltered (gdb_stdlog
,
7102 "notif: discard queued event: 'Stop' in %s\n",
7103 target_pid_to_str (ptid
).c_str ());
7108 /* Look for a queued stop reply belonging to PTID. If one is found,
7109 remove it from the queue, and return it. Returns NULL if none is
7110 found. If there are still queued events left to process, tell the
7111 event loop to get back to target_wait soon. */
7114 remote_target::queued_stop_reply (ptid_t ptid
)
7116 remote_state
*rs
= get_remote_state ();
7117 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7119 if (!rs
->stop_reply_queue
.empty ())
7121 /* There's still at least an event left. */
7122 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7128 /* Push a fully parsed stop reply in the stop reply queue. Since we
7129 know that we now have at least one queued event left to pass to the
7130 core side, tell the event loop to get back to target_wait soon. */
7133 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7135 remote_state
*rs
= get_remote_state ();
7136 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7139 fprintf_unfiltered (gdb_stdlog
,
7140 "notif: push 'Stop' %s to queue %d\n",
7141 target_pid_to_str (new_event
->ptid
).c_str (),
7142 int (rs
->stop_reply_queue
.size ()));
7144 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7147 /* Returns true if we have a stop reply for PTID. */
7150 remote_target::peek_stop_reply (ptid_t ptid
)
7152 remote_state
*rs
= get_remote_state ();
7153 for (auto &event
: rs
->stop_reply_queue
)
7154 if (ptid
== event
->ptid
7155 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7160 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7161 starting with P and ending with PEND matches PREFIX. */
7164 strprefix (const char *p
, const char *pend
, const char *prefix
)
7166 for ( ; p
< pend
; p
++, prefix
++)
7169 return *prefix
== '\0';
7172 /* Parse the stop reply in BUF. Either the function succeeds, and the
7173 result is stored in EVENT, or throws an error. */
7176 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7178 remote_arch_state
*rsa
= NULL
;
7183 event
->ptid
= null_ptid
;
7184 event
->rs
= get_remote_state ();
7185 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7186 event
->ws
.value
.integer
= 0;
7187 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7188 event
->regcache
.clear ();
7193 case 'T': /* Status with PC, SP, FP, ... */
7194 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7195 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7197 n... = register number
7198 r... = register contents
7201 p
= &buf
[3]; /* after Txx */
7207 p1
= strchr (p
, ':');
7209 error (_("Malformed packet(a) (missing colon): %s\n\
7213 error (_("Malformed packet(a) (missing register number): %s\n\
7217 /* Some "registers" are actually extended stop information.
7218 Note if you're adding a new entry here: GDB 7.9 and
7219 earlier assume that all register "numbers" that start
7220 with an hex digit are real register numbers. Make sure
7221 the server only sends such a packet if it knows the
7222 client understands it. */
7224 if (strprefix (p
, p1
, "thread"))
7225 event
->ptid
= read_ptid (++p1
, &p
);
7226 else if (strprefix (p
, p1
, "syscall_entry"))
7230 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7231 p
= unpack_varlen_hex (++p1
, &sysno
);
7232 event
->ws
.value
.syscall_number
= (int) sysno
;
7234 else if (strprefix (p
, p1
, "syscall_return"))
7238 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7239 p
= unpack_varlen_hex (++p1
, &sysno
);
7240 event
->ws
.value
.syscall_number
= (int) sysno
;
7242 else if (strprefix (p
, p1
, "watch")
7243 || strprefix (p
, p1
, "rwatch")
7244 || strprefix (p
, p1
, "awatch"))
7246 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7247 p
= unpack_varlen_hex (++p1
, &addr
);
7248 event
->watch_data_address
= (CORE_ADDR
) addr
;
7250 else if (strprefix (p
, p1
, "swbreak"))
7252 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7254 /* Make sure the stub doesn't forget to indicate support
7256 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7257 error (_("Unexpected swbreak stop reason"));
7259 /* The value part is documented as "must be empty",
7260 though we ignore it, in case we ever decide to make
7261 use of it in a backward compatible way. */
7262 p
= strchrnul (p1
+ 1, ';');
7264 else if (strprefix (p
, p1
, "hwbreak"))
7266 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7268 /* Make sure the stub doesn't forget to indicate support
7270 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7271 error (_("Unexpected hwbreak stop reason"));
7274 p
= strchrnul (p1
+ 1, ';');
7276 else if (strprefix (p
, p1
, "library"))
7278 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7279 p
= strchrnul (p1
+ 1, ';');
7281 else if (strprefix (p
, p1
, "replaylog"))
7283 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7284 /* p1 will indicate "begin" or "end", but it makes
7285 no difference for now, so ignore it. */
7286 p
= strchrnul (p1
+ 1, ';');
7288 else if (strprefix (p
, p1
, "core"))
7292 p
= unpack_varlen_hex (++p1
, &c
);
7295 else if (strprefix (p
, p1
, "fork"))
7297 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7298 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7300 else if (strprefix (p
, p1
, "vfork"))
7302 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7303 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7305 else if (strprefix (p
, p1
, "vforkdone"))
7307 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7308 p
= strchrnul (p1
+ 1, ';');
7310 else if (strprefix (p
, p1
, "exec"))
7315 /* Determine the length of the execd pathname. */
7316 p
= unpack_varlen_hex (++p1
, &ignored
);
7317 pathlen
= (p
- p1
) / 2;
7319 /* Save the pathname for event reporting and for
7320 the next run command. */
7321 gdb::unique_xmalloc_ptr
<char[]> pathname
7322 ((char *) xmalloc (pathlen
+ 1));
7323 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7324 pathname
[pathlen
] = '\0';
7326 /* This is freed during event handling. */
7327 event
->ws
.value
.execd_pathname
= pathname
.release ();
7328 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7330 /* Skip the registers included in this packet, since
7331 they may be for an architecture different from the
7332 one used by the original program. */
7335 else if (strprefix (p
, p1
, "create"))
7337 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7338 p
= strchrnul (p1
+ 1, ';');
7347 p
= strchrnul (p1
+ 1, ';');
7352 /* Maybe a real ``P'' register number. */
7353 p_temp
= unpack_varlen_hex (p
, &pnum
);
7354 /* If the first invalid character is the colon, we got a
7355 register number. Otherwise, it's an unknown stop
7359 /* If we haven't parsed the event's thread yet, find
7360 it now, in order to find the architecture of the
7361 reported expedited registers. */
7362 if (event
->ptid
== null_ptid
)
7364 const char *thr
= strstr (p1
+ 1, ";thread:");
7366 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7370 /* Either the current thread hasn't changed,
7371 or the inferior is not multi-threaded.
7372 The event must be for the thread we last
7373 set as (or learned as being) current. */
7374 event
->ptid
= event
->rs
->general_thread
;
7380 inferior
*inf
= (event
->ptid
== null_ptid
7382 : find_inferior_ptid (event
->ptid
));
7383 /* If this is the first time we learn anything
7384 about this process, skip the registers
7385 included in this packet, since we don't yet
7386 know which architecture to use to parse them.
7387 We'll determine the architecture later when
7388 we process the stop reply and retrieve the
7389 target description, via
7390 remote_notice_new_inferior ->
7391 post_create_inferior. */
7394 p
= strchrnul (p1
+ 1, ';');
7399 event
->arch
= inf
->gdbarch
;
7400 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7404 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7405 cached_reg_t cached_reg
;
7408 error (_("Remote sent bad register number %s: %s\n\
7410 hex_string (pnum
), p
, buf
);
7412 cached_reg
.num
= reg
->regnum
;
7413 cached_reg
.data
= (gdb_byte
*)
7414 xmalloc (register_size (event
->arch
, reg
->regnum
));
7417 fieldsize
= hex2bin (p
, cached_reg
.data
,
7418 register_size (event
->arch
, reg
->regnum
));
7420 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7421 warning (_("Remote reply is too short: %s"), buf
);
7423 event
->regcache
.push_back (cached_reg
);
7427 /* Not a number. Silently skip unknown optional
7429 p
= strchrnul (p1
+ 1, ';');
7434 error (_("Remote register badly formatted: %s\nhere: %s"),
7439 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7443 case 'S': /* Old style status, just signal only. */
7447 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7448 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7449 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7450 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7452 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7455 case 'w': /* Thread exited. */
7459 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7460 p
= unpack_varlen_hex (&buf
[1], &value
);
7461 event
->ws
.value
.integer
= value
;
7463 error (_("stop reply packet badly formatted: %s"), buf
);
7464 event
->ptid
= read_ptid (++p
, NULL
);
7467 case 'W': /* Target exited. */
7472 /* GDB used to accept only 2 hex chars here. Stubs should
7473 only send more if they detect GDB supports multi-process
7475 p
= unpack_varlen_hex (&buf
[1], &value
);
7479 /* The remote process exited. */
7480 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7481 event
->ws
.value
.integer
= value
;
7485 /* The remote process exited with a signal. */
7486 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7487 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7488 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7490 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7493 /* If no process is specified, return null_ptid, and let the
7494 caller figure out the right process to use. */
7504 else if (startswith (p
, "process:"))
7508 p
+= sizeof ("process:") - 1;
7509 unpack_varlen_hex (p
, &upid
);
7513 error (_("unknown stop reply packet: %s"), buf
);
7516 error (_("unknown stop reply packet: %s"), buf
);
7517 event
->ptid
= ptid_t (pid
);
7521 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7522 event
->ptid
= minus_one_ptid
;
7526 if (target_is_non_stop_p () && event
->ptid
== null_ptid
)
7527 error (_("No process or thread specified in stop reply: %s"), buf
);
7530 /* When the stub wants to tell GDB about a new notification reply, it
7531 sends a notification (%Stop, for example). Those can come it at
7532 any time, hence, we have to make sure that any pending
7533 putpkt/getpkt sequence we're making is finished, before querying
7534 the stub for more events with the corresponding ack command
7535 (vStopped, for example). E.g., if we started a vStopped sequence
7536 immediately upon receiving the notification, something like this
7544 1.6) <-- (registers reply to step #1.3)
7546 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7549 To solve this, whenever we parse a %Stop notification successfully,
7550 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7551 doing whatever we were doing:
7557 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7558 2.5) <-- (registers reply to step #2.3)
7560 Eventually after step #2.5, we return to the event loop, which
7561 notices there's an event on the
7562 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7563 associated callback --- the function below. At this point, we're
7564 always safe to start a vStopped sequence. :
7567 2.7) <-- T05 thread:2
7573 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7575 struct remote_state
*rs
= get_remote_state ();
7577 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7580 fprintf_unfiltered (gdb_stdlog
,
7581 "notif: process: '%s' ack pending event\n",
7585 nc
->ack (this, nc
, rs
->buf
.data (),
7586 rs
->notif_state
->pending_event
[nc
->id
]);
7587 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7591 getpkt (&rs
->buf
, 0);
7592 if (strcmp (rs
->buf
.data (), "OK") == 0)
7595 remote_notif_ack (this, nc
, rs
->buf
.data ());
7601 fprintf_unfiltered (gdb_stdlog
,
7602 "notif: process: '%s' no pending reply\n",
7607 /* Wrapper around remote_target::remote_notif_get_pending_events to
7608 avoid having to export the whole remote_target class. */
7611 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7613 remote
->remote_notif_get_pending_events (nc
);
7616 /* Called when it is decided that STOP_REPLY holds the info of the
7617 event that is to be returned to the core. This function always
7618 destroys STOP_REPLY. */
7621 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7622 struct target_waitstatus
*status
)
7626 *status
= stop_reply
->ws
;
7627 ptid
= stop_reply
->ptid
;
7629 /* If no thread/process was reported by the stub, assume the current
7631 if (ptid
== null_ptid
)
7632 ptid
= inferior_ptid
;
7634 if (status
->kind
!= TARGET_WAITKIND_EXITED
7635 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7636 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7638 /* Expedited registers. */
7639 if (!stop_reply
->regcache
.empty ())
7641 struct regcache
*regcache
7642 = get_thread_arch_regcache (ptid
, stop_reply
->arch
);
7644 for (cached_reg_t
®
: stop_reply
->regcache
)
7646 regcache
->raw_supply (reg
.num
, reg
.data
);
7650 stop_reply
->regcache
.clear ();
7653 remote_notice_new_inferior (ptid
, 0);
7654 remote_thread_info
*remote_thr
= get_remote_thread_info (ptid
);
7655 remote_thr
->core
= stop_reply
->core
;
7656 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7657 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7658 remote_thr
->vcont_resumed
= 0;
7665 /* The non-stop mode version of target_wait. */
7668 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7670 struct remote_state
*rs
= get_remote_state ();
7671 struct stop_reply
*stop_reply
;
7675 /* If in non-stop mode, get out of getpkt even if a
7676 notification is received. */
7678 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7681 if (ret
!= -1 && !is_notif
)
7684 case 'E': /* Error of some sort. */
7685 /* We're out of sync with the target now. Did it continue
7686 or not? We can't tell which thread it was in non-stop,
7687 so just ignore this. */
7688 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7690 case 'O': /* Console output. */
7691 remote_console_output (&rs
->buf
[1]);
7694 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7698 /* Acknowledge a pending stop reply that may have arrived in the
7700 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7701 remote_notif_get_pending_events (¬if_client_stop
);
7703 /* If indeed we noticed a stop reply, we're done. */
7704 stop_reply
= queued_stop_reply (ptid
);
7705 if (stop_reply
!= NULL
)
7706 return process_stop_reply (stop_reply
, status
);
7708 /* Still no event. If we're just polling for an event, then
7709 return to the event loop. */
7710 if (options
& TARGET_WNOHANG
)
7712 status
->kind
= TARGET_WAITKIND_IGNORE
;
7713 return minus_one_ptid
;
7716 /* Otherwise do a blocking wait. */
7717 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7721 /* Return the first resumed thread. */
7724 first_remote_resumed_thread ()
7726 for (thread_info
*tp
: all_non_exited_threads (minus_one_ptid
))
7732 /* Wait until the remote machine stops, then return, storing status in
7733 STATUS just as `wait' would. */
7736 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
, int options
)
7738 struct remote_state
*rs
= get_remote_state ();
7739 ptid_t event_ptid
= null_ptid
;
7741 struct stop_reply
*stop_reply
;
7745 status
->kind
= TARGET_WAITKIND_IGNORE
;
7746 status
->value
.integer
= 0;
7748 stop_reply
= queued_stop_reply (ptid
);
7749 if (stop_reply
!= NULL
)
7750 return process_stop_reply (stop_reply
, status
);
7752 if (rs
->cached_wait_status
)
7753 /* Use the cached wait status, but only once. */
7754 rs
->cached_wait_status
= 0;
7759 int forever
= ((options
& TARGET_WNOHANG
) == 0
7760 && rs
->wait_forever_enabled_p
);
7762 if (!rs
->waiting_for_stop_reply
)
7764 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7765 return minus_one_ptid
;
7768 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7769 _never_ wait for ever -> test on target_is_async_p().
7770 However, before we do that we need to ensure that the caller
7771 knows how to take the target into/out of async mode. */
7772 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
7774 /* GDB gets a notification. Return to core as this event is
7776 if (ret
!= -1 && is_notif
)
7777 return minus_one_ptid
;
7779 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7780 return minus_one_ptid
;
7783 buf
= rs
->buf
.data ();
7785 /* Assume that the target has acknowledged Ctrl-C unless we receive
7786 an 'F' or 'O' packet. */
7787 if (buf
[0] != 'F' && buf
[0] != 'O')
7788 rs
->ctrlc_pending_p
= 0;
7792 case 'E': /* Error of some sort. */
7793 /* We're out of sync with the target now. Did it continue or
7794 not? Not is more likely, so report a stop. */
7795 rs
->waiting_for_stop_reply
= 0;
7797 warning (_("Remote failure reply: %s"), buf
);
7798 status
->kind
= TARGET_WAITKIND_STOPPED
;
7799 status
->value
.sig
= GDB_SIGNAL_0
;
7801 case 'F': /* File-I/O request. */
7802 /* GDB may access the inferior memory while handling the File-I/O
7803 request, but we don't want GDB accessing memory while waiting
7804 for a stop reply. See the comments in putpkt_binary. Set
7805 waiting_for_stop_reply to 0 temporarily. */
7806 rs
->waiting_for_stop_reply
= 0;
7807 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
7808 rs
->ctrlc_pending_p
= 0;
7809 /* GDB handled the File-I/O request, and the target is running
7810 again. Keep waiting for events. */
7811 rs
->waiting_for_stop_reply
= 1;
7813 case 'N': case 'T': case 'S': case 'X': case 'W':
7815 /* There is a stop reply to handle. */
7816 rs
->waiting_for_stop_reply
= 0;
7819 = (struct stop_reply
*) remote_notif_parse (this,
7823 event_ptid
= process_stop_reply (stop_reply
, status
);
7826 case 'O': /* Console output. */
7827 remote_console_output (buf
+ 1);
7830 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7832 /* Zero length reply means that we tried 'S' or 'C' and the
7833 remote system doesn't support it. */
7834 target_terminal::ours_for_output ();
7836 ("Can't send signals to this remote system. %s not sent.\n",
7837 gdb_signal_to_name (rs
->last_sent_signal
));
7838 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7839 target_terminal::inferior ();
7841 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7847 warning (_("Invalid remote reply: %s"), buf
);
7851 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7852 return minus_one_ptid
;
7853 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7855 /* Nothing interesting happened. If we're doing a non-blocking
7856 poll, we're done. Otherwise, go back to waiting. */
7857 if (options
& TARGET_WNOHANG
)
7858 return minus_one_ptid
;
7862 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7863 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7865 if (event_ptid
!= null_ptid
)
7866 record_currthread (rs
, event_ptid
);
7868 event_ptid
= first_remote_resumed_thread ();
7872 /* A process exit. Invalidate our notion of current thread. */
7873 record_currthread (rs
, minus_one_ptid
);
7874 /* It's possible that the packet did not include a pid. */
7875 if (event_ptid
== null_ptid
)
7876 event_ptid
= first_remote_resumed_thread ();
7877 /* EVENT_PTID could still be NULL_PTID. Double-check. */
7878 if (event_ptid
== null_ptid
)
7879 event_ptid
= magic_null_ptid
;
7885 /* Wait until the remote machine stops, then return, storing status in
7886 STATUS just as `wait' would. */
7889 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7893 if (target_is_non_stop_p ())
7894 event_ptid
= wait_ns (ptid
, status
, options
);
7896 event_ptid
= wait_as (ptid
, status
, options
);
7898 if (target_is_async_p ())
7900 remote_state
*rs
= get_remote_state ();
7902 /* If there are are events left in the queue tell the event loop
7904 if (!rs
->stop_reply_queue
.empty ())
7905 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7911 /* Fetch a single register using a 'p' packet. */
7914 remote_target::fetch_register_using_p (struct regcache
*regcache
,
7917 struct gdbarch
*gdbarch
= regcache
->arch ();
7918 struct remote_state
*rs
= get_remote_state ();
7920 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7923 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7926 if (reg
->pnum
== -1)
7929 p
= rs
->buf
.data ();
7931 p
+= hexnumstr (p
, reg
->pnum
);
7934 getpkt (&rs
->buf
, 0);
7936 buf
= rs
->buf
.data ();
7938 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
7942 case PACKET_UNKNOWN
:
7945 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7946 gdbarch_register_name (regcache
->arch (),
7951 /* If this register is unfetchable, tell the regcache. */
7954 regcache
->raw_supply (reg
->regnum
, NULL
);
7958 /* Otherwise, parse and supply the value. */
7964 error (_("fetch_register_using_p: early buf termination"));
7966 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7969 regcache
->raw_supply (reg
->regnum
, regp
);
7973 /* Fetch the registers included in the target's 'g' packet. */
7976 remote_target::send_g_packet ()
7978 struct remote_state
*rs
= get_remote_state ();
7981 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
7983 getpkt (&rs
->buf
, 0);
7984 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
7985 error (_("Could not read registers; remote failure reply '%s'"),
7988 /* We can get out of synch in various cases. If the first character
7989 in the buffer is not a hex character, assume that has happened
7990 and try to fetch another packet to read. */
7991 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
7992 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
7993 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
7994 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
7997 fprintf_unfiltered (gdb_stdlog
,
7998 "Bad register packet; fetching a new packet\n");
7999 getpkt (&rs
->buf
, 0);
8002 buf_len
= strlen (rs
->buf
.data ());
8004 /* Sanity check the received packet. */
8005 if (buf_len
% 2 != 0)
8006 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
8012 remote_target::process_g_packet (struct regcache
*regcache
)
8014 struct gdbarch
*gdbarch
= regcache
->arch ();
8015 struct remote_state
*rs
= get_remote_state ();
8016 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8021 buf_len
= strlen (rs
->buf
.data ());
8023 /* Further sanity checks, with knowledge of the architecture. */
8024 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
8025 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8027 rsa
->sizeof_g_packet
, buf_len
/ 2,
8030 /* Save the size of the packet sent to us by the target. It is used
8031 as a heuristic when determining the max size of packets that the
8032 target can safely receive. */
8033 if (rsa
->actual_register_packet_size
== 0)
8034 rsa
->actual_register_packet_size
= buf_len
;
8036 /* If this is smaller than we guessed the 'g' packet would be,
8037 update our records. A 'g' reply that doesn't include a register's
8038 value implies either that the register is not available, or that
8039 the 'p' packet must be used. */
8040 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8042 long sizeof_g_packet
= buf_len
/ 2;
8044 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8046 long offset
= rsa
->regs
[i
].offset
;
8047 long reg_size
= register_size (gdbarch
, i
);
8049 if (rsa
->regs
[i
].pnum
== -1)
8052 if (offset
>= sizeof_g_packet
)
8053 rsa
->regs
[i
].in_g_packet
= 0;
8054 else if (offset
+ reg_size
> sizeof_g_packet
)
8055 error (_("Truncated register %d in remote 'g' packet"), i
);
8057 rsa
->regs
[i
].in_g_packet
= 1;
8060 /* Looks valid enough, we can assume this is the correct length
8061 for a 'g' packet. It's important not to adjust
8062 rsa->sizeof_g_packet if we have truncated registers otherwise
8063 this "if" won't be run the next time the method is called
8064 with a packet of the same size and one of the internal errors
8065 below will trigger instead. */
8066 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8069 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8071 /* Unimplemented registers read as all bits zero. */
8072 memset (regs
, 0, rsa
->sizeof_g_packet
);
8074 /* Reply describes registers byte by byte, each byte encoded as two
8075 hex characters. Suck them all up, then supply them to the
8076 register cacheing/storage mechanism. */
8078 p
= rs
->buf
.data ();
8079 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8081 if (p
[0] == 0 || p
[1] == 0)
8082 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8083 internal_error (__FILE__
, __LINE__
,
8084 _("unexpected end of 'g' packet reply"));
8086 if (p
[0] == 'x' && p
[1] == 'x')
8087 regs
[i
] = 0; /* 'x' */
8089 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8093 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8095 struct packet_reg
*r
= &rsa
->regs
[i
];
8096 long reg_size
= register_size (gdbarch
, i
);
8100 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8101 /* This shouldn't happen - we adjusted in_g_packet above. */
8102 internal_error (__FILE__
, __LINE__
,
8103 _("unexpected end of 'g' packet reply"));
8104 else if (rs
->buf
[r
->offset
* 2] == 'x')
8106 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8107 /* The register isn't available, mark it as such (at
8108 the same time setting the value to zero). */
8109 regcache
->raw_supply (r
->regnum
, NULL
);
8112 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8118 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8121 process_g_packet (regcache
);
8124 /* Make the remote selected traceframe match GDB's selected
8128 remote_target::set_remote_traceframe ()
8131 struct remote_state
*rs
= get_remote_state ();
8133 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8136 /* Avoid recursion, remote_trace_find calls us again. */
8137 rs
->remote_traceframe_number
= get_traceframe_number ();
8139 newnum
= target_trace_find (tfind_number
,
8140 get_traceframe_number (), 0, 0, NULL
);
8142 /* Should not happen. If it does, all bets are off. */
8143 if (newnum
!= get_traceframe_number ())
8144 warning (_("could not set remote traceframe"));
8148 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8150 struct gdbarch
*gdbarch
= regcache
->arch ();
8151 struct remote_state
*rs
= get_remote_state ();
8152 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8155 set_remote_traceframe ();
8156 set_general_thread (regcache
->ptid ());
8160 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8162 gdb_assert (reg
!= NULL
);
8164 /* If this register might be in the 'g' packet, try that first -
8165 we are likely to read more than one register. If this is the
8166 first 'g' packet, we might be overly optimistic about its
8167 contents, so fall back to 'p'. */
8168 if (reg
->in_g_packet
)
8170 fetch_registers_using_g (regcache
);
8171 if (reg
->in_g_packet
)
8175 if (fetch_register_using_p (regcache
, reg
))
8178 /* This register is not available. */
8179 regcache
->raw_supply (reg
->regnum
, NULL
);
8184 fetch_registers_using_g (regcache
);
8186 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8187 if (!rsa
->regs
[i
].in_g_packet
)
8188 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8190 /* This register is not available. */
8191 regcache
->raw_supply (i
, NULL
);
8195 /* Prepare to store registers. Since we may send them all (using a
8196 'G' request), we have to read out the ones we don't want to change
8200 remote_target::prepare_to_store (struct regcache
*regcache
)
8202 struct remote_state
*rs
= get_remote_state ();
8203 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8206 /* Make sure the entire registers array is valid. */
8207 switch (packet_support (PACKET_P
))
8209 case PACKET_DISABLE
:
8210 case PACKET_SUPPORT_UNKNOWN
:
8211 /* Make sure all the necessary registers are cached. */
8212 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8213 if (rsa
->regs
[i
].in_g_packet
)
8214 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8221 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8222 packet was not recognized. */
8225 remote_target::store_register_using_P (const struct regcache
*regcache
,
8228 struct gdbarch
*gdbarch
= regcache
->arch ();
8229 struct remote_state
*rs
= get_remote_state ();
8230 /* Try storing a single register. */
8231 char *buf
= rs
->buf
.data ();
8232 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8235 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8238 if (reg
->pnum
== -1)
8241 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8242 p
= buf
+ strlen (buf
);
8243 regcache
->raw_collect (reg
->regnum
, regp
);
8244 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8246 getpkt (&rs
->buf
, 0);
8248 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8253 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8254 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8255 case PACKET_UNKNOWN
:
8258 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8262 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8263 contents of the register cache buffer. FIXME: ignores errors. */
8266 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8268 struct remote_state
*rs
= get_remote_state ();
8269 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8273 /* Extract all the registers in the regcache copying them into a
8278 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8279 memset (regs
, 0, rsa
->sizeof_g_packet
);
8280 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8282 struct packet_reg
*r
= &rsa
->regs
[i
];
8285 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8289 /* Command describes registers byte by byte,
8290 each byte encoded as two hex characters. */
8291 p
= rs
->buf
.data ();
8293 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8295 getpkt (&rs
->buf
, 0);
8296 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8297 error (_("Could not write registers; remote failure reply '%s'"),
8301 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8302 of the register cache buffer. FIXME: ignores errors. */
8305 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8307 struct gdbarch
*gdbarch
= regcache
->arch ();
8308 struct remote_state
*rs
= get_remote_state ();
8309 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8312 set_remote_traceframe ();
8313 set_general_thread (regcache
->ptid ());
8317 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8319 gdb_assert (reg
!= NULL
);
8321 /* Always prefer to store registers using the 'P' packet if
8322 possible; we often change only a small number of registers.
8323 Sometimes we change a larger number; we'd need help from a
8324 higher layer to know to use 'G'. */
8325 if (store_register_using_P (regcache
, reg
))
8328 /* For now, don't complain if we have no way to write the
8329 register. GDB loses track of unavailable registers too
8330 easily. Some day, this may be an error. We don't have
8331 any way to read the register, either... */
8332 if (!reg
->in_g_packet
)
8335 store_registers_using_G (regcache
);
8339 store_registers_using_G (regcache
);
8341 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8342 if (!rsa
->regs
[i
].in_g_packet
)
8343 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8344 /* See above for why we do not issue an error here. */
8349 /* Return the number of hex digits in num. */
8352 hexnumlen (ULONGEST num
)
8356 for (i
= 0; num
!= 0; i
++)
8359 return std::max (i
, 1);
8362 /* Set BUF to the minimum number of hex digits representing NUM. */
8365 hexnumstr (char *buf
, ULONGEST num
)
8367 int len
= hexnumlen (num
);
8369 return hexnumnstr (buf
, num
, len
);
8373 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8376 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8382 for (i
= width
- 1; i
>= 0; i
--)
8384 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8391 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8394 remote_address_masked (CORE_ADDR addr
)
8396 unsigned int address_size
= remote_address_size
;
8398 /* If "remoteaddresssize" was not set, default to target address size. */
8400 address_size
= gdbarch_addr_bit (target_gdbarch ());
8402 if (address_size
> 0
8403 && address_size
< (sizeof (ULONGEST
) * 8))
8405 /* Only create a mask when that mask can safely be constructed
8406 in a ULONGEST variable. */
8409 mask
= (mask
<< address_size
) - 1;
8415 /* Determine whether the remote target supports binary downloading.
8416 This is accomplished by sending a no-op memory write of zero length
8417 to the target at the specified address. It does not suffice to send
8418 the whole packet, since many stubs strip the eighth bit and
8419 subsequently compute a wrong checksum, which causes real havoc with
8422 NOTE: This can still lose if the serial line is not eight-bit
8423 clean. In cases like this, the user should clear "remote
8427 remote_target::check_binary_download (CORE_ADDR addr
)
8429 struct remote_state
*rs
= get_remote_state ();
8431 switch (packet_support (PACKET_X
))
8433 case PACKET_DISABLE
:
8437 case PACKET_SUPPORT_UNKNOWN
:
8441 p
= rs
->buf
.data ();
8443 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8445 p
+= hexnumstr (p
, (ULONGEST
) 0);
8449 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8450 getpkt (&rs
->buf
, 0);
8452 if (rs
->buf
[0] == '\0')
8455 fprintf_unfiltered (gdb_stdlog
,
8456 "binary downloading NOT "
8457 "supported by target\n");
8458 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8463 fprintf_unfiltered (gdb_stdlog
,
8464 "binary downloading supported by target\n");
8465 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8472 /* Helper function to resize the payload in order to try to get a good
8473 alignment. We try to write an amount of data such that the next write will
8474 start on an address aligned on REMOTE_ALIGN_WRITES. */
8477 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8479 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8482 /* Write memory data directly to the remote machine.
8483 This does not inform the data cache; the data cache uses this.
8484 HEADER is the starting part of the packet.
8485 MEMADDR is the address in the remote memory space.
8486 MYADDR is the address of the buffer in our space.
8487 LEN_UNITS is the number of addressable units to write.
8488 UNIT_SIZE is the length in bytes of an addressable unit.
8489 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8490 should send data as binary ('X'), or hex-encoded ('M').
8492 The function creates packet of the form
8493 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8495 where encoding of <DATA> is terminated by PACKET_FORMAT.
8497 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8500 Return the transferred status, error or OK (an
8501 'enum target_xfer_status' value). Save the number of addressable units
8502 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8504 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8505 exchange between gdb and the stub could look like (?? in place of the
8511 -> $M1000,3:eeeeffffeeee#??
8515 <- eeeeffffeeeedddd */
8518 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8519 const gdb_byte
*myaddr
,
8522 ULONGEST
*xfered_len_units
,
8523 char packet_format
, int use_length
)
8525 struct remote_state
*rs
= get_remote_state ();
8531 int payload_capacity_bytes
;
8532 int payload_length_bytes
;
8534 if (packet_format
!= 'X' && packet_format
!= 'M')
8535 internal_error (__FILE__
, __LINE__
,
8536 _("remote_write_bytes_aux: bad packet format"));
8539 return TARGET_XFER_EOF
;
8541 payload_capacity_bytes
= get_memory_write_packet_size ();
8543 /* The packet buffer will be large enough for the payload;
8544 get_memory_packet_size ensures this. */
8547 /* Compute the size of the actual payload by subtracting out the
8548 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8550 payload_capacity_bytes
-= strlen ("$,:#NN");
8552 /* The comma won't be used. */
8553 payload_capacity_bytes
+= 1;
8554 payload_capacity_bytes
-= strlen (header
);
8555 payload_capacity_bytes
-= hexnumlen (memaddr
);
8557 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8559 strcat (rs
->buf
.data (), header
);
8560 p
= rs
->buf
.data () + strlen (header
);
8562 /* Compute a best guess of the number of bytes actually transfered. */
8563 if (packet_format
== 'X')
8565 /* Best guess at number of bytes that will fit. */
8566 todo_units
= std::min (len_units
,
8567 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8569 payload_capacity_bytes
-= hexnumlen (todo_units
);
8570 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8574 /* Number of bytes that will fit. */
8576 = std::min (len_units
,
8577 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8579 payload_capacity_bytes
-= hexnumlen (todo_units
);
8580 todo_units
= std::min (todo_units
,
8581 (payload_capacity_bytes
/ unit_size
) / 2);
8584 if (todo_units
<= 0)
8585 internal_error (__FILE__
, __LINE__
,
8586 _("minimum packet size too small to write data"));
8588 /* If we already need another packet, then try to align the end
8589 of this packet to a useful boundary. */
8590 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8591 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8593 /* Append "<memaddr>". */
8594 memaddr
= remote_address_masked (memaddr
);
8595 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8602 /* Append the length and retain its location and size. It may need to be
8603 adjusted once the packet body has been created. */
8605 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8613 /* Append the packet body. */
8614 if (packet_format
== 'X')
8616 /* Binary mode. Send target system values byte by byte, in
8617 increasing byte addresses. Only escape certain critical
8619 payload_length_bytes
=
8620 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8621 &units_written
, payload_capacity_bytes
);
8623 /* If not all TODO units fit, then we'll need another packet. Make
8624 a second try to keep the end of the packet aligned. Don't do
8625 this if the packet is tiny. */
8626 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8630 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8632 if (new_todo_units
!= units_written
)
8633 payload_length_bytes
=
8634 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8635 (gdb_byte
*) p
, &units_written
,
8636 payload_capacity_bytes
);
8639 p
+= payload_length_bytes
;
8640 if (use_length
&& units_written
< todo_units
)
8642 /* Escape chars have filled up the buffer prematurely,
8643 and we have actually sent fewer units than planned.
8644 Fix-up the length field of the packet. Use the same
8645 number of characters as before. */
8646 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8648 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8653 /* Normal mode: Send target system values byte by byte, in
8654 increasing byte addresses. Each byte is encoded as a two hex
8656 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8657 units_written
= todo_units
;
8660 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8661 getpkt (&rs
->buf
, 0);
8663 if (rs
->buf
[0] == 'E')
8664 return TARGET_XFER_E_IO
;
8666 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8667 send fewer units than we'd planned. */
8668 *xfered_len_units
= (ULONGEST
) units_written
;
8669 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8672 /* Write memory data directly to the remote machine.
8673 This does not inform the data cache; the data cache uses this.
8674 MEMADDR is the address in the remote memory space.
8675 MYADDR is the address of the buffer in our space.
8676 LEN is the number of bytes.
8678 Return the transferred status, error or OK (an
8679 'enum target_xfer_status' value). Save the number of bytes
8680 transferred in *XFERED_LEN. Only transfer a single packet. */
8683 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8684 ULONGEST len
, int unit_size
,
8685 ULONGEST
*xfered_len
)
8687 const char *packet_format
= NULL
;
8689 /* Check whether the target supports binary download. */
8690 check_binary_download (memaddr
);
8692 switch (packet_support (PACKET_X
))
8695 packet_format
= "X";
8697 case PACKET_DISABLE
:
8698 packet_format
= "M";
8700 case PACKET_SUPPORT_UNKNOWN
:
8701 internal_error (__FILE__
, __LINE__
,
8702 _("remote_write_bytes: bad internal state"));
8704 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8707 return remote_write_bytes_aux (packet_format
,
8708 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8709 packet_format
[0], 1);
8712 /* Read memory data directly from the remote machine.
8713 This does not use the data cache; the data cache uses this.
8714 MEMADDR is the address in the remote memory space.
8715 MYADDR is the address of the buffer in our space.
8716 LEN_UNITS is the number of addressable memory units to read..
8717 UNIT_SIZE is the length in bytes of an addressable unit.
8719 Return the transferred status, error or OK (an
8720 'enum target_xfer_status' value). Save the number of bytes
8721 transferred in *XFERED_LEN_UNITS.
8723 See the comment of remote_write_bytes_aux for an example of
8724 memory read/write exchange between gdb and the stub. */
8727 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8729 int unit_size
, ULONGEST
*xfered_len_units
)
8731 struct remote_state
*rs
= get_remote_state ();
8732 int buf_size_bytes
; /* Max size of packet output buffer. */
8737 buf_size_bytes
= get_memory_read_packet_size ();
8738 /* The packet buffer will be large enough for the payload;
8739 get_memory_packet_size ensures this. */
8741 /* Number of units that will fit. */
8742 todo_units
= std::min (len_units
,
8743 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8745 /* Construct "m"<memaddr>","<len>". */
8746 memaddr
= remote_address_masked (memaddr
);
8747 p
= rs
->buf
.data ();
8749 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8751 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8754 getpkt (&rs
->buf
, 0);
8755 if (rs
->buf
[0] == 'E'
8756 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8757 && rs
->buf
[3] == '\0')
8758 return TARGET_XFER_E_IO
;
8759 /* Reply describes memory byte by byte, each byte encoded as two hex
8761 p
= rs
->buf
.data ();
8762 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8763 /* Return what we have. Let higher layers handle partial reads. */
8764 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8765 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8768 /* Using the set of read-only target sections of remote, read live
8771 For interface/parameters/return description see target.h,
8775 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
8779 ULONGEST
*xfered_len
)
8781 struct target_section
*secp
;
8782 struct target_section_table
*table
;
8784 secp
= target_section_by_addr (this, memaddr
);
8786 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
8788 struct target_section
*p
;
8789 ULONGEST memend
= memaddr
+ len
;
8791 table
= target_get_section_table (this);
8793 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8795 if (memaddr
>= p
->addr
)
8797 if (memend
<= p
->endaddr
)
8799 /* Entire transfer is within this section. */
8800 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8803 else if (memaddr
>= p
->endaddr
)
8805 /* This section ends before the transfer starts. */
8810 /* This section overlaps the transfer. Just do half. */
8811 len
= p
->endaddr
- memaddr
;
8812 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8819 return TARGET_XFER_EOF
;
8822 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8823 first if the requested memory is unavailable in traceframe.
8824 Otherwise, fall back to remote_read_bytes_1. */
8827 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
8828 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8829 ULONGEST
*xfered_len
)
8832 return TARGET_XFER_EOF
;
8834 if (get_traceframe_number () != -1)
8836 std::vector
<mem_range
> available
;
8838 /* If we fail to get the set of available memory, then the
8839 target does not support querying traceframe info, and so we
8840 attempt reading from the traceframe anyway (assuming the
8841 target implements the old QTro packet then). */
8842 if (traceframe_available_memory (&available
, memaddr
, len
))
8844 if (available
.empty () || available
[0].start
!= memaddr
)
8846 enum target_xfer_status res
;
8848 /* Don't read into the traceframe's available
8850 if (!available
.empty ())
8852 LONGEST oldlen
= len
;
8854 len
= available
[0].start
- memaddr
;
8855 gdb_assert (len
<= oldlen
);
8858 /* This goes through the topmost target again. */
8859 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
8860 len
, unit_size
, xfered_len
);
8861 if (res
== TARGET_XFER_OK
)
8862 return TARGET_XFER_OK
;
8865 /* No use trying further, we know some memory starting
8866 at MEMADDR isn't available. */
8868 return (*xfered_len
!= 0) ?
8869 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
8873 /* Don't try to read more than how much is available, in
8874 case the target implements the deprecated QTro packet to
8875 cater for older GDBs (the target's knowledge of read-only
8876 sections may be outdated by now). */
8877 len
= available
[0].length
;
8881 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8886 /* Sends a packet with content determined by the printf format string
8887 FORMAT and the remaining arguments, then gets the reply. Returns
8888 whether the packet was a success, a failure, or unknown. */
8891 remote_target::remote_send_printf (const char *format
, ...)
8893 struct remote_state
*rs
= get_remote_state ();
8894 int max_size
= get_remote_packet_size ();
8897 va_start (ap
, format
);
8900 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
8904 if (size
>= max_size
)
8905 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8907 if (putpkt (rs
->buf
) < 0)
8908 error (_("Communication problem with target."));
8911 getpkt (&rs
->buf
, 0);
8913 return packet_check_result (rs
->buf
);
8916 /* Flash writing can take quite some time. We'll set
8917 effectively infinite timeout for flash operations.
8918 In future, we'll need to decide on a better approach. */
8919 static const int remote_flash_timeout
= 1000;
8922 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
8924 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8925 enum packet_result ret
;
8926 scoped_restore restore_timeout
8927 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8929 ret
= remote_send_printf ("vFlashErase:%s,%s",
8930 phex (address
, addr_size
),
8934 case PACKET_UNKNOWN
:
8935 error (_("Remote target does not support flash erase"));
8937 error (_("Error erasing flash with vFlashErase packet"));
8944 remote_target::remote_flash_write (ULONGEST address
,
8945 ULONGEST length
, ULONGEST
*xfered_len
,
8946 const gdb_byte
*data
)
8948 scoped_restore restore_timeout
8949 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8950 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8955 remote_target::flash_done ()
8959 scoped_restore restore_timeout
8960 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8962 ret
= remote_send_printf ("vFlashDone");
8966 case PACKET_UNKNOWN
:
8967 error (_("Remote target does not support vFlashDone"));
8969 error (_("Error finishing flash operation"));
8976 remote_target::files_info ()
8978 puts_filtered ("Debugging a target over a serial line.\n");
8981 /* Stuff for dealing with the packets which are part of this protocol.
8982 See comment at top of file for details. */
8984 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8985 error to higher layers. Called when a serial error is detected.
8986 The exception message is STRING, followed by a colon and a blank,
8987 the system error message for errno at function entry and final dot
8988 for output compatibility with throw_perror_with_name. */
8991 unpush_and_perror (const char *string
)
8993 int saved_errno
= errno
;
8995 remote_unpush_target ();
8996 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
8997 safe_strerror (saved_errno
));
9000 /* Read a single character from the remote end. The current quit
9001 handler is overridden to avoid quitting in the middle of packet
9002 sequence, as that would break communication with the remote server.
9003 See remote_serial_quit_handler for more detail. */
9006 remote_target::readchar (int timeout
)
9009 struct remote_state
*rs
= get_remote_state ();
9012 scoped_restore restore_quit_target
9013 = make_scoped_restore (&curr_quit_handler_target
, this);
9014 scoped_restore restore_quit
9015 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9017 rs
->got_ctrlc_during_io
= 0;
9019 ch
= serial_readchar (rs
->remote_desc
, timeout
);
9021 if (rs
->got_ctrlc_during_io
)
9028 switch ((enum serial_rc
) ch
)
9031 remote_unpush_target ();
9032 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9035 unpush_and_perror (_("Remote communication error. "
9036 "Target disconnected."));
9038 case SERIAL_TIMEOUT
:
9044 /* Wrapper for serial_write that closes the target and throws if
9045 writing fails. The current quit handler is overridden to avoid
9046 quitting in the middle of packet sequence, as that would break
9047 communication with the remote server. See
9048 remote_serial_quit_handler for more detail. */
9051 remote_target::remote_serial_write (const char *str
, int len
)
9053 struct remote_state
*rs
= get_remote_state ();
9055 scoped_restore restore_quit_target
9056 = make_scoped_restore (&curr_quit_handler_target
, this);
9057 scoped_restore restore_quit
9058 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9060 rs
->got_ctrlc_during_io
= 0;
9062 if (serial_write (rs
->remote_desc
, str
, len
))
9064 unpush_and_perror (_("Remote communication error. "
9065 "Target disconnected."));
9068 if (rs
->got_ctrlc_during_io
)
9072 /* Return a string representing an escaped version of BUF, of len N.
9073 E.g. \n is converted to \\n, \t to \\t, etc. */
9076 escape_buffer (const char *buf
, int n
)
9080 stb
.putstrn (buf
, n
, '\\');
9081 return std::move (stb
.string ());
9084 /* Display a null-terminated packet on stdout, for debugging, using C
9088 print_packet (const char *buf
)
9090 puts_filtered ("\"");
9091 fputstr_filtered (buf
, '"', gdb_stdout
);
9092 puts_filtered ("\"");
9096 remote_target::putpkt (const char *buf
)
9098 return putpkt_binary (buf
, strlen (buf
));
9101 /* Wrapper around remote_target::putpkt to avoid exporting
9105 putpkt (remote_target
*remote
, const char *buf
)
9107 return remote
->putpkt (buf
);
9110 /* Send a packet to the remote machine, with error checking. The data
9111 of the packet is in BUF. The string in BUF can be at most
9112 get_remote_packet_size () - 5 to account for the $, # and checksum,
9113 and for a possible /0 if we are debugging (remote_debug) and want
9114 to print the sent packet as a string. */
9117 remote_target::putpkt_binary (const char *buf
, int cnt
)
9119 struct remote_state
*rs
= get_remote_state ();
9121 unsigned char csum
= 0;
9122 gdb::def_vector
<char> data (cnt
+ 6);
9123 char *buf2
= data
.data ();
9129 /* Catch cases like trying to read memory or listing threads while
9130 we're waiting for a stop reply. The remote server wouldn't be
9131 ready to handle this request, so we'd hang and timeout. We don't
9132 have to worry about this in synchronous mode, because in that
9133 case it's not possible to issue a command while the target is
9134 running. This is not a problem in non-stop mode, because in that
9135 case, the stub is always ready to process serial input. */
9136 if (!target_is_non_stop_p ()
9137 && target_is_async_p ()
9138 && rs
->waiting_for_stop_reply
)
9140 error (_("Cannot execute this command while the target is running.\n"
9141 "Use the \"interrupt\" command to stop the target\n"
9142 "and then try again."));
9145 /* We're sending out a new packet. Make sure we don't look at a
9146 stale cached response. */
9147 rs
->cached_wait_status
= 0;
9149 /* Copy the packet into buffer BUF2, encapsulating it
9150 and giving it a checksum. */
9155 for (i
= 0; i
< cnt
; i
++)
9161 *p
++ = tohex ((csum
>> 4) & 0xf);
9162 *p
++ = tohex (csum
& 0xf);
9164 /* Send it over and over until we get a positive ack. */
9168 int started_error_output
= 0;
9174 int len
= (int) (p
- buf2
);
9177 if (remote_packet_max_chars
< 0)
9180 max_chars
= remote_packet_max_chars
;
9183 = escape_buffer (buf2
, std::min (len
, max_chars
));
9185 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9187 if (len
> max_chars
)
9188 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9191 fprintf_unfiltered (gdb_stdlog
, "...");
9193 gdb_flush (gdb_stdlog
);
9195 remote_serial_write (buf2
, p
- buf2
);
9197 /* If this is a no acks version of the remote protocol, send the
9198 packet and move on. */
9202 /* Read until either a timeout occurs (-2) or '+' is read.
9203 Handle any notification that arrives in the mean time. */
9206 ch
= readchar (remote_timeout
);
9214 case SERIAL_TIMEOUT
:
9217 if (started_error_output
)
9219 putchar_unfiltered ('\n');
9220 started_error_output
= 0;
9229 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9233 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9235 case SERIAL_TIMEOUT
:
9239 break; /* Retransmit buffer. */
9243 fprintf_unfiltered (gdb_stdlog
,
9244 "Packet instead of Ack, ignoring it\n");
9245 /* It's probably an old response sent because an ACK
9246 was lost. Gobble up the packet and ack it so it
9247 doesn't get retransmitted when we resend this
9250 remote_serial_write ("+", 1);
9251 continue; /* Now, go look for +. */
9258 /* If we got a notification, handle it, and go back to looking
9260 /* We've found the start of a notification. Now
9261 collect the data. */
9262 val
= read_frame (&rs
->buf
);
9267 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9269 fprintf_unfiltered (gdb_stdlog
,
9270 " Notification received: %s\n",
9273 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9274 /* We're in sync now, rewait for the ack. */
9281 if (!started_error_output
)
9283 started_error_output
= 1;
9284 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9286 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9287 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9296 if (!started_error_output
)
9298 started_error_output
= 1;
9299 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9301 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9305 break; /* Here to retransmit. */
9309 /* This is wrong. If doing a long backtrace, the user should be
9310 able to get out next time we call QUIT, without anything as
9311 violent as interrupt_query. If we want to provide a way out of
9312 here without getting to the next QUIT, it should be based on
9313 hitting ^C twice as in remote_wait. */
9325 /* Come here after finding the start of a frame when we expected an
9326 ack. Do our best to discard the rest of this packet. */
9329 remote_target::skip_frame ()
9335 c
= readchar (remote_timeout
);
9338 case SERIAL_TIMEOUT
:
9339 /* Nothing we can do. */
9342 /* Discard the two bytes of checksum and stop. */
9343 c
= readchar (remote_timeout
);
9345 c
= readchar (remote_timeout
);
9348 case '*': /* Run length encoding. */
9349 /* Discard the repeat count. */
9350 c
= readchar (remote_timeout
);
9355 /* A regular character. */
9361 /* Come here after finding the start of the frame. Collect the rest
9362 into *BUF, verifying the checksum, length, and handling run-length
9363 compression. NUL terminate the buffer. If there is not enough room,
9366 Returns -1 on error, number of characters in buffer (ignoring the
9367 trailing NULL) on success. (could be extended to return one of the
9368 SERIAL status indications). */
9371 remote_target::read_frame (gdb::char_vector
*buf_p
)
9376 char *buf
= buf_p
->data ();
9377 struct remote_state
*rs
= get_remote_state ();
9384 c
= readchar (remote_timeout
);
9387 case SERIAL_TIMEOUT
:
9389 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9393 fputs_filtered ("Saw new packet start in middle of old one\n",
9395 return -1; /* Start a new packet, count retries. */
9398 unsigned char pktcsum
;
9404 check_0
= readchar (remote_timeout
);
9406 check_1
= readchar (remote_timeout
);
9408 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9411 fputs_filtered ("Timeout in checksum, retrying\n",
9415 else if (check_0
< 0 || check_1
< 0)
9418 fputs_filtered ("Communication error in checksum\n",
9423 /* Don't recompute the checksum; with no ack packets we
9424 don't have any way to indicate a packet retransmission
9429 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9430 if (csum
== pktcsum
)
9435 std::string str
= escape_buffer (buf
, bc
);
9437 fprintf_unfiltered (gdb_stdlog
,
9438 "Bad checksum, sentsum=0x%x, "
9439 "csum=0x%x, buf=%s\n",
9440 pktcsum
, csum
, str
.c_str ());
9442 /* Number of characters in buffer ignoring trailing
9446 case '*': /* Run length encoding. */
9451 c
= readchar (remote_timeout
);
9453 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9455 /* The character before ``*'' is repeated. */
9457 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9459 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9461 /* Make some more room in the buffer. */
9462 buf_p
->resize (buf_p
->size () + repeat
);
9463 buf
= buf_p
->data ();
9466 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9472 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9476 if (bc
>= buf_p
->size () - 1)
9478 /* Make some more room in the buffer. */
9479 buf_p
->resize (buf_p
->size () * 2);
9480 buf
= buf_p
->data ();
9490 /* Set this to the maximum number of seconds to wait instead of waiting forever
9491 in target_wait(). If this timer times out, then it generates an error and
9492 the command is aborted. This replaces most of the need for timeouts in the
9493 GDB test suite, and makes it possible to distinguish between a hung target
9494 and one with slow communications. */
9496 static int watchdog
= 0;
9498 show_watchdog (struct ui_file
*file
, int from_tty
,
9499 struct cmd_list_element
*c
, const char *value
)
9501 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9504 /* Read a packet from the remote machine, with error checking, and
9505 store it in *BUF. Resize *BUF if necessary to hold the result. If
9506 FOREVER, wait forever rather than timing out; this is used (in
9507 synchronous mode) to wait for a target that is is executing user
9509 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9510 don't have to change all the calls to getpkt to deal with the
9511 return value, because at the moment I don't know what the right
9512 thing to do it for those. */
9515 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9517 getpkt_sane (buf
, forever
);
9521 /* Read a packet from the remote machine, with error checking, and
9522 store it in *BUF. Resize *BUF if necessary to hold the result. If
9523 FOREVER, wait forever rather than timing out; this is used (in
9524 synchronous mode) to wait for a target that is is executing user
9525 code to stop. If FOREVER == 0, this function is allowed to time
9526 out gracefully and return an indication of this to the caller.
9527 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9528 consider receiving a notification enough reason to return to the
9529 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9530 holds a notification or not (a regular packet). */
9533 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9534 int forever
, int expecting_notif
,
9537 struct remote_state
*rs
= get_remote_state ();
9543 /* We're reading a new response. Make sure we don't look at a
9544 previously cached response. */
9545 rs
->cached_wait_status
= 0;
9547 strcpy (buf
->data (), "timeout");
9550 timeout
= watchdog
> 0 ? watchdog
: -1;
9551 else if (expecting_notif
)
9552 timeout
= 0; /* There should already be a char in the buffer. If
9555 timeout
= remote_timeout
;
9559 /* Process any number of notifications, and then return when
9563 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9565 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9567 /* This can loop forever if the remote side sends us
9568 characters continuously, but if it pauses, we'll get
9569 SERIAL_TIMEOUT from readchar because of timeout. Then
9570 we'll count that as a retry.
9572 Note that even when forever is set, we will only wait
9573 forever prior to the start of a packet. After that, we
9574 expect characters to arrive at a brisk pace. They should
9575 show up within remote_timeout intervals. */
9577 c
= readchar (timeout
);
9578 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9580 if (c
== SERIAL_TIMEOUT
)
9582 if (expecting_notif
)
9583 return -1; /* Don't complain, it's normal to not get
9584 anything in this case. */
9586 if (forever
) /* Watchdog went off? Kill the target. */
9588 remote_unpush_target ();
9589 throw_error (TARGET_CLOSE_ERROR
,
9590 _("Watchdog timeout has expired. "
9591 "Target detached."));
9594 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9598 /* We've found the start of a packet or notification.
9599 Now collect the data. */
9600 val
= read_frame (buf
);
9605 remote_serial_write ("-", 1);
9608 if (tries
> MAX_TRIES
)
9610 /* We have tried hard enough, and just can't receive the
9611 packet/notification. Give up. */
9612 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9614 /* Skip the ack char if we're in no-ack mode. */
9615 if (!rs
->noack_mode
)
9616 remote_serial_write ("+", 1);
9620 /* If we got an ordinary packet, return that to our caller. */
9627 if (remote_packet_max_chars
< 0)
9630 max_chars
= remote_packet_max_chars
;
9633 = escape_buffer (buf
->data (),
9634 std::min (val
, max_chars
));
9636 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9639 if (val
> max_chars
)
9640 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9643 fprintf_unfiltered (gdb_stdlog
, "\n");
9646 /* Skip the ack char if we're in no-ack mode. */
9647 if (!rs
->noack_mode
)
9648 remote_serial_write ("+", 1);
9649 if (is_notif
!= NULL
)
9654 /* If we got a notification, handle it, and go back to looking
9658 gdb_assert (c
== '%');
9662 std::string str
= escape_buffer (buf
->data (), val
);
9664 fprintf_unfiltered (gdb_stdlog
,
9665 " Notification received: %s\n",
9668 if (is_notif
!= NULL
)
9671 handle_notification (rs
->notif_state
, buf
->data ());
9673 /* Notifications require no acknowledgement. */
9675 if (expecting_notif
)
9682 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9684 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9688 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9691 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9694 /* Kill any new fork children of process PID that haven't been
9695 processed by follow_fork. */
9698 remote_target::kill_new_fork_children (int pid
)
9700 remote_state
*rs
= get_remote_state ();
9701 struct notif_client
*notif
= ¬if_client_stop
;
9703 /* Kill the fork child threads of any threads in process PID
9704 that are stopped at a fork event. */
9705 for (thread_info
*thread
: all_non_exited_threads ())
9707 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9709 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9711 int child_pid
= ws
->value
.related_pid
.pid ();
9714 res
= remote_vkill (child_pid
);
9716 error (_("Can't kill fork child process %d"), child_pid
);
9720 /* Check for any pending fork events (not reported or processed yet)
9721 in process PID and kill those fork child threads as well. */
9722 remote_notif_get_pending_events (notif
);
9723 for (auto &event
: rs
->stop_reply_queue
)
9724 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9726 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9729 res
= remote_vkill (child_pid
);
9731 error (_("Can't kill fork child process %d"), child_pid
);
9736 /* Target hook to kill the current inferior. */
9739 remote_target::kill ()
9742 int pid
= inferior_ptid
.pid ();
9743 struct remote_state
*rs
= get_remote_state ();
9745 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9747 /* If we're stopped while forking and we haven't followed yet,
9748 kill the child task. We need to do this before killing the
9749 parent task because if this is a vfork then the parent will
9751 kill_new_fork_children (pid
);
9753 res
= remote_vkill (pid
);
9756 target_mourn_inferior (inferior_ptid
);
9761 /* If we are in 'target remote' mode and we are killing the only
9762 inferior, then we will tell gdbserver to exit and unpush the
9764 if (res
== -1 && !remote_multi_process_p (rs
)
9765 && number_of_live_inferiors () == 1)
9769 /* We've killed the remote end, we get to mourn it. If we are
9770 not in extended mode, mourning the inferior also unpushes
9771 remote_ops from the target stack, which closes the remote
9773 target_mourn_inferior (inferior_ptid
);
9778 error (_("Can't kill process"));
9781 /* Send a kill request to the target using the 'vKill' packet. */
9784 remote_target::remote_vkill (int pid
)
9786 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9789 remote_state
*rs
= get_remote_state ();
9791 /* Tell the remote target to detach. */
9792 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
9794 getpkt (&rs
->buf
, 0);
9796 switch (packet_ok (rs
->buf
,
9797 &remote_protocol_packets
[PACKET_vKill
]))
9803 case PACKET_UNKNOWN
:
9806 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9810 /* Send a kill request to the target using the 'k' packet. */
9813 remote_target::remote_kill_k ()
9815 /* Catch errors so the user can quit from gdb even when we
9816 aren't on speaking terms with the remote system. */
9821 catch (const gdb_exception_error
&ex
)
9823 if (ex
.error
== TARGET_CLOSE_ERROR
)
9825 /* If we got an (EOF) error that caused the target
9826 to go away, then we're done, that's what we wanted.
9827 "k" is susceptible to cause a premature EOF, given
9828 that the remote server isn't actually required to
9829 reply to "k", and it can happen that it doesn't
9830 even get to reply ACK to the "k". */
9834 /* Otherwise, something went wrong. We didn't actually kill
9835 the target. Just propagate the exception, and let the
9836 user or higher layers decide what to do. */
9842 remote_target::mourn_inferior ()
9844 struct remote_state
*rs
= get_remote_state ();
9846 /* We're no longer interested in notification events of an inferior
9847 that exited or was killed/detached. */
9848 discard_pending_stop_replies (current_inferior ());
9850 /* In 'target remote' mode with one inferior, we close the connection. */
9851 if (!rs
->extended
&& number_of_live_inferiors () <= 1)
9853 unpush_target (this);
9855 /* remote_close takes care of doing most of the clean up. */
9856 generic_mourn_inferior ();
9860 /* In case we got here due to an error, but we're going to stay
9862 rs
->waiting_for_stop_reply
= 0;
9864 /* If the current general thread belonged to the process we just
9865 detached from or has exited, the remote side current general
9866 thread becomes undefined. Considering a case like this:
9868 - We just got here due to a detach.
9869 - The process that we're detaching from happens to immediately
9870 report a global breakpoint being hit in non-stop mode, in the
9871 same thread we had selected before.
9872 - GDB attaches to this process again.
9873 - This event happens to be the next event we handle.
9875 GDB would consider that the current general thread didn't need to
9876 be set on the stub side (with Hg), since for all it knew,
9877 GENERAL_THREAD hadn't changed.
9879 Notice that although in all-stop mode, the remote server always
9880 sets the current thread to the thread reporting the stop event,
9881 that doesn't happen in non-stop mode; in non-stop, the stub *must
9882 not* change the current thread when reporting a breakpoint hit,
9883 due to the decoupling of event reporting and event handling.
9885 To keep things simple, we always invalidate our notion of the
9887 record_currthread (rs
, minus_one_ptid
);
9889 /* Call common code to mark the inferior as not running. */
9890 generic_mourn_inferior ();
9894 extended_remote_target::supports_disable_randomization ()
9896 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9900 remote_target::extended_remote_disable_randomization (int val
)
9902 struct remote_state
*rs
= get_remote_state ();
9905 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9906 "QDisableRandomization:%x", val
);
9908 reply
= remote_get_noisy_reply ();
9910 error (_("Target does not support QDisableRandomization."));
9911 if (strcmp (reply
, "OK") != 0)
9912 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9916 remote_target::extended_remote_run (const std::string
&args
)
9918 struct remote_state
*rs
= get_remote_state ();
9920 const char *remote_exec_file
= get_remote_exec_file ();
9922 /* If the user has disabled vRun support, or we have detected that
9923 support is not available, do not try it. */
9924 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9927 strcpy (rs
->buf
.data (), "vRun;");
9928 len
= strlen (rs
->buf
.data ());
9930 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9931 error (_("Remote file name too long for run packet"));
9932 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
9933 strlen (remote_exec_file
));
9939 gdb_argv
argv (args
.c_str ());
9940 for (i
= 0; argv
[i
] != NULL
; i
++)
9942 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9943 error (_("Argument list too long for run packet"));
9944 rs
->buf
[len
++] = ';';
9945 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
9950 rs
->buf
[len
++] = '\0';
9953 getpkt (&rs
->buf
, 0);
9955 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9958 /* We have a wait response. All is well. */
9960 case PACKET_UNKNOWN
:
9963 if (remote_exec_file
[0] == '\0')
9964 error (_("Running the default executable on the remote target failed; "
9965 "try \"set remote exec-file\"?"));
9967 error (_("Running \"%s\" on the remote target failed"),
9970 gdb_assert_not_reached (_("bad switch"));
9974 /* Helper function to send set/unset environment packets. ACTION is
9975 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
9976 or "QEnvironmentUnsetVariable". VALUE is the variable to be
9980 remote_target::send_environment_packet (const char *action
,
9984 remote_state
*rs
= get_remote_state ();
9986 /* Convert the environment variable to an hex string, which
9987 is the best format to be transmitted over the wire. */
9988 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
9991 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9992 "%s:%s", packet
, encoded_value
.c_str ());
9995 getpkt (&rs
->buf
, 0);
9996 if (strcmp (rs
->buf
.data (), "OK") != 0)
9997 warning (_("Unable to %s environment variable '%s' on remote."),
10001 /* Helper function to handle the QEnvironment* packets. */
10004 remote_target::extended_remote_environment_support ()
10006 remote_state
*rs
= get_remote_state ();
10008 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
10010 putpkt ("QEnvironmentReset");
10011 getpkt (&rs
->buf
, 0);
10012 if (strcmp (rs
->buf
.data (), "OK") != 0)
10013 warning (_("Unable to reset environment on remote."));
10016 gdb_environ
*e
= ¤t_inferior ()->environment
;
10018 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
10019 for (const std::string
&el
: e
->user_set_env ())
10020 send_environment_packet ("set", "QEnvironmentHexEncoded",
10023 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
10024 for (const std::string
&el
: e
->user_unset_env ())
10025 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10028 /* Helper function to set the current working directory for the
10029 inferior in the remote target. */
10032 remote_target::extended_remote_set_inferior_cwd ()
10034 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10036 const char *inferior_cwd
= get_inferior_cwd ();
10037 remote_state
*rs
= get_remote_state ();
10039 if (inferior_cwd
!= NULL
)
10041 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10042 strlen (inferior_cwd
));
10044 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10045 "QSetWorkingDir:%s", hexpath
.c_str ());
10049 /* An empty inferior_cwd means that the user wants us to
10050 reset the remote server's inferior's cwd. */
10051 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10052 "QSetWorkingDir:");
10056 getpkt (&rs
->buf
, 0);
10057 if (packet_ok (rs
->buf
,
10058 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10061 Remote replied unexpectedly while setting the inferior's working\n\
10068 /* In the extended protocol we want to be able to do things like
10069 "run" and have them basically work as expected. So we need
10070 a special create_inferior function. We support changing the
10071 executable file and the command line arguments, but not the
10075 extended_remote_target::create_inferior (const char *exec_file
,
10076 const std::string
&args
,
10077 char **env
, int from_tty
)
10081 struct remote_state
*rs
= get_remote_state ();
10082 const char *remote_exec_file
= get_remote_exec_file ();
10084 /* If running asynchronously, register the target file descriptor
10085 with the event loop. */
10086 if (target_can_async_p ())
10089 /* Disable address space randomization if requested (and supported). */
10090 if (supports_disable_randomization ())
10091 extended_remote_disable_randomization (disable_randomization
);
10093 /* If startup-with-shell is on, we inform gdbserver to start the
10094 remote inferior using a shell. */
10095 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10097 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10098 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10100 getpkt (&rs
->buf
, 0);
10101 if (strcmp (rs
->buf
.data (), "OK") != 0)
10103 Remote replied unexpectedly while setting startup-with-shell: %s"),
10107 extended_remote_environment_support ();
10109 extended_remote_set_inferior_cwd ();
10111 /* Now restart the remote server. */
10112 run_worked
= extended_remote_run (args
) != -1;
10115 /* vRun was not supported. Fail if we need it to do what the
10117 if (remote_exec_file
[0])
10118 error (_("Remote target does not support \"set remote exec-file\""));
10119 if (!args
.empty ())
10120 error (_("Remote target does not support \"set args\" or run ARGS"));
10122 /* Fall back to "R". */
10123 extended_remote_restart ();
10126 /* vRun's success return is a stop reply. */
10127 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10128 add_current_inferior_and_thread (stop_reply
);
10130 /* Get updated offsets, if the stub uses qOffsets. */
10135 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10136 the list of conditions (in agent expression bytecode format), if any, the
10137 target needs to evaluate. The output is placed into the packet buffer
10138 started from BUF and ended at BUF_END. */
10141 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10142 struct bp_target_info
*bp_tgt
, char *buf
,
10145 if (bp_tgt
->conditions
.empty ())
10148 buf
+= strlen (buf
);
10149 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10152 /* Send conditions to the target. */
10153 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10155 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10156 buf
+= strlen (buf
);
10157 for (int i
= 0; i
< aexpr
->len
; ++i
)
10158 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10165 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10166 struct bp_target_info
*bp_tgt
, char *buf
)
10168 if (bp_tgt
->tcommands
.empty ())
10171 buf
+= strlen (buf
);
10173 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10174 buf
+= strlen (buf
);
10176 /* Concatenate all the agent expressions that are commands into the
10178 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10180 sprintf (buf
, "X%x,", aexpr
->len
);
10181 buf
+= strlen (buf
);
10182 for (int i
= 0; i
< aexpr
->len
; ++i
)
10183 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10188 /* Insert a breakpoint. On targets that have software breakpoint
10189 support, we ask the remote target to do the work; on targets
10190 which don't, we insert a traditional memory breakpoint. */
10193 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10194 struct bp_target_info
*bp_tgt
)
10196 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10197 If it succeeds, then set the support to PACKET_ENABLE. If it
10198 fails, and the user has explicitly requested the Z support then
10199 report an error, otherwise, mark it disabled and go on. */
10201 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10203 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10204 struct remote_state
*rs
;
10207 /* Make sure the remote is pointing at the right process, if
10209 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10210 set_general_process ();
10212 rs
= get_remote_state ();
10213 p
= rs
->buf
.data ();
10214 endbuf
= p
+ get_remote_packet_size ();
10219 addr
= (ULONGEST
) remote_address_masked (addr
);
10220 p
+= hexnumstr (p
, addr
);
10221 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10223 if (supports_evaluation_of_breakpoint_conditions ())
10224 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10226 if (can_run_breakpoint_commands ())
10227 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10230 getpkt (&rs
->buf
, 0);
10232 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10238 case PACKET_UNKNOWN
:
10243 /* If this breakpoint has target-side commands but this stub doesn't
10244 support Z0 packets, throw error. */
10245 if (!bp_tgt
->tcommands
.empty ())
10246 throw_error (NOT_SUPPORTED_ERROR
, _("\
10247 Target doesn't support breakpoints that have target side commands."));
10249 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10253 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10254 struct bp_target_info
*bp_tgt
,
10255 enum remove_bp_reason reason
)
10257 CORE_ADDR addr
= bp_tgt
->placed_address
;
10258 struct remote_state
*rs
= get_remote_state ();
10260 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10262 char *p
= rs
->buf
.data ();
10263 char *endbuf
= p
+ get_remote_packet_size ();
10265 /* Make sure the remote is pointing at the right process, if
10267 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10268 set_general_process ();
10274 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10275 p
+= hexnumstr (p
, addr
);
10276 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10279 getpkt (&rs
->buf
, 0);
10281 return (rs
->buf
[0] == 'E');
10284 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10287 static enum Z_packet_type
10288 watchpoint_to_Z_packet (int type
)
10293 return Z_PACKET_WRITE_WP
;
10296 return Z_PACKET_READ_WP
;
10299 return Z_PACKET_ACCESS_WP
;
10302 internal_error (__FILE__
, __LINE__
,
10303 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10308 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10309 enum target_hw_bp_type type
, struct expression
*cond
)
10311 struct remote_state
*rs
= get_remote_state ();
10312 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10314 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10316 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10319 /* Make sure the remote is pointing at the right process, if
10321 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10322 set_general_process ();
10324 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10325 p
= strchr (rs
->buf
.data (), '\0');
10326 addr
= remote_address_masked (addr
);
10327 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10328 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10331 getpkt (&rs
->buf
, 0);
10333 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10337 case PACKET_UNKNOWN
:
10342 internal_error (__FILE__
, __LINE__
,
10343 _("remote_insert_watchpoint: reached end of function"));
10347 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10348 CORE_ADDR start
, int length
)
10350 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10352 return diff
< length
;
10357 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10358 enum target_hw_bp_type type
, struct expression
*cond
)
10360 struct remote_state
*rs
= get_remote_state ();
10361 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10363 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10365 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10368 /* Make sure the remote is pointing at the right process, if
10370 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10371 set_general_process ();
10373 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10374 p
= strchr (rs
->buf
.data (), '\0');
10375 addr
= remote_address_masked (addr
);
10376 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10377 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10379 getpkt (&rs
->buf
, 0);
10381 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10384 case PACKET_UNKNOWN
:
10389 internal_error (__FILE__
, __LINE__
,
10390 _("remote_remove_watchpoint: reached end of function"));
10394 static int remote_hw_watchpoint_limit
= -1;
10395 static int remote_hw_watchpoint_length_limit
= -1;
10396 static int remote_hw_breakpoint_limit
= -1;
10399 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10401 if (remote_hw_watchpoint_length_limit
== 0)
10403 else if (remote_hw_watchpoint_length_limit
< 0)
10405 else if (len
<= remote_hw_watchpoint_length_limit
)
10412 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10414 if (type
== bp_hardware_breakpoint
)
10416 if (remote_hw_breakpoint_limit
== 0)
10418 else if (remote_hw_breakpoint_limit
< 0)
10420 else if (cnt
<= remote_hw_breakpoint_limit
)
10425 if (remote_hw_watchpoint_limit
== 0)
10427 else if (remote_hw_watchpoint_limit
< 0)
10431 else if (cnt
<= remote_hw_watchpoint_limit
)
10437 /* The to_stopped_by_sw_breakpoint method of target remote. */
10440 remote_target::stopped_by_sw_breakpoint ()
10442 struct thread_info
*thread
= inferior_thread ();
10444 return (thread
->priv
!= NULL
10445 && (get_remote_thread_info (thread
)->stop_reason
10446 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10449 /* The to_supports_stopped_by_sw_breakpoint method of target
10453 remote_target::supports_stopped_by_sw_breakpoint ()
10455 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10458 /* The to_stopped_by_hw_breakpoint method of target remote. */
10461 remote_target::stopped_by_hw_breakpoint ()
10463 struct thread_info
*thread
= inferior_thread ();
10465 return (thread
->priv
!= NULL
10466 && (get_remote_thread_info (thread
)->stop_reason
10467 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10470 /* The to_supports_stopped_by_hw_breakpoint method of target
10474 remote_target::supports_stopped_by_hw_breakpoint ()
10476 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10480 remote_target::stopped_by_watchpoint ()
10482 struct thread_info
*thread
= inferior_thread ();
10484 return (thread
->priv
!= NULL
10485 && (get_remote_thread_info (thread
)->stop_reason
10486 == TARGET_STOPPED_BY_WATCHPOINT
));
10490 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10492 struct thread_info
*thread
= inferior_thread ();
10494 if (thread
->priv
!= NULL
10495 && (get_remote_thread_info (thread
)->stop_reason
10496 == TARGET_STOPPED_BY_WATCHPOINT
))
10498 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10507 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10508 struct bp_target_info
*bp_tgt
)
10510 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10511 struct remote_state
*rs
;
10515 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10518 /* Make sure the remote is pointing at the right process, if
10520 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10521 set_general_process ();
10523 rs
= get_remote_state ();
10524 p
= rs
->buf
.data ();
10525 endbuf
= p
+ get_remote_packet_size ();
10531 addr
= remote_address_masked (addr
);
10532 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10533 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10535 if (supports_evaluation_of_breakpoint_conditions ())
10536 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10538 if (can_run_breakpoint_commands ())
10539 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10542 getpkt (&rs
->buf
, 0);
10544 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10547 if (rs
->buf
[1] == '.')
10549 message
= strchr (&rs
->buf
[2], '.');
10551 error (_("Remote failure reply: %s"), message
+ 1);
10554 case PACKET_UNKNOWN
:
10559 internal_error (__FILE__
, __LINE__
,
10560 _("remote_insert_hw_breakpoint: reached end of function"));
10565 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10566 struct bp_target_info
*bp_tgt
)
10569 struct remote_state
*rs
= get_remote_state ();
10570 char *p
= rs
->buf
.data ();
10571 char *endbuf
= p
+ get_remote_packet_size ();
10573 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10576 /* Make sure the remote is pointing at the right process, if
10578 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10579 set_general_process ();
10585 addr
= remote_address_masked (bp_tgt
->placed_address
);
10586 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10587 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10590 getpkt (&rs
->buf
, 0);
10592 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10595 case PACKET_UNKNOWN
:
10600 internal_error (__FILE__
, __LINE__
,
10601 _("remote_remove_hw_breakpoint: reached end of function"));
10604 /* Verify memory using the "qCRC:" request. */
10607 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10609 struct remote_state
*rs
= get_remote_state ();
10610 unsigned long host_crc
, target_crc
;
10613 /* It doesn't make sense to use qCRC if the remote target is
10614 connected but not running. */
10615 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10617 enum packet_result result
;
10619 /* Make sure the remote is pointing at the right process. */
10620 set_general_process ();
10622 /* FIXME: assumes lma can fit into long. */
10623 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10624 (long) lma
, (long) size
);
10627 /* Be clever; compute the host_crc before waiting for target
10629 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10631 getpkt (&rs
->buf
, 0);
10633 result
= packet_ok (rs
->buf
,
10634 &remote_protocol_packets
[PACKET_qCRC
]);
10635 if (result
== PACKET_ERROR
)
10637 else if (result
== PACKET_OK
)
10639 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10640 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10642 return (host_crc
== target_crc
);
10646 return simple_verify_memory (this, data
, lma
, size
);
10649 /* compare-sections command
10651 With no arguments, compares each loadable section in the exec bfd
10652 with the same memory range on the target, and reports mismatches.
10653 Useful for verifying the image on the target against the exec file. */
10656 compare_sections_command (const char *args
, int from_tty
)
10659 const char *sectname
;
10660 bfd_size_type size
;
10663 int mismatched
= 0;
10668 error (_("command cannot be used without an exec file"));
10670 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10676 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10678 if (!(s
->flags
& SEC_LOAD
))
10679 continue; /* Skip non-loadable section. */
10681 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10682 continue; /* Skip writeable sections */
10684 size
= bfd_section_size (s
);
10686 continue; /* Skip zero-length section. */
10688 sectname
= bfd_section_name (s
);
10689 if (args
&& strcmp (args
, sectname
) != 0)
10690 continue; /* Not the section selected by user. */
10692 matched
= 1; /* Do this section. */
10695 gdb::byte_vector
sectdata (size
);
10696 bfd_get_section_contents (exec_bfd
, s
, sectdata
.data (), 0, size
);
10698 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10701 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10702 paddress (target_gdbarch (), lma
),
10703 paddress (target_gdbarch (), lma
+ size
));
10705 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10706 paddress (target_gdbarch (), lma
),
10707 paddress (target_gdbarch (), lma
+ size
));
10709 printf_filtered ("matched.\n");
10712 printf_filtered ("MIS-MATCHED!\n");
10716 if (mismatched
> 0)
10717 warning (_("One or more sections of the target image does not match\n\
10718 the loaded file\n"));
10719 if (args
&& !matched
)
10720 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10723 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10724 into remote target. The number of bytes written to the remote
10725 target is returned, or -1 for error. */
10728 remote_target::remote_write_qxfer (const char *object_name
,
10729 const char *annex
, const gdb_byte
*writebuf
,
10730 ULONGEST offset
, LONGEST len
,
10731 ULONGEST
*xfered_len
,
10732 struct packet_config
*packet
)
10736 struct remote_state
*rs
= get_remote_state ();
10737 int max_size
= get_memory_write_packet_size ();
10739 if (packet_config_support (packet
) == PACKET_DISABLE
)
10740 return TARGET_XFER_E_IO
;
10742 /* Insert header. */
10743 i
= snprintf (rs
->buf
.data (), max_size
,
10744 "qXfer:%s:write:%s:%s:",
10745 object_name
, annex
? annex
: "",
10746 phex_nz (offset
, sizeof offset
));
10747 max_size
-= (i
+ 1);
10749 /* Escape as much data as fits into rs->buf. */
10750 buf_len
= remote_escape_output
10751 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10753 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10754 || getpkt_sane (&rs
->buf
, 0) < 0
10755 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10756 return TARGET_XFER_E_IO
;
10758 unpack_varlen_hex (rs
->buf
.data (), &n
);
10761 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10764 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10765 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10766 number of bytes read is returned, or 0 for EOF, or -1 for error.
10767 The number of bytes read may be less than LEN without indicating an
10768 EOF. PACKET is checked and updated to indicate whether the remote
10769 target supports this object. */
10772 remote_target::remote_read_qxfer (const char *object_name
,
10774 gdb_byte
*readbuf
, ULONGEST offset
,
10776 ULONGEST
*xfered_len
,
10777 struct packet_config
*packet
)
10779 struct remote_state
*rs
= get_remote_state ();
10780 LONGEST i
, n
, packet_len
;
10782 if (packet_config_support (packet
) == PACKET_DISABLE
)
10783 return TARGET_XFER_E_IO
;
10785 /* Check whether we've cached an end-of-object packet that matches
10787 if (rs
->finished_object
)
10789 if (strcmp (object_name
, rs
->finished_object
) == 0
10790 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10791 && offset
== rs
->finished_offset
)
10792 return TARGET_XFER_EOF
;
10795 /* Otherwise, we're now reading something different. Discard
10797 xfree (rs
->finished_object
);
10798 xfree (rs
->finished_annex
);
10799 rs
->finished_object
= NULL
;
10800 rs
->finished_annex
= NULL
;
10803 /* Request only enough to fit in a single packet. The actual data
10804 may not, since we don't know how much of it will need to be escaped;
10805 the target is free to respond with slightly less data. We subtract
10806 five to account for the response type and the protocol frame. */
10807 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10808 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
10809 "qXfer:%s:read:%s:%s,%s",
10810 object_name
, annex
? annex
: "",
10811 phex_nz (offset
, sizeof offset
),
10812 phex_nz (n
, sizeof n
));
10813 i
= putpkt (rs
->buf
);
10815 return TARGET_XFER_E_IO
;
10818 packet_len
= getpkt_sane (&rs
->buf
, 0);
10819 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10820 return TARGET_XFER_E_IO
;
10822 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10823 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
10825 /* 'm' means there is (or at least might be) more data after this
10826 batch. That does not make sense unless there's at least one byte
10827 of data in this reply. */
10828 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10829 error (_("Remote qXfer reply contained no data."));
10831 /* Got some data. */
10832 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
10833 packet_len
- 1, readbuf
, n
);
10835 /* 'l' is an EOF marker, possibly including a final block of data,
10836 or possibly empty. If we have the final block of a non-empty
10837 object, record this fact to bypass a subsequent partial read. */
10838 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10840 rs
->finished_object
= xstrdup (object_name
);
10841 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10842 rs
->finished_offset
= offset
+ i
;
10846 return TARGET_XFER_EOF
;
10850 return TARGET_XFER_OK
;
10854 enum target_xfer_status
10855 remote_target::xfer_partial (enum target_object object
,
10856 const char *annex
, gdb_byte
*readbuf
,
10857 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10858 ULONGEST
*xfered_len
)
10860 struct remote_state
*rs
;
10864 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10866 set_remote_traceframe ();
10867 set_general_thread (inferior_ptid
);
10869 rs
= get_remote_state ();
10871 /* Handle memory using the standard memory routines. */
10872 if (object
== TARGET_OBJECT_MEMORY
)
10874 /* If the remote target is connected but not running, we should
10875 pass this request down to a lower stratum (e.g. the executable
10877 if (!target_has_execution
)
10878 return TARGET_XFER_EOF
;
10880 if (writebuf
!= NULL
)
10881 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10884 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
10888 /* Handle extra signal info using qxfer packets. */
10889 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10892 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
10893 xfered_len
, &remote_protocol_packets
10894 [PACKET_qXfer_siginfo_read
]);
10896 return remote_write_qxfer ("siginfo", annex
,
10897 writebuf
, offset
, len
, xfered_len
,
10898 &remote_protocol_packets
10899 [PACKET_qXfer_siginfo_write
]);
10902 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10905 return remote_read_qxfer ("statictrace", annex
,
10906 readbuf
, offset
, len
, xfered_len
,
10907 &remote_protocol_packets
10908 [PACKET_qXfer_statictrace_read
]);
10910 return TARGET_XFER_E_IO
;
10913 /* Only handle flash writes. */
10914 if (writebuf
!= NULL
)
10918 case TARGET_OBJECT_FLASH
:
10919 return remote_flash_write (offset
, len
, xfered_len
,
10923 return TARGET_XFER_E_IO
;
10927 /* Map pre-existing objects onto letters. DO NOT do this for new
10928 objects!!! Instead specify new query packets. */
10931 case TARGET_OBJECT_AVR
:
10935 case TARGET_OBJECT_AUXV
:
10936 gdb_assert (annex
== NULL
);
10937 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
10939 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10941 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10942 return remote_read_qxfer
10943 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
10944 &remote_protocol_packets
[PACKET_qXfer_features
]);
10946 case TARGET_OBJECT_LIBRARIES
:
10947 return remote_read_qxfer
10948 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10949 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10951 case TARGET_OBJECT_LIBRARIES_SVR4
:
10952 return remote_read_qxfer
10953 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10954 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10956 case TARGET_OBJECT_MEMORY_MAP
:
10957 gdb_assert (annex
== NULL
);
10958 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
10960 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10962 case TARGET_OBJECT_OSDATA
:
10963 /* Should only get here if we're connected. */
10964 gdb_assert (rs
->remote_desc
);
10965 return remote_read_qxfer
10966 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
10967 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
10969 case TARGET_OBJECT_THREADS
:
10970 gdb_assert (annex
== NULL
);
10971 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
10973 &remote_protocol_packets
[PACKET_qXfer_threads
]);
10975 case TARGET_OBJECT_TRACEFRAME_INFO
:
10976 gdb_assert (annex
== NULL
);
10977 return remote_read_qxfer
10978 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
10979 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
10981 case TARGET_OBJECT_FDPIC
:
10982 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
10984 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
10986 case TARGET_OBJECT_OPENVMS_UIB
:
10987 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
10989 &remote_protocol_packets
[PACKET_qXfer_uib
]);
10991 case TARGET_OBJECT_BTRACE
:
10992 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
10994 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
10996 case TARGET_OBJECT_BTRACE_CONF
:
10997 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
10999 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
11001 case TARGET_OBJECT_EXEC_FILE
:
11002 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
11004 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
11007 return TARGET_XFER_E_IO
;
11010 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
11011 large enough let the caller deal with it. */
11012 if (len
< get_remote_packet_size ())
11013 return TARGET_XFER_E_IO
;
11014 len
= get_remote_packet_size ();
11016 /* Except for querying the minimum buffer size, target must be open. */
11017 if (!rs
->remote_desc
)
11018 error (_("remote query is only available after target open"));
11020 gdb_assert (annex
!= NULL
);
11021 gdb_assert (readbuf
!= NULL
);
11023 p2
= rs
->buf
.data ();
11025 *p2
++ = query_type
;
11027 /* We used one buffer char for the remote protocol q command and
11028 another for the query type. As the remote protocol encapsulation
11029 uses 4 chars plus one extra in case we are debugging
11030 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11033 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11035 /* Bad caller may have sent forbidden characters. */
11036 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11041 gdb_assert (annex
[i
] == '\0');
11043 i
= putpkt (rs
->buf
);
11045 return TARGET_XFER_E_IO
;
11047 getpkt (&rs
->buf
, 0);
11048 strcpy ((char *) readbuf
, rs
->buf
.data ());
11050 *xfered_len
= strlen ((char *) readbuf
);
11051 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11054 /* Implementation of to_get_memory_xfer_limit. */
11057 remote_target::get_memory_xfer_limit ()
11059 return get_memory_write_packet_size ();
11063 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11064 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11065 CORE_ADDR
*found_addrp
)
11067 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11068 struct remote_state
*rs
= get_remote_state ();
11069 int max_size
= get_memory_write_packet_size ();
11070 struct packet_config
*packet
=
11071 &remote_protocol_packets
[PACKET_qSearch_memory
];
11072 /* Number of packet bytes used to encode the pattern;
11073 this could be more than PATTERN_LEN due to escape characters. */
11074 int escaped_pattern_len
;
11075 /* Amount of pattern that was encodable in the packet. */
11076 int used_pattern_len
;
11079 ULONGEST found_addr
;
11081 /* Don't go to the target if we don't have to. This is done before
11082 checking packet_config_support to avoid the possibility that a
11083 success for this edge case means the facility works in
11085 if (pattern_len
> search_space_len
)
11087 if (pattern_len
== 0)
11089 *found_addrp
= start_addr
;
11093 /* If we already know the packet isn't supported, fall back to the simple
11094 way of searching memory. */
11096 if (packet_config_support (packet
) == PACKET_DISABLE
)
11098 /* Target doesn't provided special support, fall back and use the
11099 standard support (copy memory and do the search here). */
11100 return simple_search_memory (this, start_addr
, search_space_len
,
11101 pattern
, pattern_len
, found_addrp
);
11104 /* Make sure the remote is pointing at the right process. */
11105 set_general_process ();
11107 /* Insert header. */
11108 i
= snprintf (rs
->buf
.data (), max_size
,
11109 "qSearch:memory:%s;%s;",
11110 phex_nz (start_addr
, addr_size
),
11111 phex_nz (search_space_len
, sizeof (search_space_len
)));
11112 max_size
-= (i
+ 1);
11114 /* Escape as much data as fits into rs->buf. */
11115 escaped_pattern_len
=
11116 remote_escape_output (pattern
, pattern_len
, 1,
11117 (gdb_byte
*) rs
->buf
.data () + i
,
11118 &used_pattern_len
, max_size
);
11120 /* Bail if the pattern is too large. */
11121 if (used_pattern_len
!= pattern_len
)
11122 error (_("Pattern is too large to transmit to remote target."));
11124 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11125 || getpkt_sane (&rs
->buf
, 0) < 0
11126 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11128 /* The request may not have worked because the command is not
11129 supported. If so, fall back to the simple way. */
11130 if (packet_config_support (packet
) == PACKET_DISABLE
)
11132 return simple_search_memory (this, start_addr
, search_space_len
,
11133 pattern
, pattern_len
, found_addrp
);
11138 if (rs
->buf
[0] == '0')
11140 else if (rs
->buf
[0] == '1')
11143 if (rs
->buf
[1] != ',')
11144 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11145 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11146 *found_addrp
= found_addr
;
11149 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11155 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11157 struct remote_state
*rs
= get_remote_state ();
11158 char *p
= rs
->buf
.data ();
11160 if (!rs
->remote_desc
)
11161 error (_("remote rcmd is only available after target open"));
11163 /* Send a NULL command across as an empty command. */
11164 if (command
== NULL
)
11167 /* The query prefix. */
11168 strcpy (rs
->buf
.data (), "qRcmd,");
11169 p
= strchr (rs
->buf
.data (), '\0');
11171 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11172 > get_remote_packet_size ())
11173 error (_("\"monitor\" command ``%s'' is too long."), command
);
11175 /* Encode the actual command. */
11176 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11178 if (putpkt (rs
->buf
) < 0)
11179 error (_("Communication problem with target."));
11181 /* get/display the response */
11186 /* XXX - see also remote_get_noisy_reply(). */
11187 QUIT
; /* Allow user to bail out with ^C. */
11189 if (getpkt_sane (&rs
->buf
, 0) == -1)
11191 /* Timeout. Continue to (try to) read responses.
11192 This is better than stopping with an error, assuming the stub
11193 is still executing the (long) monitor command.
11194 If needed, the user can interrupt gdb using C-c, obtaining
11195 an effect similar to stop on timeout. */
11198 buf
= rs
->buf
.data ();
11199 if (buf
[0] == '\0')
11200 error (_("Target does not support this command."));
11201 if (buf
[0] == 'O' && buf
[1] != 'K')
11203 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11206 if (strcmp (buf
, "OK") == 0)
11208 if (strlen (buf
) == 3 && buf
[0] == 'E'
11209 && isdigit (buf
[1]) && isdigit (buf
[2]))
11211 error (_("Protocol error with Rcmd"));
11213 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11215 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11217 fputc_unfiltered (c
, outbuf
);
11223 std::vector
<mem_region
>
11224 remote_target::memory_map ()
11226 std::vector
<mem_region
> result
;
11227 gdb::optional
<gdb::char_vector
> text
11228 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11231 result
= parse_memory_map (text
->data ());
11237 packet_command (const char *args
, int from_tty
)
11239 remote_target
*remote
= get_current_remote_target ();
11241 if (remote
== nullptr)
11242 error (_("command can only be used with remote target"));
11244 remote
->packet_command (args
, from_tty
);
11248 remote_target::packet_command (const char *args
, int from_tty
)
11251 error (_("remote-packet command requires packet text as argument"));
11253 puts_filtered ("sending: ");
11254 print_packet (args
);
11255 puts_filtered ("\n");
11258 remote_state
*rs
= get_remote_state ();
11260 getpkt (&rs
->buf
, 0);
11261 puts_filtered ("received: ");
11262 print_packet (rs
->buf
.data ());
11263 puts_filtered ("\n");
11267 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11269 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11271 static void threadset_test_cmd (char *cmd
, int tty
);
11273 static void threadalive_test (char *cmd
, int tty
);
11275 static void threadlist_test_cmd (char *cmd
, int tty
);
11277 int get_and_display_threadinfo (threadref
*ref
);
11279 static void threadinfo_test_cmd (char *cmd
, int tty
);
11281 static int thread_display_step (threadref
*ref
, void *context
);
11283 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11285 static void init_remote_threadtests (void);
11287 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11290 threadset_test_cmd (const char *cmd
, int tty
)
11292 int sample_thread
= SAMPLE_THREAD
;
11294 printf_filtered (_("Remote threadset test\n"));
11295 set_general_thread (sample_thread
);
11300 threadalive_test (const char *cmd
, int tty
)
11302 int sample_thread
= SAMPLE_THREAD
;
11303 int pid
= inferior_ptid
.pid ();
11304 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11306 if (remote_thread_alive (ptid
))
11307 printf_filtered ("PASS: Thread alive test\n");
11309 printf_filtered ("FAIL: Thread alive test\n");
11312 void output_threadid (char *title
, threadref
*ref
);
11315 output_threadid (char *title
, threadref
*ref
)
11319 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11321 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11325 threadlist_test_cmd (const char *cmd
, int tty
)
11328 threadref nextthread
;
11329 int done
, result_count
;
11330 threadref threadlist
[3];
11332 printf_filtered ("Remote Threadlist test\n");
11333 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11334 &result_count
, &threadlist
[0]))
11335 printf_filtered ("FAIL: threadlist test\n");
11338 threadref
*scan
= threadlist
;
11339 threadref
*limit
= scan
+ result_count
;
11341 while (scan
< limit
)
11342 output_threadid (" thread ", scan
++);
11347 display_thread_info (struct gdb_ext_thread_info
*info
)
11349 output_threadid ("Threadid: ", &info
->threadid
);
11350 printf_filtered ("Name: %s\n ", info
->shortname
);
11351 printf_filtered ("State: %s\n", info
->display
);
11352 printf_filtered ("other: %s\n\n", info
->more_display
);
11356 get_and_display_threadinfo (threadref
*ref
)
11360 struct gdb_ext_thread_info threadinfo
;
11362 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11363 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11364 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11365 display_thread_info (&threadinfo
);
11370 threadinfo_test_cmd (const char *cmd
, int tty
)
11372 int athread
= SAMPLE_THREAD
;
11376 int_to_threadref (&thread
, athread
);
11377 printf_filtered ("Remote Threadinfo test\n");
11378 if (!get_and_display_threadinfo (&thread
))
11379 printf_filtered ("FAIL cannot get thread info\n");
11383 thread_display_step (threadref
*ref
, void *context
)
11385 /* output_threadid(" threadstep ",ref); *//* simple test */
11386 return get_and_display_threadinfo (ref
);
11390 threadlist_update_test_cmd (const char *cmd
, int tty
)
11392 printf_filtered ("Remote Threadlist update test\n");
11393 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11397 init_remote_threadtests (void)
11399 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11400 _("Fetch and print the remote list of "
11401 "thread identifiers, one pkt only."));
11402 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11403 _("Fetch and display info about one thread."));
11404 add_com ("tset", class_obscure
, threadset_test_cmd
,
11405 _("Test setting to a different thread."));
11406 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11407 _("Iterate through updating all remote thread info."));
11408 add_com ("talive", class_obscure
, threadalive_test
,
11409 _("Remote thread alive test."));
11414 /* Convert a thread ID to a string. */
11417 remote_target::pid_to_str (ptid_t ptid
)
11419 struct remote_state
*rs
= get_remote_state ();
11421 if (ptid
== null_ptid
)
11422 return normal_pid_to_str (ptid
);
11423 else if (ptid
.is_pid ())
11425 /* Printing an inferior target id. */
11427 /* When multi-process extensions are off, there's no way in the
11428 remote protocol to know the remote process id, if there's any
11429 at all. There's one exception --- when we're connected with
11430 target extended-remote, and we manually attached to a process
11431 with "attach PID". We don't record anywhere a flag that
11432 allows us to distinguish that case from the case of
11433 connecting with extended-remote and the stub already being
11434 attached to a process, and reporting yes to qAttached, hence
11435 no smart special casing here. */
11436 if (!remote_multi_process_p (rs
))
11437 return "Remote target";
11439 return normal_pid_to_str (ptid
);
11443 if (magic_null_ptid
== ptid
)
11444 return "Thread <main>";
11445 else if (remote_multi_process_p (rs
))
11446 if (ptid
.lwp () == 0)
11447 return normal_pid_to_str (ptid
);
11449 return string_printf ("Thread %d.%ld",
11450 ptid
.pid (), ptid
.lwp ());
11452 return string_printf ("Thread %ld", ptid
.lwp ());
11456 /* Get the address of the thread local variable in OBJFILE which is
11457 stored at OFFSET within the thread local storage for thread PTID. */
11460 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11463 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11465 struct remote_state
*rs
= get_remote_state ();
11466 char *p
= rs
->buf
.data ();
11467 char *endp
= p
+ get_remote_packet_size ();
11468 enum packet_result result
;
11470 strcpy (p
, "qGetTLSAddr:");
11472 p
= write_ptid (p
, endp
, ptid
);
11474 p
+= hexnumstr (p
, offset
);
11476 p
+= hexnumstr (p
, lm
);
11480 getpkt (&rs
->buf
, 0);
11481 result
= packet_ok (rs
->buf
,
11482 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11483 if (result
== PACKET_OK
)
11487 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11490 else if (result
== PACKET_UNKNOWN
)
11491 throw_error (TLS_GENERIC_ERROR
,
11492 _("Remote target doesn't support qGetTLSAddr packet"));
11494 throw_error (TLS_GENERIC_ERROR
,
11495 _("Remote target failed to process qGetTLSAddr request"));
11498 throw_error (TLS_GENERIC_ERROR
,
11499 _("TLS not supported or disabled on this target"));
11504 /* Provide thread local base, i.e. Thread Information Block address.
11505 Returns 1 if ptid is found and thread_local_base is non zero. */
11508 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11510 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11512 struct remote_state
*rs
= get_remote_state ();
11513 char *p
= rs
->buf
.data ();
11514 char *endp
= p
+ get_remote_packet_size ();
11515 enum packet_result result
;
11517 strcpy (p
, "qGetTIBAddr:");
11519 p
= write_ptid (p
, endp
, ptid
);
11523 getpkt (&rs
->buf
, 0);
11524 result
= packet_ok (rs
->buf
,
11525 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11526 if (result
== PACKET_OK
)
11529 unpack_varlen_hex (rs
->buf
.data (), &val
);
11531 *addr
= (CORE_ADDR
) val
;
11534 else if (result
== PACKET_UNKNOWN
)
11535 error (_("Remote target doesn't support qGetTIBAddr packet"));
11537 error (_("Remote target failed to process qGetTIBAddr request"));
11540 error (_("qGetTIBAddr not supported or disabled on this target"));
11545 /* Support for inferring a target description based on the current
11546 architecture and the size of a 'g' packet. While the 'g' packet
11547 can have any size (since optional registers can be left off the
11548 end), some sizes are easily recognizable given knowledge of the
11549 approximate architecture. */
11551 struct remote_g_packet_guess
11553 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11560 const struct target_desc
*tdesc
;
11563 struct remote_g_packet_data
: public allocate_on_obstack
11565 std::vector
<remote_g_packet_guess
> guesses
;
11568 static struct gdbarch_data
*remote_g_packet_data_handle
;
11571 remote_g_packet_data_init (struct obstack
*obstack
)
11573 return new (obstack
) remote_g_packet_data
;
11577 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11578 const struct target_desc
*tdesc
)
11580 struct remote_g_packet_data
*data
11581 = ((struct remote_g_packet_data
*)
11582 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11584 gdb_assert (tdesc
!= NULL
);
11586 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11587 if (guess
.bytes
== bytes
)
11588 internal_error (__FILE__
, __LINE__
,
11589 _("Duplicate g packet description added for size %d"),
11592 data
->guesses
.emplace_back (bytes
, tdesc
);
11595 /* Return true if remote_read_description would do anything on this target
11596 and architecture, false otherwise. */
11599 remote_read_description_p (struct target_ops
*target
)
11601 struct remote_g_packet_data
*data
11602 = ((struct remote_g_packet_data
*)
11603 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11605 return !data
->guesses
.empty ();
11608 const struct target_desc
*
11609 remote_target::read_description ()
11611 struct remote_g_packet_data
*data
11612 = ((struct remote_g_packet_data
*)
11613 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11615 /* Do not try this during initial connection, when we do not know
11616 whether there is a running but stopped thread. */
11617 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
11618 return beneath ()->read_description ();
11620 if (!data
->guesses
.empty ())
11622 int bytes
= send_g_packet ();
11624 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11625 if (guess
.bytes
== bytes
)
11626 return guess
.tdesc
;
11628 /* We discard the g packet. A minor optimization would be to
11629 hold on to it, and fill the register cache once we have selected
11630 an architecture, but it's too tricky to do safely. */
11633 return beneath ()->read_description ();
11636 /* Remote file transfer support. This is host-initiated I/O, not
11637 target-initiated; for target-initiated, see remote-fileio.c. */
11639 /* If *LEFT is at least the length of STRING, copy STRING to
11640 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11641 decrease *LEFT. Otherwise raise an error. */
11644 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11646 int len
= strlen (string
);
11649 error (_("Packet too long for target."));
11651 memcpy (*buffer
, string
, len
);
11655 /* NUL-terminate the buffer as a convenience, if there is
11661 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11662 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11663 decrease *LEFT. Otherwise raise an error. */
11666 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11669 if (2 * len
> *left
)
11670 error (_("Packet too long for target."));
11672 bin2hex (bytes
, *buffer
, len
);
11673 *buffer
+= 2 * len
;
11676 /* NUL-terminate the buffer as a convenience, if there is
11682 /* If *LEFT is large enough, convert VALUE to hex and add it to
11683 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11684 decrease *LEFT. Otherwise raise an error. */
11687 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11689 int len
= hexnumlen (value
);
11692 error (_("Packet too long for target."));
11694 hexnumstr (*buffer
, value
);
11698 /* NUL-terminate the buffer as a convenience, if there is
11704 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11705 value, *REMOTE_ERRNO to the remote error number or zero if none
11706 was included, and *ATTACHMENT to point to the start of the annex
11707 if any. The length of the packet isn't needed here; there may
11708 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11710 Return 0 if the packet could be parsed, -1 if it could not. If
11711 -1 is returned, the other variables may not be initialized. */
11714 remote_hostio_parse_result (char *buffer
, int *retcode
,
11715 int *remote_errno
, char **attachment
)
11720 *attachment
= NULL
;
11722 if (buffer
[0] != 'F')
11726 *retcode
= strtol (&buffer
[1], &p
, 16);
11727 if (errno
!= 0 || p
== &buffer
[1])
11730 /* Check for ",errno". */
11734 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11735 if (errno
!= 0 || p
+ 1 == p2
)
11740 /* Check for ";attachment". If there is no attachment, the
11741 packet should end here. */
11744 *attachment
= p
+ 1;
11747 else if (*p
== '\0')
11753 /* Send a prepared I/O packet to the target and read its response.
11754 The prepared packet is in the global RS->BUF before this function
11755 is called, and the answer is there when we return.
11757 COMMAND_BYTES is the length of the request to send, which may include
11758 binary data. WHICH_PACKET is the packet configuration to check
11759 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11760 is set to the error number and -1 is returned. Otherwise the value
11761 returned by the function is returned.
11763 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11764 attachment is expected; an error will be reported if there's a
11765 mismatch. If one is found, *ATTACHMENT will be set to point into
11766 the packet buffer and *ATTACHMENT_LEN will be set to the
11767 attachment's length. */
11770 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11771 int *remote_errno
, char **attachment
,
11772 int *attachment_len
)
11774 struct remote_state
*rs
= get_remote_state ();
11775 int ret
, bytes_read
;
11776 char *attachment_tmp
;
11778 if (packet_support (which_packet
) == PACKET_DISABLE
)
11780 *remote_errno
= FILEIO_ENOSYS
;
11784 putpkt_binary (rs
->buf
.data (), command_bytes
);
11785 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11787 /* If it timed out, something is wrong. Don't try to parse the
11789 if (bytes_read
< 0)
11791 *remote_errno
= FILEIO_EINVAL
;
11795 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11798 *remote_errno
= FILEIO_EINVAL
;
11800 case PACKET_UNKNOWN
:
11801 *remote_errno
= FILEIO_ENOSYS
;
11807 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
11810 *remote_errno
= FILEIO_EINVAL
;
11814 /* Make sure we saw an attachment if and only if we expected one. */
11815 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11816 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11818 *remote_errno
= FILEIO_EINVAL
;
11822 /* If an attachment was found, it must point into the packet buffer;
11823 work out how many bytes there were. */
11824 if (attachment_tmp
!= NULL
)
11826 *attachment
= attachment_tmp
;
11827 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
11833 /* See declaration.h. */
11836 readahead_cache::invalidate ()
11841 /* See declaration.h. */
11844 readahead_cache::invalidate_fd (int fd
)
11846 if (this->fd
== fd
)
11850 /* Set the filesystem remote_hostio functions that take FILENAME
11851 arguments will use. Return 0 on success, or -1 if an error
11852 occurs (and set *REMOTE_ERRNO). */
11855 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
11858 struct remote_state
*rs
= get_remote_state ();
11859 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11860 char *p
= rs
->buf
.data ();
11861 int left
= get_remote_packet_size () - 1;
11865 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11868 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11871 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11873 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11874 remote_buffer_add_string (&p
, &left
, arg
);
11876 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
11877 remote_errno
, NULL
, NULL
);
11879 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11883 rs
->fs_pid
= required_pid
;
11888 /* Implementation of to_fileio_open. */
11891 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
11892 int flags
, int mode
, int warn_if_slow
,
11895 struct remote_state
*rs
= get_remote_state ();
11896 char *p
= rs
->buf
.data ();
11897 int left
= get_remote_packet_size () - 1;
11901 static int warning_issued
= 0;
11903 printf_unfiltered (_("Reading %s from remote target...\n"),
11906 if (!warning_issued
)
11908 warning (_("File transfers from remote targets can be slow."
11909 " Use \"set sysroot\" to access files locally"
11911 warning_issued
= 1;
11915 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11918 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11920 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11921 strlen (filename
));
11922 remote_buffer_add_string (&p
, &left
, ",");
11924 remote_buffer_add_int (&p
, &left
, flags
);
11925 remote_buffer_add_string (&p
, &left
, ",");
11927 remote_buffer_add_int (&p
, &left
, mode
);
11929 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
11930 remote_errno
, NULL
, NULL
);
11934 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
11935 int flags
, int mode
, int warn_if_slow
,
11938 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
11942 /* Implementation of to_fileio_pwrite. */
11945 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11946 ULONGEST offset
, int *remote_errno
)
11948 struct remote_state
*rs
= get_remote_state ();
11949 char *p
= rs
->buf
.data ();
11950 int left
= get_remote_packet_size ();
11953 rs
->readahead_cache
.invalidate_fd (fd
);
11955 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11957 remote_buffer_add_int (&p
, &left
, fd
);
11958 remote_buffer_add_string (&p
, &left
, ",");
11960 remote_buffer_add_int (&p
, &left
, offset
);
11961 remote_buffer_add_string (&p
, &left
, ",");
11963 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
11964 (get_remote_packet_size ()
11965 - (p
- rs
->buf
.data ())));
11967 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
11968 remote_errno
, NULL
, NULL
);
11972 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11973 ULONGEST offset
, int *remote_errno
)
11975 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
11978 /* Helper for the implementation of to_fileio_pread. Read the file
11979 from the remote side with vFile:pread. */
11982 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
11983 ULONGEST offset
, int *remote_errno
)
11985 struct remote_state
*rs
= get_remote_state ();
11986 char *p
= rs
->buf
.data ();
11988 int left
= get_remote_packet_size ();
11989 int ret
, attachment_len
;
11992 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
11994 remote_buffer_add_int (&p
, &left
, fd
);
11995 remote_buffer_add_string (&p
, &left
, ",");
11997 remote_buffer_add_int (&p
, &left
, len
);
11998 remote_buffer_add_string (&p
, &left
, ",");
12000 remote_buffer_add_int (&p
, &left
, offset
);
12002 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
12003 remote_errno
, &attachment
,
12009 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12011 if (read_len
!= ret
)
12012 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
12017 /* See declaration.h. */
12020 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12024 && this->offset
<= offset
12025 && offset
< this->offset
+ this->bufsize
)
12027 ULONGEST max
= this->offset
+ this->bufsize
;
12029 if (offset
+ len
> max
)
12030 len
= max
- offset
;
12032 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12039 /* Implementation of to_fileio_pread. */
12042 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12043 ULONGEST offset
, int *remote_errno
)
12046 struct remote_state
*rs
= get_remote_state ();
12047 readahead_cache
*cache
= &rs
->readahead_cache
;
12049 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12052 cache
->hit_count
++;
12055 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12056 pulongest (cache
->hit_count
));
12060 cache
->miss_count
++;
12062 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12063 pulongest (cache
->miss_count
));
12066 cache
->offset
= offset
;
12067 cache
->bufsize
= get_remote_packet_size ();
12068 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12070 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12071 cache
->offset
, remote_errno
);
12074 cache
->invalidate_fd (fd
);
12078 cache
->bufsize
= ret
;
12079 return cache
->pread (fd
, read_buf
, len
, offset
);
12083 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12084 ULONGEST offset
, int *remote_errno
)
12086 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12089 /* Implementation of to_fileio_close. */
12092 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12094 struct remote_state
*rs
= get_remote_state ();
12095 char *p
= rs
->buf
.data ();
12096 int left
= get_remote_packet_size () - 1;
12098 rs
->readahead_cache
.invalidate_fd (fd
);
12100 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12102 remote_buffer_add_int (&p
, &left
, fd
);
12104 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12105 remote_errno
, NULL
, NULL
);
12109 remote_target::fileio_close (int fd
, int *remote_errno
)
12111 return remote_hostio_close (fd
, remote_errno
);
12114 /* Implementation of to_fileio_unlink. */
12117 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12120 struct remote_state
*rs
= get_remote_state ();
12121 char *p
= rs
->buf
.data ();
12122 int left
= get_remote_packet_size () - 1;
12124 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12127 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12129 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12130 strlen (filename
));
12132 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12133 remote_errno
, NULL
, NULL
);
12137 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12140 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12143 /* Implementation of to_fileio_readlink. */
12145 gdb::optional
<std::string
>
12146 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12149 struct remote_state
*rs
= get_remote_state ();
12150 char *p
= rs
->buf
.data ();
12152 int left
= get_remote_packet_size ();
12153 int len
, attachment_len
;
12156 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12159 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12161 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12162 strlen (filename
));
12164 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12165 remote_errno
, &attachment
,
12171 std::string
ret (len
, '\0');
12173 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12174 (gdb_byte
*) &ret
[0], len
);
12175 if (read_len
!= len
)
12176 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12181 /* Implementation of to_fileio_fstat. */
12184 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12186 struct remote_state
*rs
= get_remote_state ();
12187 char *p
= rs
->buf
.data ();
12188 int left
= get_remote_packet_size ();
12189 int attachment_len
, ret
;
12191 struct fio_stat fst
;
12194 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12196 remote_buffer_add_int (&p
, &left
, fd
);
12198 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12199 remote_errno
, &attachment
,
12203 if (*remote_errno
!= FILEIO_ENOSYS
)
12206 /* Strictly we should return -1, ENOSYS here, but when
12207 "set sysroot remote:" was implemented in August 2008
12208 BFD's need for a stat function was sidestepped with
12209 this hack. This was not remedied until March 2015
12210 so we retain the previous behavior to avoid breaking
12213 Note that the memset is a March 2015 addition; older
12214 GDBs set st_size *and nothing else* so the structure
12215 would have garbage in all other fields. This might
12216 break something but retaining the previous behavior
12217 here would be just too wrong. */
12219 memset (st
, 0, sizeof (struct stat
));
12220 st
->st_size
= INT_MAX
;
12224 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12225 (gdb_byte
*) &fst
, sizeof (fst
));
12227 if (read_len
!= ret
)
12228 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12230 if (read_len
!= sizeof (fst
))
12231 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12232 read_len
, (int) sizeof (fst
));
12234 remote_fileio_to_host_stat (&fst
, st
);
12239 /* Implementation of to_filesystem_is_local. */
12242 remote_target::filesystem_is_local ()
12244 /* Valgrind GDB presents itself as a remote target but works
12245 on the local filesystem: it does not implement remote get
12246 and users are not expected to set a sysroot. To handle
12247 this case we treat the remote filesystem as local if the
12248 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12249 does not support vFile:open. */
12250 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12252 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12254 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12256 int fd
, remote_errno
;
12258 /* Try opening a file to probe support. The supplied
12259 filename is irrelevant, we only care about whether
12260 the stub recognizes the packet or not. */
12261 fd
= remote_hostio_open (NULL
, "just probing",
12262 FILEIO_O_RDONLY
, 0700, 0,
12266 remote_hostio_close (fd
, &remote_errno
);
12268 ps
= packet_support (PACKET_vFile_open
);
12271 if (ps
== PACKET_DISABLE
)
12273 static int warning_issued
= 0;
12275 if (!warning_issued
)
12277 warning (_("remote target does not support file"
12278 " transfer, attempting to access files"
12279 " from local filesystem."));
12280 warning_issued
= 1;
12291 remote_fileio_errno_to_host (int errnum
)
12297 case FILEIO_ENOENT
:
12305 case FILEIO_EACCES
:
12307 case FILEIO_EFAULT
:
12311 case FILEIO_EEXIST
:
12313 case FILEIO_ENODEV
:
12315 case FILEIO_ENOTDIR
:
12317 case FILEIO_EISDIR
:
12319 case FILEIO_EINVAL
:
12321 case FILEIO_ENFILE
:
12323 case FILEIO_EMFILE
:
12327 case FILEIO_ENOSPC
:
12329 case FILEIO_ESPIPE
:
12333 case FILEIO_ENOSYS
:
12335 case FILEIO_ENAMETOOLONG
:
12336 return ENAMETOOLONG
;
12342 remote_hostio_error (int errnum
)
12344 int host_error
= remote_fileio_errno_to_host (errnum
);
12346 if (host_error
== -1)
12347 error (_("Unknown remote I/O error %d"), errnum
);
12349 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12352 /* A RAII wrapper around a remote file descriptor. */
12354 class scoped_remote_fd
12357 scoped_remote_fd (remote_target
*remote
, int fd
)
12358 : m_remote (remote
), m_fd (fd
)
12362 ~scoped_remote_fd ()
12369 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12373 /* Swallow exception before it escapes the dtor. If
12374 something goes wrong, likely the connection is gone,
12375 and there's nothing else that can be done. */
12380 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12382 /* Release ownership of the file descriptor, and return it. */
12383 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12390 /* Return the owned file descriptor. */
12391 int get () const noexcept
12397 /* The remote target. */
12398 remote_target
*m_remote
;
12400 /* The owned remote I/O file descriptor. */
12405 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12407 remote_target
*remote
= get_current_remote_target ();
12409 if (remote
== nullptr)
12410 error (_("command can only be used with remote target"));
12412 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12416 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12419 int retcode
, remote_errno
, bytes
, io_size
;
12420 int bytes_in_buffer
;
12424 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12426 perror_with_name (local_file
);
12428 scoped_remote_fd fd
12429 (this, remote_hostio_open (NULL
,
12430 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12432 0700, 0, &remote_errno
));
12433 if (fd
.get () == -1)
12434 remote_hostio_error (remote_errno
);
12436 /* Send up to this many bytes at once. They won't all fit in the
12437 remote packet limit, so we'll transfer slightly fewer. */
12438 io_size
= get_remote_packet_size ();
12439 gdb::byte_vector
buffer (io_size
);
12441 bytes_in_buffer
= 0;
12444 while (bytes_in_buffer
|| !saw_eof
)
12448 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12449 io_size
- bytes_in_buffer
,
12453 if (ferror (file
.get ()))
12454 error (_("Error reading %s."), local_file
);
12457 /* EOF. Unless there is something still in the
12458 buffer from the last iteration, we are done. */
12460 if (bytes_in_buffer
== 0)
12468 bytes
+= bytes_in_buffer
;
12469 bytes_in_buffer
= 0;
12471 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12472 offset
, &remote_errno
);
12475 remote_hostio_error (remote_errno
);
12476 else if (retcode
== 0)
12477 error (_("Remote write of %d bytes returned 0!"), bytes
);
12478 else if (retcode
< bytes
)
12480 /* Short write. Save the rest of the read data for the next
12482 bytes_in_buffer
= bytes
- retcode
;
12483 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12489 if (remote_hostio_close (fd
.release (), &remote_errno
))
12490 remote_hostio_error (remote_errno
);
12493 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12497 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12499 remote_target
*remote
= get_current_remote_target ();
12501 if (remote
== nullptr)
12502 error (_("command can only be used with remote target"));
12504 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12508 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12511 int remote_errno
, bytes
, io_size
;
12514 scoped_remote_fd fd
12515 (this, remote_hostio_open (NULL
,
12516 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12518 if (fd
.get () == -1)
12519 remote_hostio_error (remote_errno
);
12521 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12523 perror_with_name (local_file
);
12525 /* Send up to this many bytes at once. They won't all fit in the
12526 remote packet limit, so we'll transfer slightly fewer. */
12527 io_size
= get_remote_packet_size ();
12528 gdb::byte_vector
buffer (io_size
);
12533 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12536 /* Success, but no bytes, means end-of-file. */
12539 remote_hostio_error (remote_errno
);
12543 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12545 perror_with_name (local_file
);
12548 if (remote_hostio_close (fd
.release (), &remote_errno
))
12549 remote_hostio_error (remote_errno
);
12552 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12556 remote_file_delete (const char *remote_file
, int from_tty
)
12558 remote_target
*remote
= get_current_remote_target ();
12560 if (remote
== nullptr)
12561 error (_("command can only be used with remote target"));
12563 remote
->remote_file_delete (remote_file
, from_tty
);
12567 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12569 int retcode
, remote_errno
;
12571 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12573 remote_hostio_error (remote_errno
);
12576 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12580 remote_put_command (const char *args
, int from_tty
)
12583 error_no_arg (_("file to put"));
12585 gdb_argv
argv (args
);
12586 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12587 error (_("Invalid parameters to remote put"));
12589 remote_file_put (argv
[0], argv
[1], from_tty
);
12593 remote_get_command (const char *args
, int from_tty
)
12596 error_no_arg (_("file to get"));
12598 gdb_argv
argv (args
);
12599 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12600 error (_("Invalid parameters to remote get"));
12602 remote_file_get (argv
[0], argv
[1], from_tty
);
12606 remote_delete_command (const char *args
, int from_tty
)
12609 error_no_arg (_("file to delete"));
12611 gdb_argv
argv (args
);
12612 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12613 error (_("Invalid parameters to remote delete"));
12615 remote_file_delete (argv
[0], from_tty
);
12619 remote_command (const char *args
, int from_tty
)
12621 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12625 remote_target::can_execute_reverse ()
12627 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12628 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12635 remote_target::supports_non_stop ()
12641 remote_target::supports_disable_randomization ()
12643 /* Only supported in extended mode. */
12648 remote_target::supports_multi_process ()
12650 struct remote_state
*rs
= get_remote_state ();
12652 return remote_multi_process_p (rs
);
12656 remote_supports_cond_tracepoints ()
12658 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12662 remote_target::supports_evaluation_of_breakpoint_conditions ()
12664 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12668 remote_supports_fast_tracepoints ()
12670 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12674 remote_supports_static_tracepoints ()
12676 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12680 remote_supports_install_in_trace ()
12682 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12686 remote_target::supports_enable_disable_tracepoint ()
12688 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12693 remote_target::supports_string_tracing ()
12695 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12699 remote_target::can_run_breakpoint_commands ()
12701 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12705 remote_target::trace_init ()
12707 struct remote_state
*rs
= get_remote_state ();
12710 remote_get_noisy_reply ();
12711 if (strcmp (rs
->buf
.data (), "OK") != 0)
12712 error (_("Target does not support this command."));
12715 /* Recursive routine to walk through command list including loops, and
12716 download packets for each command. */
12719 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12720 struct command_line
*cmds
)
12722 struct remote_state
*rs
= get_remote_state ();
12723 struct command_line
*cmd
;
12725 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12727 QUIT
; /* Allow user to bail out with ^C. */
12728 strcpy (rs
->buf
.data (), "QTDPsrc:");
12729 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12730 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12731 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12733 remote_get_noisy_reply ();
12734 if (strcmp (rs
->buf
.data (), "OK"))
12735 warning (_("Target does not support source download."));
12737 if (cmd
->control_type
== while_control
12738 || cmd
->control_type
== while_stepping_control
)
12740 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12742 QUIT
; /* Allow user to bail out with ^C. */
12743 strcpy (rs
->buf
.data (), "QTDPsrc:");
12744 encode_source_string (num
, addr
, "cmd", "end",
12745 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12746 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12748 remote_get_noisy_reply ();
12749 if (strcmp (rs
->buf
.data (), "OK"))
12750 warning (_("Target does not support source download."));
12756 remote_target::download_tracepoint (struct bp_location
*loc
)
12760 std::vector
<std::string
> tdp_actions
;
12761 std::vector
<std::string
> stepping_actions
;
12763 struct breakpoint
*b
= loc
->owner
;
12764 struct tracepoint
*t
= (struct tracepoint
*) b
;
12765 struct remote_state
*rs
= get_remote_state ();
12767 const char *err_msg
= _("Tracepoint packet too large for target.");
12770 /* We use a buffer other than rs->buf because we'll build strings
12771 across multiple statements, and other statements in between could
12773 gdb::char_vector
buf (get_remote_packet_size ());
12775 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12777 tpaddr
= loc
->address
;
12778 sprintf_vma (addrbuf
, tpaddr
);
12779 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12780 b
->number
, addrbuf
, /* address */
12781 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12782 t
->step_count
, t
->pass_count
);
12784 if (ret
< 0 || ret
>= buf
.size ())
12785 error ("%s", err_msg
);
12787 /* Fast tracepoints are mostly handled by the target, but we can
12788 tell the target how big of an instruction block should be moved
12790 if (b
->type
== bp_fast_tracepoint
)
12792 /* Only test for support at download time; we may not know
12793 target capabilities at definition time. */
12794 if (remote_supports_fast_tracepoints ())
12796 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12799 size_left
= buf
.size () - strlen (buf
.data ());
12800 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12802 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12804 if (ret
< 0 || ret
>= size_left
)
12805 error ("%s", err_msg
);
12808 /* If it passed validation at definition but fails now,
12809 something is very wrong. */
12810 internal_error (__FILE__
, __LINE__
,
12811 _("Fast tracepoint not "
12812 "valid during download"));
12815 /* Fast tracepoints are functionally identical to regular
12816 tracepoints, so don't take lack of support as a reason to
12817 give up on the trace run. */
12818 warning (_("Target does not support fast tracepoints, "
12819 "downloading %d as regular tracepoint"), b
->number
);
12821 else if (b
->type
== bp_static_tracepoint
)
12823 /* Only test for support at download time; we may not know
12824 target capabilities at definition time. */
12825 if (remote_supports_static_tracepoints ())
12827 struct static_tracepoint_marker marker
;
12829 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12831 size_left
= buf
.size () - strlen (buf
.data ());
12832 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12835 if (ret
< 0 || ret
>= size_left
)
12836 error ("%s", err_msg
);
12839 error (_("Static tracepoint not valid during download"));
12842 /* Fast tracepoints are functionally identical to regular
12843 tracepoints, so don't take lack of support as a reason
12844 to give up on the trace run. */
12845 error (_("Target does not support static tracepoints"));
12847 /* If the tracepoint has a conditional, make it into an agent
12848 expression and append to the definition. */
12851 /* Only test support at download time, we may not know target
12852 capabilities at definition time. */
12853 if (remote_supports_cond_tracepoints ())
12855 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
12858 size_left
= buf
.size () - strlen (buf
.data ());
12860 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12861 size_left
, ":X%x,", aexpr
->len
);
12863 if (ret
< 0 || ret
>= size_left
)
12864 error ("%s", err_msg
);
12866 size_left
= buf
.size () - strlen (buf
.data ());
12868 /* Two bytes to encode each aexpr byte, plus the terminating
12870 if (aexpr
->len
* 2 + 1 > size_left
)
12871 error ("%s", err_msg
);
12873 pkt
= buf
.data () + strlen (buf
.data ());
12875 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12876 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12880 warning (_("Target does not support conditional tracepoints, "
12881 "ignoring tp %d cond"), b
->number
);
12884 if (b
->commands
|| *default_collect
)
12886 size_left
= buf
.size () - strlen (buf
.data ());
12888 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12891 if (ret
< 0 || ret
>= size_left
)
12892 error ("%s", err_msg
);
12895 putpkt (buf
.data ());
12896 remote_get_noisy_reply ();
12897 if (strcmp (rs
->buf
.data (), "OK"))
12898 error (_("Target does not support tracepoints."));
12900 /* do_single_steps (t); */
12901 for (auto action_it
= tdp_actions
.begin ();
12902 action_it
!= tdp_actions
.end (); action_it
++)
12904 QUIT
; /* Allow user to bail out with ^C. */
12906 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
12907 || !stepping_actions
.empty ());
12909 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
12910 b
->number
, addrbuf
, /* address */
12911 action_it
->c_str (),
12912 has_more
? '-' : 0);
12914 if (ret
< 0 || ret
>= buf
.size ())
12915 error ("%s", err_msg
);
12917 putpkt (buf
.data ());
12918 remote_get_noisy_reply ();
12919 if (strcmp (rs
->buf
.data (), "OK"))
12920 error (_("Error on target while setting tracepoints."));
12923 for (auto action_it
= stepping_actions
.begin ();
12924 action_it
!= stepping_actions
.end (); action_it
++)
12926 QUIT
; /* Allow user to bail out with ^C. */
12928 bool is_first
= action_it
== stepping_actions
.begin ();
12929 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
12931 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
12932 b
->number
, addrbuf
, /* address */
12933 is_first
? "S" : "",
12934 action_it
->c_str (),
12935 has_more
? "-" : "");
12937 if (ret
< 0 || ret
>= buf
.size ())
12938 error ("%s", err_msg
);
12940 putpkt (buf
.data ());
12941 remote_get_noisy_reply ();
12942 if (strcmp (rs
->buf
.data (), "OK"))
12943 error (_("Error on target while setting tracepoints."));
12946 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12948 if (b
->location
!= NULL
)
12950 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12952 if (ret
< 0 || ret
>= buf
.size ())
12953 error ("%s", err_msg
);
12955 encode_source_string (b
->number
, loc
->address
, "at",
12956 event_location_to_string (b
->location
.get ()),
12957 buf
.data () + strlen (buf
.data ()),
12958 buf
.size () - strlen (buf
.data ()));
12959 putpkt (buf
.data ());
12960 remote_get_noisy_reply ();
12961 if (strcmp (rs
->buf
.data (), "OK"))
12962 warning (_("Target does not support source download."));
12964 if (b
->cond_string
)
12966 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12968 if (ret
< 0 || ret
>= buf
.size ())
12969 error ("%s", err_msg
);
12971 encode_source_string (b
->number
, loc
->address
,
12972 "cond", b
->cond_string
,
12973 buf
.data () + strlen (buf
.data ()),
12974 buf
.size () - strlen (buf
.data ()));
12975 putpkt (buf
.data ());
12976 remote_get_noisy_reply ();
12977 if (strcmp (rs
->buf
.data (), "OK"))
12978 warning (_("Target does not support source download."));
12980 remote_download_command_source (b
->number
, loc
->address
,
12981 breakpoint_commands (b
));
12986 remote_target::can_download_tracepoint ()
12988 struct remote_state
*rs
= get_remote_state ();
12989 struct trace_status
*ts
;
12992 /* Don't try to install tracepoints until we've relocated our
12993 symbols, and fetched and merged the target's tracepoint list with
12995 if (rs
->starting_up
)
12998 ts
= current_trace_status ();
12999 status
= get_trace_status (ts
);
13001 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
13004 /* If we are in a tracing experiment, but remote stub doesn't support
13005 installing tracepoint in trace, we have to return. */
13006 if (!remote_supports_install_in_trace ())
13014 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
13016 struct remote_state
*rs
= get_remote_state ();
13019 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13020 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13022 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13023 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13024 >= get_remote_packet_size ())
13025 error (_("Trace state variable name too long for tsv definition packet"));
13026 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13029 remote_get_noisy_reply ();
13030 if (rs
->buf
[0] == '\0')
13031 error (_("Target does not support this command."));
13032 if (strcmp (rs
->buf
.data (), "OK") != 0)
13033 error (_("Error on target while downloading trace state variable."));
13037 remote_target::enable_tracepoint (struct bp_location
*location
)
13039 struct remote_state
*rs
= get_remote_state ();
13042 sprintf_vma (addr_buf
, location
->address
);
13043 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13044 location
->owner
->number
, addr_buf
);
13046 remote_get_noisy_reply ();
13047 if (rs
->buf
[0] == '\0')
13048 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13049 if (strcmp (rs
->buf
.data (), "OK") != 0)
13050 error (_("Error on target while enabling tracepoint."));
13054 remote_target::disable_tracepoint (struct bp_location
*location
)
13056 struct remote_state
*rs
= get_remote_state ();
13059 sprintf_vma (addr_buf
, location
->address
);
13060 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13061 location
->owner
->number
, addr_buf
);
13063 remote_get_noisy_reply ();
13064 if (rs
->buf
[0] == '\0')
13065 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13066 if (strcmp (rs
->buf
.data (), "OK") != 0)
13067 error (_("Error on target while disabling tracepoint."));
13071 remote_target::trace_set_readonly_regions ()
13074 bfd_size_type size
;
13080 return; /* No information to give. */
13082 struct remote_state
*rs
= get_remote_state ();
13084 strcpy (rs
->buf
.data (), "QTro");
13085 offset
= strlen (rs
->buf
.data ());
13086 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
13088 char tmp1
[40], tmp2
[40];
13091 if ((s
->flags
& SEC_LOAD
) == 0 ||
13092 /* (s->flags & SEC_CODE) == 0 || */
13093 (s
->flags
& SEC_READONLY
) == 0)
13097 vma
= bfd_section_vma (s
);
13098 size
= bfd_section_size (s
);
13099 sprintf_vma (tmp1
, vma
);
13100 sprintf_vma (tmp2
, vma
+ size
);
13101 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13102 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13104 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13106 Too many sections for read-only sections definition packet."));
13109 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13111 offset
+= sec_length
;
13116 getpkt (&rs
->buf
, 0);
13121 remote_target::trace_start ()
13123 struct remote_state
*rs
= get_remote_state ();
13125 putpkt ("QTStart");
13126 remote_get_noisy_reply ();
13127 if (rs
->buf
[0] == '\0')
13128 error (_("Target does not support this command."));
13129 if (strcmp (rs
->buf
.data (), "OK") != 0)
13130 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13134 remote_target::get_trace_status (struct trace_status
*ts
)
13136 /* Initialize it just to avoid a GCC false warning. */
13138 enum packet_result result
;
13139 struct remote_state
*rs
= get_remote_state ();
13141 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13144 /* FIXME we need to get register block size some other way. */
13145 trace_regblock_size
13146 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13148 putpkt ("qTStatus");
13152 p
= remote_get_noisy_reply ();
13154 catch (const gdb_exception_error
&ex
)
13156 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13158 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13164 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13166 /* If the remote target doesn't do tracing, flag it. */
13167 if (result
== PACKET_UNKNOWN
)
13170 /* We're working with a live target. */
13171 ts
->filename
= NULL
;
13174 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13176 /* Function 'parse_trace_status' sets default value of each field of
13177 'ts' at first, so we don't have to do it here. */
13178 parse_trace_status (p
, ts
);
13180 return ts
->running
;
13184 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13185 struct uploaded_tp
*utp
)
13187 struct remote_state
*rs
= get_remote_state ();
13189 struct bp_location
*loc
;
13190 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13191 size_t size
= get_remote_packet_size ();
13196 tp
->traceframe_usage
= 0;
13197 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13199 /* If the tracepoint was never downloaded, don't go asking for
13201 if (tp
->number_on_target
== 0)
13203 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13204 phex_nz (loc
->address
, 0));
13206 reply
= remote_get_noisy_reply ();
13207 if (reply
&& *reply
)
13210 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13216 utp
->hit_count
= 0;
13217 utp
->traceframe_usage
= 0;
13218 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13219 phex_nz (utp
->addr
, 0));
13221 reply
= remote_get_noisy_reply ();
13222 if (reply
&& *reply
)
13225 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13231 remote_target::trace_stop ()
13233 struct remote_state
*rs
= get_remote_state ();
13236 remote_get_noisy_reply ();
13237 if (rs
->buf
[0] == '\0')
13238 error (_("Target does not support this command."));
13239 if (strcmp (rs
->buf
.data (), "OK") != 0)
13240 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13244 remote_target::trace_find (enum trace_find_type type
, int num
,
13245 CORE_ADDR addr1
, CORE_ADDR addr2
,
13248 struct remote_state
*rs
= get_remote_state ();
13249 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13251 int target_frameno
= -1, target_tracept
= -1;
13253 /* Lookups other than by absolute frame number depend on the current
13254 trace selected, so make sure it is correct on the remote end
13256 if (type
!= tfind_number
)
13257 set_remote_traceframe ();
13259 p
= rs
->buf
.data ();
13260 strcpy (p
, "QTFrame:");
13261 p
= strchr (p
, '\0');
13265 xsnprintf (p
, endbuf
- p
, "%x", num
);
13268 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13271 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13274 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13275 phex_nz (addr2
, 0));
13277 case tfind_outside
:
13278 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13279 phex_nz (addr2
, 0));
13282 error (_("Unknown trace find type %d"), type
);
13286 reply
= remote_get_noisy_reply ();
13287 if (*reply
== '\0')
13288 error (_("Target does not support this command."));
13290 while (reply
&& *reply
)
13295 target_frameno
= (int) strtol (p
, &reply
, 16);
13297 error (_("Unable to parse trace frame number"));
13298 /* Don't update our remote traceframe number cache on failure
13299 to select a remote traceframe. */
13300 if (target_frameno
== -1)
13305 target_tracept
= (int) strtol (p
, &reply
, 16);
13307 error (_("Unable to parse tracepoint number"));
13309 case 'O': /* "OK"? */
13310 if (reply
[1] == 'K' && reply
[2] == '\0')
13313 error (_("Bogus reply from target: %s"), reply
);
13316 error (_("Bogus reply from target: %s"), reply
);
13319 *tpp
= target_tracept
;
13321 rs
->remote_traceframe_number
= target_frameno
;
13322 return target_frameno
;
13326 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13328 struct remote_state
*rs
= get_remote_state ();
13332 set_remote_traceframe ();
13334 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13336 reply
= remote_get_noisy_reply ();
13337 if (reply
&& *reply
)
13341 unpack_varlen_hex (reply
+ 1, &uval
);
13342 *val
= (LONGEST
) uval
;
13350 remote_target::save_trace_data (const char *filename
)
13352 struct remote_state
*rs
= get_remote_state ();
13355 p
= rs
->buf
.data ();
13356 strcpy (p
, "QTSave:");
13358 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13359 >= get_remote_packet_size ())
13360 error (_("Remote file name too long for trace save packet"));
13361 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13364 reply
= remote_get_noisy_reply ();
13365 if (*reply
== '\0')
13366 error (_("Target does not support this command."));
13367 if (strcmp (reply
, "OK") != 0)
13368 error (_("Bogus reply from target: %s"), reply
);
13372 /* This is basically a memory transfer, but needs to be its own packet
13373 because we don't know how the target actually organizes its trace
13374 memory, plus we want to be able to ask for as much as possible, but
13375 not be unhappy if we don't get as much as we ask for. */
13378 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13380 struct remote_state
*rs
= get_remote_state ();
13385 p
= rs
->buf
.data ();
13386 strcpy (p
, "qTBuffer:");
13388 p
+= hexnumstr (p
, offset
);
13390 p
+= hexnumstr (p
, len
);
13394 reply
= remote_get_noisy_reply ();
13395 if (reply
&& *reply
)
13397 /* 'l' by itself means we're at the end of the buffer and
13398 there is nothing more to get. */
13402 /* Convert the reply into binary. Limit the number of bytes to
13403 convert according to our passed-in buffer size, rather than
13404 what was returned in the packet; if the target is
13405 unexpectedly generous and gives us a bigger reply than we
13406 asked for, we don't want to crash. */
13407 rslt
= hex2bin (reply
, buf
, len
);
13411 /* Something went wrong, flag as an error. */
13416 remote_target::set_disconnected_tracing (int val
)
13418 struct remote_state
*rs
= get_remote_state ();
13420 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13424 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13425 "QTDisconnected:%x", val
);
13427 reply
= remote_get_noisy_reply ();
13428 if (*reply
== '\0')
13429 error (_("Target does not support this command."));
13430 if (strcmp (reply
, "OK") != 0)
13431 error (_("Bogus reply from target: %s"), reply
);
13434 warning (_("Target does not support disconnected tracing."));
13438 remote_target::core_of_thread (ptid_t ptid
)
13440 struct thread_info
*info
= find_thread_ptid (ptid
);
13442 if (info
!= NULL
&& info
->priv
!= NULL
)
13443 return get_remote_thread_info (info
)->core
;
13449 remote_target::set_circular_trace_buffer (int val
)
13451 struct remote_state
*rs
= get_remote_state ();
13454 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13455 "QTBuffer:circular:%x", val
);
13457 reply
= remote_get_noisy_reply ();
13458 if (*reply
== '\0')
13459 error (_("Target does not support this command."));
13460 if (strcmp (reply
, "OK") != 0)
13461 error (_("Bogus reply from target: %s"), reply
);
13465 remote_target::traceframe_info ()
13467 gdb::optional
<gdb::char_vector
> text
13468 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13471 return parse_traceframe_info (text
->data ());
13476 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13477 instruction on which a fast tracepoint may be placed. Returns -1
13478 if the packet is not supported, and 0 if the minimum instruction
13479 length is unknown. */
13482 remote_target::get_min_fast_tracepoint_insn_len ()
13484 struct remote_state
*rs
= get_remote_state ();
13487 /* If we're not debugging a process yet, the IPA can't be
13489 if (!target_has_execution
)
13492 /* Make sure the remote is pointing at the right process. */
13493 set_general_process ();
13495 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13497 reply
= remote_get_noisy_reply ();
13498 if (*reply
== '\0')
13502 ULONGEST min_insn_len
;
13504 unpack_varlen_hex (reply
, &min_insn_len
);
13506 return (int) min_insn_len
;
13511 remote_target::set_trace_buffer_size (LONGEST val
)
13513 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13515 struct remote_state
*rs
= get_remote_state ();
13516 char *buf
= rs
->buf
.data ();
13517 char *endbuf
= buf
+ get_remote_packet_size ();
13518 enum packet_result result
;
13520 gdb_assert (val
>= 0 || val
== -1);
13521 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13522 /* Send -1 as literal "-1" to avoid host size dependency. */
13526 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13529 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13532 remote_get_noisy_reply ();
13533 result
= packet_ok (rs
->buf
,
13534 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13536 if (result
!= PACKET_OK
)
13537 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13542 remote_target::set_trace_notes (const char *user
, const char *notes
,
13543 const char *stop_notes
)
13545 struct remote_state
*rs
= get_remote_state ();
13547 char *buf
= rs
->buf
.data ();
13548 char *endbuf
= buf
+ get_remote_packet_size ();
13551 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13554 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13555 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13561 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13562 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13568 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13569 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13573 /* Ensure the buffer is terminated. */
13577 reply
= remote_get_noisy_reply ();
13578 if (*reply
== '\0')
13581 if (strcmp (reply
, "OK") != 0)
13582 error (_("Bogus reply from target: %s"), reply
);
13588 remote_target::use_agent (bool use
)
13590 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13592 struct remote_state
*rs
= get_remote_state ();
13594 /* If the stub supports QAgent. */
13595 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13597 getpkt (&rs
->buf
, 0);
13599 if (strcmp (rs
->buf
.data (), "OK") == 0)
13610 remote_target::can_use_agent ()
13612 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13615 struct btrace_target_info
13617 /* The ptid of the traced thread. */
13620 /* The obtained branch trace configuration. */
13621 struct btrace_config conf
;
13624 /* Reset our idea of our target's btrace configuration. */
13627 remote_btrace_reset (remote_state
*rs
)
13629 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13632 /* Synchronize the configuration with the target. */
13635 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13637 struct packet_config
*packet
;
13638 struct remote_state
*rs
;
13639 char *buf
, *pos
, *endbuf
;
13641 rs
= get_remote_state ();
13642 buf
= rs
->buf
.data ();
13643 endbuf
= buf
+ get_remote_packet_size ();
13645 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13646 if (packet_config_support (packet
) == PACKET_ENABLE
13647 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13650 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13654 getpkt (&rs
->buf
, 0);
13656 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13658 if (buf
[0] == 'E' && buf
[1] == '.')
13659 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13661 error (_("Failed to configure the BTS buffer size."));
13664 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13667 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13668 if (packet_config_support (packet
) == PACKET_ENABLE
13669 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13672 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13676 getpkt (&rs
->buf
, 0);
13678 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13680 if (buf
[0] == 'E' && buf
[1] == '.')
13681 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13683 error (_("Failed to configure the trace buffer size."));
13686 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13690 /* Read the current thread's btrace configuration from the target and
13691 store it into CONF. */
13694 btrace_read_config (struct btrace_config
*conf
)
13696 gdb::optional
<gdb::char_vector
> xml
13697 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13699 parse_xml_btrace_conf (conf
, xml
->data ());
13702 /* Maybe reopen target btrace. */
13705 remote_target::remote_btrace_maybe_reopen ()
13707 struct remote_state
*rs
= get_remote_state ();
13708 int btrace_target_pushed
= 0;
13709 #if !defined (HAVE_LIBIPT)
13713 /* Don't bother walking the entirety of the remote thread list when
13714 we know the feature isn't supported by the remote. */
13715 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13718 scoped_restore_current_thread restore_thread
;
13720 for (thread_info
*tp
: all_non_exited_threads ())
13722 set_general_thread (tp
->ptid
);
13724 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13725 btrace_read_config (&rs
->btrace_config
);
13727 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13730 #if !defined (HAVE_LIBIPT)
13731 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13736 warning (_("Target is recording using Intel Processor Trace "
13737 "but support was disabled at compile time."));
13742 #endif /* !defined (HAVE_LIBIPT) */
13744 /* Push target, once, but before anything else happens. This way our
13745 changes to the threads will be cleaned up by unpushing the target
13746 in case btrace_read_config () throws. */
13747 if (!btrace_target_pushed
)
13749 btrace_target_pushed
= 1;
13750 record_btrace_push_target ();
13751 printf_filtered (_("Target is recording using %s.\n"),
13752 btrace_format_string (rs
->btrace_config
.format
));
13755 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13756 tp
->btrace
.target
->ptid
= tp
->ptid
;
13757 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13761 /* Enable branch tracing. */
13763 struct btrace_target_info
*
13764 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13766 struct btrace_target_info
*tinfo
= NULL
;
13767 struct packet_config
*packet
= NULL
;
13768 struct remote_state
*rs
= get_remote_state ();
13769 char *buf
= rs
->buf
.data ();
13770 char *endbuf
= buf
+ get_remote_packet_size ();
13772 switch (conf
->format
)
13774 case BTRACE_FORMAT_BTS
:
13775 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13778 case BTRACE_FORMAT_PT
:
13779 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13783 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13784 error (_("Target does not support branch tracing."));
13786 btrace_sync_conf (conf
);
13788 set_general_thread (ptid
);
13790 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13792 getpkt (&rs
->buf
, 0);
13794 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13796 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13797 error (_("Could not enable branch tracing for %s: %s"),
13798 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
13800 error (_("Could not enable branch tracing for %s."),
13801 target_pid_to_str (ptid
).c_str ());
13804 tinfo
= XCNEW (struct btrace_target_info
);
13805 tinfo
->ptid
= ptid
;
13807 /* If we fail to read the configuration, we lose some information, but the
13808 tracing itself is not impacted. */
13811 btrace_read_config (&tinfo
->conf
);
13813 catch (const gdb_exception_error
&err
)
13815 if (err
.message
!= NULL
)
13816 warning ("%s", err
.what ());
13822 /* Disable branch tracing. */
13825 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
13827 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13828 struct remote_state
*rs
= get_remote_state ();
13829 char *buf
= rs
->buf
.data ();
13830 char *endbuf
= buf
+ get_remote_packet_size ();
13832 if (packet_config_support (packet
) != PACKET_ENABLE
)
13833 error (_("Target does not support branch tracing."));
13835 set_general_thread (tinfo
->ptid
);
13837 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13839 getpkt (&rs
->buf
, 0);
13841 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13843 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13844 error (_("Could not disable branch tracing for %s: %s"),
13845 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
13847 error (_("Could not disable branch tracing for %s."),
13848 target_pid_to_str (tinfo
->ptid
).c_str ());
13854 /* Teardown branch tracing. */
13857 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
13859 /* We must not talk to the target during teardown. */
13863 /* Read the branch trace. */
13866 remote_target::read_btrace (struct btrace_data
*btrace
,
13867 struct btrace_target_info
*tinfo
,
13868 enum btrace_read_type type
)
13870 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13873 if (packet_config_support (packet
) != PACKET_ENABLE
)
13874 error (_("Target does not support branch tracing."));
13876 #if !defined(HAVE_LIBEXPAT)
13877 error (_("Cannot process branch tracing result. XML parsing not supported."));
13882 case BTRACE_READ_ALL
:
13885 case BTRACE_READ_NEW
:
13888 case BTRACE_READ_DELTA
:
13892 internal_error (__FILE__
, __LINE__
,
13893 _("Bad branch tracing read type: %u."),
13894 (unsigned int) type
);
13897 gdb::optional
<gdb::char_vector
> xml
13898 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
13900 return BTRACE_ERR_UNKNOWN
;
13902 parse_xml_btrace (btrace
, xml
->data ());
13904 return BTRACE_ERR_NONE
;
13907 const struct btrace_config
*
13908 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
13910 return &tinfo
->conf
;
13914 remote_target::augmented_libraries_svr4_read ()
13916 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13920 /* Implementation of to_load. */
13923 remote_target::load (const char *name
, int from_tty
)
13925 generic_load (name
, from_tty
);
13928 /* Accepts an integer PID; returns a string representing a file that
13929 can be opened on the remote side to get the symbols for the child
13930 process. Returns NULL if the operation is not supported. */
13933 remote_target::pid_to_exec_file (int pid
)
13935 static gdb::optional
<gdb::char_vector
> filename
;
13936 struct inferior
*inf
;
13937 char *annex
= NULL
;
13939 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13942 inf
= find_inferior_pid (pid
);
13944 internal_error (__FILE__
, __LINE__
,
13945 _("not currently attached to process %d"), pid
);
13947 if (!inf
->fake_pid_p
)
13949 const int annex_size
= 9;
13951 annex
= (char *) alloca (annex_size
);
13952 xsnprintf (annex
, annex_size
, "%x", pid
);
13955 filename
= target_read_stralloc (current_top_target (),
13956 TARGET_OBJECT_EXEC_FILE
, annex
);
13958 return filename
? filename
->data () : nullptr;
13961 /* Implement the to_can_do_single_step target_ops method. */
13964 remote_target::can_do_single_step ()
13966 /* We can only tell whether target supports single step or not by
13967 supported s and S vCont actions if the stub supports vContSupported
13968 feature. If the stub doesn't support vContSupported feature,
13969 we have conservatively to think target doesn't supports single
13971 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
13973 struct remote_state
*rs
= get_remote_state ();
13975 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13976 remote_vcont_probe ();
13978 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
13984 /* Implementation of the to_execution_direction method for the remote
13987 enum exec_direction_kind
13988 remote_target::execution_direction ()
13990 struct remote_state
*rs
= get_remote_state ();
13992 return rs
->last_resume_exec_dir
;
13995 /* Return pointer to the thread_info struct which corresponds to
13996 THREAD_HANDLE (having length HANDLE_LEN). */
13999 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
14003 for (thread_info
*tp
: all_non_exited_threads ())
14005 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14007 if (tp
->inf
== inf
&& priv
!= NULL
)
14009 if (handle_len
!= priv
->thread_handle
.size ())
14010 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14011 handle_len
, priv
->thread_handle
.size ());
14012 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14022 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
14024 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14025 return priv
->thread_handle
;
14029 remote_target::can_async_p ()
14031 struct remote_state
*rs
= get_remote_state ();
14033 /* We don't go async if the user has explicitly prevented it with the
14034 "maint set target-async" command. */
14035 if (!target_async_permitted
)
14038 /* We're async whenever the serial device is. */
14039 return serial_can_async_p (rs
->remote_desc
);
14043 remote_target::is_async_p ()
14045 struct remote_state
*rs
= get_remote_state ();
14047 if (!target_async_permitted
)
14048 /* We only enable async when the user specifically asks for it. */
14051 /* We're async whenever the serial device is. */
14052 return serial_is_async_p (rs
->remote_desc
);
14055 /* Pass the SERIAL event on and up to the client. One day this code
14056 will be able to delay notifying the client of an event until the
14057 point where an entire packet has been received. */
14059 static serial_event_ftype remote_async_serial_handler
;
14062 remote_async_serial_handler (struct serial
*scb
, void *context
)
14064 /* Don't propogate error information up to the client. Instead let
14065 the client find out about the error by querying the target. */
14066 inferior_event_handler (INF_REG_EVENT
, NULL
);
14070 remote_async_inferior_event_handler (gdb_client_data data
)
14072 inferior_event_handler (INF_REG_EVENT
, data
);
14076 remote_target::async (int enable
)
14078 struct remote_state
*rs
= get_remote_state ();
14082 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14084 /* If there are pending events in the stop reply queue tell the
14085 event loop to process them. */
14086 if (!rs
->stop_reply_queue
.empty ())
14087 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14088 /* For simplicity, below we clear the pending events token
14089 without remembering whether it is marked, so here we always
14090 mark it. If there's actually no pending notification to
14091 process, this ends up being a no-op (other than a spurious
14092 event-loop wakeup). */
14093 if (target_is_non_stop_p ())
14094 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14098 serial_async (rs
->remote_desc
, NULL
, NULL
);
14099 /* If the core is disabling async, it doesn't want to be
14100 disturbed with target events. Clear all async event sources
14102 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14103 if (target_is_non_stop_p ())
14104 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14108 /* Implementation of the to_thread_events method. */
14111 remote_target::thread_events (int enable
)
14113 struct remote_state
*rs
= get_remote_state ();
14114 size_t size
= get_remote_packet_size ();
14116 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14119 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14121 getpkt (&rs
->buf
, 0);
14123 switch (packet_ok (rs
->buf
,
14124 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14127 if (strcmp (rs
->buf
.data (), "OK") != 0)
14128 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14131 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14133 case PACKET_UNKNOWN
:
14139 set_remote_cmd (const char *args
, int from_tty
)
14141 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
14145 show_remote_cmd (const char *args
, int from_tty
)
14147 /* We can't just use cmd_show_list here, because we want to skip
14148 the redundant "show remote Z-packet" and the legacy aliases. */
14149 struct cmd_list_element
*list
= remote_show_cmdlist
;
14150 struct ui_out
*uiout
= current_uiout
;
14152 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14153 for (; list
!= NULL
; list
= list
->next
)
14154 if (strcmp (list
->name
, "Z-packet") == 0)
14156 else if (list
->type
== not_set_cmd
)
14157 /* Alias commands are exactly like the original, except they
14158 don't have the normal type. */
14162 ui_out_emit_tuple
option_emitter (uiout
, "option");
14164 uiout
->field_string ("name", list
->name
);
14165 uiout
->text (": ");
14166 if (list
->type
== show_cmd
)
14167 do_show_command (NULL
, from_tty
, list
);
14169 cmd_func (list
, NULL
, from_tty
);
14174 /* Function to be called whenever a new objfile (shlib) is detected. */
14176 remote_new_objfile (struct objfile
*objfile
)
14178 remote_target
*remote
= get_current_remote_target ();
14180 if (remote
!= NULL
) /* Have a remote connection. */
14181 remote
->remote_check_symbols ();
14184 /* Pull all the tracepoints defined on the target and create local
14185 data structures representing them. We don't want to create real
14186 tracepoints yet, we don't want to mess up the user's existing
14190 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14192 struct remote_state
*rs
= get_remote_state ();
14195 /* Ask for a first packet of tracepoint definition. */
14197 getpkt (&rs
->buf
, 0);
14198 p
= rs
->buf
.data ();
14199 while (*p
&& *p
!= 'l')
14201 parse_tracepoint_definition (p
, utpp
);
14202 /* Ask for another packet of tracepoint definition. */
14204 getpkt (&rs
->buf
, 0);
14205 p
= rs
->buf
.data ();
14211 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14213 struct remote_state
*rs
= get_remote_state ();
14216 /* Ask for a first packet of variable definition. */
14218 getpkt (&rs
->buf
, 0);
14219 p
= rs
->buf
.data ();
14220 while (*p
&& *p
!= 'l')
14222 parse_tsv_definition (p
, utsvp
);
14223 /* Ask for another packet of variable definition. */
14225 getpkt (&rs
->buf
, 0);
14226 p
= rs
->buf
.data ();
14231 /* The "set/show range-stepping" show hook. */
14234 show_range_stepping (struct ui_file
*file
, int from_tty
,
14235 struct cmd_list_element
*c
,
14238 fprintf_filtered (file
,
14239 _("Debugger's willingness to use range stepping "
14240 "is %s.\n"), value
);
14243 /* Return true if the vCont;r action is supported by the remote
14247 remote_target::vcont_r_supported ()
14249 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14250 remote_vcont_probe ();
14252 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14253 && get_remote_state ()->supports_vCont
.r
);
14256 /* The "set/show range-stepping" set hook. */
14259 set_range_stepping (const char *ignore_args
, int from_tty
,
14260 struct cmd_list_element
*c
)
14262 /* When enabling, check whether range stepping is actually supported
14263 by the target, and warn if not. */
14264 if (use_range_stepping
)
14266 remote_target
*remote
= get_current_remote_target ();
14268 || !remote
->vcont_r_supported ())
14269 warning (_("Range stepping is not supported by the current target"));
14274 _initialize_remote (void)
14276 struct cmd_list_element
*cmd
;
14277 const char *cmd_name
;
14279 /* architecture specific data */
14280 remote_g_packet_data_handle
=
14281 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14283 add_target (remote_target_info
, remote_target::open
);
14284 add_target (extended_remote_target_info
, extended_remote_target::open
);
14286 /* Hook into new objfile notification. */
14287 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14290 init_remote_threadtests ();
14293 /* set/show remote ... */
14295 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14296 Remote protocol specific variables.\n\
14297 Configure various remote-protocol specific variables such as\n\
14298 the packets being used."),
14299 &remote_set_cmdlist
, "set remote ",
14300 0 /* allow-unknown */, &setlist
);
14301 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14302 Remote protocol specific variables.\n\
14303 Configure various remote-protocol specific variables such as\n\
14304 the packets being used."),
14305 &remote_show_cmdlist
, "show remote ",
14306 0 /* allow-unknown */, &showlist
);
14308 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14309 Compare section data on target to the exec file.\n\
14310 Argument is a single section name (default: all loaded sections).\n\
14311 To compare only read-only loaded sections, specify the -r option."),
14314 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14315 Send an arbitrary packet to a remote target.\n\
14316 maintenance packet TEXT\n\
14317 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14318 this command sends the string TEXT to the inferior, and displays the\n\
14319 response packet. GDB supplies the initial `$' character, and the\n\
14320 terminating `#' character and checksum."),
14323 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14324 Set whether to send break if interrupted."), _("\
14325 Show whether to send break if interrupted."), _("\
14326 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14327 set_remotebreak
, show_remotebreak
,
14328 &setlist
, &showlist
);
14329 cmd_name
= "remotebreak";
14330 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14331 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14332 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14333 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14334 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14336 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14337 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14339 Set interrupt sequence to remote target."), _("\
14340 Show interrupt sequence to remote target."), _("\
14341 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14342 NULL
, show_interrupt_sequence
,
14343 &remote_set_cmdlist
,
14344 &remote_show_cmdlist
);
14346 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14347 &interrupt_on_connect
, _("\
14348 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14349 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14350 If set, interrupt sequence is sent to remote target."),
14352 &remote_set_cmdlist
, &remote_show_cmdlist
);
14354 /* Install commands for configuring memory read/write packets. */
14356 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14357 Set the maximum number of bytes per memory write packet (deprecated)."),
14359 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14360 Show the maximum number of bytes per memory write packet (deprecated)."),
14362 add_cmd ("memory-write-packet-size", no_class
,
14363 set_memory_write_packet_size
, _("\
14364 Set the maximum number of bytes per memory-write packet.\n\
14365 Specify the number of bytes in a packet or 0 (zero) for the\n\
14366 default packet size. The actual limit is further reduced\n\
14367 dependent on the target. Specify ``fixed'' to disable the\n\
14368 further restriction and ``limit'' to enable that restriction."),
14369 &remote_set_cmdlist
);
14370 add_cmd ("memory-read-packet-size", no_class
,
14371 set_memory_read_packet_size
, _("\
14372 Set the maximum number of bytes per memory-read packet.\n\
14373 Specify the number of bytes in a packet or 0 (zero) for the\n\
14374 default packet size. The actual limit is further reduced\n\
14375 dependent on the target. Specify ``fixed'' to disable the\n\
14376 further restriction and ``limit'' to enable that restriction."),
14377 &remote_set_cmdlist
);
14378 add_cmd ("memory-write-packet-size", no_class
,
14379 show_memory_write_packet_size
,
14380 _("Show the maximum number of bytes per memory-write packet."),
14381 &remote_show_cmdlist
);
14382 add_cmd ("memory-read-packet-size", no_class
,
14383 show_memory_read_packet_size
,
14384 _("Show the maximum number of bytes per memory-read packet."),
14385 &remote_show_cmdlist
);
14387 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14388 &remote_hw_watchpoint_limit
, _("\
14389 Set the maximum number of target hardware watchpoints."), _("\
14390 Show the maximum number of target hardware watchpoints."), _("\
14391 Specify \"unlimited\" for unlimited hardware watchpoints."),
14392 NULL
, show_hardware_watchpoint_limit
,
14393 &remote_set_cmdlist
,
14394 &remote_show_cmdlist
);
14395 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14397 &remote_hw_watchpoint_length_limit
, _("\
14398 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14399 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14400 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14401 NULL
, show_hardware_watchpoint_length_limit
,
14402 &remote_set_cmdlist
, &remote_show_cmdlist
);
14403 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14404 &remote_hw_breakpoint_limit
, _("\
14405 Set the maximum number of target hardware breakpoints."), _("\
14406 Show the maximum number of target hardware breakpoints."), _("\
14407 Specify \"unlimited\" for unlimited hardware breakpoints."),
14408 NULL
, show_hardware_breakpoint_limit
,
14409 &remote_set_cmdlist
, &remote_show_cmdlist
);
14411 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14412 &remote_address_size
, _("\
14413 Set the maximum size of the address (in bits) in a memory packet."), _("\
14414 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14416 NULL
, /* FIXME: i18n: */
14417 &setlist
, &showlist
);
14419 init_all_packet_configs ();
14421 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14422 "X", "binary-download", 1);
14424 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14425 "vCont", "verbose-resume", 0);
14427 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14428 "QPassSignals", "pass-signals", 0);
14430 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14431 "QCatchSyscalls", "catch-syscalls", 0);
14433 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14434 "QProgramSignals", "program-signals", 0);
14436 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14437 "QSetWorkingDir", "set-working-dir", 0);
14439 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14440 "QStartupWithShell", "startup-with-shell", 0);
14442 add_packet_config_cmd (&remote_protocol_packets
14443 [PACKET_QEnvironmentHexEncoded
],
14444 "QEnvironmentHexEncoded", "environment-hex-encoded",
14447 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14448 "QEnvironmentReset", "environment-reset",
14451 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14452 "QEnvironmentUnset", "environment-unset",
14455 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14456 "qSymbol", "symbol-lookup", 0);
14458 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14459 "P", "set-register", 1);
14461 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14462 "p", "fetch-register", 1);
14464 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14465 "Z0", "software-breakpoint", 0);
14467 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14468 "Z1", "hardware-breakpoint", 0);
14470 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14471 "Z2", "write-watchpoint", 0);
14473 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14474 "Z3", "read-watchpoint", 0);
14476 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14477 "Z4", "access-watchpoint", 0);
14479 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14480 "qXfer:auxv:read", "read-aux-vector", 0);
14482 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14483 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14485 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14486 "qXfer:features:read", "target-features", 0);
14488 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14489 "qXfer:libraries:read", "library-info", 0);
14491 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14492 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14494 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14495 "qXfer:memory-map:read", "memory-map", 0);
14497 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14498 "qXfer:osdata:read", "osdata", 0);
14500 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14501 "qXfer:threads:read", "threads", 0);
14503 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14504 "qXfer:siginfo:read", "read-siginfo-object", 0);
14506 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14507 "qXfer:siginfo:write", "write-siginfo-object", 0);
14509 add_packet_config_cmd
14510 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14511 "qXfer:traceframe-info:read", "traceframe-info", 0);
14513 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14514 "qXfer:uib:read", "unwind-info-block", 0);
14516 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14517 "qGetTLSAddr", "get-thread-local-storage-address",
14520 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14521 "qGetTIBAddr", "get-thread-information-block-address",
14524 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14525 "bc", "reverse-continue", 0);
14527 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14528 "bs", "reverse-step", 0);
14530 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14531 "qSupported", "supported-packets", 0);
14533 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14534 "qSearch:memory", "search-memory", 0);
14536 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14537 "qTStatus", "trace-status", 0);
14539 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14540 "vFile:setfs", "hostio-setfs", 0);
14542 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14543 "vFile:open", "hostio-open", 0);
14545 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14546 "vFile:pread", "hostio-pread", 0);
14548 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14549 "vFile:pwrite", "hostio-pwrite", 0);
14551 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14552 "vFile:close", "hostio-close", 0);
14554 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14555 "vFile:unlink", "hostio-unlink", 0);
14557 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14558 "vFile:readlink", "hostio-readlink", 0);
14560 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14561 "vFile:fstat", "hostio-fstat", 0);
14563 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14564 "vAttach", "attach", 0);
14566 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14569 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14570 "QStartNoAckMode", "noack", 0);
14572 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14573 "vKill", "kill", 0);
14575 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14576 "qAttached", "query-attached", 0);
14578 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14579 "ConditionalTracepoints",
14580 "conditional-tracepoints", 0);
14582 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14583 "ConditionalBreakpoints",
14584 "conditional-breakpoints", 0);
14586 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14587 "BreakpointCommands",
14588 "breakpoint-commands", 0);
14590 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14591 "FastTracepoints", "fast-tracepoints", 0);
14593 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14594 "TracepointSource", "TracepointSource", 0);
14596 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14597 "QAllow", "allow", 0);
14599 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14600 "StaticTracepoints", "static-tracepoints", 0);
14602 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14603 "InstallInTrace", "install-in-trace", 0);
14605 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14606 "qXfer:statictrace:read", "read-sdata-object", 0);
14608 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14609 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14611 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14612 "QDisableRandomization", "disable-randomization", 0);
14614 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14615 "QAgent", "agent", 0);
14617 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14618 "QTBuffer:size", "trace-buffer-size", 0);
14620 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14621 "Qbtrace:off", "disable-btrace", 0);
14623 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14624 "Qbtrace:bts", "enable-btrace-bts", 0);
14626 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14627 "Qbtrace:pt", "enable-btrace-pt", 0);
14629 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14630 "qXfer:btrace", "read-btrace", 0);
14632 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14633 "qXfer:btrace-conf", "read-btrace-conf", 0);
14635 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14636 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14638 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14639 "multiprocess-feature", "multiprocess-feature", 0);
14641 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14642 "swbreak-feature", "swbreak-feature", 0);
14644 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14645 "hwbreak-feature", "hwbreak-feature", 0);
14647 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14648 "fork-event-feature", "fork-event-feature", 0);
14650 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14651 "vfork-event-feature", "vfork-event-feature", 0);
14653 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14654 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14656 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14657 "vContSupported", "verbose-resume-supported", 0);
14659 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14660 "exec-event-feature", "exec-event-feature", 0);
14662 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14663 "vCtrlC", "ctrl-c", 0);
14665 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14666 "QThreadEvents", "thread-events", 0);
14668 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14669 "N stop reply", "no-resumed-stop-reply", 0);
14671 /* Assert that we've registered "set remote foo-packet" commands
14672 for all packet configs. */
14676 for (i
= 0; i
< PACKET_MAX
; i
++)
14678 /* Ideally all configs would have a command associated. Some
14679 still don't though. */
14684 case PACKET_QNonStop
:
14685 case PACKET_EnableDisableTracepoints_feature
:
14686 case PACKET_tracenz_feature
:
14687 case PACKET_DisconnectedTracing_feature
:
14688 case PACKET_augmented_libraries_svr4_read_feature
:
14690 /* Additions to this list need to be well justified:
14691 pre-existing packets are OK; new packets are not. */
14699 /* This catches both forgetting to add a config command, and
14700 forgetting to remove a packet from the exception list. */
14701 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14705 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14706 Z sub-packet has its own set and show commands, but users may
14707 have sets to this variable in their .gdbinit files (or in their
14709 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14710 &remote_Z_packet_detect
, _("\
14711 Set use of remote protocol `Z' packets."), _("\
14712 Show use of remote protocol `Z' packets."), _("\
14713 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14715 set_remote_protocol_Z_packet_cmd
,
14716 show_remote_protocol_Z_packet_cmd
,
14717 /* FIXME: i18n: Use of remote protocol
14718 `Z' packets is %s. */
14719 &remote_set_cmdlist
, &remote_show_cmdlist
);
14721 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14722 Manipulate files on the remote system.\n\
14723 Transfer files to and from the remote target system."),
14724 &remote_cmdlist
, "remote ",
14725 0 /* allow-unknown */, &cmdlist
);
14727 add_cmd ("put", class_files
, remote_put_command
,
14728 _("Copy a local file to the remote system."),
14731 add_cmd ("get", class_files
, remote_get_command
,
14732 _("Copy a remote file to the local system."),
14735 add_cmd ("delete", class_files
, remote_delete_command
,
14736 _("Delete a remote file."),
14739 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14740 &remote_exec_file_var
, _("\
14741 Set the remote pathname for \"run\"."), _("\
14742 Show the remote pathname for \"run\"."), NULL
,
14743 set_remote_exec_file
,
14744 show_remote_exec_file
,
14745 &remote_set_cmdlist
,
14746 &remote_show_cmdlist
);
14748 add_setshow_boolean_cmd ("range-stepping", class_run
,
14749 &use_range_stepping
, _("\
14750 Enable or disable range stepping."), _("\
14751 Show whether target-assisted range stepping is enabled."), _("\
14752 If on, and the target supports it, when stepping a source line, GDB\n\
14753 tells the target to step the corresponding range of addresses itself instead\n\
14754 of issuing multiple single-steps. This speeds up source level\n\
14755 stepping. If off, GDB always issues single-steps, even if range\n\
14756 stepping is supported by the target. The default is on."),
14757 set_range_stepping
,
14758 show_range_stepping
,
14762 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
14763 Set watchdog timer."), _("\
14764 Show watchdog timer."), _("\
14765 When non-zero, this timeout is used instead of waiting forever for a target\n\
14766 to finish a low-level step or continue operation. If the specified amount\n\
14767 of time passes without a response from the target, an error occurs."),
14770 &setlist
, &showlist
);
14772 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
14773 &remote_packet_max_chars
, _("\
14774 Set the maximum number of characters to display for each remote packet."), _("\
14775 Show the maximum number of characters to display for each remote packet."), _("\
14776 Specify \"unlimited\" to display all the characters."),
14777 NULL
, show_remote_packet_max_chars
,
14778 &setdebuglist
, &showdebuglist
);
14780 /* Eventually initialize fileio. See fileio.c */
14781 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);