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 inferior_ptid
= get_current_thread (wait_status
);
4705 if (inferior_ptid
== 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 inferior_ptid
= inferior_list
->thread_list
->ptid
;
4721 /* init_wait_for_inferior should be called before get_offsets in order
4722 to manage `inserted' flag in bp loc in a correct state.
4723 breakpoint_init_inferior, called from init_wait_for_inferior, set
4724 `inserted' flag to 0, while before breakpoint_re_set, called from
4725 start_remote, set `inserted' flag to 1. In the initialization of
4726 inferior, breakpoint_init_inferior should be called first, and then
4727 breakpoint_re_set can be called. If this order is broken, state of
4728 `inserted' flag is wrong, and cause some problems on breakpoint
4730 init_wait_for_inferior ();
4732 get_offsets (); /* Get text, data & bss offsets. */
4734 /* If we could not find a description using qXfer, and we know
4735 how to do it some other way, try again. This is not
4736 supported for non-stop; it could be, but it is tricky if
4737 there are no stopped threads when we connect. */
4738 if (remote_read_description_p (this)
4739 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4741 target_clear_description ();
4742 target_find_description ();
4745 /* Use the previously fetched status. */
4746 gdb_assert (wait_status
!= NULL
);
4747 strcpy (rs
->buf
.data (), wait_status
);
4748 rs
->cached_wait_status
= 1;
4750 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4754 /* Clear WFI global state. Do this before finding about new
4755 threads and inferiors, and setting the current inferior.
4756 Otherwise we would clear the proceed status of the current
4757 inferior when we want its stop_soon state to be preserved
4758 (see notice_new_inferior). */
4759 init_wait_for_inferior ();
4761 /* In non-stop, we will either get an "OK", meaning that there
4762 are no stopped threads at this time; or, a regular stop
4763 reply. In the latter case, there may be more than one thread
4764 stopped --- we pull them all out using the vStopped
4766 if (strcmp (rs
->buf
.data (), "OK") != 0)
4768 struct notif_client
*notif
= ¬if_client_stop
;
4770 /* remote_notif_get_pending_replies acks this one, and gets
4772 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4773 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4774 remote_notif_get_pending_events (notif
);
4777 if (thread_count () == 0)
4780 error (_("The target is not running (try extended-remote?)"));
4782 /* We're connected, but not running. Drop out before we
4783 call start_remote. */
4784 rs
->starting_up
= 0;
4788 /* In non-stop mode, any cached wait status will be stored in
4789 the stop reply queue. */
4790 gdb_assert (wait_status
== NULL
);
4792 /* Report all signals during attach/startup. */
4795 /* If there are already stopped threads, mark them stopped and
4796 report their stops before giving the prompt to the user. */
4797 process_initial_stop_replies (from_tty
);
4799 if (target_can_async_p ())
4803 /* If we connected to a live target, do some additional setup. */
4804 if (target_has_execution
)
4806 if (symfile_objfile
) /* No use without a symbol-file. */
4807 remote_check_symbols ();
4810 /* Possibly the target has been engaged in a trace run started
4811 previously; find out where things are at. */
4812 if (get_trace_status (current_trace_status ()) != -1)
4814 struct uploaded_tp
*uploaded_tps
= NULL
;
4816 if (current_trace_status ()->running
)
4817 printf_filtered (_("Trace is already running on the target.\n"));
4819 upload_tracepoints (&uploaded_tps
);
4821 merge_uploaded_tracepoints (&uploaded_tps
);
4824 /* Possibly the target has been engaged in a btrace record started
4825 previously; find out where things are at. */
4826 remote_btrace_maybe_reopen ();
4828 /* The thread and inferior lists are now synchronized with the
4829 target, our symbols have been relocated, and we're merged the
4830 target's tracepoints with ours. We're done with basic start
4832 rs
->starting_up
= 0;
4834 /* Maybe breakpoints are global and need to be inserted now. */
4835 if (breakpoints_should_be_inserted_now ())
4836 insert_breakpoints ();
4839 /* Open a connection to a remote debugger.
4840 NAME is the filename used for communication. */
4843 remote_target::open (const char *name
, int from_tty
)
4845 open_1 (name
, from_tty
, 0);
4848 /* Open a connection to a remote debugger using the extended
4849 remote gdb protocol. NAME is the filename used for communication. */
4852 extended_remote_target::open (const char *name
, int from_tty
)
4854 open_1 (name
, from_tty
, 1 /*extended_p */);
4857 /* Reset all packets back to "unknown support". Called when opening a
4858 new connection to a remote target. */
4861 reset_all_packet_configs_support (void)
4865 for (i
= 0; i
< PACKET_MAX
; i
++)
4866 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4869 /* Initialize all packet configs. */
4872 init_all_packet_configs (void)
4876 for (i
= 0; i
< PACKET_MAX
; i
++)
4878 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4879 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4883 /* Symbol look-up. */
4886 remote_target::remote_check_symbols ()
4891 /* The remote side has no concept of inferiors that aren't running
4892 yet, it only knows about running processes. If we're connected
4893 but our current inferior is not running, we should not invite the
4894 remote target to request symbol lookups related to its
4895 (unrelated) current process. */
4896 if (!target_has_execution
)
4899 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4902 /* Make sure the remote is pointing at the right process. Note
4903 there's no way to select "no process". */
4904 set_general_process ();
4906 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4907 because we need both at the same time. */
4908 gdb::char_vector
msg (get_remote_packet_size ());
4909 gdb::char_vector
reply (get_remote_packet_size ());
4911 /* Invite target to request symbol lookups. */
4913 putpkt ("qSymbol::");
4915 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4917 while (startswith (reply
.data (), "qSymbol:"))
4919 struct bound_minimal_symbol sym
;
4922 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
4925 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
4926 if (sym
.minsym
== NULL
)
4927 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
4931 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4932 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4934 /* If this is a function address, return the start of code
4935 instead of any data function descriptor. */
4936 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4938 current_top_target ());
4940 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4941 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4944 putpkt (msg
.data ());
4949 static struct serial
*
4950 remote_serial_open (const char *name
)
4952 static int udp_warning
= 0;
4954 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4955 of in ser-tcp.c, because it is the remote protocol assuming that the
4956 serial connection is reliable and not the serial connection promising
4958 if (!udp_warning
&& startswith (name
, "udp:"))
4960 warning (_("The remote protocol may be unreliable over UDP.\n"
4961 "Some events may be lost, rendering further debugging "
4966 return serial_open (name
);
4969 /* Inform the target of our permission settings. The permission flags
4970 work without this, but if the target knows the settings, it can do
4971 a couple things. First, it can add its own check, to catch cases
4972 that somehow manage to get by the permissions checks in target
4973 methods. Second, if the target is wired to disallow particular
4974 settings (for instance, a system in the field that is not set up to
4975 be able to stop at a breakpoint), it can object to any unavailable
4979 remote_target::set_permissions ()
4981 struct remote_state
*rs
= get_remote_state ();
4983 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
4984 "WriteReg:%x;WriteMem:%x;"
4985 "InsertBreak:%x;InsertTrace:%x;"
4986 "InsertFastTrace:%x;Stop:%x",
4987 may_write_registers
, may_write_memory
,
4988 may_insert_breakpoints
, may_insert_tracepoints
,
4989 may_insert_fast_tracepoints
, may_stop
);
4991 getpkt (&rs
->buf
, 0);
4993 /* If the target didn't like the packet, warn the user. Do not try
4994 to undo the user's settings, that would just be maddening. */
4995 if (strcmp (rs
->buf
.data (), "OK") != 0)
4996 warning (_("Remote refused setting permissions with: %s"),
5000 /* This type describes each known response to the qSupported
5002 struct protocol_feature
5004 /* The name of this protocol feature. */
5007 /* The default for this protocol feature. */
5008 enum packet_support default_support
;
5010 /* The function to call when this feature is reported, or after
5011 qSupported processing if the feature is not supported.
5012 The first argument points to this structure. The second
5013 argument indicates whether the packet requested support be
5014 enabled, disabled, or probed (or the default, if this function
5015 is being called at the end of processing and this feature was
5016 not reported). The third argument may be NULL; if not NULL, it
5017 is a NUL-terminated string taken from the packet following
5018 this feature's name and an equals sign. */
5019 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5020 enum packet_support
, const char *);
5022 /* The corresponding packet for this feature. Only used if
5023 FUNC is remote_supported_packet. */
5028 remote_supported_packet (remote_target
*remote
,
5029 const struct protocol_feature
*feature
,
5030 enum packet_support support
,
5031 const char *argument
)
5035 warning (_("Remote qSupported response supplied an unexpected value for"
5036 " \"%s\"."), feature
->name
);
5040 remote_protocol_packets
[feature
->packet
].support
= support
;
5044 remote_target::remote_packet_size (const protocol_feature
*feature
,
5045 enum packet_support support
, const char *value
)
5047 struct remote_state
*rs
= get_remote_state ();
5052 if (support
!= PACKET_ENABLE
)
5055 if (value
== NULL
|| *value
== '\0')
5057 warning (_("Remote target reported \"%s\" without a size."),
5063 packet_size
= strtol (value
, &value_end
, 16);
5064 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5066 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5067 feature
->name
, value
);
5071 /* Record the new maximum packet size. */
5072 rs
->explicit_packet_size
= packet_size
;
5076 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5077 enum packet_support support
, const char *value
)
5079 remote
->remote_packet_size (feature
, support
, value
);
5082 static const struct protocol_feature remote_protocol_features
[] = {
5083 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5084 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5085 PACKET_qXfer_auxv
},
5086 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5087 PACKET_qXfer_exec_file
},
5088 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5089 PACKET_qXfer_features
},
5090 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5091 PACKET_qXfer_libraries
},
5092 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5093 PACKET_qXfer_libraries_svr4
},
5094 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5095 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5096 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5097 PACKET_qXfer_memory_map
},
5098 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5099 PACKET_qXfer_osdata
},
5100 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5101 PACKET_qXfer_threads
},
5102 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5103 PACKET_qXfer_traceframe_info
},
5104 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5105 PACKET_QPassSignals
},
5106 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5107 PACKET_QCatchSyscalls
},
5108 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5109 PACKET_QProgramSignals
},
5110 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5111 PACKET_QSetWorkingDir
},
5112 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5113 PACKET_QStartupWithShell
},
5114 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5115 PACKET_QEnvironmentHexEncoded
},
5116 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5117 PACKET_QEnvironmentReset
},
5118 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5119 PACKET_QEnvironmentUnset
},
5120 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5121 PACKET_QStartNoAckMode
},
5122 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5123 PACKET_multiprocess_feature
},
5124 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5125 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5126 PACKET_qXfer_siginfo_read
},
5127 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5128 PACKET_qXfer_siginfo_write
},
5129 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5130 PACKET_ConditionalTracepoints
},
5131 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5132 PACKET_ConditionalBreakpoints
},
5133 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5134 PACKET_BreakpointCommands
},
5135 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5136 PACKET_FastTracepoints
},
5137 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5138 PACKET_StaticTracepoints
},
5139 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5140 PACKET_InstallInTrace
},
5141 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5142 PACKET_DisconnectedTracing_feature
},
5143 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5145 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5147 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5148 PACKET_TracepointSource
},
5149 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5151 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5152 PACKET_EnableDisableTracepoints_feature
},
5153 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5154 PACKET_qXfer_fdpic
},
5155 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5157 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5158 PACKET_QDisableRandomization
},
5159 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5160 { "QTBuffer:size", PACKET_DISABLE
,
5161 remote_supported_packet
, PACKET_QTBuffer_size
},
5162 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5163 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5164 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5165 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5166 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5167 PACKET_qXfer_btrace
},
5168 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5169 PACKET_qXfer_btrace_conf
},
5170 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5171 PACKET_Qbtrace_conf_bts_size
},
5172 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5173 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5174 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5175 PACKET_fork_event_feature
},
5176 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5177 PACKET_vfork_event_feature
},
5178 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5179 PACKET_exec_event_feature
},
5180 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5181 PACKET_Qbtrace_conf_pt_size
},
5182 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5183 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5184 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5187 static char *remote_support_xml
;
5189 /* Register string appended to "xmlRegisters=" in qSupported query. */
5192 register_remote_support_xml (const char *xml
)
5194 #if defined(HAVE_LIBEXPAT)
5195 if (remote_support_xml
== NULL
)
5196 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5199 char *copy
= xstrdup (remote_support_xml
+ 13);
5201 char *p
= strtok_r (copy
, ",", &saveptr
);
5205 if (strcmp (p
, xml
) == 0)
5212 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5215 remote_support_xml
= reconcat (remote_support_xml
,
5216 remote_support_xml
, ",", xml
,
5223 remote_query_supported_append (std::string
*msg
, const char *append
)
5227 msg
->append (append
);
5231 remote_target::remote_query_supported ()
5233 struct remote_state
*rs
= get_remote_state ();
5236 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5238 /* The packet support flags are handled differently for this packet
5239 than for most others. We treat an error, a disabled packet, and
5240 an empty response identically: any features which must be reported
5241 to be used will be automatically disabled. An empty buffer
5242 accomplishes this, since that is also the representation for a list
5243 containing no features. */
5246 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5250 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5251 remote_query_supported_append (&q
, "multiprocess+");
5253 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5254 remote_query_supported_append (&q
, "swbreak+");
5255 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5256 remote_query_supported_append (&q
, "hwbreak+");
5258 remote_query_supported_append (&q
, "qRelocInsn+");
5260 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5261 != AUTO_BOOLEAN_FALSE
)
5262 remote_query_supported_append (&q
, "fork-events+");
5263 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5264 != AUTO_BOOLEAN_FALSE
)
5265 remote_query_supported_append (&q
, "vfork-events+");
5266 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5267 != AUTO_BOOLEAN_FALSE
)
5268 remote_query_supported_append (&q
, "exec-events+");
5270 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5271 remote_query_supported_append (&q
, "vContSupported+");
5273 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5274 remote_query_supported_append (&q
, "QThreadEvents+");
5276 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5277 remote_query_supported_append (&q
, "no-resumed+");
5279 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5280 the qSupported:xmlRegisters=i386 handling. */
5281 if (remote_support_xml
!= NULL
5282 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5283 remote_query_supported_append (&q
, remote_support_xml
);
5285 q
= "qSupported:" + q
;
5286 putpkt (q
.c_str ());
5288 getpkt (&rs
->buf
, 0);
5290 /* If an error occured, warn, but do not return - just reset the
5291 buffer to empty and go on to disable features. */
5292 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5295 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5300 memset (seen
, 0, sizeof (seen
));
5302 next
= rs
->buf
.data ();
5305 enum packet_support is_supported
;
5306 char *p
, *end
, *name_end
, *value
;
5308 /* First separate out this item from the rest of the packet. If
5309 there's another item after this, we overwrite the separator
5310 (terminated strings are much easier to work with). */
5312 end
= strchr (p
, ';');
5315 end
= p
+ strlen (p
);
5325 warning (_("empty item in \"qSupported\" response"));
5330 name_end
= strchr (p
, '=');
5333 /* This is a name=value entry. */
5334 is_supported
= PACKET_ENABLE
;
5335 value
= name_end
+ 1;
5344 is_supported
= PACKET_ENABLE
;
5348 is_supported
= PACKET_DISABLE
;
5352 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5356 warning (_("unrecognized item \"%s\" "
5357 "in \"qSupported\" response"), p
);
5363 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5364 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5366 const struct protocol_feature
*feature
;
5369 feature
= &remote_protocol_features
[i
];
5370 feature
->func (this, feature
, is_supported
, value
);
5375 /* If we increased the packet size, make sure to increase the global
5376 buffer size also. We delay this until after parsing the entire
5377 qSupported packet, because this is the same buffer we were
5379 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5380 rs
->buf
.resize (rs
->explicit_packet_size
);
5382 /* Handle the defaults for unmentioned features. */
5383 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5386 const struct protocol_feature
*feature
;
5388 feature
= &remote_protocol_features
[i
];
5389 feature
->func (this, feature
, feature
->default_support
, NULL
);
5393 /* Serial QUIT handler for the remote serial descriptor.
5395 Defers handling a Ctrl-C until we're done with the current
5396 command/response packet sequence, unless:
5398 - We're setting up the connection. Don't send a remote interrupt
5399 request, as we're not fully synced yet. Quit immediately
5402 - The target has been resumed in the foreground
5403 (target_terminal::is_ours is false) with a synchronous resume
5404 packet, and we're blocked waiting for the stop reply, thus a
5405 Ctrl-C should be immediately sent to the target.
5407 - We get a second Ctrl-C while still within the same serial read or
5408 write. In that case the serial is seemingly wedged --- offer to
5411 - We see a second Ctrl-C without target response, after having
5412 previously interrupted the target. In that case the target/stub
5413 is probably wedged --- offer to quit/disconnect.
5417 remote_target::remote_serial_quit_handler ()
5419 struct remote_state
*rs
= get_remote_state ();
5421 if (check_quit_flag ())
5423 /* If we're starting up, we're not fully synced yet. Quit
5425 if (rs
->starting_up
)
5427 else if (rs
->got_ctrlc_during_io
)
5429 if (query (_("The target is not responding to GDB commands.\n"
5430 "Stop debugging it? ")))
5431 remote_unpush_and_throw ();
5433 /* If ^C has already been sent once, offer to disconnect. */
5434 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5436 /* All-stop protocol, and blocked waiting for stop reply. Send
5437 an interrupt request. */
5438 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5439 target_interrupt ();
5441 rs
->got_ctrlc_during_io
= 1;
5445 /* The remote_target that is current while the quit handler is
5446 overridden with remote_serial_quit_handler. */
5447 static remote_target
*curr_quit_handler_target
;
5450 remote_serial_quit_handler ()
5452 curr_quit_handler_target
->remote_serial_quit_handler ();
5455 /* Remove any of the remote.c targets from target stack. Upper targets depend
5456 on it so remove them first. */
5459 remote_unpush_target (void)
5461 pop_all_targets_at_and_above (process_stratum
);
5465 remote_unpush_and_throw (void)
5467 remote_unpush_target ();
5468 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5472 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5474 remote_target
*curr_remote
= get_current_remote_target ();
5477 error (_("To open a remote debug connection, you need to specify what\n"
5478 "serial device is attached to the remote system\n"
5479 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5481 /* If we're connected to a running target, target_preopen will kill it.
5482 Ask this question first, before target_preopen has a chance to kill
5484 if (curr_remote
!= NULL
&& !have_inferiors ())
5487 && !query (_("Already connected to a remote target. Disconnect? ")))
5488 error (_("Still connected."));
5491 /* Here the possibly existing remote target gets unpushed. */
5492 target_preopen (from_tty
);
5494 remote_fileio_reset ();
5495 reopen_exec_file ();
5498 remote_target
*remote
5499 = (extended_p
? new extended_remote_target () : new remote_target ());
5500 target_ops_up
target_holder (remote
);
5502 remote_state
*rs
= remote
->get_remote_state ();
5504 /* See FIXME above. */
5505 if (!target_async_permitted
)
5506 rs
->wait_forever_enabled_p
= 1;
5508 rs
->remote_desc
= remote_serial_open (name
);
5509 if (!rs
->remote_desc
)
5510 perror_with_name (name
);
5512 if (baud_rate
!= -1)
5514 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5516 /* The requested speed could not be set. Error out to
5517 top level after closing remote_desc. Take care to
5518 set remote_desc to NULL to avoid closing remote_desc
5520 serial_close (rs
->remote_desc
);
5521 rs
->remote_desc
= NULL
;
5522 perror_with_name (name
);
5526 serial_setparity (rs
->remote_desc
, serial_parity
);
5527 serial_raw (rs
->remote_desc
);
5529 /* If there is something sitting in the buffer we might take it as a
5530 response to a command, which would be bad. */
5531 serial_flush_input (rs
->remote_desc
);
5535 puts_filtered ("Remote debugging using ");
5536 puts_filtered (name
);
5537 puts_filtered ("\n");
5540 /* Switch to using the remote target now. */
5541 push_target (std::move (target_holder
));
5543 /* Register extra event sources in the event loop. */
5544 rs
->remote_async_inferior_event_token
5545 = create_async_event_handler (remote_async_inferior_event_handler
,
5547 rs
->notif_state
= remote_notif_state_allocate (remote
);
5549 /* Reset the target state; these things will be queried either by
5550 remote_query_supported or as they are needed. */
5551 reset_all_packet_configs_support ();
5552 rs
->cached_wait_status
= 0;
5553 rs
->explicit_packet_size
= 0;
5555 rs
->extended
= extended_p
;
5556 rs
->waiting_for_stop_reply
= 0;
5557 rs
->ctrlc_pending_p
= 0;
5558 rs
->got_ctrlc_during_io
= 0;
5560 rs
->general_thread
= not_sent_ptid
;
5561 rs
->continue_thread
= not_sent_ptid
;
5562 rs
->remote_traceframe_number
= -1;
5564 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5566 /* Probe for ability to use "ThreadInfo" query, as required. */
5567 rs
->use_threadinfo_query
= 1;
5568 rs
->use_threadextra_query
= 1;
5570 rs
->readahead_cache
.invalidate ();
5572 if (target_async_permitted
)
5574 /* FIXME: cagney/1999-09-23: During the initial connection it is
5575 assumed that the target is already ready and able to respond to
5576 requests. Unfortunately remote_start_remote() eventually calls
5577 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5578 around this. Eventually a mechanism that allows
5579 wait_for_inferior() to expect/get timeouts will be
5581 rs
->wait_forever_enabled_p
= 0;
5584 /* First delete any symbols previously loaded from shared libraries. */
5585 no_shared_libraries (NULL
, 0);
5587 /* Start the remote connection. If error() or QUIT, discard this
5588 target (we'd otherwise be in an inconsistent state) and then
5589 propogate the error on up the exception chain. This ensures that
5590 the caller doesn't stumble along blindly assuming that the
5591 function succeeded. The CLI doesn't have this problem but other
5592 UI's, such as MI do.
5594 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5595 this function should return an error indication letting the
5596 caller restore the previous state. Unfortunately the command
5597 ``target remote'' is directly wired to this function making that
5598 impossible. On a positive note, the CLI side of this problem has
5599 been fixed - the function set_cmd_context() makes it possible for
5600 all the ``target ....'' commands to share a common callback
5601 function. See cli-dump.c. */
5606 remote
->start_remote (from_tty
, extended_p
);
5608 catch (const gdb_exception
&ex
)
5610 /* Pop the partially set up target - unless something else did
5611 already before throwing the exception. */
5612 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5613 remote_unpush_target ();
5618 remote_btrace_reset (rs
);
5620 if (target_async_permitted
)
5621 rs
->wait_forever_enabled_p
= 1;
5624 /* Detach the specified process. */
5627 remote_target::remote_detach_pid (int pid
)
5629 struct remote_state
*rs
= get_remote_state ();
5631 /* This should not be necessary, but the handling for D;PID in
5632 GDBserver versions prior to 8.2 incorrectly assumes that the
5633 selected process points to the same process we're detaching,
5634 leading to misbehavior (and possibly GDBserver crashing) when it
5635 does not. Since it's easy and cheap, work around it by forcing
5636 GDBserver to select GDB's current process. */
5637 set_general_process ();
5639 if (remote_multi_process_p (rs
))
5640 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5642 strcpy (rs
->buf
.data (), "D");
5645 getpkt (&rs
->buf
, 0);
5647 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5649 else if (rs
->buf
[0] == '\0')
5650 error (_("Remote doesn't know how to detach"));
5652 error (_("Can't detach process."));
5655 /* This detaches a program to which we previously attached, using
5656 inferior_ptid to identify the process. After this is done, GDB
5657 can be used to debug some other program. We better not have left
5658 any breakpoints in the target program or it'll die when it hits
5662 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5664 int pid
= inferior_ptid
.pid ();
5665 struct remote_state
*rs
= get_remote_state ();
5668 if (!target_has_execution
)
5669 error (_("No process to detach from."));
5671 target_announce_detach (from_tty
);
5673 /* Tell the remote target to detach. */
5674 remote_detach_pid (pid
);
5676 /* Exit only if this is the only active inferior. */
5677 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors () == 1)
5678 puts_filtered (_("Ending remote debugging.\n"));
5680 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
5682 /* Check to see if we are detaching a fork parent. Note that if we
5683 are detaching a fork child, tp == NULL. */
5684 is_fork_parent
= (tp
!= NULL
5685 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5687 /* If doing detach-on-fork, we don't mourn, because that will delete
5688 breakpoints that should be available for the followed inferior. */
5689 if (!is_fork_parent
)
5691 /* Save the pid as a string before mourning, since that will
5692 unpush the remote target, and we need the string after. */
5693 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5695 target_mourn_inferior (inferior_ptid
);
5696 if (print_inferior_events
)
5697 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5698 inf
->num
, infpid
.c_str ());
5702 inferior_ptid
= null_ptid
;
5703 detach_inferior (current_inferior ());
5708 remote_target::detach (inferior
*inf
, int from_tty
)
5710 remote_detach_1 (inf
, from_tty
);
5714 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5716 remote_detach_1 (inf
, from_tty
);
5719 /* Target follow-fork function for remote targets. On entry, and
5720 at return, the current inferior is the fork parent.
5722 Note that although this is currently only used for extended-remote,
5723 it is named remote_follow_fork in anticipation of using it for the
5724 remote target as well. */
5727 remote_target::follow_fork (int follow_child
, int detach_fork
)
5729 struct remote_state
*rs
= get_remote_state ();
5730 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5732 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5733 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5735 /* When following the parent and detaching the child, we detach
5736 the child here. For the case of following the child and
5737 detaching the parent, the detach is done in the target-
5738 independent follow fork code in infrun.c. We can't use
5739 target_detach when detaching an unfollowed child because
5740 the client side doesn't know anything about the child. */
5741 if (detach_fork
&& !follow_child
)
5743 /* Detach the fork child. */
5747 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5748 child_pid
= child_ptid
.pid ();
5750 remote_detach_pid (child_pid
);
5756 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5757 in the program space of the new inferior. On entry and at return the
5758 current inferior is the exec'ing inferior. INF is the new exec'd
5759 inferior, which may be the same as the exec'ing inferior unless
5760 follow-exec-mode is "new". */
5763 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5765 /* We know that this is a target file name, so if it has the "target:"
5766 prefix we strip it off before saving it in the program space. */
5767 if (is_target_filename (execd_pathname
))
5768 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5770 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5773 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5776 remote_target::disconnect (const char *args
, int from_tty
)
5779 error (_("Argument given to \"disconnect\" when remotely debugging."));
5781 /* Make sure we unpush even the extended remote targets. Calling
5782 target_mourn_inferior won't unpush, and remote_mourn won't
5783 unpush if there is more than one inferior left. */
5784 unpush_target (this);
5785 generic_mourn_inferior ();
5788 puts_filtered ("Ending remote debugging.\n");
5791 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5792 be chatty about it. */
5795 extended_remote_target::attach (const char *args
, int from_tty
)
5797 struct remote_state
*rs
= get_remote_state ();
5799 char *wait_status
= NULL
;
5801 pid
= parse_pid_to_attach (args
);
5803 /* Remote PID can be freely equal to getpid, do not check it here the same
5804 way as in other targets. */
5806 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5807 error (_("This target does not support attaching to a process"));
5811 const char *exec_file
= get_exec_file (0);
5814 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5815 target_pid_to_str (ptid_t (pid
)).c_str ());
5817 printf_unfiltered (_("Attaching to %s\n"),
5818 target_pid_to_str (ptid_t (pid
)).c_str ());
5821 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5823 getpkt (&rs
->buf
, 0);
5825 switch (packet_ok (rs
->buf
,
5826 &remote_protocol_packets
[PACKET_vAttach
]))
5829 if (!target_is_non_stop_p ())
5831 /* Save the reply for later. */
5832 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5833 strcpy (wait_status
, rs
->buf
.data ());
5835 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5836 error (_("Attaching to %s failed with: %s"),
5837 target_pid_to_str (ptid_t (pid
)).c_str (),
5840 case PACKET_UNKNOWN
:
5841 error (_("This target does not support attaching to a process"));
5843 error (_("Attaching to %s failed"),
5844 target_pid_to_str (ptid_t (pid
)).c_str ());
5847 set_current_inferior (remote_add_inferior (false, pid
, 1, 0));
5849 inferior_ptid
= ptid_t (pid
);
5851 if (target_is_non_stop_p ())
5853 struct thread_info
*thread
;
5855 /* Get list of threads. */
5856 update_thread_list ();
5858 thread
= first_thread_of_inferior (current_inferior ());
5860 inferior_ptid
= thread
->ptid
;
5862 inferior_ptid
= ptid_t (pid
);
5864 /* Invalidate our notion of the remote current thread. */
5865 record_currthread (rs
, minus_one_ptid
);
5869 /* Now, if we have thread information, update inferior_ptid. */
5870 inferior_ptid
= remote_current_thread (inferior_ptid
);
5872 /* Add the main thread to the thread list. */
5873 thread_info
*thr
= add_thread_silent (inferior_ptid
);
5874 /* Don't consider the thread stopped until we've processed the
5875 saved stop reply. */
5876 set_executing (thr
->ptid
, true);
5879 /* Next, if the target can specify a description, read it. We do
5880 this before anything involving memory or registers. */
5881 target_find_description ();
5883 if (!target_is_non_stop_p ())
5885 /* Use the previously fetched status. */
5886 gdb_assert (wait_status
!= NULL
);
5888 if (target_can_async_p ())
5890 struct notif_event
*reply
5891 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
5893 push_stop_reply ((struct stop_reply
*) reply
);
5899 gdb_assert (wait_status
!= NULL
);
5900 strcpy (rs
->buf
.data (), wait_status
);
5901 rs
->cached_wait_status
= 1;
5905 gdb_assert (wait_status
== NULL
);
5908 /* Implementation of the to_post_attach method. */
5911 extended_remote_target::post_attach (int pid
)
5913 /* Get text, data & bss offsets. */
5916 /* In certain cases GDB might not have had the chance to start
5917 symbol lookup up until now. This could happen if the debugged
5918 binary is not using shared libraries, the vsyscall page is not
5919 present (on Linux) and the binary itself hadn't changed since the
5920 debugging process was started. */
5921 if (symfile_objfile
!= NULL
)
5922 remote_check_symbols();
5926 /* Check for the availability of vCont. This function should also check
5930 remote_target::remote_vcont_probe ()
5932 remote_state
*rs
= get_remote_state ();
5935 strcpy (rs
->buf
.data (), "vCont?");
5937 getpkt (&rs
->buf
, 0);
5938 buf
= rs
->buf
.data ();
5940 /* Make sure that the features we assume are supported. */
5941 if (startswith (buf
, "vCont"))
5944 int support_c
, support_C
;
5946 rs
->supports_vCont
.s
= 0;
5947 rs
->supports_vCont
.S
= 0;
5950 rs
->supports_vCont
.t
= 0;
5951 rs
->supports_vCont
.r
= 0;
5952 while (p
&& *p
== ';')
5955 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5956 rs
->supports_vCont
.s
= 1;
5957 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5958 rs
->supports_vCont
.S
= 1;
5959 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5961 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5963 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5964 rs
->supports_vCont
.t
= 1;
5965 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5966 rs
->supports_vCont
.r
= 1;
5968 p
= strchr (p
, ';');
5971 /* If c, and C are not all supported, we can't use vCont. Clearing
5972 BUF will make packet_ok disable the packet. */
5973 if (!support_c
|| !support_C
)
5977 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
5980 /* Helper function for building "vCont" resumptions. Write a
5981 resumption to P. ENDP points to one-passed-the-end of the buffer
5982 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
5983 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5984 resumed thread should be single-stepped and/or signalled. If PTID
5985 equals minus_one_ptid, then all threads are resumed; if PTID
5986 represents a process, then all threads of the process are resumed;
5987 the thread to be stepped and/or signalled is given in the global
5991 remote_target::append_resumption (char *p
, char *endp
,
5992 ptid_t ptid
, int step
, gdb_signal siggnal
)
5994 struct remote_state
*rs
= get_remote_state ();
5996 if (step
&& siggnal
!= GDB_SIGNAL_0
)
5997 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
5999 /* GDB is willing to range step. */
6000 && use_range_stepping
6001 /* Target supports range stepping. */
6002 && rs
->supports_vCont
.r
6003 /* We don't currently support range stepping multiple
6004 threads with a wildcard (though the protocol allows it,
6005 so stubs shouldn't make an active effort to forbid
6007 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6009 struct thread_info
*tp
;
6011 if (ptid
== minus_one_ptid
)
6013 /* If we don't know about the target thread's tid, then
6014 we're resuming magic_null_ptid (see caller). */
6015 tp
= find_thread_ptid (magic_null_ptid
);
6018 tp
= find_thread_ptid (ptid
);
6019 gdb_assert (tp
!= NULL
);
6021 if (tp
->control
.may_range_step
)
6023 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6025 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6026 phex_nz (tp
->control
.step_range_start
,
6028 phex_nz (tp
->control
.step_range_end
,
6032 p
+= xsnprintf (p
, endp
- p
, ";s");
6035 p
+= xsnprintf (p
, endp
- p
, ";s");
6036 else if (siggnal
!= GDB_SIGNAL_0
)
6037 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6039 p
+= xsnprintf (p
, endp
- p
, ";c");
6041 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6045 /* All (-1) threads of process. */
6046 nptid
= ptid_t (ptid
.pid (), -1, 0);
6048 p
+= xsnprintf (p
, endp
- p
, ":");
6049 p
= write_ptid (p
, endp
, nptid
);
6051 else if (ptid
!= minus_one_ptid
)
6053 p
+= xsnprintf (p
, endp
- p
, ":");
6054 p
= write_ptid (p
, endp
, ptid
);
6060 /* Clear the thread's private info on resume. */
6063 resume_clear_thread_private_info (struct thread_info
*thread
)
6065 if (thread
->priv
!= NULL
)
6067 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6069 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6070 priv
->watch_data_address
= 0;
6074 /* Append a vCont continue-with-signal action for threads that have a
6075 non-zero stop signal. */
6078 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6081 for (thread_info
*thread
: all_non_exited_threads (ptid
))
6082 if (inferior_ptid
!= thread
->ptid
6083 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6085 p
= append_resumption (p
, endp
, thread
->ptid
,
6086 0, thread
->suspend
.stop_signal
);
6087 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6088 resume_clear_thread_private_info (thread
);
6094 /* Set the target running, using the packets that use Hc
6098 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6101 struct remote_state
*rs
= get_remote_state ();
6104 rs
->last_sent_signal
= siggnal
;
6105 rs
->last_sent_step
= step
;
6107 /* The c/s/C/S resume packets use Hc, so set the continue
6109 if (ptid
== minus_one_ptid
)
6110 set_continue_thread (any_thread_ptid
);
6112 set_continue_thread (ptid
);
6114 for (thread_info
*thread
: all_non_exited_threads ())
6115 resume_clear_thread_private_info (thread
);
6117 buf
= rs
->buf
.data ();
6118 if (::execution_direction
== EXEC_REVERSE
)
6120 /* We don't pass signals to the target in reverse exec mode. */
6121 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6122 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6125 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6126 error (_("Remote reverse-step not supported."));
6127 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6128 error (_("Remote reverse-continue not supported."));
6130 strcpy (buf
, step
? "bs" : "bc");
6132 else if (siggnal
!= GDB_SIGNAL_0
)
6134 buf
[0] = step
? 'S' : 'C';
6135 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6136 buf
[2] = tohex (((int) siggnal
) & 0xf);
6140 strcpy (buf
, step
? "s" : "c");
6145 /* Resume the remote inferior by using a "vCont" packet. The thread
6146 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6147 resumed thread should be single-stepped and/or signalled. If PTID
6148 equals minus_one_ptid, then all threads are resumed; the thread to
6149 be stepped and/or signalled is given in the global INFERIOR_PTID.
6150 This function returns non-zero iff it resumes the inferior.
6152 This function issues a strict subset of all possible vCont commands
6156 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6157 enum gdb_signal siggnal
)
6159 struct remote_state
*rs
= get_remote_state ();
6163 /* No reverse execution actions defined for vCont. */
6164 if (::execution_direction
== EXEC_REVERSE
)
6167 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6168 remote_vcont_probe ();
6170 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6173 p
= rs
->buf
.data ();
6174 endp
= p
+ get_remote_packet_size ();
6176 /* If we could generate a wider range of packets, we'd have to worry
6177 about overflowing BUF. Should there be a generic
6178 "multi-part-packet" packet? */
6180 p
+= xsnprintf (p
, endp
- p
, "vCont");
6182 if (ptid
== magic_null_ptid
)
6184 /* MAGIC_NULL_PTID means that we don't have any active threads,
6185 so we don't have any TID numbers the inferior will
6186 understand. Make sure to only send forms that do not specify
6188 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6190 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6192 /* Resume all threads (of all processes, or of a single
6193 process), with preference for INFERIOR_PTID. This assumes
6194 inferior_ptid belongs to the set of all threads we are about
6196 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6198 /* Step inferior_ptid, with or without signal. */
6199 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6202 /* Also pass down any pending signaled resumption for other
6203 threads not the current. */
6204 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6206 /* And continue others without a signal. */
6207 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6211 /* Scheduler locking; resume only PTID. */
6212 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6215 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6218 if (target_is_non_stop_p ())
6220 /* In non-stop, the stub replies to vCont with "OK". The stop
6221 reply will be reported asynchronously by means of a `%Stop'
6223 getpkt (&rs
->buf
, 0);
6224 if (strcmp (rs
->buf
.data (), "OK") != 0)
6225 error (_("Unexpected vCont reply in non-stop mode: %s"),
6232 /* Tell the remote machine to resume. */
6235 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6237 struct remote_state
*rs
= get_remote_state ();
6239 /* When connected in non-stop mode, the core resumes threads
6240 individually. Resuming remote threads directly in target_resume
6241 would thus result in sending one packet per thread. Instead, to
6242 minimize roundtrip latency, here we just store the resume
6243 request; the actual remote resumption will be done in
6244 target_commit_resume / remote_commit_resume, where we'll be able
6245 to do vCont action coalescing. */
6246 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6248 remote_thread_info
*remote_thr
;
6250 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6251 remote_thr
= get_remote_thread_info (inferior_ptid
);
6253 remote_thr
= get_remote_thread_info (ptid
);
6255 remote_thr
->last_resume_step
= step
;
6256 remote_thr
->last_resume_sig
= siggnal
;
6260 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6261 (explained in remote-notif.c:handle_notification) so
6262 remote_notif_process is not called. We need find a place where
6263 it is safe to start a 'vNotif' sequence. It is good to do it
6264 before resuming inferior, because inferior was stopped and no RSP
6265 traffic at that moment. */
6266 if (!target_is_non_stop_p ())
6267 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6269 rs
->last_resume_exec_dir
= ::execution_direction
;
6271 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6272 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6273 remote_resume_with_hc (ptid
, step
, siggnal
);
6275 /* We are about to start executing the inferior, let's register it
6276 with the event loop. NOTE: this is the one place where all the
6277 execution commands end up. We could alternatively do this in each
6278 of the execution commands in infcmd.c. */
6279 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6280 into infcmd.c in order to allow inferior function calls to work
6281 NOT asynchronously. */
6282 if (target_can_async_p ())
6285 /* We've just told the target to resume. The remote server will
6286 wait for the inferior to stop, and then send a stop reply. In
6287 the mean time, we can't start another command/query ourselves
6288 because the stub wouldn't be ready to process it. This applies
6289 only to the base all-stop protocol, however. In non-stop (which
6290 only supports vCont), the stub replies with an "OK", and is
6291 immediate able to process further serial input. */
6292 if (!target_is_non_stop_p ())
6293 rs
->waiting_for_stop_reply
= 1;
6296 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6298 /* Private per-inferior info for target remote processes. */
6300 struct remote_inferior
: public private_inferior
6302 /* Whether we can send a wildcard vCont for this process. */
6303 bool may_wildcard_vcont
= true;
6306 /* Get the remote private inferior data associated to INF. */
6308 static remote_inferior
*
6309 get_remote_inferior (inferior
*inf
)
6311 if (inf
->priv
== NULL
)
6312 inf
->priv
.reset (new remote_inferior
);
6314 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6317 /* Class used to track the construction of a vCont packet in the
6318 outgoing packet buffer. This is used to send multiple vCont
6319 packets if we have more actions than would fit a single packet. */
6324 explicit vcont_builder (remote_target
*remote
)
6331 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6336 /* The remote target. */
6337 remote_target
*m_remote
;
6339 /* Pointer to the first action. P points here if no action has been
6341 char *m_first_action
;
6343 /* Where the next action will be appended. */
6346 /* The end of the buffer. Must never write past this. */
6350 /* Prepare the outgoing buffer for a new vCont packet. */
6353 vcont_builder::restart ()
6355 struct remote_state
*rs
= m_remote
->get_remote_state ();
6357 m_p
= rs
->buf
.data ();
6358 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6359 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6360 m_first_action
= m_p
;
6363 /* If the vCont packet being built has any action, send it to the
6367 vcont_builder::flush ()
6369 struct remote_state
*rs
;
6371 if (m_p
== m_first_action
)
6374 rs
= m_remote
->get_remote_state ();
6375 m_remote
->putpkt (rs
->buf
);
6376 m_remote
->getpkt (&rs
->buf
, 0);
6377 if (strcmp (rs
->buf
.data (), "OK") != 0)
6378 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6381 /* The largest action is range-stepping, with its two addresses. This
6382 is more than sufficient. If a new, bigger action is created, it'll
6383 quickly trigger a failed assertion in append_resumption (and we'll
6385 #define MAX_ACTION_SIZE 200
6387 /* Append a new vCont action in the outgoing packet being built. If
6388 the action doesn't fit the packet along with previous actions, push
6389 what we've got so far to the remote end and start over a new vCont
6390 packet (with the new action). */
6393 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6395 char buf
[MAX_ACTION_SIZE
+ 1];
6397 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6398 ptid
, step
, siggnal
);
6400 /* Check whether this new action would fit in the vCont packet along
6401 with previous actions. If not, send what we've got so far and
6402 start a new vCont packet. */
6403 size_t rsize
= endp
- buf
;
6404 if (rsize
> m_endp
- m_p
)
6409 /* Should now fit. */
6410 gdb_assert (rsize
<= m_endp
- m_p
);
6413 memcpy (m_p
, buf
, rsize
);
6418 /* to_commit_resume implementation. */
6421 remote_target::commit_resume ()
6423 int any_process_wildcard
;
6424 int may_global_wildcard_vcont
;
6426 /* If connected in all-stop mode, we'd send the remote resume
6427 request directly from remote_resume. Likewise if
6428 reverse-debugging, as there are no defined vCont actions for
6429 reverse execution. */
6430 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6433 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6434 instead of resuming all threads of each process individually.
6435 However, if any thread of a process must remain halted, we can't
6436 send wildcard resumes and must send one action per thread.
6438 Care must be taken to not resume threads/processes the server
6439 side already told us are stopped, but the core doesn't know about
6440 yet, because the events are still in the vStopped notification
6443 #1 => vCont s:p1.1;c
6445 #3 <= %Stopped T05 p1.1
6450 #8 (infrun handles the stop for p1.1 and continues stepping)
6451 #9 => vCont s:p1.1;c
6453 The last vCont above would resume thread p1.2 by mistake, because
6454 the server has no idea that the event for p1.2 had not been
6457 The server side must similarly ignore resume actions for the
6458 thread that has a pending %Stopped notification (and any other
6459 threads with events pending), until GDB acks the notification
6460 with vStopped. Otherwise, e.g., the following case is
6463 #1 => g (or any other packet)
6465 #3 <= %Stopped T05 p1.2
6466 #4 => vCont s:p1.1;c
6469 Above, the server must not resume thread p1.2. GDB can't know
6470 that p1.2 stopped until it acks the %Stopped notification, and
6471 since from GDB's perspective all threads should be running, it
6474 Finally, special care must also be given to handling fork/vfork
6475 events. A (v)fork event actually tells us that two processes
6476 stopped -- the parent and the child. Until we follow the fork,
6477 we must not resume the child. Therefore, if we have a pending
6478 fork follow, we must not send a global wildcard resume action
6479 (vCont;c). We can still send process-wide wildcards though. */
6481 /* Start by assuming a global wildcard (vCont;c) is possible. */
6482 may_global_wildcard_vcont
= 1;
6484 /* And assume every process is individually wildcard-able too. */
6485 for (inferior
*inf
: all_non_exited_inferiors ())
6487 remote_inferior
*priv
= get_remote_inferior (inf
);
6489 priv
->may_wildcard_vcont
= true;
6492 /* Check for any pending events (not reported or processed yet) and
6493 disable process and global wildcard resumes appropriately. */
6494 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6496 for (thread_info
*tp
: all_non_exited_threads ())
6498 /* If a thread of a process is not meant to be resumed, then we
6499 can't wildcard that process. */
6502 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6504 /* And if we can't wildcard a process, we can't wildcard
6505 everything either. */
6506 may_global_wildcard_vcont
= 0;
6510 /* If a thread is the parent of an unfollowed fork, then we
6511 can't do a global wildcard, as that would resume the fork
6513 if (is_pending_fork_parent_thread (tp
))
6514 may_global_wildcard_vcont
= 0;
6517 /* Now let's build the vCont packet(s). Actions must be appended
6518 from narrower to wider scopes (thread -> process -> global). If
6519 we end up with too many actions for a single packet vcont_builder
6520 flushes the current vCont packet to the remote side and starts a
6522 struct vcont_builder
vcont_builder (this);
6524 /* Threads first. */
6525 for (thread_info
*tp
: all_non_exited_threads ())
6527 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6529 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6532 gdb_assert (!thread_is_in_step_over_chain (tp
));
6534 if (!remote_thr
->last_resume_step
6535 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6536 && get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6538 /* We'll send a wildcard resume instead. */
6539 remote_thr
->vcont_resumed
= 1;
6543 vcont_builder
.push_action (tp
->ptid
,
6544 remote_thr
->last_resume_step
,
6545 remote_thr
->last_resume_sig
);
6546 remote_thr
->vcont_resumed
= 1;
6549 /* Now check whether we can send any process-wide wildcard. This is
6550 to avoid sending a global wildcard in the case nothing is
6551 supposed to be resumed. */
6552 any_process_wildcard
= 0;
6554 for (inferior
*inf
: all_non_exited_inferiors ())
6556 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6558 any_process_wildcard
= 1;
6563 if (any_process_wildcard
)
6565 /* If all processes are wildcard-able, then send a single "c"
6566 action, otherwise, send an "all (-1) threads of process"
6567 continue action for each running process, if any. */
6568 if (may_global_wildcard_vcont
)
6570 vcont_builder
.push_action (minus_one_ptid
,
6571 false, GDB_SIGNAL_0
);
6575 for (inferior
*inf
: all_non_exited_inferiors ())
6577 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6579 vcont_builder
.push_action (ptid_t (inf
->pid
),
6580 false, GDB_SIGNAL_0
);
6586 vcont_builder
.flush ();
6591 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6592 thread, all threads of a remote process, or all threads of all
6596 remote_target::remote_stop_ns (ptid_t ptid
)
6598 struct remote_state
*rs
= get_remote_state ();
6599 char *p
= rs
->buf
.data ();
6600 char *endp
= p
+ get_remote_packet_size ();
6602 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6603 remote_vcont_probe ();
6605 if (!rs
->supports_vCont
.t
)
6606 error (_("Remote server does not support stopping threads"));
6608 if (ptid
== minus_one_ptid
6609 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6610 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6615 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6618 /* All (-1) threads of process. */
6619 nptid
= ptid_t (ptid
.pid (), -1, 0);
6622 /* Small optimization: if we already have a stop reply for
6623 this thread, no use in telling the stub we want this
6625 if (peek_stop_reply (ptid
))
6631 write_ptid (p
, endp
, nptid
);
6634 /* In non-stop, we get an immediate OK reply. The stop reply will
6635 come in asynchronously by notification. */
6637 getpkt (&rs
->buf
, 0);
6638 if (strcmp (rs
->buf
.data (), "OK") != 0)
6639 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6643 /* All-stop version of target_interrupt. Sends a break or a ^C to
6644 interrupt the remote target. It is undefined which thread of which
6645 process reports the interrupt. */
6648 remote_target::remote_interrupt_as ()
6650 struct remote_state
*rs
= get_remote_state ();
6652 rs
->ctrlc_pending_p
= 1;
6654 /* If the inferior is stopped already, but the core didn't know
6655 about it yet, just ignore the request. The cached wait status
6656 will be collected in remote_wait. */
6657 if (rs
->cached_wait_status
)
6660 /* Send interrupt_sequence to remote target. */
6661 send_interrupt_sequence ();
6664 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6665 the remote target. It is undefined which thread of which process
6666 reports the interrupt. Throws an error if the packet is not
6667 supported by the server. */
6670 remote_target::remote_interrupt_ns ()
6672 struct remote_state
*rs
= get_remote_state ();
6673 char *p
= rs
->buf
.data ();
6674 char *endp
= p
+ get_remote_packet_size ();
6676 xsnprintf (p
, endp
- p
, "vCtrlC");
6678 /* In non-stop, we get an immediate OK reply. The stop reply will
6679 come in asynchronously by notification. */
6681 getpkt (&rs
->buf
, 0);
6683 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6687 case PACKET_UNKNOWN
:
6688 error (_("No support for interrupting the remote target."));
6690 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6694 /* Implement the to_stop function for the remote targets. */
6697 remote_target::stop (ptid_t ptid
)
6700 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6702 if (target_is_non_stop_p ())
6703 remote_stop_ns (ptid
);
6706 /* We don't currently have a way to transparently pause the
6707 remote target in all-stop mode. Interrupt it instead. */
6708 remote_interrupt_as ();
6712 /* Implement the to_interrupt function for the remote targets. */
6715 remote_target::interrupt ()
6718 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6720 if (target_is_non_stop_p ())
6721 remote_interrupt_ns ();
6723 remote_interrupt_as ();
6726 /* Implement the to_pass_ctrlc function for the remote targets. */
6729 remote_target::pass_ctrlc ()
6731 struct remote_state
*rs
= get_remote_state ();
6734 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6736 /* If we're starting up, we're not fully synced yet. Quit
6738 if (rs
->starting_up
)
6740 /* If ^C has already been sent once, offer to disconnect. */
6741 else if (rs
->ctrlc_pending_p
)
6744 target_interrupt ();
6747 /* Ask the user what to do when an interrupt is received. */
6750 remote_target::interrupt_query ()
6752 struct remote_state
*rs
= get_remote_state ();
6754 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6756 if (query (_("The target is not responding to interrupt requests.\n"
6757 "Stop debugging it? ")))
6759 remote_unpush_target ();
6760 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6765 if (query (_("Interrupted while waiting for the program.\n"
6766 "Give up waiting? ")))
6771 /* Enable/disable target terminal ownership. Most targets can use
6772 terminal groups to control terminal ownership. Remote targets are
6773 different in that explicit transfer of ownership to/from GDB/target
6777 remote_target::terminal_inferior ()
6779 /* NOTE: At this point we could also register our selves as the
6780 recipient of all input. Any characters typed could then be
6781 passed on down to the target. */
6785 remote_target::terminal_ours ()
6790 remote_console_output (const char *msg
)
6794 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6797 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6801 fputs_unfiltered (tb
, gdb_stdtarg
);
6803 gdb_flush (gdb_stdtarg
);
6806 struct stop_reply
: public notif_event
6810 /* The identifier of the thread about this event */
6813 /* The remote state this event is associated with. When the remote
6814 connection, represented by a remote_state object, is closed,
6815 all the associated stop_reply events should be released. */
6816 struct remote_state
*rs
;
6818 struct target_waitstatus ws
;
6820 /* The architecture associated with the expedited registers. */
6823 /* Expedited registers. This makes remote debugging a bit more
6824 efficient for those targets that provide critical registers as
6825 part of their normal status mechanism (as another roundtrip to
6826 fetch them is avoided). */
6827 std::vector
<cached_reg_t
> regcache
;
6829 enum target_stop_reason stop_reason
;
6831 CORE_ADDR watch_data_address
;
6836 /* Return the length of the stop reply queue. */
6839 remote_target::stop_reply_queue_length ()
6841 remote_state
*rs
= get_remote_state ();
6842 return rs
->stop_reply_queue
.size ();
6846 remote_notif_stop_parse (remote_target
*remote
,
6847 struct notif_client
*self
, const char *buf
,
6848 struct notif_event
*event
)
6850 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6854 remote_notif_stop_ack (remote_target
*remote
,
6855 struct notif_client
*self
, const char *buf
,
6856 struct notif_event
*event
)
6858 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6861 putpkt (remote
, self
->ack_command
);
6863 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6865 /* We got an unknown stop reply. */
6866 error (_("Unknown stop reply"));
6869 remote
->push_stop_reply (stop_reply
);
6873 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
6874 struct notif_client
*self
)
6876 /* We can't get pending events in remote_notif_process for
6877 notification stop, and we have to do this in remote_wait_ns
6878 instead. If we fetch all queued events from stub, remote stub
6879 may exit and we have no chance to process them back in
6881 remote_state
*rs
= remote
->get_remote_state ();
6882 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
6886 stop_reply::~stop_reply ()
6888 for (cached_reg_t
®
: regcache
)
6892 static notif_event_up
6893 remote_notif_stop_alloc_reply ()
6895 return notif_event_up (new struct stop_reply ());
6898 /* A client of notification Stop. */
6900 struct notif_client notif_client_stop
=
6904 remote_notif_stop_parse
,
6905 remote_notif_stop_ack
,
6906 remote_notif_stop_can_get_pending_events
,
6907 remote_notif_stop_alloc_reply
,
6911 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6912 the pid of the process that owns the threads we want to check, or
6913 -1 if we want to check all threads. */
6916 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6919 if (ws
->kind
== TARGET_WAITKIND_FORKED
6920 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6922 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
6929 /* Return the thread's pending status used to determine whether the
6930 thread is a fork parent stopped at a fork event. */
6932 static struct target_waitstatus
*
6933 thread_pending_fork_status (struct thread_info
*thread
)
6935 if (thread
->suspend
.waitstatus_pending_p
)
6936 return &thread
->suspend
.waitstatus
;
6938 return &thread
->pending_follow
;
6941 /* Determine if THREAD is a pending fork parent thread. */
6944 is_pending_fork_parent_thread (struct thread_info
*thread
)
6946 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6949 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6952 /* If CONTEXT contains any fork child threads that have not been
6953 reported yet, remove them from the CONTEXT list. If such a
6954 thread exists it is because we are stopped at a fork catchpoint
6955 and have not yet called follow_fork, which will set up the
6956 host-side data structures for the new process. */
6959 remote_target::remove_new_fork_children (threads_listing_context
*context
)
6962 struct notif_client
*notif
= ¬if_client_stop
;
6964 /* For any threads stopped at a fork event, remove the corresponding
6965 fork child threads from the CONTEXT list. */
6966 for (thread_info
*thread
: all_non_exited_threads ())
6968 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6970 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
6971 context
->remove_thread (ws
->value
.related_pid
);
6974 /* Check for any pending fork events (not reported or processed yet)
6975 in process PID and remove those fork child threads from the
6976 CONTEXT list as well. */
6977 remote_notif_get_pending_events (notif
);
6978 for (auto &event
: get_remote_state ()->stop_reply_queue
)
6979 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6980 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
6981 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
6982 context
->remove_thread (event
->ws
.value
.related_pid
);
6985 /* Check whether any event pending in the vStopped queue would prevent
6986 a global or process wildcard vCont action. Clear
6987 *may_global_wildcard if we can't do a global wildcard (vCont;c),
6988 and clear the event inferior's may_wildcard_vcont flag if we can't
6989 do a process-wide wildcard resume (vCont;c:pPID.-1). */
6992 remote_target::check_pending_events_prevent_wildcard_vcont
6993 (int *may_global_wildcard
)
6995 struct notif_client
*notif
= ¬if_client_stop
;
6997 remote_notif_get_pending_events (notif
);
6998 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7000 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
7001 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
7004 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7005 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
7006 *may_global_wildcard
= 0;
7008 struct inferior
*inf
= find_inferior_ptid (event
->ptid
);
7010 /* This may be the first time we heard about this process.
7011 Regardless, we must not do a global wildcard resume, otherwise
7012 we'd resume this process too. */
7013 *may_global_wildcard
= 0;
7015 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7019 /* Discard all pending stop replies of inferior INF. */
7022 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7024 struct stop_reply
*reply
;
7025 struct remote_state
*rs
= get_remote_state ();
7026 struct remote_notif_state
*rns
= rs
->notif_state
;
7028 /* This function can be notified when an inferior exists. When the
7029 target is not remote, the notification state is NULL. */
7030 if (rs
->remote_desc
== NULL
)
7033 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7035 /* Discard the in-flight notification. */
7036 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7039 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7042 /* Discard the stop replies we have already pulled with
7044 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7045 rs
->stop_reply_queue
.end (),
7046 [=] (const stop_reply_up
&event
)
7048 return event
->ptid
.pid () == inf
->pid
;
7050 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7053 /* Discard the stop replies for RS in stop_reply_queue. */
7056 remote_target::discard_pending_stop_replies_in_queue ()
7058 remote_state
*rs
= get_remote_state ();
7060 /* Discard the stop replies we have already pulled with
7062 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7063 rs
->stop_reply_queue
.end (),
7064 [=] (const stop_reply_up
&event
)
7066 return event
->rs
== rs
;
7068 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7071 /* Remove the first reply in 'stop_reply_queue' which matches
7075 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7077 remote_state
*rs
= get_remote_state ();
7079 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7080 rs
->stop_reply_queue
.end (),
7081 [=] (const stop_reply_up
&event
)
7083 return event
->ptid
.matches (ptid
);
7085 struct stop_reply
*result
;
7086 if (iter
== rs
->stop_reply_queue
.end ())
7090 result
= iter
->release ();
7091 rs
->stop_reply_queue
.erase (iter
);
7095 fprintf_unfiltered (gdb_stdlog
,
7096 "notif: discard queued event: 'Stop' in %s\n",
7097 target_pid_to_str (ptid
).c_str ());
7102 /* Look for a queued stop reply belonging to PTID. If one is found,
7103 remove it from the queue, and return it. Returns NULL if none is
7104 found. If there are still queued events left to process, tell the
7105 event loop to get back to target_wait soon. */
7108 remote_target::queued_stop_reply (ptid_t ptid
)
7110 remote_state
*rs
= get_remote_state ();
7111 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7113 if (!rs
->stop_reply_queue
.empty ())
7115 /* There's still at least an event left. */
7116 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7122 /* Push a fully parsed stop reply in the stop reply queue. Since we
7123 know that we now have at least one queued event left to pass to the
7124 core side, tell the event loop to get back to target_wait soon. */
7127 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7129 remote_state
*rs
= get_remote_state ();
7130 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7133 fprintf_unfiltered (gdb_stdlog
,
7134 "notif: push 'Stop' %s to queue %d\n",
7135 target_pid_to_str (new_event
->ptid
).c_str (),
7136 int (rs
->stop_reply_queue
.size ()));
7138 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7141 /* Returns true if we have a stop reply for PTID. */
7144 remote_target::peek_stop_reply (ptid_t ptid
)
7146 remote_state
*rs
= get_remote_state ();
7147 for (auto &event
: rs
->stop_reply_queue
)
7148 if (ptid
== event
->ptid
7149 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7154 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7155 starting with P and ending with PEND matches PREFIX. */
7158 strprefix (const char *p
, const char *pend
, const char *prefix
)
7160 for ( ; p
< pend
; p
++, prefix
++)
7163 return *prefix
== '\0';
7166 /* Parse the stop reply in BUF. Either the function succeeds, and the
7167 result is stored in EVENT, or throws an error. */
7170 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7172 remote_arch_state
*rsa
= NULL
;
7177 event
->ptid
= null_ptid
;
7178 event
->rs
= get_remote_state ();
7179 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7180 event
->ws
.value
.integer
= 0;
7181 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7182 event
->regcache
.clear ();
7187 case 'T': /* Status with PC, SP, FP, ... */
7188 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7189 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7191 n... = register number
7192 r... = register contents
7195 p
= &buf
[3]; /* after Txx */
7201 p1
= strchr (p
, ':');
7203 error (_("Malformed packet(a) (missing colon): %s\n\
7207 error (_("Malformed packet(a) (missing register number): %s\n\
7211 /* Some "registers" are actually extended stop information.
7212 Note if you're adding a new entry here: GDB 7.9 and
7213 earlier assume that all register "numbers" that start
7214 with an hex digit are real register numbers. Make sure
7215 the server only sends such a packet if it knows the
7216 client understands it. */
7218 if (strprefix (p
, p1
, "thread"))
7219 event
->ptid
= read_ptid (++p1
, &p
);
7220 else if (strprefix (p
, p1
, "syscall_entry"))
7224 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7225 p
= unpack_varlen_hex (++p1
, &sysno
);
7226 event
->ws
.value
.syscall_number
= (int) sysno
;
7228 else if (strprefix (p
, p1
, "syscall_return"))
7232 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7233 p
= unpack_varlen_hex (++p1
, &sysno
);
7234 event
->ws
.value
.syscall_number
= (int) sysno
;
7236 else if (strprefix (p
, p1
, "watch")
7237 || strprefix (p
, p1
, "rwatch")
7238 || strprefix (p
, p1
, "awatch"))
7240 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7241 p
= unpack_varlen_hex (++p1
, &addr
);
7242 event
->watch_data_address
= (CORE_ADDR
) addr
;
7244 else if (strprefix (p
, p1
, "swbreak"))
7246 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7248 /* Make sure the stub doesn't forget to indicate support
7250 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7251 error (_("Unexpected swbreak stop reason"));
7253 /* The value part is documented as "must be empty",
7254 though we ignore it, in case we ever decide to make
7255 use of it in a backward compatible way. */
7256 p
= strchrnul (p1
+ 1, ';');
7258 else if (strprefix (p
, p1
, "hwbreak"))
7260 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7262 /* Make sure the stub doesn't forget to indicate support
7264 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7265 error (_("Unexpected hwbreak stop reason"));
7268 p
= strchrnul (p1
+ 1, ';');
7270 else if (strprefix (p
, p1
, "library"))
7272 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7273 p
= strchrnul (p1
+ 1, ';');
7275 else if (strprefix (p
, p1
, "replaylog"))
7277 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7278 /* p1 will indicate "begin" or "end", but it makes
7279 no difference for now, so ignore it. */
7280 p
= strchrnul (p1
+ 1, ';');
7282 else if (strprefix (p
, p1
, "core"))
7286 p
= unpack_varlen_hex (++p1
, &c
);
7289 else if (strprefix (p
, p1
, "fork"))
7291 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7292 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7294 else if (strprefix (p
, p1
, "vfork"))
7296 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7297 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7299 else if (strprefix (p
, p1
, "vforkdone"))
7301 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7302 p
= strchrnul (p1
+ 1, ';');
7304 else if (strprefix (p
, p1
, "exec"))
7309 /* Determine the length of the execd pathname. */
7310 p
= unpack_varlen_hex (++p1
, &ignored
);
7311 pathlen
= (p
- p1
) / 2;
7313 /* Save the pathname for event reporting and for
7314 the next run command. */
7315 gdb::unique_xmalloc_ptr
<char[]> pathname
7316 ((char *) xmalloc (pathlen
+ 1));
7317 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7318 pathname
[pathlen
] = '\0';
7320 /* This is freed during event handling. */
7321 event
->ws
.value
.execd_pathname
= pathname
.release ();
7322 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7324 /* Skip the registers included in this packet, since
7325 they may be for an architecture different from the
7326 one used by the original program. */
7329 else if (strprefix (p
, p1
, "create"))
7331 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7332 p
= strchrnul (p1
+ 1, ';');
7341 p
= strchrnul (p1
+ 1, ';');
7346 /* Maybe a real ``P'' register number. */
7347 p_temp
= unpack_varlen_hex (p
, &pnum
);
7348 /* If the first invalid character is the colon, we got a
7349 register number. Otherwise, it's an unknown stop
7353 /* If we haven't parsed the event's thread yet, find
7354 it now, in order to find the architecture of the
7355 reported expedited registers. */
7356 if (event
->ptid
== null_ptid
)
7358 const char *thr
= strstr (p1
+ 1, ";thread:");
7360 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7364 /* Either the current thread hasn't changed,
7365 or the inferior is not multi-threaded.
7366 The event must be for the thread we last
7367 set as (or learned as being) current. */
7368 event
->ptid
= event
->rs
->general_thread
;
7374 inferior
*inf
= (event
->ptid
== null_ptid
7376 : find_inferior_ptid (event
->ptid
));
7377 /* If this is the first time we learn anything
7378 about this process, skip the registers
7379 included in this packet, since we don't yet
7380 know which architecture to use to parse them.
7381 We'll determine the architecture later when
7382 we process the stop reply and retrieve the
7383 target description, via
7384 remote_notice_new_inferior ->
7385 post_create_inferior. */
7388 p
= strchrnul (p1
+ 1, ';');
7393 event
->arch
= inf
->gdbarch
;
7394 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7398 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7399 cached_reg_t cached_reg
;
7402 error (_("Remote sent bad register number %s: %s\n\
7404 hex_string (pnum
), p
, buf
);
7406 cached_reg
.num
= reg
->regnum
;
7407 cached_reg
.data
= (gdb_byte
*)
7408 xmalloc (register_size (event
->arch
, reg
->regnum
));
7411 fieldsize
= hex2bin (p
, cached_reg
.data
,
7412 register_size (event
->arch
, reg
->regnum
));
7414 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7415 warning (_("Remote reply is too short: %s"), buf
);
7417 event
->regcache
.push_back (cached_reg
);
7421 /* Not a number. Silently skip unknown optional
7423 p
= strchrnul (p1
+ 1, ';');
7428 error (_("Remote register badly formatted: %s\nhere: %s"),
7433 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7437 case 'S': /* Old style status, just signal only. */
7441 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7442 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7443 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7444 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7446 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7449 case 'w': /* Thread exited. */
7453 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7454 p
= unpack_varlen_hex (&buf
[1], &value
);
7455 event
->ws
.value
.integer
= value
;
7457 error (_("stop reply packet badly formatted: %s"), buf
);
7458 event
->ptid
= read_ptid (++p
, NULL
);
7461 case 'W': /* Target exited. */
7466 /* GDB used to accept only 2 hex chars here. Stubs should
7467 only send more if they detect GDB supports multi-process
7469 p
= unpack_varlen_hex (&buf
[1], &value
);
7473 /* The remote process exited. */
7474 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7475 event
->ws
.value
.integer
= value
;
7479 /* The remote process exited with a signal. */
7480 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7481 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7482 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7484 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7487 /* If no process is specified, return null_ptid, and let the
7488 caller figure out the right process to use. */
7498 else if (startswith (p
, "process:"))
7502 p
+= sizeof ("process:") - 1;
7503 unpack_varlen_hex (p
, &upid
);
7507 error (_("unknown stop reply packet: %s"), buf
);
7510 error (_("unknown stop reply packet: %s"), buf
);
7511 event
->ptid
= ptid_t (pid
);
7515 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7516 event
->ptid
= minus_one_ptid
;
7520 if (target_is_non_stop_p () && event
->ptid
== null_ptid
)
7521 error (_("No process or thread specified in stop reply: %s"), buf
);
7524 /* When the stub wants to tell GDB about a new notification reply, it
7525 sends a notification (%Stop, for example). Those can come it at
7526 any time, hence, we have to make sure that any pending
7527 putpkt/getpkt sequence we're making is finished, before querying
7528 the stub for more events with the corresponding ack command
7529 (vStopped, for example). E.g., if we started a vStopped sequence
7530 immediately upon receiving the notification, something like this
7538 1.6) <-- (registers reply to step #1.3)
7540 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7543 To solve this, whenever we parse a %Stop notification successfully,
7544 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7545 doing whatever we were doing:
7551 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7552 2.5) <-- (registers reply to step #2.3)
7554 Eventually after step #2.5, we return to the event loop, which
7555 notices there's an event on the
7556 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7557 associated callback --- the function below. At this point, we're
7558 always safe to start a vStopped sequence. :
7561 2.7) <-- T05 thread:2
7567 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7569 struct remote_state
*rs
= get_remote_state ();
7571 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7574 fprintf_unfiltered (gdb_stdlog
,
7575 "notif: process: '%s' ack pending event\n",
7579 nc
->ack (this, nc
, rs
->buf
.data (),
7580 rs
->notif_state
->pending_event
[nc
->id
]);
7581 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7585 getpkt (&rs
->buf
, 0);
7586 if (strcmp (rs
->buf
.data (), "OK") == 0)
7589 remote_notif_ack (this, nc
, rs
->buf
.data ());
7595 fprintf_unfiltered (gdb_stdlog
,
7596 "notif: process: '%s' no pending reply\n",
7601 /* Wrapper around remote_target::remote_notif_get_pending_events to
7602 avoid having to export the whole remote_target class. */
7605 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7607 remote
->remote_notif_get_pending_events (nc
);
7610 /* Called when it is decided that STOP_REPLY holds the info of the
7611 event that is to be returned to the core. This function always
7612 destroys STOP_REPLY. */
7615 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7616 struct target_waitstatus
*status
)
7620 *status
= stop_reply
->ws
;
7621 ptid
= stop_reply
->ptid
;
7623 /* If no thread/process was reported by the stub, assume the current
7625 if (ptid
== null_ptid
)
7626 ptid
= inferior_ptid
;
7628 if (status
->kind
!= TARGET_WAITKIND_EXITED
7629 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7630 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7632 /* Expedited registers. */
7633 if (!stop_reply
->regcache
.empty ())
7635 struct regcache
*regcache
7636 = get_thread_arch_regcache (ptid
, stop_reply
->arch
);
7638 for (cached_reg_t
®
: stop_reply
->regcache
)
7640 regcache
->raw_supply (reg
.num
, reg
.data
);
7644 stop_reply
->regcache
.clear ();
7647 remote_notice_new_inferior (ptid
, 0);
7648 remote_thread_info
*remote_thr
= get_remote_thread_info (ptid
);
7649 remote_thr
->core
= stop_reply
->core
;
7650 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7651 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7652 remote_thr
->vcont_resumed
= 0;
7659 /* The non-stop mode version of target_wait. */
7662 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7664 struct remote_state
*rs
= get_remote_state ();
7665 struct stop_reply
*stop_reply
;
7669 /* If in non-stop mode, get out of getpkt even if a
7670 notification is received. */
7672 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7675 if (ret
!= -1 && !is_notif
)
7678 case 'E': /* Error of some sort. */
7679 /* We're out of sync with the target now. Did it continue
7680 or not? We can't tell which thread it was in non-stop,
7681 so just ignore this. */
7682 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7684 case 'O': /* Console output. */
7685 remote_console_output (&rs
->buf
[1]);
7688 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7692 /* Acknowledge a pending stop reply that may have arrived in the
7694 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7695 remote_notif_get_pending_events (¬if_client_stop
);
7697 /* If indeed we noticed a stop reply, we're done. */
7698 stop_reply
= queued_stop_reply (ptid
);
7699 if (stop_reply
!= NULL
)
7700 return process_stop_reply (stop_reply
, status
);
7702 /* Still no event. If we're just polling for an event, then
7703 return to the event loop. */
7704 if (options
& TARGET_WNOHANG
)
7706 status
->kind
= TARGET_WAITKIND_IGNORE
;
7707 return minus_one_ptid
;
7710 /* Otherwise do a blocking wait. */
7711 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7715 /* Return the first resumed thread. */
7718 first_remote_resumed_thread ()
7720 for (thread_info
*tp
: all_non_exited_threads (minus_one_ptid
))
7726 /* Wait until the remote machine stops, then return, storing status in
7727 STATUS just as `wait' would. */
7730 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
, int options
)
7732 struct remote_state
*rs
= get_remote_state ();
7733 ptid_t event_ptid
= null_ptid
;
7735 struct stop_reply
*stop_reply
;
7739 status
->kind
= TARGET_WAITKIND_IGNORE
;
7740 status
->value
.integer
= 0;
7742 stop_reply
= queued_stop_reply (ptid
);
7743 if (stop_reply
!= NULL
)
7744 return process_stop_reply (stop_reply
, status
);
7746 if (rs
->cached_wait_status
)
7747 /* Use the cached wait status, but only once. */
7748 rs
->cached_wait_status
= 0;
7753 int forever
= ((options
& TARGET_WNOHANG
) == 0
7754 && rs
->wait_forever_enabled_p
);
7756 if (!rs
->waiting_for_stop_reply
)
7758 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7759 return minus_one_ptid
;
7762 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7763 _never_ wait for ever -> test on target_is_async_p().
7764 However, before we do that we need to ensure that the caller
7765 knows how to take the target into/out of async mode. */
7766 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
7768 /* GDB gets a notification. Return to core as this event is
7770 if (ret
!= -1 && is_notif
)
7771 return minus_one_ptid
;
7773 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7774 return minus_one_ptid
;
7777 buf
= rs
->buf
.data ();
7779 /* Assume that the target has acknowledged Ctrl-C unless we receive
7780 an 'F' or 'O' packet. */
7781 if (buf
[0] != 'F' && buf
[0] != 'O')
7782 rs
->ctrlc_pending_p
= 0;
7786 case 'E': /* Error of some sort. */
7787 /* We're out of sync with the target now. Did it continue or
7788 not? Not is more likely, so report a stop. */
7789 rs
->waiting_for_stop_reply
= 0;
7791 warning (_("Remote failure reply: %s"), buf
);
7792 status
->kind
= TARGET_WAITKIND_STOPPED
;
7793 status
->value
.sig
= GDB_SIGNAL_0
;
7795 case 'F': /* File-I/O request. */
7796 /* GDB may access the inferior memory while handling the File-I/O
7797 request, but we don't want GDB accessing memory while waiting
7798 for a stop reply. See the comments in putpkt_binary. Set
7799 waiting_for_stop_reply to 0 temporarily. */
7800 rs
->waiting_for_stop_reply
= 0;
7801 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
7802 rs
->ctrlc_pending_p
= 0;
7803 /* GDB handled the File-I/O request, and the target is running
7804 again. Keep waiting for events. */
7805 rs
->waiting_for_stop_reply
= 1;
7807 case 'N': case 'T': case 'S': case 'X': case 'W':
7809 /* There is a stop reply to handle. */
7810 rs
->waiting_for_stop_reply
= 0;
7813 = (struct stop_reply
*) remote_notif_parse (this,
7817 event_ptid
= process_stop_reply (stop_reply
, status
);
7820 case 'O': /* Console output. */
7821 remote_console_output (buf
+ 1);
7824 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7826 /* Zero length reply means that we tried 'S' or 'C' and the
7827 remote system doesn't support it. */
7828 target_terminal::ours_for_output ();
7830 ("Can't send signals to this remote system. %s not sent.\n",
7831 gdb_signal_to_name (rs
->last_sent_signal
));
7832 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7833 target_terminal::inferior ();
7835 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7841 warning (_("Invalid remote reply: %s"), buf
);
7845 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7846 return minus_one_ptid
;
7847 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7849 /* Nothing interesting happened. If we're doing a non-blocking
7850 poll, we're done. Otherwise, go back to waiting. */
7851 if (options
& TARGET_WNOHANG
)
7852 return minus_one_ptid
;
7856 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7857 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7859 if (event_ptid
!= null_ptid
)
7860 record_currthread (rs
, event_ptid
);
7862 event_ptid
= first_remote_resumed_thread ();
7866 /* A process exit. Invalidate our notion of current thread. */
7867 record_currthread (rs
, minus_one_ptid
);
7868 /* It's possible that the packet did not include a pid. */
7869 if (event_ptid
== null_ptid
)
7870 event_ptid
= first_remote_resumed_thread ();
7871 /* EVENT_PTID could still be NULL_PTID. Double-check. */
7872 if (event_ptid
== null_ptid
)
7873 event_ptid
= magic_null_ptid
;
7879 /* Wait until the remote machine stops, then return, storing status in
7880 STATUS just as `wait' would. */
7883 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7887 if (target_is_non_stop_p ())
7888 event_ptid
= wait_ns (ptid
, status
, options
);
7890 event_ptid
= wait_as (ptid
, status
, options
);
7892 if (target_is_async_p ())
7894 remote_state
*rs
= get_remote_state ();
7896 /* If there are are events left in the queue tell the event loop
7898 if (!rs
->stop_reply_queue
.empty ())
7899 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7905 /* Fetch a single register using a 'p' packet. */
7908 remote_target::fetch_register_using_p (struct regcache
*regcache
,
7911 struct gdbarch
*gdbarch
= regcache
->arch ();
7912 struct remote_state
*rs
= get_remote_state ();
7914 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7917 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7920 if (reg
->pnum
== -1)
7923 p
= rs
->buf
.data ();
7925 p
+= hexnumstr (p
, reg
->pnum
);
7928 getpkt (&rs
->buf
, 0);
7930 buf
= rs
->buf
.data ();
7932 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
7936 case PACKET_UNKNOWN
:
7939 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7940 gdbarch_register_name (regcache
->arch (),
7945 /* If this register is unfetchable, tell the regcache. */
7948 regcache
->raw_supply (reg
->regnum
, NULL
);
7952 /* Otherwise, parse and supply the value. */
7958 error (_("fetch_register_using_p: early buf termination"));
7960 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7963 regcache
->raw_supply (reg
->regnum
, regp
);
7967 /* Fetch the registers included in the target's 'g' packet. */
7970 remote_target::send_g_packet ()
7972 struct remote_state
*rs
= get_remote_state ();
7975 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
7977 getpkt (&rs
->buf
, 0);
7978 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
7979 error (_("Could not read registers; remote failure reply '%s'"),
7982 /* We can get out of synch in various cases. If the first character
7983 in the buffer is not a hex character, assume that has happened
7984 and try to fetch another packet to read. */
7985 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
7986 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
7987 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
7988 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
7991 fprintf_unfiltered (gdb_stdlog
,
7992 "Bad register packet; fetching a new packet\n");
7993 getpkt (&rs
->buf
, 0);
7996 buf_len
= strlen (rs
->buf
.data ());
7998 /* Sanity check the received packet. */
7999 if (buf_len
% 2 != 0)
8000 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
8006 remote_target::process_g_packet (struct regcache
*regcache
)
8008 struct gdbarch
*gdbarch
= regcache
->arch ();
8009 struct remote_state
*rs
= get_remote_state ();
8010 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8015 buf_len
= strlen (rs
->buf
.data ());
8017 /* Further sanity checks, with knowledge of the architecture. */
8018 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
8019 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8021 rsa
->sizeof_g_packet
, buf_len
/ 2,
8024 /* Save the size of the packet sent to us by the target. It is used
8025 as a heuristic when determining the max size of packets that the
8026 target can safely receive. */
8027 if (rsa
->actual_register_packet_size
== 0)
8028 rsa
->actual_register_packet_size
= buf_len
;
8030 /* If this is smaller than we guessed the 'g' packet would be,
8031 update our records. A 'g' reply that doesn't include a register's
8032 value implies either that the register is not available, or that
8033 the 'p' packet must be used. */
8034 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8036 long sizeof_g_packet
= buf_len
/ 2;
8038 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8040 long offset
= rsa
->regs
[i
].offset
;
8041 long reg_size
= register_size (gdbarch
, i
);
8043 if (rsa
->regs
[i
].pnum
== -1)
8046 if (offset
>= sizeof_g_packet
)
8047 rsa
->regs
[i
].in_g_packet
= 0;
8048 else if (offset
+ reg_size
> sizeof_g_packet
)
8049 error (_("Truncated register %d in remote 'g' packet"), i
);
8051 rsa
->regs
[i
].in_g_packet
= 1;
8054 /* Looks valid enough, we can assume this is the correct length
8055 for a 'g' packet. It's important not to adjust
8056 rsa->sizeof_g_packet if we have truncated registers otherwise
8057 this "if" won't be run the next time the method is called
8058 with a packet of the same size and one of the internal errors
8059 below will trigger instead. */
8060 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8063 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8065 /* Unimplemented registers read as all bits zero. */
8066 memset (regs
, 0, rsa
->sizeof_g_packet
);
8068 /* Reply describes registers byte by byte, each byte encoded as two
8069 hex characters. Suck them all up, then supply them to the
8070 register cacheing/storage mechanism. */
8072 p
= rs
->buf
.data ();
8073 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8075 if (p
[0] == 0 || p
[1] == 0)
8076 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8077 internal_error (__FILE__
, __LINE__
,
8078 _("unexpected end of 'g' packet reply"));
8080 if (p
[0] == 'x' && p
[1] == 'x')
8081 regs
[i
] = 0; /* 'x' */
8083 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8087 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8089 struct packet_reg
*r
= &rsa
->regs
[i
];
8090 long reg_size
= register_size (gdbarch
, i
);
8094 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8095 /* This shouldn't happen - we adjusted in_g_packet above. */
8096 internal_error (__FILE__
, __LINE__
,
8097 _("unexpected end of 'g' packet reply"));
8098 else if (rs
->buf
[r
->offset
* 2] == 'x')
8100 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8101 /* The register isn't available, mark it as such (at
8102 the same time setting the value to zero). */
8103 regcache
->raw_supply (r
->regnum
, NULL
);
8106 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8112 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8115 process_g_packet (regcache
);
8118 /* Make the remote selected traceframe match GDB's selected
8122 remote_target::set_remote_traceframe ()
8125 struct remote_state
*rs
= get_remote_state ();
8127 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8130 /* Avoid recursion, remote_trace_find calls us again. */
8131 rs
->remote_traceframe_number
= get_traceframe_number ();
8133 newnum
= target_trace_find (tfind_number
,
8134 get_traceframe_number (), 0, 0, NULL
);
8136 /* Should not happen. If it does, all bets are off. */
8137 if (newnum
!= get_traceframe_number ())
8138 warning (_("could not set remote traceframe"));
8142 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8144 struct gdbarch
*gdbarch
= regcache
->arch ();
8145 struct remote_state
*rs
= get_remote_state ();
8146 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8149 set_remote_traceframe ();
8150 set_general_thread (regcache
->ptid ());
8154 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8156 gdb_assert (reg
!= NULL
);
8158 /* If this register might be in the 'g' packet, try that first -
8159 we are likely to read more than one register. If this is the
8160 first 'g' packet, we might be overly optimistic about its
8161 contents, so fall back to 'p'. */
8162 if (reg
->in_g_packet
)
8164 fetch_registers_using_g (regcache
);
8165 if (reg
->in_g_packet
)
8169 if (fetch_register_using_p (regcache
, reg
))
8172 /* This register is not available. */
8173 regcache
->raw_supply (reg
->regnum
, NULL
);
8178 fetch_registers_using_g (regcache
);
8180 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8181 if (!rsa
->regs
[i
].in_g_packet
)
8182 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8184 /* This register is not available. */
8185 regcache
->raw_supply (i
, NULL
);
8189 /* Prepare to store registers. Since we may send them all (using a
8190 'G' request), we have to read out the ones we don't want to change
8194 remote_target::prepare_to_store (struct regcache
*regcache
)
8196 struct remote_state
*rs
= get_remote_state ();
8197 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8200 /* Make sure the entire registers array is valid. */
8201 switch (packet_support (PACKET_P
))
8203 case PACKET_DISABLE
:
8204 case PACKET_SUPPORT_UNKNOWN
:
8205 /* Make sure all the necessary registers are cached. */
8206 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8207 if (rsa
->regs
[i
].in_g_packet
)
8208 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8215 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8216 packet was not recognized. */
8219 remote_target::store_register_using_P (const struct regcache
*regcache
,
8222 struct gdbarch
*gdbarch
= regcache
->arch ();
8223 struct remote_state
*rs
= get_remote_state ();
8224 /* Try storing a single register. */
8225 char *buf
= rs
->buf
.data ();
8226 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8229 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8232 if (reg
->pnum
== -1)
8235 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8236 p
= buf
+ strlen (buf
);
8237 regcache
->raw_collect (reg
->regnum
, regp
);
8238 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8240 getpkt (&rs
->buf
, 0);
8242 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8247 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8248 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8249 case PACKET_UNKNOWN
:
8252 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8256 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8257 contents of the register cache buffer. FIXME: ignores errors. */
8260 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8262 struct remote_state
*rs
= get_remote_state ();
8263 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8267 /* Extract all the registers in the regcache copying them into a
8272 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8273 memset (regs
, 0, rsa
->sizeof_g_packet
);
8274 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8276 struct packet_reg
*r
= &rsa
->regs
[i
];
8279 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8283 /* Command describes registers byte by byte,
8284 each byte encoded as two hex characters. */
8285 p
= rs
->buf
.data ();
8287 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8289 getpkt (&rs
->buf
, 0);
8290 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8291 error (_("Could not write registers; remote failure reply '%s'"),
8295 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8296 of the register cache buffer. FIXME: ignores errors. */
8299 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8301 struct gdbarch
*gdbarch
= regcache
->arch ();
8302 struct remote_state
*rs
= get_remote_state ();
8303 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8306 set_remote_traceframe ();
8307 set_general_thread (regcache
->ptid ());
8311 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8313 gdb_assert (reg
!= NULL
);
8315 /* Always prefer to store registers using the 'P' packet if
8316 possible; we often change only a small number of registers.
8317 Sometimes we change a larger number; we'd need help from a
8318 higher layer to know to use 'G'. */
8319 if (store_register_using_P (regcache
, reg
))
8322 /* For now, don't complain if we have no way to write the
8323 register. GDB loses track of unavailable registers too
8324 easily. Some day, this may be an error. We don't have
8325 any way to read the register, either... */
8326 if (!reg
->in_g_packet
)
8329 store_registers_using_G (regcache
);
8333 store_registers_using_G (regcache
);
8335 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8336 if (!rsa
->regs
[i
].in_g_packet
)
8337 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8338 /* See above for why we do not issue an error here. */
8343 /* Return the number of hex digits in num. */
8346 hexnumlen (ULONGEST num
)
8350 for (i
= 0; num
!= 0; i
++)
8353 return std::max (i
, 1);
8356 /* Set BUF to the minimum number of hex digits representing NUM. */
8359 hexnumstr (char *buf
, ULONGEST num
)
8361 int len
= hexnumlen (num
);
8363 return hexnumnstr (buf
, num
, len
);
8367 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8370 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8376 for (i
= width
- 1; i
>= 0; i
--)
8378 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8385 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8388 remote_address_masked (CORE_ADDR addr
)
8390 unsigned int address_size
= remote_address_size
;
8392 /* If "remoteaddresssize" was not set, default to target address size. */
8394 address_size
= gdbarch_addr_bit (target_gdbarch ());
8396 if (address_size
> 0
8397 && address_size
< (sizeof (ULONGEST
) * 8))
8399 /* Only create a mask when that mask can safely be constructed
8400 in a ULONGEST variable. */
8403 mask
= (mask
<< address_size
) - 1;
8409 /* Determine whether the remote target supports binary downloading.
8410 This is accomplished by sending a no-op memory write of zero length
8411 to the target at the specified address. It does not suffice to send
8412 the whole packet, since many stubs strip the eighth bit and
8413 subsequently compute a wrong checksum, which causes real havoc with
8416 NOTE: This can still lose if the serial line is not eight-bit
8417 clean. In cases like this, the user should clear "remote
8421 remote_target::check_binary_download (CORE_ADDR addr
)
8423 struct remote_state
*rs
= get_remote_state ();
8425 switch (packet_support (PACKET_X
))
8427 case PACKET_DISABLE
:
8431 case PACKET_SUPPORT_UNKNOWN
:
8435 p
= rs
->buf
.data ();
8437 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8439 p
+= hexnumstr (p
, (ULONGEST
) 0);
8443 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8444 getpkt (&rs
->buf
, 0);
8446 if (rs
->buf
[0] == '\0')
8449 fprintf_unfiltered (gdb_stdlog
,
8450 "binary downloading NOT "
8451 "supported by target\n");
8452 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8457 fprintf_unfiltered (gdb_stdlog
,
8458 "binary downloading supported by target\n");
8459 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8466 /* Helper function to resize the payload in order to try to get a good
8467 alignment. We try to write an amount of data such that the next write will
8468 start on an address aligned on REMOTE_ALIGN_WRITES. */
8471 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8473 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8476 /* Write memory data directly to the remote machine.
8477 This does not inform the data cache; the data cache uses this.
8478 HEADER is the starting part of the packet.
8479 MEMADDR is the address in the remote memory space.
8480 MYADDR is the address of the buffer in our space.
8481 LEN_UNITS is the number of addressable units to write.
8482 UNIT_SIZE is the length in bytes of an addressable unit.
8483 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8484 should send data as binary ('X'), or hex-encoded ('M').
8486 The function creates packet of the form
8487 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8489 where encoding of <DATA> is terminated by PACKET_FORMAT.
8491 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8494 Return the transferred status, error or OK (an
8495 'enum target_xfer_status' value). Save the number of addressable units
8496 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8498 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8499 exchange between gdb and the stub could look like (?? in place of the
8505 -> $M1000,3:eeeeffffeeee#??
8509 <- eeeeffffeeeedddd */
8512 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8513 const gdb_byte
*myaddr
,
8516 ULONGEST
*xfered_len_units
,
8517 char packet_format
, int use_length
)
8519 struct remote_state
*rs
= get_remote_state ();
8525 int payload_capacity_bytes
;
8526 int payload_length_bytes
;
8528 if (packet_format
!= 'X' && packet_format
!= 'M')
8529 internal_error (__FILE__
, __LINE__
,
8530 _("remote_write_bytes_aux: bad packet format"));
8533 return TARGET_XFER_EOF
;
8535 payload_capacity_bytes
= get_memory_write_packet_size ();
8537 /* The packet buffer will be large enough for the payload;
8538 get_memory_packet_size ensures this. */
8541 /* Compute the size of the actual payload by subtracting out the
8542 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8544 payload_capacity_bytes
-= strlen ("$,:#NN");
8546 /* The comma won't be used. */
8547 payload_capacity_bytes
+= 1;
8548 payload_capacity_bytes
-= strlen (header
);
8549 payload_capacity_bytes
-= hexnumlen (memaddr
);
8551 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8553 strcat (rs
->buf
.data (), header
);
8554 p
= rs
->buf
.data () + strlen (header
);
8556 /* Compute a best guess of the number of bytes actually transfered. */
8557 if (packet_format
== 'X')
8559 /* Best guess at number of bytes that will fit. */
8560 todo_units
= std::min (len_units
,
8561 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8563 payload_capacity_bytes
-= hexnumlen (todo_units
);
8564 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8568 /* Number of bytes that will fit. */
8570 = std::min (len_units
,
8571 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8573 payload_capacity_bytes
-= hexnumlen (todo_units
);
8574 todo_units
= std::min (todo_units
,
8575 (payload_capacity_bytes
/ unit_size
) / 2);
8578 if (todo_units
<= 0)
8579 internal_error (__FILE__
, __LINE__
,
8580 _("minimum packet size too small to write data"));
8582 /* If we already need another packet, then try to align the end
8583 of this packet to a useful boundary. */
8584 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8585 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8587 /* Append "<memaddr>". */
8588 memaddr
= remote_address_masked (memaddr
);
8589 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8596 /* Append the length and retain its location and size. It may need to be
8597 adjusted once the packet body has been created. */
8599 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8607 /* Append the packet body. */
8608 if (packet_format
== 'X')
8610 /* Binary mode. Send target system values byte by byte, in
8611 increasing byte addresses. Only escape certain critical
8613 payload_length_bytes
=
8614 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8615 &units_written
, payload_capacity_bytes
);
8617 /* If not all TODO units fit, then we'll need another packet. Make
8618 a second try to keep the end of the packet aligned. Don't do
8619 this if the packet is tiny. */
8620 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8624 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8626 if (new_todo_units
!= units_written
)
8627 payload_length_bytes
=
8628 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8629 (gdb_byte
*) p
, &units_written
,
8630 payload_capacity_bytes
);
8633 p
+= payload_length_bytes
;
8634 if (use_length
&& units_written
< todo_units
)
8636 /* Escape chars have filled up the buffer prematurely,
8637 and we have actually sent fewer units than planned.
8638 Fix-up the length field of the packet. Use the same
8639 number of characters as before. */
8640 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8642 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8647 /* Normal mode: Send target system values byte by byte, in
8648 increasing byte addresses. Each byte is encoded as a two hex
8650 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8651 units_written
= todo_units
;
8654 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8655 getpkt (&rs
->buf
, 0);
8657 if (rs
->buf
[0] == 'E')
8658 return TARGET_XFER_E_IO
;
8660 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8661 send fewer units than we'd planned. */
8662 *xfered_len_units
= (ULONGEST
) units_written
;
8663 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8666 /* Write memory data directly to the remote machine.
8667 This does not inform the data cache; the data cache uses this.
8668 MEMADDR is the address in the remote memory space.
8669 MYADDR is the address of the buffer in our space.
8670 LEN is the number of bytes.
8672 Return the transferred status, error or OK (an
8673 'enum target_xfer_status' value). Save the number of bytes
8674 transferred in *XFERED_LEN. Only transfer a single packet. */
8677 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8678 ULONGEST len
, int unit_size
,
8679 ULONGEST
*xfered_len
)
8681 const char *packet_format
= NULL
;
8683 /* Check whether the target supports binary download. */
8684 check_binary_download (memaddr
);
8686 switch (packet_support (PACKET_X
))
8689 packet_format
= "X";
8691 case PACKET_DISABLE
:
8692 packet_format
= "M";
8694 case PACKET_SUPPORT_UNKNOWN
:
8695 internal_error (__FILE__
, __LINE__
,
8696 _("remote_write_bytes: bad internal state"));
8698 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8701 return remote_write_bytes_aux (packet_format
,
8702 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8703 packet_format
[0], 1);
8706 /* Read memory data directly from the remote machine.
8707 This does not use the data cache; the data cache uses this.
8708 MEMADDR is the address in the remote memory space.
8709 MYADDR is the address of the buffer in our space.
8710 LEN_UNITS is the number of addressable memory units to read..
8711 UNIT_SIZE is the length in bytes of an addressable unit.
8713 Return the transferred status, error or OK (an
8714 'enum target_xfer_status' value). Save the number of bytes
8715 transferred in *XFERED_LEN_UNITS.
8717 See the comment of remote_write_bytes_aux for an example of
8718 memory read/write exchange between gdb and the stub. */
8721 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8723 int unit_size
, ULONGEST
*xfered_len_units
)
8725 struct remote_state
*rs
= get_remote_state ();
8726 int buf_size_bytes
; /* Max size of packet output buffer. */
8731 buf_size_bytes
= get_memory_read_packet_size ();
8732 /* The packet buffer will be large enough for the payload;
8733 get_memory_packet_size ensures this. */
8735 /* Number of units that will fit. */
8736 todo_units
= std::min (len_units
,
8737 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8739 /* Construct "m"<memaddr>","<len>". */
8740 memaddr
= remote_address_masked (memaddr
);
8741 p
= rs
->buf
.data ();
8743 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8745 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8748 getpkt (&rs
->buf
, 0);
8749 if (rs
->buf
[0] == 'E'
8750 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8751 && rs
->buf
[3] == '\0')
8752 return TARGET_XFER_E_IO
;
8753 /* Reply describes memory byte by byte, each byte encoded as two hex
8755 p
= rs
->buf
.data ();
8756 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8757 /* Return what we have. Let higher layers handle partial reads. */
8758 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8759 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8762 /* Using the set of read-only target sections of remote, read live
8765 For interface/parameters/return description see target.h,
8769 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
8773 ULONGEST
*xfered_len
)
8775 struct target_section
*secp
;
8776 struct target_section_table
*table
;
8778 secp
= target_section_by_addr (this, memaddr
);
8780 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
8782 struct target_section
*p
;
8783 ULONGEST memend
= memaddr
+ len
;
8785 table
= target_get_section_table (this);
8787 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8789 if (memaddr
>= p
->addr
)
8791 if (memend
<= p
->endaddr
)
8793 /* Entire transfer is within this section. */
8794 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8797 else if (memaddr
>= p
->endaddr
)
8799 /* This section ends before the transfer starts. */
8804 /* This section overlaps the transfer. Just do half. */
8805 len
= p
->endaddr
- memaddr
;
8806 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8813 return TARGET_XFER_EOF
;
8816 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8817 first if the requested memory is unavailable in traceframe.
8818 Otherwise, fall back to remote_read_bytes_1. */
8821 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
8822 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8823 ULONGEST
*xfered_len
)
8826 return TARGET_XFER_EOF
;
8828 if (get_traceframe_number () != -1)
8830 std::vector
<mem_range
> available
;
8832 /* If we fail to get the set of available memory, then the
8833 target does not support querying traceframe info, and so we
8834 attempt reading from the traceframe anyway (assuming the
8835 target implements the old QTro packet then). */
8836 if (traceframe_available_memory (&available
, memaddr
, len
))
8838 if (available
.empty () || available
[0].start
!= memaddr
)
8840 enum target_xfer_status res
;
8842 /* Don't read into the traceframe's available
8844 if (!available
.empty ())
8846 LONGEST oldlen
= len
;
8848 len
= available
[0].start
- memaddr
;
8849 gdb_assert (len
<= oldlen
);
8852 /* This goes through the topmost target again. */
8853 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
8854 len
, unit_size
, xfered_len
);
8855 if (res
== TARGET_XFER_OK
)
8856 return TARGET_XFER_OK
;
8859 /* No use trying further, we know some memory starting
8860 at MEMADDR isn't available. */
8862 return (*xfered_len
!= 0) ?
8863 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
8867 /* Don't try to read more than how much is available, in
8868 case the target implements the deprecated QTro packet to
8869 cater for older GDBs (the target's knowledge of read-only
8870 sections may be outdated by now). */
8871 len
= available
[0].length
;
8875 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8880 /* Sends a packet with content determined by the printf format string
8881 FORMAT and the remaining arguments, then gets the reply. Returns
8882 whether the packet was a success, a failure, or unknown. */
8885 remote_target::remote_send_printf (const char *format
, ...)
8887 struct remote_state
*rs
= get_remote_state ();
8888 int max_size
= get_remote_packet_size ();
8891 va_start (ap
, format
);
8894 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
8898 if (size
>= max_size
)
8899 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8901 if (putpkt (rs
->buf
) < 0)
8902 error (_("Communication problem with target."));
8905 getpkt (&rs
->buf
, 0);
8907 return packet_check_result (rs
->buf
);
8910 /* Flash writing can take quite some time. We'll set
8911 effectively infinite timeout for flash operations.
8912 In future, we'll need to decide on a better approach. */
8913 static const int remote_flash_timeout
= 1000;
8916 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
8918 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8919 enum packet_result ret
;
8920 scoped_restore restore_timeout
8921 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8923 ret
= remote_send_printf ("vFlashErase:%s,%s",
8924 phex (address
, addr_size
),
8928 case PACKET_UNKNOWN
:
8929 error (_("Remote target does not support flash erase"));
8931 error (_("Error erasing flash with vFlashErase packet"));
8938 remote_target::remote_flash_write (ULONGEST address
,
8939 ULONGEST length
, ULONGEST
*xfered_len
,
8940 const gdb_byte
*data
)
8942 scoped_restore restore_timeout
8943 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8944 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8949 remote_target::flash_done ()
8953 scoped_restore restore_timeout
8954 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8956 ret
= remote_send_printf ("vFlashDone");
8960 case PACKET_UNKNOWN
:
8961 error (_("Remote target does not support vFlashDone"));
8963 error (_("Error finishing flash operation"));
8970 remote_target::files_info ()
8972 puts_filtered ("Debugging a target over a serial line.\n");
8975 /* Stuff for dealing with the packets which are part of this protocol.
8976 See comment at top of file for details. */
8978 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8979 error to higher layers. Called when a serial error is detected.
8980 The exception message is STRING, followed by a colon and a blank,
8981 the system error message for errno at function entry and final dot
8982 for output compatibility with throw_perror_with_name. */
8985 unpush_and_perror (const char *string
)
8987 int saved_errno
= errno
;
8989 remote_unpush_target ();
8990 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
8991 safe_strerror (saved_errno
));
8994 /* Read a single character from the remote end. The current quit
8995 handler is overridden to avoid quitting in the middle of packet
8996 sequence, as that would break communication with the remote server.
8997 See remote_serial_quit_handler for more detail. */
9000 remote_target::readchar (int timeout
)
9003 struct remote_state
*rs
= get_remote_state ();
9006 scoped_restore restore_quit_target
9007 = make_scoped_restore (&curr_quit_handler_target
, this);
9008 scoped_restore restore_quit
9009 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9011 rs
->got_ctrlc_during_io
= 0;
9013 ch
= serial_readchar (rs
->remote_desc
, timeout
);
9015 if (rs
->got_ctrlc_during_io
)
9022 switch ((enum serial_rc
) ch
)
9025 remote_unpush_target ();
9026 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9029 unpush_and_perror (_("Remote communication error. "
9030 "Target disconnected."));
9032 case SERIAL_TIMEOUT
:
9038 /* Wrapper for serial_write that closes the target and throws if
9039 writing fails. The current quit handler is overridden to avoid
9040 quitting in the middle of packet sequence, as that would break
9041 communication with the remote server. See
9042 remote_serial_quit_handler for more detail. */
9045 remote_target::remote_serial_write (const char *str
, int len
)
9047 struct remote_state
*rs
= get_remote_state ();
9049 scoped_restore restore_quit_target
9050 = make_scoped_restore (&curr_quit_handler_target
, this);
9051 scoped_restore restore_quit
9052 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9054 rs
->got_ctrlc_during_io
= 0;
9056 if (serial_write (rs
->remote_desc
, str
, len
))
9058 unpush_and_perror (_("Remote communication error. "
9059 "Target disconnected."));
9062 if (rs
->got_ctrlc_during_io
)
9066 /* Return a string representing an escaped version of BUF, of len N.
9067 E.g. \n is converted to \\n, \t to \\t, etc. */
9070 escape_buffer (const char *buf
, int n
)
9074 stb
.putstrn (buf
, n
, '\\');
9075 return std::move (stb
.string ());
9078 /* Display a null-terminated packet on stdout, for debugging, using C
9082 print_packet (const char *buf
)
9084 puts_filtered ("\"");
9085 fputstr_filtered (buf
, '"', gdb_stdout
);
9086 puts_filtered ("\"");
9090 remote_target::putpkt (const char *buf
)
9092 return putpkt_binary (buf
, strlen (buf
));
9095 /* Wrapper around remote_target::putpkt to avoid exporting
9099 putpkt (remote_target
*remote
, const char *buf
)
9101 return remote
->putpkt (buf
);
9104 /* Send a packet to the remote machine, with error checking. The data
9105 of the packet is in BUF. The string in BUF can be at most
9106 get_remote_packet_size () - 5 to account for the $, # and checksum,
9107 and for a possible /0 if we are debugging (remote_debug) and want
9108 to print the sent packet as a string. */
9111 remote_target::putpkt_binary (const char *buf
, int cnt
)
9113 struct remote_state
*rs
= get_remote_state ();
9115 unsigned char csum
= 0;
9116 gdb::def_vector
<char> data (cnt
+ 6);
9117 char *buf2
= data
.data ();
9123 /* Catch cases like trying to read memory or listing threads while
9124 we're waiting for a stop reply. The remote server wouldn't be
9125 ready to handle this request, so we'd hang and timeout. We don't
9126 have to worry about this in synchronous mode, because in that
9127 case it's not possible to issue a command while the target is
9128 running. This is not a problem in non-stop mode, because in that
9129 case, the stub is always ready to process serial input. */
9130 if (!target_is_non_stop_p ()
9131 && target_is_async_p ()
9132 && rs
->waiting_for_stop_reply
)
9134 error (_("Cannot execute this command while the target is running.\n"
9135 "Use the \"interrupt\" command to stop the target\n"
9136 "and then try again."));
9139 /* We're sending out a new packet. Make sure we don't look at a
9140 stale cached response. */
9141 rs
->cached_wait_status
= 0;
9143 /* Copy the packet into buffer BUF2, encapsulating it
9144 and giving it a checksum. */
9149 for (i
= 0; i
< cnt
; i
++)
9155 *p
++ = tohex ((csum
>> 4) & 0xf);
9156 *p
++ = tohex (csum
& 0xf);
9158 /* Send it over and over until we get a positive ack. */
9162 int started_error_output
= 0;
9168 int len
= (int) (p
- buf2
);
9171 if (remote_packet_max_chars
< 0)
9174 max_chars
= remote_packet_max_chars
;
9177 = escape_buffer (buf2
, std::min (len
, max_chars
));
9179 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9181 if (len
> max_chars
)
9182 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9185 fprintf_unfiltered (gdb_stdlog
, "...");
9187 gdb_flush (gdb_stdlog
);
9189 remote_serial_write (buf2
, p
- buf2
);
9191 /* If this is a no acks version of the remote protocol, send the
9192 packet and move on. */
9196 /* Read until either a timeout occurs (-2) or '+' is read.
9197 Handle any notification that arrives in the mean time. */
9200 ch
= readchar (remote_timeout
);
9208 case SERIAL_TIMEOUT
:
9211 if (started_error_output
)
9213 putchar_unfiltered ('\n');
9214 started_error_output
= 0;
9223 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9227 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9229 case SERIAL_TIMEOUT
:
9233 break; /* Retransmit buffer. */
9237 fprintf_unfiltered (gdb_stdlog
,
9238 "Packet instead of Ack, ignoring it\n");
9239 /* It's probably an old response sent because an ACK
9240 was lost. Gobble up the packet and ack it so it
9241 doesn't get retransmitted when we resend this
9244 remote_serial_write ("+", 1);
9245 continue; /* Now, go look for +. */
9252 /* If we got a notification, handle it, and go back to looking
9254 /* We've found the start of a notification. Now
9255 collect the data. */
9256 val
= read_frame (&rs
->buf
);
9261 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9263 fprintf_unfiltered (gdb_stdlog
,
9264 " Notification received: %s\n",
9267 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9268 /* We're in sync now, rewait for the ack. */
9275 if (!started_error_output
)
9277 started_error_output
= 1;
9278 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9280 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9281 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9290 if (!started_error_output
)
9292 started_error_output
= 1;
9293 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9295 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9299 break; /* Here to retransmit. */
9303 /* This is wrong. If doing a long backtrace, the user should be
9304 able to get out next time we call QUIT, without anything as
9305 violent as interrupt_query. If we want to provide a way out of
9306 here without getting to the next QUIT, it should be based on
9307 hitting ^C twice as in remote_wait. */
9319 /* Come here after finding the start of a frame when we expected an
9320 ack. Do our best to discard the rest of this packet. */
9323 remote_target::skip_frame ()
9329 c
= readchar (remote_timeout
);
9332 case SERIAL_TIMEOUT
:
9333 /* Nothing we can do. */
9336 /* Discard the two bytes of checksum and stop. */
9337 c
= readchar (remote_timeout
);
9339 c
= readchar (remote_timeout
);
9342 case '*': /* Run length encoding. */
9343 /* Discard the repeat count. */
9344 c
= readchar (remote_timeout
);
9349 /* A regular character. */
9355 /* Come here after finding the start of the frame. Collect the rest
9356 into *BUF, verifying the checksum, length, and handling run-length
9357 compression. NUL terminate the buffer. If there is not enough room,
9360 Returns -1 on error, number of characters in buffer (ignoring the
9361 trailing NULL) on success. (could be extended to return one of the
9362 SERIAL status indications). */
9365 remote_target::read_frame (gdb::char_vector
*buf_p
)
9370 char *buf
= buf_p
->data ();
9371 struct remote_state
*rs
= get_remote_state ();
9378 c
= readchar (remote_timeout
);
9381 case SERIAL_TIMEOUT
:
9383 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9387 fputs_filtered ("Saw new packet start in middle of old one\n",
9389 return -1; /* Start a new packet, count retries. */
9392 unsigned char pktcsum
;
9398 check_0
= readchar (remote_timeout
);
9400 check_1
= readchar (remote_timeout
);
9402 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9405 fputs_filtered ("Timeout in checksum, retrying\n",
9409 else if (check_0
< 0 || check_1
< 0)
9412 fputs_filtered ("Communication error in checksum\n",
9417 /* Don't recompute the checksum; with no ack packets we
9418 don't have any way to indicate a packet retransmission
9423 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9424 if (csum
== pktcsum
)
9429 std::string str
= escape_buffer (buf
, bc
);
9431 fprintf_unfiltered (gdb_stdlog
,
9432 "Bad checksum, sentsum=0x%x, "
9433 "csum=0x%x, buf=%s\n",
9434 pktcsum
, csum
, str
.c_str ());
9436 /* Number of characters in buffer ignoring trailing
9440 case '*': /* Run length encoding. */
9445 c
= readchar (remote_timeout
);
9447 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9449 /* The character before ``*'' is repeated. */
9451 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9453 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9455 /* Make some more room in the buffer. */
9456 buf_p
->resize (buf_p
->size () + repeat
);
9457 buf
= buf_p
->data ();
9460 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9466 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9470 if (bc
>= buf_p
->size () - 1)
9472 /* Make some more room in the buffer. */
9473 buf_p
->resize (buf_p
->size () * 2);
9474 buf
= buf_p
->data ();
9484 /* Set this to the maximum number of seconds to wait instead of waiting forever
9485 in target_wait(). If this timer times out, then it generates an error and
9486 the command is aborted. This replaces most of the need for timeouts in the
9487 GDB test suite, and makes it possible to distinguish between a hung target
9488 and one with slow communications. */
9490 static int watchdog
= 0;
9492 show_watchdog (struct ui_file
*file
, int from_tty
,
9493 struct cmd_list_element
*c
, const char *value
)
9495 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9498 /* Read a packet from the remote machine, with error checking, and
9499 store it in *BUF. Resize *BUF if necessary to hold the result. If
9500 FOREVER, wait forever rather than timing out; this is used (in
9501 synchronous mode) to wait for a target that is is executing user
9503 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9504 don't have to change all the calls to getpkt to deal with the
9505 return value, because at the moment I don't know what the right
9506 thing to do it for those. */
9509 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9511 getpkt_sane (buf
, forever
);
9515 /* Read a packet from the remote machine, with error checking, and
9516 store it in *BUF. Resize *BUF if necessary to hold the result. If
9517 FOREVER, wait forever rather than timing out; this is used (in
9518 synchronous mode) to wait for a target that is is executing user
9519 code to stop. If FOREVER == 0, this function is allowed to time
9520 out gracefully and return an indication of this to the caller.
9521 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9522 consider receiving a notification enough reason to return to the
9523 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9524 holds a notification or not (a regular packet). */
9527 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9528 int forever
, int expecting_notif
,
9531 struct remote_state
*rs
= get_remote_state ();
9537 /* We're reading a new response. Make sure we don't look at a
9538 previously cached response. */
9539 rs
->cached_wait_status
= 0;
9541 strcpy (buf
->data (), "timeout");
9544 timeout
= watchdog
> 0 ? watchdog
: -1;
9545 else if (expecting_notif
)
9546 timeout
= 0; /* There should already be a char in the buffer. If
9549 timeout
= remote_timeout
;
9553 /* Process any number of notifications, and then return when
9557 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9559 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9561 /* This can loop forever if the remote side sends us
9562 characters continuously, but if it pauses, we'll get
9563 SERIAL_TIMEOUT from readchar because of timeout. Then
9564 we'll count that as a retry.
9566 Note that even when forever is set, we will only wait
9567 forever prior to the start of a packet. After that, we
9568 expect characters to arrive at a brisk pace. They should
9569 show up within remote_timeout intervals. */
9571 c
= readchar (timeout
);
9572 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9574 if (c
== SERIAL_TIMEOUT
)
9576 if (expecting_notif
)
9577 return -1; /* Don't complain, it's normal to not get
9578 anything in this case. */
9580 if (forever
) /* Watchdog went off? Kill the target. */
9582 remote_unpush_target ();
9583 throw_error (TARGET_CLOSE_ERROR
,
9584 _("Watchdog timeout has expired. "
9585 "Target detached."));
9588 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9592 /* We've found the start of a packet or notification.
9593 Now collect the data. */
9594 val
= read_frame (buf
);
9599 remote_serial_write ("-", 1);
9602 if (tries
> MAX_TRIES
)
9604 /* We have tried hard enough, and just can't receive the
9605 packet/notification. Give up. */
9606 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9608 /* Skip the ack char if we're in no-ack mode. */
9609 if (!rs
->noack_mode
)
9610 remote_serial_write ("+", 1);
9614 /* If we got an ordinary packet, return that to our caller. */
9621 if (remote_packet_max_chars
< 0)
9624 max_chars
= remote_packet_max_chars
;
9627 = escape_buffer (buf
->data (),
9628 std::min (val
, max_chars
));
9630 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9633 if (val
> max_chars
)
9634 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9637 fprintf_unfiltered (gdb_stdlog
, "\n");
9640 /* Skip the ack char if we're in no-ack mode. */
9641 if (!rs
->noack_mode
)
9642 remote_serial_write ("+", 1);
9643 if (is_notif
!= NULL
)
9648 /* If we got a notification, handle it, and go back to looking
9652 gdb_assert (c
== '%');
9656 std::string str
= escape_buffer (buf
->data (), val
);
9658 fprintf_unfiltered (gdb_stdlog
,
9659 " Notification received: %s\n",
9662 if (is_notif
!= NULL
)
9665 handle_notification (rs
->notif_state
, buf
->data ());
9667 /* Notifications require no acknowledgement. */
9669 if (expecting_notif
)
9676 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9678 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9682 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9685 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9688 /* Kill any new fork children of process PID that haven't been
9689 processed by follow_fork. */
9692 remote_target::kill_new_fork_children (int pid
)
9694 remote_state
*rs
= get_remote_state ();
9695 struct notif_client
*notif
= ¬if_client_stop
;
9697 /* Kill the fork child threads of any threads in process PID
9698 that are stopped at a fork event. */
9699 for (thread_info
*thread
: all_non_exited_threads ())
9701 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9703 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9705 int child_pid
= ws
->value
.related_pid
.pid ();
9708 res
= remote_vkill (child_pid
);
9710 error (_("Can't kill fork child process %d"), child_pid
);
9714 /* Check for any pending fork events (not reported or processed yet)
9715 in process PID and kill those fork child threads as well. */
9716 remote_notif_get_pending_events (notif
);
9717 for (auto &event
: rs
->stop_reply_queue
)
9718 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9720 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9723 res
= remote_vkill (child_pid
);
9725 error (_("Can't kill fork child process %d"), child_pid
);
9730 /* Target hook to kill the current inferior. */
9733 remote_target::kill ()
9736 int pid
= inferior_ptid
.pid ();
9737 struct remote_state
*rs
= get_remote_state ();
9739 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9741 /* If we're stopped while forking and we haven't followed yet,
9742 kill the child task. We need to do this before killing the
9743 parent task because if this is a vfork then the parent will
9745 kill_new_fork_children (pid
);
9747 res
= remote_vkill (pid
);
9750 target_mourn_inferior (inferior_ptid
);
9755 /* If we are in 'target remote' mode and we are killing the only
9756 inferior, then we will tell gdbserver to exit and unpush the
9758 if (res
== -1 && !remote_multi_process_p (rs
)
9759 && number_of_live_inferiors () == 1)
9763 /* We've killed the remote end, we get to mourn it. If we are
9764 not in extended mode, mourning the inferior also unpushes
9765 remote_ops from the target stack, which closes the remote
9767 target_mourn_inferior (inferior_ptid
);
9772 error (_("Can't kill process"));
9775 /* Send a kill request to the target using the 'vKill' packet. */
9778 remote_target::remote_vkill (int pid
)
9780 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9783 remote_state
*rs
= get_remote_state ();
9785 /* Tell the remote target to detach. */
9786 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
9788 getpkt (&rs
->buf
, 0);
9790 switch (packet_ok (rs
->buf
,
9791 &remote_protocol_packets
[PACKET_vKill
]))
9797 case PACKET_UNKNOWN
:
9800 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9804 /* Send a kill request to the target using the 'k' packet. */
9807 remote_target::remote_kill_k ()
9809 /* Catch errors so the user can quit from gdb even when we
9810 aren't on speaking terms with the remote system. */
9815 catch (const gdb_exception_error
&ex
)
9817 if (ex
.error
== TARGET_CLOSE_ERROR
)
9819 /* If we got an (EOF) error that caused the target
9820 to go away, then we're done, that's what we wanted.
9821 "k" is susceptible to cause a premature EOF, given
9822 that the remote server isn't actually required to
9823 reply to "k", and it can happen that it doesn't
9824 even get to reply ACK to the "k". */
9828 /* Otherwise, something went wrong. We didn't actually kill
9829 the target. Just propagate the exception, and let the
9830 user or higher layers decide what to do. */
9836 remote_target::mourn_inferior ()
9838 struct remote_state
*rs
= get_remote_state ();
9840 /* We're no longer interested in notification events of an inferior
9841 that exited or was killed/detached. */
9842 discard_pending_stop_replies (current_inferior ());
9844 /* In 'target remote' mode with one inferior, we close the connection. */
9845 if (!rs
->extended
&& number_of_live_inferiors () <= 1)
9847 unpush_target (this);
9849 /* remote_close takes care of doing most of the clean up. */
9850 generic_mourn_inferior ();
9854 /* In case we got here due to an error, but we're going to stay
9856 rs
->waiting_for_stop_reply
= 0;
9858 /* If the current general thread belonged to the process we just
9859 detached from or has exited, the remote side current general
9860 thread becomes undefined. Considering a case like this:
9862 - We just got here due to a detach.
9863 - The process that we're detaching from happens to immediately
9864 report a global breakpoint being hit in non-stop mode, in the
9865 same thread we had selected before.
9866 - GDB attaches to this process again.
9867 - This event happens to be the next event we handle.
9869 GDB would consider that the current general thread didn't need to
9870 be set on the stub side (with Hg), since for all it knew,
9871 GENERAL_THREAD hadn't changed.
9873 Notice that although in all-stop mode, the remote server always
9874 sets the current thread to the thread reporting the stop event,
9875 that doesn't happen in non-stop mode; in non-stop, the stub *must
9876 not* change the current thread when reporting a breakpoint hit,
9877 due to the decoupling of event reporting and event handling.
9879 To keep things simple, we always invalidate our notion of the
9881 record_currthread (rs
, minus_one_ptid
);
9883 /* Call common code to mark the inferior as not running. */
9884 generic_mourn_inferior ();
9888 extended_remote_target::supports_disable_randomization ()
9890 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9894 remote_target::extended_remote_disable_randomization (int val
)
9896 struct remote_state
*rs
= get_remote_state ();
9899 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9900 "QDisableRandomization:%x", val
);
9902 reply
= remote_get_noisy_reply ();
9904 error (_("Target does not support QDisableRandomization."));
9905 if (strcmp (reply
, "OK") != 0)
9906 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9910 remote_target::extended_remote_run (const std::string
&args
)
9912 struct remote_state
*rs
= get_remote_state ();
9914 const char *remote_exec_file
= get_remote_exec_file ();
9916 /* If the user has disabled vRun support, or we have detected that
9917 support is not available, do not try it. */
9918 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9921 strcpy (rs
->buf
.data (), "vRun;");
9922 len
= strlen (rs
->buf
.data ());
9924 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9925 error (_("Remote file name too long for run packet"));
9926 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
9927 strlen (remote_exec_file
));
9933 gdb_argv
argv (args
.c_str ());
9934 for (i
= 0; argv
[i
] != NULL
; i
++)
9936 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9937 error (_("Argument list too long for run packet"));
9938 rs
->buf
[len
++] = ';';
9939 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
9944 rs
->buf
[len
++] = '\0';
9947 getpkt (&rs
->buf
, 0);
9949 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9952 /* We have a wait response. All is well. */
9954 case PACKET_UNKNOWN
:
9957 if (remote_exec_file
[0] == '\0')
9958 error (_("Running the default executable on the remote target failed; "
9959 "try \"set remote exec-file\"?"));
9961 error (_("Running \"%s\" on the remote target failed"),
9964 gdb_assert_not_reached (_("bad switch"));
9968 /* Helper function to send set/unset environment packets. ACTION is
9969 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
9970 or "QEnvironmentUnsetVariable". VALUE is the variable to be
9974 remote_target::send_environment_packet (const char *action
,
9978 remote_state
*rs
= get_remote_state ();
9980 /* Convert the environment variable to an hex string, which
9981 is the best format to be transmitted over the wire. */
9982 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
9985 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9986 "%s:%s", packet
, encoded_value
.c_str ());
9989 getpkt (&rs
->buf
, 0);
9990 if (strcmp (rs
->buf
.data (), "OK") != 0)
9991 warning (_("Unable to %s environment variable '%s' on remote."),
9995 /* Helper function to handle the QEnvironment* packets. */
9998 remote_target::extended_remote_environment_support ()
10000 remote_state
*rs
= get_remote_state ();
10002 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
10004 putpkt ("QEnvironmentReset");
10005 getpkt (&rs
->buf
, 0);
10006 if (strcmp (rs
->buf
.data (), "OK") != 0)
10007 warning (_("Unable to reset environment on remote."));
10010 gdb_environ
*e
= ¤t_inferior ()->environment
;
10012 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
10013 for (const std::string
&el
: e
->user_set_env ())
10014 send_environment_packet ("set", "QEnvironmentHexEncoded",
10017 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
10018 for (const std::string
&el
: e
->user_unset_env ())
10019 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10022 /* Helper function to set the current working directory for the
10023 inferior in the remote target. */
10026 remote_target::extended_remote_set_inferior_cwd ()
10028 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10030 const char *inferior_cwd
= get_inferior_cwd ();
10031 remote_state
*rs
= get_remote_state ();
10033 if (inferior_cwd
!= NULL
)
10035 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10036 strlen (inferior_cwd
));
10038 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10039 "QSetWorkingDir:%s", hexpath
.c_str ());
10043 /* An empty inferior_cwd means that the user wants us to
10044 reset the remote server's inferior's cwd. */
10045 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10046 "QSetWorkingDir:");
10050 getpkt (&rs
->buf
, 0);
10051 if (packet_ok (rs
->buf
,
10052 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10055 Remote replied unexpectedly while setting the inferior's working\n\
10062 /* In the extended protocol we want to be able to do things like
10063 "run" and have them basically work as expected. So we need
10064 a special create_inferior function. We support changing the
10065 executable file and the command line arguments, but not the
10069 extended_remote_target::create_inferior (const char *exec_file
,
10070 const std::string
&args
,
10071 char **env
, int from_tty
)
10075 struct remote_state
*rs
= get_remote_state ();
10076 const char *remote_exec_file
= get_remote_exec_file ();
10078 /* If running asynchronously, register the target file descriptor
10079 with the event loop. */
10080 if (target_can_async_p ())
10083 /* Disable address space randomization if requested (and supported). */
10084 if (supports_disable_randomization ())
10085 extended_remote_disable_randomization (disable_randomization
);
10087 /* If startup-with-shell is on, we inform gdbserver to start the
10088 remote inferior using a shell. */
10089 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10091 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10092 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10094 getpkt (&rs
->buf
, 0);
10095 if (strcmp (rs
->buf
.data (), "OK") != 0)
10097 Remote replied unexpectedly while setting startup-with-shell: %s"),
10101 extended_remote_environment_support ();
10103 extended_remote_set_inferior_cwd ();
10105 /* Now restart the remote server. */
10106 run_worked
= extended_remote_run (args
) != -1;
10109 /* vRun was not supported. Fail if we need it to do what the
10111 if (remote_exec_file
[0])
10112 error (_("Remote target does not support \"set remote exec-file\""));
10113 if (!args
.empty ())
10114 error (_("Remote target does not support \"set args\" or run ARGS"));
10116 /* Fall back to "R". */
10117 extended_remote_restart ();
10120 /* vRun's success return is a stop reply. */
10121 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10122 add_current_inferior_and_thread (stop_reply
);
10124 /* Get updated offsets, if the stub uses qOffsets. */
10129 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10130 the list of conditions (in agent expression bytecode format), if any, the
10131 target needs to evaluate. The output is placed into the packet buffer
10132 started from BUF and ended at BUF_END. */
10135 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10136 struct bp_target_info
*bp_tgt
, char *buf
,
10139 if (bp_tgt
->conditions
.empty ())
10142 buf
+= strlen (buf
);
10143 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10146 /* Send conditions to the target. */
10147 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10149 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10150 buf
+= strlen (buf
);
10151 for (int i
= 0; i
< aexpr
->len
; ++i
)
10152 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10159 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10160 struct bp_target_info
*bp_tgt
, char *buf
)
10162 if (bp_tgt
->tcommands
.empty ())
10165 buf
+= strlen (buf
);
10167 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10168 buf
+= strlen (buf
);
10170 /* Concatenate all the agent expressions that are commands into the
10172 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10174 sprintf (buf
, "X%x,", aexpr
->len
);
10175 buf
+= strlen (buf
);
10176 for (int i
= 0; i
< aexpr
->len
; ++i
)
10177 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10182 /* Insert a breakpoint. On targets that have software breakpoint
10183 support, we ask the remote target to do the work; on targets
10184 which don't, we insert a traditional memory breakpoint. */
10187 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10188 struct bp_target_info
*bp_tgt
)
10190 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10191 If it succeeds, then set the support to PACKET_ENABLE. If it
10192 fails, and the user has explicitly requested the Z support then
10193 report an error, otherwise, mark it disabled and go on. */
10195 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10197 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10198 struct remote_state
*rs
;
10201 /* Make sure the remote is pointing at the right process, if
10203 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10204 set_general_process ();
10206 rs
= get_remote_state ();
10207 p
= rs
->buf
.data ();
10208 endbuf
= p
+ get_remote_packet_size ();
10213 addr
= (ULONGEST
) remote_address_masked (addr
);
10214 p
+= hexnumstr (p
, addr
);
10215 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10217 if (supports_evaluation_of_breakpoint_conditions ())
10218 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10220 if (can_run_breakpoint_commands ())
10221 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10224 getpkt (&rs
->buf
, 0);
10226 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10232 case PACKET_UNKNOWN
:
10237 /* If this breakpoint has target-side commands but this stub doesn't
10238 support Z0 packets, throw error. */
10239 if (!bp_tgt
->tcommands
.empty ())
10240 throw_error (NOT_SUPPORTED_ERROR
, _("\
10241 Target doesn't support breakpoints that have target side commands."));
10243 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10247 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10248 struct bp_target_info
*bp_tgt
,
10249 enum remove_bp_reason reason
)
10251 CORE_ADDR addr
= bp_tgt
->placed_address
;
10252 struct remote_state
*rs
= get_remote_state ();
10254 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10256 char *p
= rs
->buf
.data ();
10257 char *endbuf
= p
+ get_remote_packet_size ();
10259 /* Make sure the remote is pointing at the right process, if
10261 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10262 set_general_process ();
10268 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10269 p
+= hexnumstr (p
, addr
);
10270 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10273 getpkt (&rs
->buf
, 0);
10275 return (rs
->buf
[0] == 'E');
10278 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10281 static enum Z_packet_type
10282 watchpoint_to_Z_packet (int type
)
10287 return Z_PACKET_WRITE_WP
;
10290 return Z_PACKET_READ_WP
;
10293 return Z_PACKET_ACCESS_WP
;
10296 internal_error (__FILE__
, __LINE__
,
10297 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10302 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10303 enum target_hw_bp_type type
, struct expression
*cond
)
10305 struct remote_state
*rs
= get_remote_state ();
10306 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10308 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10310 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10313 /* Make sure the remote is pointing at the right process, if
10315 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10316 set_general_process ();
10318 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10319 p
= strchr (rs
->buf
.data (), '\0');
10320 addr
= remote_address_masked (addr
);
10321 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10322 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10325 getpkt (&rs
->buf
, 0);
10327 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10331 case PACKET_UNKNOWN
:
10336 internal_error (__FILE__
, __LINE__
,
10337 _("remote_insert_watchpoint: reached end of function"));
10341 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10342 CORE_ADDR start
, int length
)
10344 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10346 return diff
< length
;
10351 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10352 enum target_hw_bp_type type
, struct expression
*cond
)
10354 struct remote_state
*rs
= get_remote_state ();
10355 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10357 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10359 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10362 /* Make sure the remote is pointing at the right process, if
10364 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10365 set_general_process ();
10367 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10368 p
= strchr (rs
->buf
.data (), '\0');
10369 addr
= remote_address_masked (addr
);
10370 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10371 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10373 getpkt (&rs
->buf
, 0);
10375 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10378 case PACKET_UNKNOWN
:
10383 internal_error (__FILE__
, __LINE__
,
10384 _("remote_remove_watchpoint: reached end of function"));
10388 static int remote_hw_watchpoint_limit
= -1;
10389 static int remote_hw_watchpoint_length_limit
= -1;
10390 static int remote_hw_breakpoint_limit
= -1;
10393 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10395 if (remote_hw_watchpoint_length_limit
== 0)
10397 else if (remote_hw_watchpoint_length_limit
< 0)
10399 else if (len
<= remote_hw_watchpoint_length_limit
)
10406 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10408 if (type
== bp_hardware_breakpoint
)
10410 if (remote_hw_breakpoint_limit
== 0)
10412 else if (remote_hw_breakpoint_limit
< 0)
10414 else if (cnt
<= remote_hw_breakpoint_limit
)
10419 if (remote_hw_watchpoint_limit
== 0)
10421 else if (remote_hw_watchpoint_limit
< 0)
10425 else if (cnt
<= remote_hw_watchpoint_limit
)
10431 /* The to_stopped_by_sw_breakpoint method of target remote. */
10434 remote_target::stopped_by_sw_breakpoint ()
10436 struct thread_info
*thread
= inferior_thread ();
10438 return (thread
->priv
!= NULL
10439 && (get_remote_thread_info (thread
)->stop_reason
10440 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10443 /* The to_supports_stopped_by_sw_breakpoint method of target
10447 remote_target::supports_stopped_by_sw_breakpoint ()
10449 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10452 /* The to_stopped_by_hw_breakpoint method of target remote. */
10455 remote_target::stopped_by_hw_breakpoint ()
10457 struct thread_info
*thread
= inferior_thread ();
10459 return (thread
->priv
!= NULL
10460 && (get_remote_thread_info (thread
)->stop_reason
10461 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10464 /* The to_supports_stopped_by_hw_breakpoint method of target
10468 remote_target::supports_stopped_by_hw_breakpoint ()
10470 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10474 remote_target::stopped_by_watchpoint ()
10476 struct thread_info
*thread
= inferior_thread ();
10478 return (thread
->priv
!= NULL
10479 && (get_remote_thread_info (thread
)->stop_reason
10480 == TARGET_STOPPED_BY_WATCHPOINT
));
10484 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10486 struct thread_info
*thread
= inferior_thread ();
10488 if (thread
->priv
!= NULL
10489 && (get_remote_thread_info (thread
)->stop_reason
10490 == TARGET_STOPPED_BY_WATCHPOINT
))
10492 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10501 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10502 struct bp_target_info
*bp_tgt
)
10504 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10505 struct remote_state
*rs
;
10509 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10512 /* Make sure the remote is pointing at the right process, if
10514 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10515 set_general_process ();
10517 rs
= get_remote_state ();
10518 p
= rs
->buf
.data ();
10519 endbuf
= p
+ get_remote_packet_size ();
10525 addr
= remote_address_masked (addr
);
10526 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10527 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10529 if (supports_evaluation_of_breakpoint_conditions ())
10530 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10532 if (can_run_breakpoint_commands ())
10533 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10536 getpkt (&rs
->buf
, 0);
10538 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10541 if (rs
->buf
[1] == '.')
10543 message
= strchr (&rs
->buf
[2], '.');
10545 error (_("Remote failure reply: %s"), message
+ 1);
10548 case PACKET_UNKNOWN
:
10553 internal_error (__FILE__
, __LINE__
,
10554 _("remote_insert_hw_breakpoint: reached end of function"));
10559 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10560 struct bp_target_info
*bp_tgt
)
10563 struct remote_state
*rs
= get_remote_state ();
10564 char *p
= rs
->buf
.data ();
10565 char *endbuf
= p
+ get_remote_packet_size ();
10567 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10570 /* Make sure the remote is pointing at the right process, if
10572 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10573 set_general_process ();
10579 addr
= remote_address_masked (bp_tgt
->placed_address
);
10580 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10581 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10584 getpkt (&rs
->buf
, 0);
10586 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10589 case PACKET_UNKNOWN
:
10594 internal_error (__FILE__
, __LINE__
,
10595 _("remote_remove_hw_breakpoint: reached end of function"));
10598 /* Verify memory using the "qCRC:" request. */
10601 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10603 struct remote_state
*rs
= get_remote_state ();
10604 unsigned long host_crc
, target_crc
;
10607 /* It doesn't make sense to use qCRC if the remote target is
10608 connected but not running. */
10609 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10611 enum packet_result result
;
10613 /* Make sure the remote is pointing at the right process. */
10614 set_general_process ();
10616 /* FIXME: assumes lma can fit into long. */
10617 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10618 (long) lma
, (long) size
);
10621 /* Be clever; compute the host_crc before waiting for target
10623 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10625 getpkt (&rs
->buf
, 0);
10627 result
= packet_ok (rs
->buf
,
10628 &remote_protocol_packets
[PACKET_qCRC
]);
10629 if (result
== PACKET_ERROR
)
10631 else if (result
== PACKET_OK
)
10633 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10634 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10636 return (host_crc
== target_crc
);
10640 return simple_verify_memory (this, data
, lma
, size
);
10643 /* compare-sections command
10645 With no arguments, compares each loadable section in the exec bfd
10646 with the same memory range on the target, and reports mismatches.
10647 Useful for verifying the image on the target against the exec file. */
10650 compare_sections_command (const char *args
, int from_tty
)
10653 const char *sectname
;
10654 bfd_size_type size
;
10657 int mismatched
= 0;
10662 error (_("command cannot be used without an exec file"));
10664 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10670 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10672 if (!(s
->flags
& SEC_LOAD
))
10673 continue; /* Skip non-loadable section. */
10675 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10676 continue; /* Skip writeable sections */
10678 size
= bfd_section_size (s
);
10680 continue; /* Skip zero-length section. */
10682 sectname
= bfd_section_name (s
);
10683 if (args
&& strcmp (args
, sectname
) != 0)
10684 continue; /* Not the section selected by user. */
10686 matched
= 1; /* Do this section. */
10689 gdb::byte_vector
sectdata (size
);
10690 bfd_get_section_contents (exec_bfd
, s
, sectdata
.data (), 0, size
);
10692 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10695 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10696 paddress (target_gdbarch (), lma
),
10697 paddress (target_gdbarch (), lma
+ size
));
10699 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10700 paddress (target_gdbarch (), lma
),
10701 paddress (target_gdbarch (), lma
+ size
));
10703 printf_filtered ("matched.\n");
10706 printf_filtered ("MIS-MATCHED!\n");
10710 if (mismatched
> 0)
10711 warning (_("One or more sections of the target image does not match\n\
10712 the loaded file\n"));
10713 if (args
&& !matched
)
10714 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10717 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10718 into remote target. The number of bytes written to the remote
10719 target is returned, or -1 for error. */
10722 remote_target::remote_write_qxfer (const char *object_name
,
10723 const char *annex
, const gdb_byte
*writebuf
,
10724 ULONGEST offset
, LONGEST len
,
10725 ULONGEST
*xfered_len
,
10726 struct packet_config
*packet
)
10730 struct remote_state
*rs
= get_remote_state ();
10731 int max_size
= get_memory_write_packet_size ();
10733 if (packet_config_support (packet
) == PACKET_DISABLE
)
10734 return TARGET_XFER_E_IO
;
10736 /* Insert header. */
10737 i
= snprintf (rs
->buf
.data (), max_size
,
10738 "qXfer:%s:write:%s:%s:",
10739 object_name
, annex
? annex
: "",
10740 phex_nz (offset
, sizeof offset
));
10741 max_size
-= (i
+ 1);
10743 /* Escape as much data as fits into rs->buf. */
10744 buf_len
= remote_escape_output
10745 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10747 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10748 || getpkt_sane (&rs
->buf
, 0) < 0
10749 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10750 return TARGET_XFER_E_IO
;
10752 unpack_varlen_hex (rs
->buf
.data (), &n
);
10755 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10758 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10759 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10760 number of bytes read is returned, or 0 for EOF, or -1 for error.
10761 The number of bytes read may be less than LEN without indicating an
10762 EOF. PACKET is checked and updated to indicate whether the remote
10763 target supports this object. */
10766 remote_target::remote_read_qxfer (const char *object_name
,
10768 gdb_byte
*readbuf
, ULONGEST offset
,
10770 ULONGEST
*xfered_len
,
10771 struct packet_config
*packet
)
10773 struct remote_state
*rs
= get_remote_state ();
10774 LONGEST i
, n
, packet_len
;
10776 if (packet_config_support (packet
) == PACKET_DISABLE
)
10777 return TARGET_XFER_E_IO
;
10779 /* Check whether we've cached an end-of-object packet that matches
10781 if (rs
->finished_object
)
10783 if (strcmp (object_name
, rs
->finished_object
) == 0
10784 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10785 && offset
== rs
->finished_offset
)
10786 return TARGET_XFER_EOF
;
10789 /* Otherwise, we're now reading something different. Discard
10791 xfree (rs
->finished_object
);
10792 xfree (rs
->finished_annex
);
10793 rs
->finished_object
= NULL
;
10794 rs
->finished_annex
= NULL
;
10797 /* Request only enough to fit in a single packet. The actual data
10798 may not, since we don't know how much of it will need to be escaped;
10799 the target is free to respond with slightly less data. We subtract
10800 five to account for the response type and the protocol frame. */
10801 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10802 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
10803 "qXfer:%s:read:%s:%s,%s",
10804 object_name
, annex
? annex
: "",
10805 phex_nz (offset
, sizeof offset
),
10806 phex_nz (n
, sizeof n
));
10807 i
= putpkt (rs
->buf
);
10809 return TARGET_XFER_E_IO
;
10812 packet_len
= getpkt_sane (&rs
->buf
, 0);
10813 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10814 return TARGET_XFER_E_IO
;
10816 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10817 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
10819 /* 'm' means there is (or at least might be) more data after this
10820 batch. That does not make sense unless there's at least one byte
10821 of data in this reply. */
10822 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10823 error (_("Remote qXfer reply contained no data."));
10825 /* Got some data. */
10826 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
10827 packet_len
- 1, readbuf
, n
);
10829 /* 'l' is an EOF marker, possibly including a final block of data,
10830 or possibly empty. If we have the final block of a non-empty
10831 object, record this fact to bypass a subsequent partial read. */
10832 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10834 rs
->finished_object
= xstrdup (object_name
);
10835 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10836 rs
->finished_offset
= offset
+ i
;
10840 return TARGET_XFER_EOF
;
10844 return TARGET_XFER_OK
;
10848 enum target_xfer_status
10849 remote_target::xfer_partial (enum target_object object
,
10850 const char *annex
, gdb_byte
*readbuf
,
10851 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10852 ULONGEST
*xfered_len
)
10854 struct remote_state
*rs
;
10858 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10860 set_remote_traceframe ();
10861 set_general_thread (inferior_ptid
);
10863 rs
= get_remote_state ();
10865 /* Handle memory using the standard memory routines. */
10866 if (object
== TARGET_OBJECT_MEMORY
)
10868 /* If the remote target is connected but not running, we should
10869 pass this request down to a lower stratum (e.g. the executable
10871 if (!target_has_execution
)
10872 return TARGET_XFER_EOF
;
10874 if (writebuf
!= NULL
)
10875 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10878 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
10882 /* Handle extra signal info using qxfer packets. */
10883 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10886 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
10887 xfered_len
, &remote_protocol_packets
10888 [PACKET_qXfer_siginfo_read
]);
10890 return remote_write_qxfer ("siginfo", annex
,
10891 writebuf
, offset
, len
, xfered_len
,
10892 &remote_protocol_packets
10893 [PACKET_qXfer_siginfo_write
]);
10896 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10899 return remote_read_qxfer ("statictrace", annex
,
10900 readbuf
, offset
, len
, xfered_len
,
10901 &remote_protocol_packets
10902 [PACKET_qXfer_statictrace_read
]);
10904 return TARGET_XFER_E_IO
;
10907 /* Only handle flash writes. */
10908 if (writebuf
!= NULL
)
10912 case TARGET_OBJECT_FLASH
:
10913 return remote_flash_write (offset
, len
, xfered_len
,
10917 return TARGET_XFER_E_IO
;
10921 /* Map pre-existing objects onto letters. DO NOT do this for new
10922 objects!!! Instead specify new query packets. */
10925 case TARGET_OBJECT_AVR
:
10929 case TARGET_OBJECT_AUXV
:
10930 gdb_assert (annex
== NULL
);
10931 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
10933 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10935 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10936 return remote_read_qxfer
10937 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
10938 &remote_protocol_packets
[PACKET_qXfer_features
]);
10940 case TARGET_OBJECT_LIBRARIES
:
10941 return remote_read_qxfer
10942 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10943 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10945 case TARGET_OBJECT_LIBRARIES_SVR4
:
10946 return remote_read_qxfer
10947 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10948 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10950 case TARGET_OBJECT_MEMORY_MAP
:
10951 gdb_assert (annex
== NULL
);
10952 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
10954 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10956 case TARGET_OBJECT_OSDATA
:
10957 /* Should only get here if we're connected. */
10958 gdb_assert (rs
->remote_desc
);
10959 return remote_read_qxfer
10960 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
10961 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
10963 case TARGET_OBJECT_THREADS
:
10964 gdb_assert (annex
== NULL
);
10965 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
10967 &remote_protocol_packets
[PACKET_qXfer_threads
]);
10969 case TARGET_OBJECT_TRACEFRAME_INFO
:
10970 gdb_assert (annex
== NULL
);
10971 return remote_read_qxfer
10972 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
10973 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
10975 case TARGET_OBJECT_FDPIC
:
10976 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
10978 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
10980 case TARGET_OBJECT_OPENVMS_UIB
:
10981 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
10983 &remote_protocol_packets
[PACKET_qXfer_uib
]);
10985 case TARGET_OBJECT_BTRACE
:
10986 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
10988 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
10990 case TARGET_OBJECT_BTRACE_CONF
:
10991 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
10993 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
10995 case TARGET_OBJECT_EXEC_FILE
:
10996 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
10998 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
11001 return TARGET_XFER_E_IO
;
11004 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
11005 large enough let the caller deal with it. */
11006 if (len
< get_remote_packet_size ())
11007 return TARGET_XFER_E_IO
;
11008 len
= get_remote_packet_size ();
11010 /* Except for querying the minimum buffer size, target must be open. */
11011 if (!rs
->remote_desc
)
11012 error (_("remote query is only available after target open"));
11014 gdb_assert (annex
!= NULL
);
11015 gdb_assert (readbuf
!= NULL
);
11017 p2
= rs
->buf
.data ();
11019 *p2
++ = query_type
;
11021 /* We used one buffer char for the remote protocol q command and
11022 another for the query type. As the remote protocol encapsulation
11023 uses 4 chars plus one extra in case we are debugging
11024 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11027 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11029 /* Bad caller may have sent forbidden characters. */
11030 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11035 gdb_assert (annex
[i
] == '\0');
11037 i
= putpkt (rs
->buf
);
11039 return TARGET_XFER_E_IO
;
11041 getpkt (&rs
->buf
, 0);
11042 strcpy ((char *) readbuf
, rs
->buf
.data ());
11044 *xfered_len
= strlen ((char *) readbuf
);
11045 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11048 /* Implementation of to_get_memory_xfer_limit. */
11051 remote_target::get_memory_xfer_limit ()
11053 return get_memory_write_packet_size ();
11057 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11058 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11059 CORE_ADDR
*found_addrp
)
11061 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11062 struct remote_state
*rs
= get_remote_state ();
11063 int max_size
= get_memory_write_packet_size ();
11064 struct packet_config
*packet
=
11065 &remote_protocol_packets
[PACKET_qSearch_memory
];
11066 /* Number of packet bytes used to encode the pattern;
11067 this could be more than PATTERN_LEN due to escape characters. */
11068 int escaped_pattern_len
;
11069 /* Amount of pattern that was encodable in the packet. */
11070 int used_pattern_len
;
11073 ULONGEST found_addr
;
11075 /* Don't go to the target if we don't have to. This is done before
11076 checking packet_config_support to avoid the possibility that a
11077 success for this edge case means the facility works in
11079 if (pattern_len
> search_space_len
)
11081 if (pattern_len
== 0)
11083 *found_addrp
= start_addr
;
11087 /* If we already know the packet isn't supported, fall back to the simple
11088 way of searching memory. */
11090 if (packet_config_support (packet
) == PACKET_DISABLE
)
11092 /* Target doesn't provided special support, fall back and use the
11093 standard support (copy memory and do the search here). */
11094 return simple_search_memory (this, start_addr
, search_space_len
,
11095 pattern
, pattern_len
, found_addrp
);
11098 /* Make sure the remote is pointing at the right process. */
11099 set_general_process ();
11101 /* Insert header. */
11102 i
= snprintf (rs
->buf
.data (), max_size
,
11103 "qSearch:memory:%s;%s;",
11104 phex_nz (start_addr
, addr_size
),
11105 phex_nz (search_space_len
, sizeof (search_space_len
)));
11106 max_size
-= (i
+ 1);
11108 /* Escape as much data as fits into rs->buf. */
11109 escaped_pattern_len
=
11110 remote_escape_output (pattern
, pattern_len
, 1,
11111 (gdb_byte
*) rs
->buf
.data () + i
,
11112 &used_pattern_len
, max_size
);
11114 /* Bail if the pattern is too large. */
11115 if (used_pattern_len
!= pattern_len
)
11116 error (_("Pattern is too large to transmit to remote target."));
11118 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11119 || getpkt_sane (&rs
->buf
, 0) < 0
11120 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11122 /* The request may not have worked because the command is not
11123 supported. If so, fall back to the simple way. */
11124 if (packet_config_support (packet
) == PACKET_DISABLE
)
11126 return simple_search_memory (this, start_addr
, search_space_len
,
11127 pattern
, pattern_len
, found_addrp
);
11132 if (rs
->buf
[0] == '0')
11134 else if (rs
->buf
[0] == '1')
11137 if (rs
->buf
[1] != ',')
11138 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11139 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11140 *found_addrp
= found_addr
;
11143 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11149 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11151 struct remote_state
*rs
= get_remote_state ();
11152 char *p
= rs
->buf
.data ();
11154 if (!rs
->remote_desc
)
11155 error (_("remote rcmd is only available after target open"));
11157 /* Send a NULL command across as an empty command. */
11158 if (command
== NULL
)
11161 /* The query prefix. */
11162 strcpy (rs
->buf
.data (), "qRcmd,");
11163 p
= strchr (rs
->buf
.data (), '\0');
11165 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11166 > get_remote_packet_size ())
11167 error (_("\"monitor\" command ``%s'' is too long."), command
);
11169 /* Encode the actual command. */
11170 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11172 if (putpkt (rs
->buf
) < 0)
11173 error (_("Communication problem with target."));
11175 /* get/display the response */
11180 /* XXX - see also remote_get_noisy_reply(). */
11181 QUIT
; /* Allow user to bail out with ^C. */
11183 if (getpkt_sane (&rs
->buf
, 0) == -1)
11185 /* Timeout. Continue to (try to) read responses.
11186 This is better than stopping with an error, assuming the stub
11187 is still executing the (long) monitor command.
11188 If needed, the user can interrupt gdb using C-c, obtaining
11189 an effect similar to stop on timeout. */
11192 buf
= rs
->buf
.data ();
11193 if (buf
[0] == '\0')
11194 error (_("Target does not support this command."));
11195 if (buf
[0] == 'O' && buf
[1] != 'K')
11197 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11200 if (strcmp (buf
, "OK") == 0)
11202 if (strlen (buf
) == 3 && buf
[0] == 'E'
11203 && isdigit (buf
[1]) && isdigit (buf
[2]))
11205 error (_("Protocol error with Rcmd"));
11207 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11209 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11211 fputc_unfiltered (c
, outbuf
);
11217 std::vector
<mem_region
>
11218 remote_target::memory_map ()
11220 std::vector
<mem_region
> result
;
11221 gdb::optional
<gdb::char_vector
> text
11222 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11225 result
= parse_memory_map (text
->data ());
11231 packet_command (const char *args
, int from_tty
)
11233 remote_target
*remote
= get_current_remote_target ();
11235 if (remote
== nullptr)
11236 error (_("command can only be used with remote target"));
11238 remote
->packet_command (args
, from_tty
);
11242 remote_target::packet_command (const char *args
, int from_tty
)
11245 error (_("remote-packet command requires packet text as argument"));
11247 puts_filtered ("sending: ");
11248 print_packet (args
);
11249 puts_filtered ("\n");
11252 remote_state
*rs
= get_remote_state ();
11254 getpkt (&rs
->buf
, 0);
11255 puts_filtered ("received: ");
11256 print_packet (rs
->buf
.data ());
11257 puts_filtered ("\n");
11261 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11263 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11265 static void threadset_test_cmd (char *cmd
, int tty
);
11267 static void threadalive_test (char *cmd
, int tty
);
11269 static void threadlist_test_cmd (char *cmd
, int tty
);
11271 int get_and_display_threadinfo (threadref
*ref
);
11273 static void threadinfo_test_cmd (char *cmd
, int tty
);
11275 static int thread_display_step (threadref
*ref
, void *context
);
11277 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11279 static void init_remote_threadtests (void);
11281 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11284 threadset_test_cmd (const char *cmd
, int tty
)
11286 int sample_thread
= SAMPLE_THREAD
;
11288 printf_filtered (_("Remote threadset test\n"));
11289 set_general_thread (sample_thread
);
11294 threadalive_test (const char *cmd
, int tty
)
11296 int sample_thread
= SAMPLE_THREAD
;
11297 int pid
= inferior_ptid
.pid ();
11298 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11300 if (remote_thread_alive (ptid
))
11301 printf_filtered ("PASS: Thread alive test\n");
11303 printf_filtered ("FAIL: Thread alive test\n");
11306 void output_threadid (char *title
, threadref
*ref
);
11309 output_threadid (char *title
, threadref
*ref
)
11313 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11315 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11319 threadlist_test_cmd (const char *cmd
, int tty
)
11322 threadref nextthread
;
11323 int done
, result_count
;
11324 threadref threadlist
[3];
11326 printf_filtered ("Remote Threadlist test\n");
11327 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11328 &result_count
, &threadlist
[0]))
11329 printf_filtered ("FAIL: threadlist test\n");
11332 threadref
*scan
= threadlist
;
11333 threadref
*limit
= scan
+ result_count
;
11335 while (scan
< limit
)
11336 output_threadid (" thread ", scan
++);
11341 display_thread_info (struct gdb_ext_thread_info
*info
)
11343 output_threadid ("Threadid: ", &info
->threadid
);
11344 printf_filtered ("Name: %s\n ", info
->shortname
);
11345 printf_filtered ("State: %s\n", info
->display
);
11346 printf_filtered ("other: %s\n\n", info
->more_display
);
11350 get_and_display_threadinfo (threadref
*ref
)
11354 struct gdb_ext_thread_info threadinfo
;
11356 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11357 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11358 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11359 display_thread_info (&threadinfo
);
11364 threadinfo_test_cmd (const char *cmd
, int tty
)
11366 int athread
= SAMPLE_THREAD
;
11370 int_to_threadref (&thread
, athread
);
11371 printf_filtered ("Remote Threadinfo test\n");
11372 if (!get_and_display_threadinfo (&thread
))
11373 printf_filtered ("FAIL cannot get thread info\n");
11377 thread_display_step (threadref
*ref
, void *context
)
11379 /* output_threadid(" threadstep ",ref); *//* simple test */
11380 return get_and_display_threadinfo (ref
);
11384 threadlist_update_test_cmd (const char *cmd
, int tty
)
11386 printf_filtered ("Remote Threadlist update test\n");
11387 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11391 init_remote_threadtests (void)
11393 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11394 _("Fetch and print the remote list of "
11395 "thread identifiers, one pkt only."));
11396 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11397 _("Fetch and display info about one thread."));
11398 add_com ("tset", class_obscure
, threadset_test_cmd
,
11399 _("Test setting to a different thread."));
11400 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11401 _("Iterate through updating all remote thread info."));
11402 add_com ("talive", class_obscure
, threadalive_test
,
11403 _("Remote thread alive test."));
11408 /* Convert a thread ID to a string. */
11411 remote_target::pid_to_str (ptid_t ptid
)
11413 struct remote_state
*rs
= get_remote_state ();
11415 if (ptid
== null_ptid
)
11416 return normal_pid_to_str (ptid
);
11417 else if (ptid
.is_pid ())
11419 /* Printing an inferior target id. */
11421 /* When multi-process extensions are off, there's no way in the
11422 remote protocol to know the remote process id, if there's any
11423 at all. There's one exception --- when we're connected with
11424 target extended-remote, and we manually attached to a process
11425 with "attach PID". We don't record anywhere a flag that
11426 allows us to distinguish that case from the case of
11427 connecting with extended-remote and the stub already being
11428 attached to a process, and reporting yes to qAttached, hence
11429 no smart special casing here. */
11430 if (!remote_multi_process_p (rs
))
11431 return "Remote target";
11433 return normal_pid_to_str (ptid
);
11437 if (magic_null_ptid
== ptid
)
11438 return "Thread <main>";
11439 else if (remote_multi_process_p (rs
))
11440 if (ptid
.lwp () == 0)
11441 return normal_pid_to_str (ptid
);
11443 return string_printf ("Thread %d.%ld",
11444 ptid
.pid (), ptid
.lwp ());
11446 return string_printf ("Thread %ld", ptid
.lwp ());
11450 /* Get the address of the thread local variable in OBJFILE which is
11451 stored at OFFSET within the thread local storage for thread PTID. */
11454 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11457 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11459 struct remote_state
*rs
= get_remote_state ();
11460 char *p
= rs
->buf
.data ();
11461 char *endp
= p
+ get_remote_packet_size ();
11462 enum packet_result result
;
11464 strcpy (p
, "qGetTLSAddr:");
11466 p
= write_ptid (p
, endp
, ptid
);
11468 p
+= hexnumstr (p
, offset
);
11470 p
+= hexnumstr (p
, lm
);
11474 getpkt (&rs
->buf
, 0);
11475 result
= packet_ok (rs
->buf
,
11476 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11477 if (result
== PACKET_OK
)
11481 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11484 else if (result
== PACKET_UNKNOWN
)
11485 throw_error (TLS_GENERIC_ERROR
,
11486 _("Remote target doesn't support qGetTLSAddr packet"));
11488 throw_error (TLS_GENERIC_ERROR
,
11489 _("Remote target failed to process qGetTLSAddr request"));
11492 throw_error (TLS_GENERIC_ERROR
,
11493 _("TLS not supported or disabled on this target"));
11498 /* Provide thread local base, i.e. Thread Information Block address.
11499 Returns 1 if ptid is found and thread_local_base is non zero. */
11502 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11504 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11506 struct remote_state
*rs
= get_remote_state ();
11507 char *p
= rs
->buf
.data ();
11508 char *endp
= p
+ get_remote_packet_size ();
11509 enum packet_result result
;
11511 strcpy (p
, "qGetTIBAddr:");
11513 p
= write_ptid (p
, endp
, ptid
);
11517 getpkt (&rs
->buf
, 0);
11518 result
= packet_ok (rs
->buf
,
11519 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11520 if (result
== PACKET_OK
)
11523 unpack_varlen_hex (rs
->buf
.data (), &val
);
11525 *addr
= (CORE_ADDR
) val
;
11528 else if (result
== PACKET_UNKNOWN
)
11529 error (_("Remote target doesn't support qGetTIBAddr packet"));
11531 error (_("Remote target failed to process qGetTIBAddr request"));
11534 error (_("qGetTIBAddr not supported or disabled on this target"));
11539 /* Support for inferring a target description based on the current
11540 architecture and the size of a 'g' packet. While the 'g' packet
11541 can have any size (since optional registers can be left off the
11542 end), some sizes are easily recognizable given knowledge of the
11543 approximate architecture. */
11545 struct remote_g_packet_guess
11547 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11554 const struct target_desc
*tdesc
;
11557 struct remote_g_packet_data
: public allocate_on_obstack
11559 std::vector
<remote_g_packet_guess
> guesses
;
11562 static struct gdbarch_data
*remote_g_packet_data_handle
;
11565 remote_g_packet_data_init (struct obstack
*obstack
)
11567 return new (obstack
) remote_g_packet_data
;
11571 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11572 const struct target_desc
*tdesc
)
11574 struct remote_g_packet_data
*data
11575 = ((struct remote_g_packet_data
*)
11576 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11578 gdb_assert (tdesc
!= NULL
);
11580 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11581 if (guess
.bytes
== bytes
)
11582 internal_error (__FILE__
, __LINE__
,
11583 _("Duplicate g packet description added for size %d"),
11586 data
->guesses
.emplace_back (bytes
, tdesc
);
11589 /* Return true if remote_read_description would do anything on this target
11590 and architecture, false otherwise. */
11593 remote_read_description_p (struct target_ops
*target
)
11595 struct remote_g_packet_data
*data
11596 = ((struct remote_g_packet_data
*)
11597 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11599 return !data
->guesses
.empty ();
11602 const struct target_desc
*
11603 remote_target::read_description ()
11605 struct remote_g_packet_data
*data
11606 = ((struct remote_g_packet_data
*)
11607 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11609 /* Do not try this during initial connection, when we do not know
11610 whether there is a running but stopped thread. */
11611 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
11612 return beneath ()->read_description ();
11614 if (!data
->guesses
.empty ())
11616 int bytes
= send_g_packet ();
11618 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11619 if (guess
.bytes
== bytes
)
11620 return guess
.tdesc
;
11622 /* We discard the g packet. A minor optimization would be to
11623 hold on to it, and fill the register cache once we have selected
11624 an architecture, but it's too tricky to do safely. */
11627 return beneath ()->read_description ();
11630 /* Remote file transfer support. This is host-initiated I/O, not
11631 target-initiated; for target-initiated, see remote-fileio.c. */
11633 /* If *LEFT is at least the length of STRING, copy STRING to
11634 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11635 decrease *LEFT. Otherwise raise an error. */
11638 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11640 int len
= strlen (string
);
11643 error (_("Packet too long for target."));
11645 memcpy (*buffer
, string
, len
);
11649 /* NUL-terminate the buffer as a convenience, if there is
11655 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11656 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11657 decrease *LEFT. Otherwise raise an error. */
11660 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11663 if (2 * len
> *left
)
11664 error (_("Packet too long for target."));
11666 bin2hex (bytes
, *buffer
, len
);
11667 *buffer
+= 2 * len
;
11670 /* NUL-terminate the buffer as a convenience, if there is
11676 /* If *LEFT is large enough, convert VALUE to hex and add it to
11677 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11678 decrease *LEFT. Otherwise raise an error. */
11681 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11683 int len
= hexnumlen (value
);
11686 error (_("Packet too long for target."));
11688 hexnumstr (*buffer
, value
);
11692 /* NUL-terminate the buffer as a convenience, if there is
11698 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11699 value, *REMOTE_ERRNO to the remote error number or zero if none
11700 was included, and *ATTACHMENT to point to the start of the annex
11701 if any. The length of the packet isn't needed here; there may
11702 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11704 Return 0 if the packet could be parsed, -1 if it could not. If
11705 -1 is returned, the other variables may not be initialized. */
11708 remote_hostio_parse_result (char *buffer
, int *retcode
,
11709 int *remote_errno
, char **attachment
)
11714 *attachment
= NULL
;
11716 if (buffer
[0] != 'F')
11720 *retcode
= strtol (&buffer
[1], &p
, 16);
11721 if (errno
!= 0 || p
== &buffer
[1])
11724 /* Check for ",errno". */
11728 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11729 if (errno
!= 0 || p
+ 1 == p2
)
11734 /* Check for ";attachment". If there is no attachment, the
11735 packet should end here. */
11738 *attachment
= p
+ 1;
11741 else if (*p
== '\0')
11747 /* Send a prepared I/O packet to the target and read its response.
11748 The prepared packet is in the global RS->BUF before this function
11749 is called, and the answer is there when we return.
11751 COMMAND_BYTES is the length of the request to send, which may include
11752 binary data. WHICH_PACKET is the packet configuration to check
11753 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11754 is set to the error number and -1 is returned. Otherwise the value
11755 returned by the function is returned.
11757 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11758 attachment is expected; an error will be reported if there's a
11759 mismatch. If one is found, *ATTACHMENT will be set to point into
11760 the packet buffer and *ATTACHMENT_LEN will be set to the
11761 attachment's length. */
11764 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11765 int *remote_errno
, char **attachment
,
11766 int *attachment_len
)
11768 struct remote_state
*rs
= get_remote_state ();
11769 int ret
, bytes_read
;
11770 char *attachment_tmp
;
11772 if (packet_support (which_packet
) == PACKET_DISABLE
)
11774 *remote_errno
= FILEIO_ENOSYS
;
11778 putpkt_binary (rs
->buf
.data (), command_bytes
);
11779 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11781 /* If it timed out, something is wrong. Don't try to parse the
11783 if (bytes_read
< 0)
11785 *remote_errno
= FILEIO_EINVAL
;
11789 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11792 *remote_errno
= FILEIO_EINVAL
;
11794 case PACKET_UNKNOWN
:
11795 *remote_errno
= FILEIO_ENOSYS
;
11801 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
11804 *remote_errno
= FILEIO_EINVAL
;
11808 /* Make sure we saw an attachment if and only if we expected one. */
11809 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11810 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11812 *remote_errno
= FILEIO_EINVAL
;
11816 /* If an attachment was found, it must point into the packet buffer;
11817 work out how many bytes there were. */
11818 if (attachment_tmp
!= NULL
)
11820 *attachment
= attachment_tmp
;
11821 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
11827 /* See declaration.h. */
11830 readahead_cache::invalidate ()
11835 /* See declaration.h. */
11838 readahead_cache::invalidate_fd (int fd
)
11840 if (this->fd
== fd
)
11844 /* Set the filesystem remote_hostio functions that take FILENAME
11845 arguments will use. Return 0 on success, or -1 if an error
11846 occurs (and set *REMOTE_ERRNO). */
11849 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
11852 struct remote_state
*rs
= get_remote_state ();
11853 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11854 char *p
= rs
->buf
.data ();
11855 int left
= get_remote_packet_size () - 1;
11859 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11862 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11865 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11867 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11868 remote_buffer_add_string (&p
, &left
, arg
);
11870 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
11871 remote_errno
, NULL
, NULL
);
11873 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11877 rs
->fs_pid
= required_pid
;
11882 /* Implementation of to_fileio_open. */
11885 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
11886 int flags
, int mode
, int warn_if_slow
,
11889 struct remote_state
*rs
= get_remote_state ();
11890 char *p
= rs
->buf
.data ();
11891 int left
= get_remote_packet_size () - 1;
11895 static int warning_issued
= 0;
11897 printf_unfiltered (_("Reading %s from remote target...\n"),
11900 if (!warning_issued
)
11902 warning (_("File transfers from remote targets can be slow."
11903 " Use \"set sysroot\" to access files locally"
11905 warning_issued
= 1;
11909 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11912 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11914 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11915 strlen (filename
));
11916 remote_buffer_add_string (&p
, &left
, ",");
11918 remote_buffer_add_int (&p
, &left
, flags
);
11919 remote_buffer_add_string (&p
, &left
, ",");
11921 remote_buffer_add_int (&p
, &left
, mode
);
11923 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
11924 remote_errno
, NULL
, NULL
);
11928 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
11929 int flags
, int mode
, int warn_if_slow
,
11932 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
11936 /* Implementation of to_fileio_pwrite. */
11939 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11940 ULONGEST offset
, int *remote_errno
)
11942 struct remote_state
*rs
= get_remote_state ();
11943 char *p
= rs
->buf
.data ();
11944 int left
= get_remote_packet_size ();
11947 rs
->readahead_cache
.invalidate_fd (fd
);
11949 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11951 remote_buffer_add_int (&p
, &left
, fd
);
11952 remote_buffer_add_string (&p
, &left
, ",");
11954 remote_buffer_add_int (&p
, &left
, offset
);
11955 remote_buffer_add_string (&p
, &left
, ",");
11957 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
11958 (get_remote_packet_size ()
11959 - (p
- rs
->buf
.data ())));
11961 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
11962 remote_errno
, NULL
, NULL
);
11966 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11967 ULONGEST offset
, int *remote_errno
)
11969 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
11972 /* Helper for the implementation of to_fileio_pread. Read the file
11973 from the remote side with vFile:pread. */
11976 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
11977 ULONGEST offset
, int *remote_errno
)
11979 struct remote_state
*rs
= get_remote_state ();
11980 char *p
= rs
->buf
.data ();
11982 int left
= get_remote_packet_size ();
11983 int ret
, attachment_len
;
11986 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
11988 remote_buffer_add_int (&p
, &left
, fd
);
11989 remote_buffer_add_string (&p
, &left
, ",");
11991 remote_buffer_add_int (&p
, &left
, len
);
11992 remote_buffer_add_string (&p
, &left
, ",");
11994 remote_buffer_add_int (&p
, &left
, offset
);
11996 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
11997 remote_errno
, &attachment
,
12003 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12005 if (read_len
!= ret
)
12006 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
12011 /* See declaration.h. */
12014 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12018 && this->offset
<= offset
12019 && offset
< this->offset
+ this->bufsize
)
12021 ULONGEST max
= this->offset
+ this->bufsize
;
12023 if (offset
+ len
> max
)
12024 len
= max
- offset
;
12026 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12033 /* Implementation of to_fileio_pread. */
12036 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12037 ULONGEST offset
, int *remote_errno
)
12040 struct remote_state
*rs
= get_remote_state ();
12041 readahead_cache
*cache
= &rs
->readahead_cache
;
12043 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12046 cache
->hit_count
++;
12049 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12050 pulongest (cache
->hit_count
));
12054 cache
->miss_count
++;
12056 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12057 pulongest (cache
->miss_count
));
12060 cache
->offset
= offset
;
12061 cache
->bufsize
= get_remote_packet_size ();
12062 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12064 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12065 cache
->offset
, remote_errno
);
12068 cache
->invalidate_fd (fd
);
12072 cache
->bufsize
= ret
;
12073 return cache
->pread (fd
, read_buf
, len
, offset
);
12077 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12078 ULONGEST offset
, int *remote_errno
)
12080 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12083 /* Implementation of to_fileio_close. */
12086 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12088 struct remote_state
*rs
= get_remote_state ();
12089 char *p
= rs
->buf
.data ();
12090 int left
= get_remote_packet_size () - 1;
12092 rs
->readahead_cache
.invalidate_fd (fd
);
12094 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12096 remote_buffer_add_int (&p
, &left
, fd
);
12098 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12099 remote_errno
, NULL
, NULL
);
12103 remote_target::fileio_close (int fd
, int *remote_errno
)
12105 return remote_hostio_close (fd
, remote_errno
);
12108 /* Implementation of to_fileio_unlink. */
12111 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12114 struct remote_state
*rs
= get_remote_state ();
12115 char *p
= rs
->buf
.data ();
12116 int left
= get_remote_packet_size () - 1;
12118 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12121 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12123 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12124 strlen (filename
));
12126 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12127 remote_errno
, NULL
, NULL
);
12131 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12134 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12137 /* Implementation of to_fileio_readlink. */
12139 gdb::optional
<std::string
>
12140 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12143 struct remote_state
*rs
= get_remote_state ();
12144 char *p
= rs
->buf
.data ();
12146 int left
= get_remote_packet_size ();
12147 int len
, attachment_len
;
12150 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12153 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12155 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12156 strlen (filename
));
12158 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12159 remote_errno
, &attachment
,
12165 std::string
ret (len
, '\0');
12167 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12168 (gdb_byte
*) &ret
[0], len
);
12169 if (read_len
!= len
)
12170 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12175 /* Implementation of to_fileio_fstat. */
12178 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12180 struct remote_state
*rs
= get_remote_state ();
12181 char *p
= rs
->buf
.data ();
12182 int left
= get_remote_packet_size ();
12183 int attachment_len
, ret
;
12185 struct fio_stat fst
;
12188 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12190 remote_buffer_add_int (&p
, &left
, fd
);
12192 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12193 remote_errno
, &attachment
,
12197 if (*remote_errno
!= FILEIO_ENOSYS
)
12200 /* Strictly we should return -1, ENOSYS here, but when
12201 "set sysroot remote:" was implemented in August 2008
12202 BFD's need for a stat function was sidestepped with
12203 this hack. This was not remedied until March 2015
12204 so we retain the previous behavior to avoid breaking
12207 Note that the memset is a March 2015 addition; older
12208 GDBs set st_size *and nothing else* so the structure
12209 would have garbage in all other fields. This might
12210 break something but retaining the previous behavior
12211 here would be just too wrong. */
12213 memset (st
, 0, sizeof (struct stat
));
12214 st
->st_size
= INT_MAX
;
12218 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12219 (gdb_byte
*) &fst
, sizeof (fst
));
12221 if (read_len
!= ret
)
12222 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12224 if (read_len
!= sizeof (fst
))
12225 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12226 read_len
, (int) sizeof (fst
));
12228 remote_fileio_to_host_stat (&fst
, st
);
12233 /* Implementation of to_filesystem_is_local. */
12236 remote_target::filesystem_is_local ()
12238 /* Valgrind GDB presents itself as a remote target but works
12239 on the local filesystem: it does not implement remote get
12240 and users are not expected to set a sysroot. To handle
12241 this case we treat the remote filesystem as local if the
12242 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12243 does not support vFile:open. */
12244 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12246 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12248 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12250 int fd
, remote_errno
;
12252 /* Try opening a file to probe support. The supplied
12253 filename is irrelevant, we only care about whether
12254 the stub recognizes the packet or not. */
12255 fd
= remote_hostio_open (NULL
, "just probing",
12256 FILEIO_O_RDONLY
, 0700, 0,
12260 remote_hostio_close (fd
, &remote_errno
);
12262 ps
= packet_support (PACKET_vFile_open
);
12265 if (ps
== PACKET_DISABLE
)
12267 static int warning_issued
= 0;
12269 if (!warning_issued
)
12271 warning (_("remote target does not support file"
12272 " transfer, attempting to access files"
12273 " from local filesystem."));
12274 warning_issued
= 1;
12285 remote_fileio_errno_to_host (int errnum
)
12291 case FILEIO_ENOENT
:
12299 case FILEIO_EACCES
:
12301 case FILEIO_EFAULT
:
12305 case FILEIO_EEXIST
:
12307 case FILEIO_ENODEV
:
12309 case FILEIO_ENOTDIR
:
12311 case FILEIO_EISDIR
:
12313 case FILEIO_EINVAL
:
12315 case FILEIO_ENFILE
:
12317 case FILEIO_EMFILE
:
12321 case FILEIO_ENOSPC
:
12323 case FILEIO_ESPIPE
:
12327 case FILEIO_ENOSYS
:
12329 case FILEIO_ENAMETOOLONG
:
12330 return ENAMETOOLONG
;
12336 remote_hostio_error (int errnum
)
12338 int host_error
= remote_fileio_errno_to_host (errnum
);
12340 if (host_error
== -1)
12341 error (_("Unknown remote I/O error %d"), errnum
);
12343 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12346 /* A RAII wrapper around a remote file descriptor. */
12348 class scoped_remote_fd
12351 scoped_remote_fd (remote_target
*remote
, int fd
)
12352 : m_remote (remote
), m_fd (fd
)
12356 ~scoped_remote_fd ()
12363 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12367 /* Swallow exception before it escapes the dtor. If
12368 something goes wrong, likely the connection is gone,
12369 and there's nothing else that can be done. */
12374 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12376 /* Release ownership of the file descriptor, and return it. */
12377 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12384 /* Return the owned file descriptor. */
12385 int get () const noexcept
12391 /* The remote target. */
12392 remote_target
*m_remote
;
12394 /* The owned remote I/O file descriptor. */
12399 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12401 remote_target
*remote
= get_current_remote_target ();
12403 if (remote
== nullptr)
12404 error (_("command can only be used with remote target"));
12406 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12410 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12413 int retcode
, remote_errno
, bytes
, io_size
;
12414 int bytes_in_buffer
;
12418 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12420 perror_with_name (local_file
);
12422 scoped_remote_fd fd
12423 (this, remote_hostio_open (NULL
,
12424 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12426 0700, 0, &remote_errno
));
12427 if (fd
.get () == -1)
12428 remote_hostio_error (remote_errno
);
12430 /* Send up to this many bytes at once. They won't all fit in the
12431 remote packet limit, so we'll transfer slightly fewer. */
12432 io_size
= get_remote_packet_size ();
12433 gdb::byte_vector
buffer (io_size
);
12435 bytes_in_buffer
= 0;
12438 while (bytes_in_buffer
|| !saw_eof
)
12442 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12443 io_size
- bytes_in_buffer
,
12447 if (ferror (file
.get ()))
12448 error (_("Error reading %s."), local_file
);
12451 /* EOF. Unless there is something still in the
12452 buffer from the last iteration, we are done. */
12454 if (bytes_in_buffer
== 0)
12462 bytes
+= bytes_in_buffer
;
12463 bytes_in_buffer
= 0;
12465 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12466 offset
, &remote_errno
);
12469 remote_hostio_error (remote_errno
);
12470 else if (retcode
== 0)
12471 error (_("Remote write of %d bytes returned 0!"), bytes
);
12472 else if (retcode
< bytes
)
12474 /* Short write. Save the rest of the read data for the next
12476 bytes_in_buffer
= bytes
- retcode
;
12477 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12483 if (remote_hostio_close (fd
.release (), &remote_errno
))
12484 remote_hostio_error (remote_errno
);
12487 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12491 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12493 remote_target
*remote
= get_current_remote_target ();
12495 if (remote
== nullptr)
12496 error (_("command can only be used with remote target"));
12498 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12502 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12505 int remote_errno
, bytes
, io_size
;
12508 scoped_remote_fd fd
12509 (this, remote_hostio_open (NULL
,
12510 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12512 if (fd
.get () == -1)
12513 remote_hostio_error (remote_errno
);
12515 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12517 perror_with_name (local_file
);
12519 /* Send up to this many bytes at once. They won't all fit in the
12520 remote packet limit, so we'll transfer slightly fewer. */
12521 io_size
= get_remote_packet_size ();
12522 gdb::byte_vector
buffer (io_size
);
12527 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12530 /* Success, but no bytes, means end-of-file. */
12533 remote_hostio_error (remote_errno
);
12537 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12539 perror_with_name (local_file
);
12542 if (remote_hostio_close (fd
.release (), &remote_errno
))
12543 remote_hostio_error (remote_errno
);
12546 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12550 remote_file_delete (const char *remote_file
, int from_tty
)
12552 remote_target
*remote
= get_current_remote_target ();
12554 if (remote
== nullptr)
12555 error (_("command can only be used with remote target"));
12557 remote
->remote_file_delete (remote_file
, from_tty
);
12561 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12563 int retcode
, remote_errno
;
12565 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12567 remote_hostio_error (remote_errno
);
12570 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12574 remote_put_command (const char *args
, int from_tty
)
12577 error_no_arg (_("file to put"));
12579 gdb_argv
argv (args
);
12580 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12581 error (_("Invalid parameters to remote put"));
12583 remote_file_put (argv
[0], argv
[1], from_tty
);
12587 remote_get_command (const char *args
, int from_tty
)
12590 error_no_arg (_("file to get"));
12592 gdb_argv
argv (args
);
12593 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12594 error (_("Invalid parameters to remote get"));
12596 remote_file_get (argv
[0], argv
[1], from_tty
);
12600 remote_delete_command (const char *args
, int from_tty
)
12603 error_no_arg (_("file to delete"));
12605 gdb_argv
argv (args
);
12606 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12607 error (_("Invalid parameters to remote delete"));
12609 remote_file_delete (argv
[0], from_tty
);
12613 remote_command (const char *args
, int from_tty
)
12615 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12619 remote_target::can_execute_reverse ()
12621 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12622 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12629 remote_target::supports_non_stop ()
12635 remote_target::supports_disable_randomization ()
12637 /* Only supported in extended mode. */
12642 remote_target::supports_multi_process ()
12644 struct remote_state
*rs
= get_remote_state ();
12646 return remote_multi_process_p (rs
);
12650 remote_supports_cond_tracepoints ()
12652 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12656 remote_target::supports_evaluation_of_breakpoint_conditions ()
12658 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12662 remote_supports_fast_tracepoints ()
12664 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12668 remote_supports_static_tracepoints ()
12670 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12674 remote_supports_install_in_trace ()
12676 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12680 remote_target::supports_enable_disable_tracepoint ()
12682 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12687 remote_target::supports_string_tracing ()
12689 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12693 remote_target::can_run_breakpoint_commands ()
12695 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12699 remote_target::trace_init ()
12701 struct remote_state
*rs
= get_remote_state ();
12704 remote_get_noisy_reply ();
12705 if (strcmp (rs
->buf
.data (), "OK") != 0)
12706 error (_("Target does not support this command."));
12709 /* Recursive routine to walk through command list including loops, and
12710 download packets for each command. */
12713 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12714 struct command_line
*cmds
)
12716 struct remote_state
*rs
= get_remote_state ();
12717 struct command_line
*cmd
;
12719 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12721 QUIT
; /* Allow user to bail out with ^C. */
12722 strcpy (rs
->buf
.data (), "QTDPsrc:");
12723 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12724 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12725 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12727 remote_get_noisy_reply ();
12728 if (strcmp (rs
->buf
.data (), "OK"))
12729 warning (_("Target does not support source download."));
12731 if (cmd
->control_type
== while_control
12732 || cmd
->control_type
== while_stepping_control
)
12734 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12736 QUIT
; /* Allow user to bail out with ^C. */
12737 strcpy (rs
->buf
.data (), "QTDPsrc:");
12738 encode_source_string (num
, addr
, "cmd", "end",
12739 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12740 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12742 remote_get_noisy_reply ();
12743 if (strcmp (rs
->buf
.data (), "OK"))
12744 warning (_("Target does not support source download."));
12750 remote_target::download_tracepoint (struct bp_location
*loc
)
12754 std::vector
<std::string
> tdp_actions
;
12755 std::vector
<std::string
> stepping_actions
;
12757 struct breakpoint
*b
= loc
->owner
;
12758 struct tracepoint
*t
= (struct tracepoint
*) b
;
12759 struct remote_state
*rs
= get_remote_state ();
12761 const char *err_msg
= _("Tracepoint packet too large for target.");
12764 /* We use a buffer other than rs->buf because we'll build strings
12765 across multiple statements, and other statements in between could
12767 gdb::char_vector
buf (get_remote_packet_size ());
12769 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12771 tpaddr
= loc
->address
;
12772 sprintf_vma (addrbuf
, tpaddr
);
12773 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12774 b
->number
, addrbuf
, /* address */
12775 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12776 t
->step_count
, t
->pass_count
);
12778 if (ret
< 0 || ret
>= buf
.size ())
12779 error ("%s", err_msg
);
12781 /* Fast tracepoints are mostly handled by the target, but we can
12782 tell the target how big of an instruction block should be moved
12784 if (b
->type
== bp_fast_tracepoint
)
12786 /* Only test for support at download time; we may not know
12787 target capabilities at definition time. */
12788 if (remote_supports_fast_tracepoints ())
12790 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12793 size_left
= buf
.size () - strlen (buf
.data ());
12794 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12796 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12798 if (ret
< 0 || ret
>= size_left
)
12799 error ("%s", err_msg
);
12802 /* If it passed validation at definition but fails now,
12803 something is very wrong. */
12804 internal_error (__FILE__
, __LINE__
,
12805 _("Fast tracepoint not "
12806 "valid during download"));
12809 /* Fast tracepoints are functionally identical to regular
12810 tracepoints, so don't take lack of support as a reason to
12811 give up on the trace run. */
12812 warning (_("Target does not support fast tracepoints, "
12813 "downloading %d as regular tracepoint"), b
->number
);
12815 else if (b
->type
== bp_static_tracepoint
)
12817 /* Only test for support at download time; we may not know
12818 target capabilities at definition time. */
12819 if (remote_supports_static_tracepoints ())
12821 struct static_tracepoint_marker marker
;
12823 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12825 size_left
= buf
.size () - strlen (buf
.data ());
12826 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12829 if (ret
< 0 || ret
>= size_left
)
12830 error ("%s", err_msg
);
12833 error (_("Static tracepoint not valid during download"));
12836 /* Fast tracepoints are functionally identical to regular
12837 tracepoints, so don't take lack of support as a reason
12838 to give up on the trace run. */
12839 error (_("Target does not support static tracepoints"));
12841 /* If the tracepoint has a conditional, make it into an agent
12842 expression and append to the definition. */
12845 /* Only test support at download time, we may not know target
12846 capabilities at definition time. */
12847 if (remote_supports_cond_tracepoints ())
12849 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
12852 size_left
= buf
.size () - strlen (buf
.data ());
12854 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12855 size_left
, ":X%x,", aexpr
->len
);
12857 if (ret
< 0 || ret
>= size_left
)
12858 error ("%s", err_msg
);
12860 size_left
= buf
.size () - strlen (buf
.data ());
12862 /* Two bytes to encode each aexpr byte, plus the terminating
12864 if (aexpr
->len
* 2 + 1 > size_left
)
12865 error ("%s", err_msg
);
12867 pkt
= buf
.data () + strlen (buf
.data ());
12869 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12870 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12874 warning (_("Target does not support conditional tracepoints, "
12875 "ignoring tp %d cond"), b
->number
);
12878 if (b
->commands
|| *default_collect
)
12880 size_left
= buf
.size () - strlen (buf
.data ());
12882 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12885 if (ret
< 0 || ret
>= size_left
)
12886 error ("%s", err_msg
);
12889 putpkt (buf
.data ());
12890 remote_get_noisy_reply ();
12891 if (strcmp (rs
->buf
.data (), "OK"))
12892 error (_("Target does not support tracepoints."));
12894 /* do_single_steps (t); */
12895 for (auto action_it
= tdp_actions
.begin ();
12896 action_it
!= tdp_actions
.end (); action_it
++)
12898 QUIT
; /* Allow user to bail out with ^C. */
12900 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
12901 || !stepping_actions
.empty ());
12903 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
12904 b
->number
, addrbuf
, /* address */
12905 action_it
->c_str (),
12906 has_more
? '-' : 0);
12908 if (ret
< 0 || ret
>= buf
.size ())
12909 error ("%s", err_msg
);
12911 putpkt (buf
.data ());
12912 remote_get_noisy_reply ();
12913 if (strcmp (rs
->buf
.data (), "OK"))
12914 error (_("Error on target while setting tracepoints."));
12917 for (auto action_it
= stepping_actions
.begin ();
12918 action_it
!= stepping_actions
.end (); action_it
++)
12920 QUIT
; /* Allow user to bail out with ^C. */
12922 bool is_first
= action_it
== stepping_actions
.begin ();
12923 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
12925 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
12926 b
->number
, addrbuf
, /* address */
12927 is_first
? "S" : "",
12928 action_it
->c_str (),
12929 has_more
? "-" : "");
12931 if (ret
< 0 || ret
>= buf
.size ())
12932 error ("%s", err_msg
);
12934 putpkt (buf
.data ());
12935 remote_get_noisy_reply ();
12936 if (strcmp (rs
->buf
.data (), "OK"))
12937 error (_("Error on target while setting tracepoints."));
12940 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12942 if (b
->location
!= NULL
)
12944 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12946 if (ret
< 0 || ret
>= buf
.size ())
12947 error ("%s", err_msg
);
12949 encode_source_string (b
->number
, loc
->address
, "at",
12950 event_location_to_string (b
->location
.get ()),
12951 buf
.data () + strlen (buf
.data ()),
12952 buf
.size () - strlen (buf
.data ()));
12953 putpkt (buf
.data ());
12954 remote_get_noisy_reply ();
12955 if (strcmp (rs
->buf
.data (), "OK"))
12956 warning (_("Target does not support source download."));
12958 if (b
->cond_string
)
12960 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12962 if (ret
< 0 || ret
>= buf
.size ())
12963 error ("%s", err_msg
);
12965 encode_source_string (b
->number
, loc
->address
,
12966 "cond", b
->cond_string
,
12967 buf
.data () + strlen (buf
.data ()),
12968 buf
.size () - strlen (buf
.data ()));
12969 putpkt (buf
.data ());
12970 remote_get_noisy_reply ();
12971 if (strcmp (rs
->buf
.data (), "OK"))
12972 warning (_("Target does not support source download."));
12974 remote_download_command_source (b
->number
, loc
->address
,
12975 breakpoint_commands (b
));
12980 remote_target::can_download_tracepoint ()
12982 struct remote_state
*rs
= get_remote_state ();
12983 struct trace_status
*ts
;
12986 /* Don't try to install tracepoints until we've relocated our
12987 symbols, and fetched and merged the target's tracepoint list with
12989 if (rs
->starting_up
)
12992 ts
= current_trace_status ();
12993 status
= get_trace_status (ts
);
12995 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
12998 /* If we are in a tracing experiment, but remote stub doesn't support
12999 installing tracepoint in trace, we have to return. */
13000 if (!remote_supports_install_in_trace ())
13008 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
13010 struct remote_state
*rs
= get_remote_state ();
13013 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13014 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13016 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13017 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13018 >= get_remote_packet_size ())
13019 error (_("Trace state variable name too long for tsv definition packet"));
13020 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13023 remote_get_noisy_reply ();
13024 if (rs
->buf
[0] == '\0')
13025 error (_("Target does not support this command."));
13026 if (strcmp (rs
->buf
.data (), "OK") != 0)
13027 error (_("Error on target while downloading trace state variable."));
13031 remote_target::enable_tracepoint (struct bp_location
*location
)
13033 struct remote_state
*rs
= get_remote_state ();
13036 sprintf_vma (addr_buf
, location
->address
);
13037 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13038 location
->owner
->number
, addr_buf
);
13040 remote_get_noisy_reply ();
13041 if (rs
->buf
[0] == '\0')
13042 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13043 if (strcmp (rs
->buf
.data (), "OK") != 0)
13044 error (_("Error on target while enabling tracepoint."));
13048 remote_target::disable_tracepoint (struct bp_location
*location
)
13050 struct remote_state
*rs
= get_remote_state ();
13053 sprintf_vma (addr_buf
, location
->address
);
13054 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13055 location
->owner
->number
, addr_buf
);
13057 remote_get_noisy_reply ();
13058 if (rs
->buf
[0] == '\0')
13059 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13060 if (strcmp (rs
->buf
.data (), "OK") != 0)
13061 error (_("Error on target while disabling tracepoint."));
13065 remote_target::trace_set_readonly_regions ()
13068 bfd_size_type size
;
13074 return; /* No information to give. */
13076 struct remote_state
*rs
= get_remote_state ();
13078 strcpy (rs
->buf
.data (), "QTro");
13079 offset
= strlen (rs
->buf
.data ());
13080 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
13082 char tmp1
[40], tmp2
[40];
13085 if ((s
->flags
& SEC_LOAD
) == 0 ||
13086 /* (s->flags & SEC_CODE) == 0 || */
13087 (s
->flags
& SEC_READONLY
) == 0)
13091 vma
= bfd_section_vma (s
);
13092 size
= bfd_section_size (s
);
13093 sprintf_vma (tmp1
, vma
);
13094 sprintf_vma (tmp2
, vma
+ size
);
13095 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13096 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13098 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13100 Too many sections for read-only sections definition packet."));
13103 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13105 offset
+= sec_length
;
13110 getpkt (&rs
->buf
, 0);
13115 remote_target::trace_start ()
13117 struct remote_state
*rs
= get_remote_state ();
13119 putpkt ("QTStart");
13120 remote_get_noisy_reply ();
13121 if (rs
->buf
[0] == '\0')
13122 error (_("Target does not support this command."));
13123 if (strcmp (rs
->buf
.data (), "OK") != 0)
13124 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13128 remote_target::get_trace_status (struct trace_status
*ts
)
13130 /* Initialize it just to avoid a GCC false warning. */
13132 enum packet_result result
;
13133 struct remote_state
*rs
= get_remote_state ();
13135 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13138 /* FIXME we need to get register block size some other way. */
13139 trace_regblock_size
13140 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13142 putpkt ("qTStatus");
13146 p
= remote_get_noisy_reply ();
13148 catch (const gdb_exception_error
&ex
)
13150 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13152 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13158 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13160 /* If the remote target doesn't do tracing, flag it. */
13161 if (result
== PACKET_UNKNOWN
)
13164 /* We're working with a live target. */
13165 ts
->filename
= NULL
;
13168 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13170 /* Function 'parse_trace_status' sets default value of each field of
13171 'ts' at first, so we don't have to do it here. */
13172 parse_trace_status (p
, ts
);
13174 return ts
->running
;
13178 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13179 struct uploaded_tp
*utp
)
13181 struct remote_state
*rs
= get_remote_state ();
13183 struct bp_location
*loc
;
13184 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13185 size_t size
= get_remote_packet_size ();
13190 tp
->traceframe_usage
= 0;
13191 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13193 /* If the tracepoint was never downloaded, don't go asking for
13195 if (tp
->number_on_target
== 0)
13197 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13198 phex_nz (loc
->address
, 0));
13200 reply
= remote_get_noisy_reply ();
13201 if (reply
&& *reply
)
13204 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13210 utp
->hit_count
= 0;
13211 utp
->traceframe_usage
= 0;
13212 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13213 phex_nz (utp
->addr
, 0));
13215 reply
= remote_get_noisy_reply ();
13216 if (reply
&& *reply
)
13219 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13225 remote_target::trace_stop ()
13227 struct remote_state
*rs
= get_remote_state ();
13230 remote_get_noisy_reply ();
13231 if (rs
->buf
[0] == '\0')
13232 error (_("Target does not support this command."));
13233 if (strcmp (rs
->buf
.data (), "OK") != 0)
13234 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13238 remote_target::trace_find (enum trace_find_type type
, int num
,
13239 CORE_ADDR addr1
, CORE_ADDR addr2
,
13242 struct remote_state
*rs
= get_remote_state ();
13243 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13245 int target_frameno
= -1, target_tracept
= -1;
13247 /* Lookups other than by absolute frame number depend on the current
13248 trace selected, so make sure it is correct on the remote end
13250 if (type
!= tfind_number
)
13251 set_remote_traceframe ();
13253 p
= rs
->buf
.data ();
13254 strcpy (p
, "QTFrame:");
13255 p
= strchr (p
, '\0');
13259 xsnprintf (p
, endbuf
- p
, "%x", num
);
13262 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13265 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13268 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13269 phex_nz (addr2
, 0));
13271 case tfind_outside
:
13272 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13273 phex_nz (addr2
, 0));
13276 error (_("Unknown trace find type %d"), type
);
13280 reply
= remote_get_noisy_reply ();
13281 if (*reply
== '\0')
13282 error (_("Target does not support this command."));
13284 while (reply
&& *reply
)
13289 target_frameno
= (int) strtol (p
, &reply
, 16);
13291 error (_("Unable to parse trace frame number"));
13292 /* Don't update our remote traceframe number cache on failure
13293 to select a remote traceframe. */
13294 if (target_frameno
== -1)
13299 target_tracept
= (int) strtol (p
, &reply
, 16);
13301 error (_("Unable to parse tracepoint number"));
13303 case 'O': /* "OK"? */
13304 if (reply
[1] == 'K' && reply
[2] == '\0')
13307 error (_("Bogus reply from target: %s"), reply
);
13310 error (_("Bogus reply from target: %s"), reply
);
13313 *tpp
= target_tracept
;
13315 rs
->remote_traceframe_number
= target_frameno
;
13316 return target_frameno
;
13320 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13322 struct remote_state
*rs
= get_remote_state ();
13326 set_remote_traceframe ();
13328 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13330 reply
= remote_get_noisy_reply ();
13331 if (reply
&& *reply
)
13335 unpack_varlen_hex (reply
+ 1, &uval
);
13336 *val
= (LONGEST
) uval
;
13344 remote_target::save_trace_data (const char *filename
)
13346 struct remote_state
*rs
= get_remote_state ();
13349 p
= rs
->buf
.data ();
13350 strcpy (p
, "QTSave:");
13352 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13353 >= get_remote_packet_size ())
13354 error (_("Remote file name too long for trace save packet"));
13355 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13358 reply
= remote_get_noisy_reply ();
13359 if (*reply
== '\0')
13360 error (_("Target does not support this command."));
13361 if (strcmp (reply
, "OK") != 0)
13362 error (_("Bogus reply from target: %s"), reply
);
13366 /* This is basically a memory transfer, but needs to be its own packet
13367 because we don't know how the target actually organizes its trace
13368 memory, plus we want to be able to ask for as much as possible, but
13369 not be unhappy if we don't get as much as we ask for. */
13372 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13374 struct remote_state
*rs
= get_remote_state ();
13379 p
= rs
->buf
.data ();
13380 strcpy (p
, "qTBuffer:");
13382 p
+= hexnumstr (p
, offset
);
13384 p
+= hexnumstr (p
, len
);
13388 reply
= remote_get_noisy_reply ();
13389 if (reply
&& *reply
)
13391 /* 'l' by itself means we're at the end of the buffer and
13392 there is nothing more to get. */
13396 /* Convert the reply into binary. Limit the number of bytes to
13397 convert according to our passed-in buffer size, rather than
13398 what was returned in the packet; if the target is
13399 unexpectedly generous and gives us a bigger reply than we
13400 asked for, we don't want to crash. */
13401 rslt
= hex2bin (reply
, buf
, len
);
13405 /* Something went wrong, flag as an error. */
13410 remote_target::set_disconnected_tracing (int val
)
13412 struct remote_state
*rs
= get_remote_state ();
13414 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13418 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13419 "QTDisconnected:%x", val
);
13421 reply
= remote_get_noisy_reply ();
13422 if (*reply
== '\0')
13423 error (_("Target does not support this command."));
13424 if (strcmp (reply
, "OK") != 0)
13425 error (_("Bogus reply from target: %s"), reply
);
13428 warning (_("Target does not support disconnected tracing."));
13432 remote_target::core_of_thread (ptid_t ptid
)
13434 struct thread_info
*info
= find_thread_ptid (ptid
);
13436 if (info
!= NULL
&& info
->priv
!= NULL
)
13437 return get_remote_thread_info (info
)->core
;
13443 remote_target::set_circular_trace_buffer (int val
)
13445 struct remote_state
*rs
= get_remote_state ();
13448 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13449 "QTBuffer:circular:%x", val
);
13451 reply
= remote_get_noisy_reply ();
13452 if (*reply
== '\0')
13453 error (_("Target does not support this command."));
13454 if (strcmp (reply
, "OK") != 0)
13455 error (_("Bogus reply from target: %s"), reply
);
13459 remote_target::traceframe_info ()
13461 gdb::optional
<gdb::char_vector
> text
13462 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13465 return parse_traceframe_info (text
->data ());
13470 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13471 instruction on which a fast tracepoint may be placed. Returns -1
13472 if the packet is not supported, and 0 if the minimum instruction
13473 length is unknown. */
13476 remote_target::get_min_fast_tracepoint_insn_len ()
13478 struct remote_state
*rs
= get_remote_state ();
13481 /* If we're not debugging a process yet, the IPA can't be
13483 if (!target_has_execution
)
13486 /* Make sure the remote is pointing at the right process. */
13487 set_general_process ();
13489 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13491 reply
= remote_get_noisy_reply ();
13492 if (*reply
== '\0')
13496 ULONGEST min_insn_len
;
13498 unpack_varlen_hex (reply
, &min_insn_len
);
13500 return (int) min_insn_len
;
13505 remote_target::set_trace_buffer_size (LONGEST val
)
13507 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13509 struct remote_state
*rs
= get_remote_state ();
13510 char *buf
= rs
->buf
.data ();
13511 char *endbuf
= buf
+ get_remote_packet_size ();
13512 enum packet_result result
;
13514 gdb_assert (val
>= 0 || val
== -1);
13515 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13516 /* Send -1 as literal "-1" to avoid host size dependency. */
13520 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13523 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13526 remote_get_noisy_reply ();
13527 result
= packet_ok (rs
->buf
,
13528 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13530 if (result
!= PACKET_OK
)
13531 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13536 remote_target::set_trace_notes (const char *user
, const char *notes
,
13537 const char *stop_notes
)
13539 struct remote_state
*rs
= get_remote_state ();
13541 char *buf
= rs
->buf
.data ();
13542 char *endbuf
= buf
+ get_remote_packet_size ();
13545 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13548 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13549 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13555 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13556 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13562 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13563 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13567 /* Ensure the buffer is terminated. */
13571 reply
= remote_get_noisy_reply ();
13572 if (*reply
== '\0')
13575 if (strcmp (reply
, "OK") != 0)
13576 error (_("Bogus reply from target: %s"), reply
);
13582 remote_target::use_agent (bool use
)
13584 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13586 struct remote_state
*rs
= get_remote_state ();
13588 /* If the stub supports QAgent. */
13589 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13591 getpkt (&rs
->buf
, 0);
13593 if (strcmp (rs
->buf
.data (), "OK") == 0)
13604 remote_target::can_use_agent ()
13606 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13609 struct btrace_target_info
13611 /* The ptid of the traced thread. */
13614 /* The obtained branch trace configuration. */
13615 struct btrace_config conf
;
13618 /* Reset our idea of our target's btrace configuration. */
13621 remote_btrace_reset (remote_state
*rs
)
13623 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13626 /* Synchronize the configuration with the target. */
13629 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13631 struct packet_config
*packet
;
13632 struct remote_state
*rs
;
13633 char *buf
, *pos
, *endbuf
;
13635 rs
= get_remote_state ();
13636 buf
= rs
->buf
.data ();
13637 endbuf
= buf
+ get_remote_packet_size ();
13639 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13640 if (packet_config_support (packet
) == PACKET_ENABLE
13641 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13644 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13648 getpkt (&rs
->buf
, 0);
13650 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13652 if (buf
[0] == 'E' && buf
[1] == '.')
13653 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13655 error (_("Failed to configure the BTS buffer size."));
13658 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13661 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13662 if (packet_config_support (packet
) == PACKET_ENABLE
13663 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13666 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13670 getpkt (&rs
->buf
, 0);
13672 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13674 if (buf
[0] == 'E' && buf
[1] == '.')
13675 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13677 error (_("Failed to configure the trace buffer size."));
13680 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13684 /* Read the current thread's btrace configuration from the target and
13685 store it into CONF. */
13688 btrace_read_config (struct btrace_config
*conf
)
13690 gdb::optional
<gdb::char_vector
> xml
13691 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13693 parse_xml_btrace_conf (conf
, xml
->data ());
13696 /* Maybe reopen target btrace. */
13699 remote_target::remote_btrace_maybe_reopen ()
13701 struct remote_state
*rs
= get_remote_state ();
13702 int btrace_target_pushed
= 0;
13703 #if !defined (HAVE_LIBIPT)
13707 /* Don't bother walking the entirety of the remote thread list when
13708 we know the feature isn't supported by the remote. */
13709 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13712 scoped_restore_current_thread restore_thread
;
13714 for (thread_info
*tp
: all_non_exited_threads ())
13716 set_general_thread (tp
->ptid
);
13718 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13719 btrace_read_config (&rs
->btrace_config
);
13721 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13724 #if !defined (HAVE_LIBIPT)
13725 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13730 warning (_("Target is recording using Intel Processor Trace "
13731 "but support was disabled at compile time."));
13736 #endif /* !defined (HAVE_LIBIPT) */
13738 /* Push target, once, but before anything else happens. This way our
13739 changes to the threads will be cleaned up by unpushing the target
13740 in case btrace_read_config () throws. */
13741 if (!btrace_target_pushed
)
13743 btrace_target_pushed
= 1;
13744 record_btrace_push_target ();
13745 printf_filtered (_("Target is recording using %s.\n"),
13746 btrace_format_string (rs
->btrace_config
.format
));
13749 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13750 tp
->btrace
.target
->ptid
= tp
->ptid
;
13751 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13755 /* Enable branch tracing. */
13757 struct btrace_target_info
*
13758 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13760 struct btrace_target_info
*tinfo
= NULL
;
13761 struct packet_config
*packet
= NULL
;
13762 struct remote_state
*rs
= get_remote_state ();
13763 char *buf
= rs
->buf
.data ();
13764 char *endbuf
= buf
+ get_remote_packet_size ();
13766 switch (conf
->format
)
13768 case BTRACE_FORMAT_BTS
:
13769 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13772 case BTRACE_FORMAT_PT
:
13773 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13777 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13778 error (_("Target does not support branch tracing."));
13780 btrace_sync_conf (conf
);
13782 set_general_thread (ptid
);
13784 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13786 getpkt (&rs
->buf
, 0);
13788 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13790 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13791 error (_("Could not enable branch tracing for %s: %s"),
13792 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
13794 error (_("Could not enable branch tracing for %s."),
13795 target_pid_to_str (ptid
).c_str ());
13798 tinfo
= XCNEW (struct btrace_target_info
);
13799 tinfo
->ptid
= ptid
;
13801 /* If we fail to read the configuration, we lose some information, but the
13802 tracing itself is not impacted. */
13805 btrace_read_config (&tinfo
->conf
);
13807 catch (const gdb_exception_error
&err
)
13809 if (err
.message
!= NULL
)
13810 warning ("%s", err
.what ());
13816 /* Disable branch tracing. */
13819 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
13821 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13822 struct remote_state
*rs
= get_remote_state ();
13823 char *buf
= rs
->buf
.data ();
13824 char *endbuf
= buf
+ get_remote_packet_size ();
13826 if (packet_config_support (packet
) != PACKET_ENABLE
)
13827 error (_("Target does not support branch tracing."));
13829 set_general_thread (tinfo
->ptid
);
13831 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13833 getpkt (&rs
->buf
, 0);
13835 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13837 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13838 error (_("Could not disable branch tracing for %s: %s"),
13839 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
13841 error (_("Could not disable branch tracing for %s."),
13842 target_pid_to_str (tinfo
->ptid
).c_str ());
13848 /* Teardown branch tracing. */
13851 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
13853 /* We must not talk to the target during teardown. */
13857 /* Read the branch trace. */
13860 remote_target::read_btrace (struct btrace_data
*btrace
,
13861 struct btrace_target_info
*tinfo
,
13862 enum btrace_read_type type
)
13864 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13867 if (packet_config_support (packet
) != PACKET_ENABLE
)
13868 error (_("Target does not support branch tracing."));
13870 #if !defined(HAVE_LIBEXPAT)
13871 error (_("Cannot process branch tracing result. XML parsing not supported."));
13876 case BTRACE_READ_ALL
:
13879 case BTRACE_READ_NEW
:
13882 case BTRACE_READ_DELTA
:
13886 internal_error (__FILE__
, __LINE__
,
13887 _("Bad branch tracing read type: %u."),
13888 (unsigned int) type
);
13891 gdb::optional
<gdb::char_vector
> xml
13892 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
13894 return BTRACE_ERR_UNKNOWN
;
13896 parse_xml_btrace (btrace
, xml
->data ());
13898 return BTRACE_ERR_NONE
;
13901 const struct btrace_config
*
13902 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
13904 return &tinfo
->conf
;
13908 remote_target::augmented_libraries_svr4_read ()
13910 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13914 /* Implementation of to_load. */
13917 remote_target::load (const char *name
, int from_tty
)
13919 generic_load (name
, from_tty
);
13922 /* Accepts an integer PID; returns a string representing a file that
13923 can be opened on the remote side to get the symbols for the child
13924 process. Returns NULL if the operation is not supported. */
13927 remote_target::pid_to_exec_file (int pid
)
13929 static gdb::optional
<gdb::char_vector
> filename
;
13930 struct inferior
*inf
;
13931 char *annex
= NULL
;
13933 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13936 inf
= find_inferior_pid (pid
);
13938 internal_error (__FILE__
, __LINE__
,
13939 _("not currently attached to process %d"), pid
);
13941 if (!inf
->fake_pid_p
)
13943 const int annex_size
= 9;
13945 annex
= (char *) alloca (annex_size
);
13946 xsnprintf (annex
, annex_size
, "%x", pid
);
13949 filename
= target_read_stralloc (current_top_target (),
13950 TARGET_OBJECT_EXEC_FILE
, annex
);
13952 return filename
? filename
->data () : nullptr;
13955 /* Implement the to_can_do_single_step target_ops method. */
13958 remote_target::can_do_single_step ()
13960 /* We can only tell whether target supports single step or not by
13961 supported s and S vCont actions if the stub supports vContSupported
13962 feature. If the stub doesn't support vContSupported feature,
13963 we have conservatively to think target doesn't supports single
13965 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
13967 struct remote_state
*rs
= get_remote_state ();
13969 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13970 remote_vcont_probe ();
13972 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
13978 /* Implementation of the to_execution_direction method for the remote
13981 enum exec_direction_kind
13982 remote_target::execution_direction ()
13984 struct remote_state
*rs
= get_remote_state ();
13986 return rs
->last_resume_exec_dir
;
13989 /* Return pointer to the thread_info struct which corresponds to
13990 THREAD_HANDLE (having length HANDLE_LEN). */
13993 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
13997 for (thread_info
*tp
: all_non_exited_threads ())
13999 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14001 if (tp
->inf
== inf
&& priv
!= NULL
)
14003 if (handle_len
!= priv
->thread_handle
.size ())
14004 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14005 handle_len
, priv
->thread_handle
.size ());
14006 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14016 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
14018 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14019 return priv
->thread_handle
;
14023 remote_target::can_async_p ()
14025 struct remote_state
*rs
= get_remote_state ();
14027 /* We don't go async if the user has explicitly prevented it with the
14028 "maint set target-async" command. */
14029 if (!target_async_permitted
)
14032 /* We're async whenever the serial device is. */
14033 return serial_can_async_p (rs
->remote_desc
);
14037 remote_target::is_async_p ()
14039 struct remote_state
*rs
= get_remote_state ();
14041 if (!target_async_permitted
)
14042 /* We only enable async when the user specifically asks for it. */
14045 /* We're async whenever the serial device is. */
14046 return serial_is_async_p (rs
->remote_desc
);
14049 /* Pass the SERIAL event on and up to the client. One day this code
14050 will be able to delay notifying the client of an event until the
14051 point where an entire packet has been received. */
14053 static serial_event_ftype remote_async_serial_handler
;
14056 remote_async_serial_handler (struct serial
*scb
, void *context
)
14058 /* Don't propogate error information up to the client. Instead let
14059 the client find out about the error by querying the target. */
14060 inferior_event_handler (INF_REG_EVENT
, NULL
);
14064 remote_async_inferior_event_handler (gdb_client_data data
)
14066 inferior_event_handler (INF_REG_EVENT
, data
);
14070 remote_target::async (int enable
)
14072 struct remote_state
*rs
= get_remote_state ();
14076 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14078 /* If there are pending events in the stop reply queue tell the
14079 event loop to process them. */
14080 if (!rs
->stop_reply_queue
.empty ())
14081 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14082 /* For simplicity, below we clear the pending events token
14083 without remembering whether it is marked, so here we always
14084 mark it. If there's actually no pending notification to
14085 process, this ends up being a no-op (other than a spurious
14086 event-loop wakeup). */
14087 if (target_is_non_stop_p ())
14088 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14092 serial_async (rs
->remote_desc
, NULL
, NULL
);
14093 /* If the core is disabling async, it doesn't want to be
14094 disturbed with target events. Clear all async event sources
14096 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14097 if (target_is_non_stop_p ())
14098 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14102 /* Implementation of the to_thread_events method. */
14105 remote_target::thread_events (int enable
)
14107 struct remote_state
*rs
= get_remote_state ();
14108 size_t size
= get_remote_packet_size ();
14110 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14113 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14115 getpkt (&rs
->buf
, 0);
14117 switch (packet_ok (rs
->buf
,
14118 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14121 if (strcmp (rs
->buf
.data (), "OK") != 0)
14122 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14125 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14127 case PACKET_UNKNOWN
:
14133 set_remote_cmd (const char *args
, int from_tty
)
14135 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
14139 show_remote_cmd (const char *args
, int from_tty
)
14141 /* We can't just use cmd_show_list here, because we want to skip
14142 the redundant "show remote Z-packet" and the legacy aliases. */
14143 struct cmd_list_element
*list
= remote_show_cmdlist
;
14144 struct ui_out
*uiout
= current_uiout
;
14146 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14147 for (; list
!= NULL
; list
= list
->next
)
14148 if (strcmp (list
->name
, "Z-packet") == 0)
14150 else if (list
->type
== not_set_cmd
)
14151 /* Alias commands are exactly like the original, except they
14152 don't have the normal type. */
14156 ui_out_emit_tuple
option_emitter (uiout
, "option");
14158 uiout
->field_string ("name", list
->name
);
14159 uiout
->text (": ");
14160 if (list
->type
== show_cmd
)
14161 do_show_command (NULL
, from_tty
, list
);
14163 cmd_func (list
, NULL
, from_tty
);
14168 /* Function to be called whenever a new objfile (shlib) is detected. */
14170 remote_new_objfile (struct objfile
*objfile
)
14172 remote_target
*remote
= get_current_remote_target ();
14174 if (remote
!= NULL
) /* Have a remote connection. */
14175 remote
->remote_check_symbols ();
14178 /* Pull all the tracepoints defined on the target and create local
14179 data structures representing them. We don't want to create real
14180 tracepoints yet, we don't want to mess up the user's existing
14184 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14186 struct remote_state
*rs
= get_remote_state ();
14189 /* Ask for a first packet of tracepoint definition. */
14191 getpkt (&rs
->buf
, 0);
14192 p
= rs
->buf
.data ();
14193 while (*p
&& *p
!= 'l')
14195 parse_tracepoint_definition (p
, utpp
);
14196 /* Ask for another packet of tracepoint definition. */
14198 getpkt (&rs
->buf
, 0);
14199 p
= rs
->buf
.data ();
14205 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14207 struct remote_state
*rs
= get_remote_state ();
14210 /* Ask for a first packet of variable definition. */
14212 getpkt (&rs
->buf
, 0);
14213 p
= rs
->buf
.data ();
14214 while (*p
&& *p
!= 'l')
14216 parse_tsv_definition (p
, utsvp
);
14217 /* Ask for another packet of variable definition. */
14219 getpkt (&rs
->buf
, 0);
14220 p
= rs
->buf
.data ();
14225 /* The "set/show range-stepping" show hook. */
14228 show_range_stepping (struct ui_file
*file
, int from_tty
,
14229 struct cmd_list_element
*c
,
14232 fprintf_filtered (file
,
14233 _("Debugger's willingness to use range stepping "
14234 "is %s.\n"), value
);
14237 /* Return true if the vCont;r action is supported by the remote
14241 remote_target::vcont_r_supported ()
14243 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14244 remote_vcont_probe ();
14246 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14247 && get_remote_state ()->supports_vCont
.r
);
14250 /* The "set/show range-stepping" set hook. */
14253 set_range_stepping (const char *ignore_args
, int from_tty
,
14254 struct cmd_list_element
*c
)
14256 /* When enabling, check whether range stepping is actually supported
14257 by the target, and warn if not. */
14258 if (use_range_stepping
)
14260 remote_target
*remote
= get_current_remote_target ();
14262 || !remote
->vcont_r_supported ())
14263 warning (_("Range stepping is not supported by the current target"));
14268 _initialize_remote (void)
14270 struct cmd_list_element
*cmd
;
14271 const char *cmd_name
;
14273 /* architecture specific data */
14274 remote_g_packet_data_handle
=
14275 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14277 add_target (remote_target_info
, remote_target::open
);
14278 add_target (extended_remote_target_info
, extended_remote_target::open
);
14280 /* Hook into new objfile notification. */
14281 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14284 init_remote_threadtests ();
14287 /* set/show remote ... */
14289 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14290 Remote protocol specific variables.\n\
14291 Configure various remote-protocol specific variables such as\n\
14292 the packets being used."),
14293 &remote_set_cmdlist
, "set remote ",
14294 0 /* allow-unknown */, &setlist
);
14295 add_prefix_cmd ("remote", class_maintenance
, show_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_show_cmdlist
, "show remote ",
14300 0 /* allow-unknown */, &showlist
);
14302 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14303 Compare section data on target to the exec file.\n\
14304 Argument is a single section name (default: all loaded sections).\n\
14305 To compare only read-only loaded sections, specify the -r option."),
14308 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14309 Send an arbitrary packet to a remote target.\n\
14310 maintenance packet TEXT\n\
14311 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14312 this command sends the string TEXT to the inferior, and displays the\n\
14313 response packet. GDB supplies the initial `$' character, and the\n\
14314 terminating `#' character and checksum."),
14317 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14318 Set whether to send break if interrupted."), _("\
14319 Show whether to send break if interrupted."), _("\
14320 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14321 set_remotebreak
, show_remotebreak
,
14322 &setlist
, &showlist
);
14323 cmd_name
= "remotebreak";
14324 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14325 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14326 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14327 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14328 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14330 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14331 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14333 Set interrupt sequence to remote target."), _("\
14334 Show interrupt sequence to remote target."), _("\
14335 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14336 NULL
, show_interrupt_sequence
,
14337 &remote_set_cmdlist
,
14338 &remote_show_cmdlist
);
14340 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14341 &interrupt_on_connect
, _("\
14342 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14343 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14344 If set, interrupt sequence is sent to remote target."),
14346 &remote_set_cmdlist
, &remote_show_cmdlist
);
14348 /* Install commands for configuring memory read/write packets. */
14350 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14351 Set the maximum number of bytes per memory write packet (deprecated)."),
14353 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14354 Show the maximum number of bytes per memory write packet (deprecated)."),
14356 add_cmd ("memory-write-packet-size", no_class
,
14357 set_memory_write_packet_size
, _("\
14358 Set the maximum number of bytes per memory-write packet.\n\
14359 Specify the number of bytes in a packet or 0 (zero) for the\n\
14360 default packet size. The actual limit is further reduced\n\
14361 dependent on the target. Specify ``fixed'' to disable the\n\
14362 further restriction and ``limit'' to enable that restriction."),
14363 &remote_set_cmdlist
);
14364 add_cmd ("memory-read-packet-size", no_class
,
14365 set_memory_read_packet_size
, _("\
14366 Set the maximum number of bytes per memory-read packet.\n\
14367 Specify the number of bytes in a packet or 0 (zero) for the\n\
14368 default packet size. The actual limit is further reduced\n\
14369 dependent on the target. Specify ``fixed'' to disable the\n\
14370 further restriction and ``limit'' to enable that restriction."),
14371 &remote_set_cmdlist
);
14372 add_cmd ("memory-write-packet-size", no_class
,
14373 show_memory_write_packet_size
,
14374 _("Show the maximum number of bytes per memory-write packet."),
14375 &remote_show_cmdlist
);
14376 add_cmd ("memory-read-packet-size", no_class
,
14377 show_memory_read_packet_size
,
14378 _("Show the maximum number of bytes per memory-read packet."),
14379 &remote_show_cmdlist
);
14381 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14382 &remote_hw_watchpoint_limit
, _("\
14383 Set the maximum number of target hardware watchpoints."), _("\
14384 Show the maximum number of target hardware watchpoints."), _("\
14385 Specify \"unlimited\" for unlimited hardware watchpoints."),
14386 NULL
, show_hardware_watchpoint_limit
,
14387 &remote_set_cmdlist
,
14388 &remote_show_cmdlist
);
14389 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14391 &remote_hw_watchpoint_length_limit
, _("\
14392 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14393 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14394 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14395 NULL
, show_hardware_watchpoint_length_limit
,
14396 &remote_set_cmdlist
, &remote_show_cmdlist
);
14397 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14398 &remote_hw_breakpoint_limit
, _("\
14399 Set the maximum number of target hardware breakpoints."), _("\
14400 Show the maximum number of target hardware breakpoints."), _("\
14401 Specify \"unlimited\" for unlimited hardware breakpoints."),
14402 NULL
, show_hardware_breakpoint_limit
,
14403 &remote_set_cmdlist
, &remote_show_cmdlist
);
14405 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14406 &remote_address_size
, _("\
14407 Set the maximum size of the address (in bits) in a memory packet."), _("\
14408 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14410 NULL
, /* FIXME: i18n: */
14411 &setlist
, &showlist
);
14413 init_all_packet_configs ();
14415 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14416 "X", "binary-download", 1);
14418 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14419 "vCont", "verbose-resume", 0);
14421 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14422 "QPassSignals", "pass-signals", 0);
14424 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14425 "QCatchSyscalls", "catch-syscalls", 0);
14427 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14428 "QProgramSignals", "program-signals", 0);
14430 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14431 "QSetWorkingDir", "set-working-dir", 0);
14433 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14434 "QStartupWithShell", "startup-with-shell", 0);
14436 add_packet_config_cmd (&remote_protocol_packets
14437 [PACKET_QEnvironmentHexEncoded
],
14438 "QEnvironmentHexEncoded", "environment-hex-encoded",
14441 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14442 "QEnvironmentReset", "environment-reset",
14445 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14446 "QEnvironmentUnset", "environment-unset",
14449 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14450 "qSymbol", "symbol-lookup", 0);
14452 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14453 "P", "set-register", 1);
14455 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14456 "p", "fetch-register", 1);
14458 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14459 "Z0", "software-breakpoint", 0);
14461 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14462 "Z1", "hardware-breakpoint", 0);
14464 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14465 "Z2", "write-watchpoint", 0);
14467 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14468 "Z3", "read-watchpoint", 0);
14470 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14471 "Z4", "access-watchpoint", 0);
14473 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14474 "qXfer:auxv:read", "read-aux-vector", 0);
14476 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14477 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14479 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14480 "qXfer:features:read", "target-features", 0);
14482 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14483 "qXfer:libraries:read", "library-info", 0);
14485 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14486 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14488 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14489 "qXfer:memory-map:read", "memory-map", 0);
14491 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14492 "qXfer:osdata:read", "osdata", 0);
14494 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14495 "qXfer:threads:read", "threads", 0);
14497 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14498 "qXfer:siginfo:read", "read-siginfo-object", 0);
14500 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14501 "qXfer:siginfo:write", "write-siginfo-object", 0);
14503 add_packet_config_cmd
14504 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14505 "qXfer:traceframe-info:read", "traceframe-info", 0);
14507 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14508 "qXfer:uib:read", "unwind-info-block", 0);
14510 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14511 "qGetTLSAddr", "get-thread-local-storage-address",
14514 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14515 "qGetTIBAddr", "get-thread-information-block-address",
14518 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14519 "bc", "reverse-continue", 0);
14521 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14522 "bs", "reverse-step", 0);
14524 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14525 "qSupported", "supported-packets", 0);
14527 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14528 "qSearch:memory", "search-memory", 0);
14530 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14531 "qTStatus", "trace-status", 0);
14533 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14534 "vFile:setfs", "hostio-setfs", 0);
14536 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14537 "vFile:open", "hostio-open", 0);
14539 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14540 "vFile:pread", "hostio-pread", 0);
14542 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14543 "vFile:pwrite", "hostio-pwrite", 0);
14545 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14546 "vFile:close", "hostio-close", 0);
14548 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14549 "vFile:unlink", "hostio-unlink", 0);
14551 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14552 "vFile:readlink", "hostio-readlink", 0);
14554 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14555 "vFile:fstat", "hostio-fstat", 0);
14557 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14558 "vAttach", "attach", 0);
14560 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14563 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14564 "QStartNoAckMode", "noack", 0);
14566 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14567 "vKill", "kill", 0);
14569 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14570 "qAttached", "query-attached", 0);
14572 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14573 "ConditionalTracepoints",
14574 "conditional-tracepoints", 0);
14576 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14577 "ConditionalBreakpoints",
14578 "conditional-breakpoints", 0);
14580 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14581 "BreakpointCommands",
14582 "breakpoint-commands", 0);
14584 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14585 "FastTracepoints", "fast-tracepoints", 0);
14587 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14588 "TracepointSource", "TracepointSource", 0);
14590 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14591 "QAllow", "allow", 0);
14593 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14594 "StaticTracepoints", "static-tracepoints", 0);
14596 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14597 "InstallInTrace", "install-in-trace", 0);
14599 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14600 "qXfer:statictrace:read", "read-sdata-object", 0);
14602 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14603 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14605 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14606 "QDisableRandomization", "disable-randomization", 0);
14608 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14609 "QAgent", "agent", 0);
14611 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14612 "QTBuffer:size", "trace-buffer-size", 0);
14614 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14615 "Qbtrace:off", "disable-btrace", 0);
14617 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14618 "Qbtrace:bts", "enable-btrace-bts", 0);
14620 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14621 "Qbtrace:pt", "enable-btrace-pt", 0);
14623 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14624 "qXfer:btrace", "read-btrace", 0);
14626 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14627 "qXfer:btrace-conf", "read-btrace-conf", 0);
14629 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14630 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14632 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14633 "multiprocess-feature", "multiprocess-feature", 0);
14635 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14636 "swbreak-feature", "swbreak-feature", 0);
14638 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14639 "hwbreak-feature", "hwbreak-feature", 0);
14641 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14642 "fork-event-feature", "fork-event-feature", 0);
14644 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14645 "vfork-event-feature", "vfork-event-feature", 0);
14647 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14648 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14650 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14651 "vContSupported", "verbose-resume-supported", 0);
14653 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14654 "exec-event-feature", "exec-event-feature", 0);
14656 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14657 "vCtrlC", "ctrl-c", 0);
14659 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14660 "QThreadEvents", "thread-events", 0);
14662 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14663 "N stop reply", "no-resumed-stop-reply", 0);
14665 /* Assert that we've registered "set remote foo-packet" commands
14666 for all packet configs. */
14670 for (i
= 0; i
< PACKET_MAX
; i
++)
14672 /* Ideally all configs would have a command associated. Some
14673 still don't though. */
14678 case PACKET_QNonStop
:
14679 case PACKET_EnableDisableTracepoints_feature
:
14680 case PACKET_tracenz_feature
:
14681 case PACKET_DisconnectedTracing_feature
:
14682 case PACKET_augmented_libraries_svr4_read_feature
:
14684 /* Additions to this list need to be well justified:
14685 pre-existing packets are OK; new packets are not. */
14693 /* This catches both forgetting to add a config command, and
14694 forgetting to remove a packet from the exception list. */
14695 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14699 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14700 Z sub-packet has its own set and show commands, but users may
14701 have sets to this variable in their .gdbinit files (or in their
14703 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14704 &remote_Z_packet_detect
, _("\
14705 Set use of remote protocol `Z' packets."), _("\
14706 Show use of remote protocol `Z' packets."), _("\
14707 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14709 set_remote_protocol_Z_packet_cmd
,
14710 show_remote_protocol_Z_packet_cmd
,
14711 /* FIXME: i18n: Use of remote protocol
14712 `Z' packets is %s. */
14713 &remote_set_cmdlist
, &remote_show_cmdlist
);
14715 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14716 Manipulate files on the remote system.\n\
14717 Transfer files to and from the remote target system."),
14718 &remote_cmdlist
, "remote ",
14719 0 /* allow-unknown */, &cmdlist
);
14721 add_cmd ("put", class_files
, remote_put_command
,
14722 _("Copy a local file to the remote system."),
14725 add_cmd ("get", class_files
, remote_get_command
,
14726 _("Copy a remote file to the local system."),
14729 add_cmd ("delete", class_files
, remote_delete_command
,
14730 _("Delete a remote file."),
14733 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14734 &remote_exec_file_var
, _("\
14735 Set the remote pathname for \"run\"."), _("\
14736 Show the remote pathname for \"run\"."), NULL
,
14737 set_remote_exec_file
,
14738 show_remote_exec_file
,
14739 &remote_set_cmdlist
,
14740 &remote_show_cmdlist
);
14742 add_setshow_boolean_cmd ("range-stepping", class_run
,
14743 &use_range_stepping
, _("\
14744 Enable or disable range stepping."), _("\
14745 Show whether target-assisted range stepping is enabled."), _("\
14746 If on, and the target supports it, when stepping a source line, GDB\n\
14747 tells the target to step the corresponding range of addresses itself instead\n\
14748 of issuing multiple single-steps. This speeds up source level\n\
14749 stepping. If off, GDB always issues single-steps, even if range\n\
14750 stepping is supported by the target. The default is on."),
14751 set_range_stepping
,
14752 show_range_stepping
,
14756 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
14757 Set watchdog timer."), _("\
14758 Show watchdog timer."), _("\
14759 When non-zero, this timeout is used instead of waiting forever for a target\n\
14760 to finish a low-level step or continue operation. If the specified amount\n\
14761 of time passes without a response from the target, an error occurs."),
14764 &setlist
, &showlist
);
14766 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
14767 &remote_packet_max_chars
, _("\
14768 Set the maximum number of characters to display for each remote packet."), _("\
14769 Show the maximum number of characters to display for each remote packet."), _("\
14770 Specify \"unlimited\" to display all the characters."),
14771 NULL
, show_remote_packet_max_chars
,
14772 &setdebuglist
, &showdebuglist
);
14774 /* Eventually initialize fileio. See fileio.c */
14775 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);