1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* See the GDB User Guide for details of the GDB remote protocol. */
30 #include "process-stratum-target.h"
33 #include "gdb-stabs.h"
34 #include "gdbthread.h"
36 #include "remote-notif.h"
39 #include "observable.h"
41 #include "cli/cli-decode.h"
42 #include "cli/cli-setshow.h"
43 #include "target-descriptions.h"
45 #include "gdbsupport/filestuff.h"
46 #include "gdbsupport/rsp-low.h"
50 #include "gdbsupport/gdb_sys_time.h"
52 #include "event-loop.h"
53 #include "event-top.h"
59 #include "gdbcore.h" /* for exec_bfd */
61 #include "remote-fileio.h"
62 #include "gdb/fileio.h"
64 #include "xml-support.h"
66 #include "memory-map.h"
68 #include "tracepoint.h"
71 #include "gdbsupport/agent.h"
73 #include "record-btrace.h"
75 #include "gdbsupport/scoped_restore.h"
76 #include "gdbsupport/environ.h"
77 #include "gdbsupport/byte-vector.h"
79 #include <unordered_map>
81 /* The remote target. */
83 static const char remote_doc
[] = N_("\
84 Use a remote computer via a serial line, using a gdb-specific protocol.\n\
85 Specify the serial device it is connected to\n\
86 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
88 #define OPAQUETHREADBYTES 8
90 /* a 64 bit opaque identifier */
91 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
93 struct gdb_ext_thread_info
;
94 struct threads_listing_context
;
95 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
96 struct protocol_feature
;
100 typedef std::unique_ptr
<stop_reply
> stop_reply_up
;
102 /* Generic configuration support for packets the stub optionally
103 supports. Allows the user to specify the use of the packet as well
104 as allowing GDB to auto-detect support in the remote stub. */
108 PACKET_SUPPORT_UNKNOWN
= 0,
113 /* Analyze a packet's return value and update the packet config
123 struct threads_listing_context
;
125 /* Stub vCont actions support.
127 Each field is a boolean flag indicating whether the stub reports
128 support for the corresponding action. */
130 struct vCont_action_support
145 /* About this many threadids fit in a packet. */
147 #define MAXTHREADLISTRESULTS 32
149 /* Data for the vFile:pread readahead cache. */
151 struct readahead_cache
153 /* Invalidate the readahead cache. */
156 /* Invalidate the readahead cache if it is holding data for FD. */
157 void invalidate_fd (int fd
);
159 /* Serve pread from the readahead cache. Returns number of bytes
160 read, or 0 if the request can't be served from the cache. */
161 int pread (int fd
, gdb_byte
*read_buf
, size_t len
, ULONGEST offset
);
163 /* The file descriptor for the file that is being cached. -1 if the
167 /* The offset into the file that the cache buffer corresponds
171 /* The buffer holding the cache contents. */
172 gdb_byte
*buf
= nullptr;
173 /* The buffer's size. We try to read as much as fits into a packet
177 /* Cache hit and miss counters. */
178 ULONGEST hit_count
= 0;
179 ULONGEST miss_count
= 0;
182 /* Description of the remote protocol for a given architecture. */
186 long offset
; /* Offset into G packet. */
187 long regnum
; /* GDB's internal register number. */
188 LONGEST pnum
; /* Remote protocol register number. */
189 int in_g_packet
; /* Always part of G packet. */
190 /* long size in bytes; == register_size (target_gdbarch (), regnum);
192 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
196 struct remote_arch_state
198 explicit remote_arch_state (struct gdbarch
*gdbarch
);
200 /* Description of the remote protocol registers. */
201 long sizeof_g_packet
;
203 /* Description of the remote protocol registers indexed by REGNUM
204 (making an array gdbarch_num_regs in size). */
205 std::unique_ptr
<packet_reg
[]> regs
;
207 /* This is the size (in chars) of the first response to the ``g''
208 packet. It is used as a heuristic when determining the maximum
209 size of memory-read and memory-write packets. A target will
210 typically only reserve a buffer large enough to hold the ``g''
211 packet. The size does not include packet overhead (headers and
213 long actual_register_packet_size
;
215 /* This is the maximum size (in chars) of a non read/write packet.
216 It is also used as a cap on the size of read/write packets. */
217 long remote_packet_size
;
220 /* Description of the remote protocol state for the currently
221 connected target. This is per-target state, and independent of the
222 selected architecture. */
231 /* Get the remote arch state for GDBARCH. */
232 struct remote_arch_state
*get_remote_arch_state (struct gdbarch
*gdbarch
);
236 /* A buffer to use for incoming packets, and its current size. The
237 buffer is grown dynamically for larger incoming packets.
238 Outgoing packets may also be constructed in this buffer.
239 The size of the buffer is always at least REMOTE_PACKET_SIZE;
240 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
242 gdb::char_vector buf
;
244 /* True if we're going through initial connection setup (finding out
245 about the remote side's threads, relocating symbols, etc.). */
246 bool starting_up
= false;
248 /* If we negotiated packet size explicitly (and thus can bypass
249 heuristics for the largest packet size that will not overflow
250 a buffer in the stub), this will be set to that packet size.
251 Otherwise zero, meaning to use the guessed size. */
252 long explicit_packet_size
= 0;
254 /* remote_wait is normally called when the target is running and
255 waits for a stop reply packet. But sometimes we need to call it
256 when the target is already stopped. We can send a "?" packet
257 and have remote_wait read the response. Or, if we already have
258 the response, we can stash it in BUF and tell remote_wait to
259 skip calling getpkt. This flag is set when BUF contains a
260 stop reply packet and the target is not waiting. */
261 int cached_wait_status
= 0;
263 /* True, if in no ack mode. That is, neither GDB nor the stub will
264 expect acks from each other. The connection is assumed to be
266 bool noack_mode
= false;
268 /* True if we're connected in extended remote mode. */
269 bool extended
= false;
271 /* True if we resumed the target and we're waiting for the target to
272 stop. In the mean time, we can't start another command/query.
273 The remote server wouldn't be ready to process it, so we'd
274 timeout waiting for a reply that would never come and eventually
275 we'd close the connection. This can happen in asynchronous mode
276 because we allow GDB commands while the target is running. */
277 bool waiting_for_stop_reply
= false;
279 /* The status of the stub support for the various vCont actions. */
280 vCont_action_support supports_vCont
;
282 /* True if the user has pressed Ctrl-C, but the target hasn't
283 responded to that. */
284 bool ctrlc_pending_p
= false;
286 /* True if we saw a Ctrl-C while reading or writing from/to the
287 remote descriptor. At that point it is not safe to send a remote
288 interrupt packet, so we instead remember we saw the Ctrl-C and
289 process it once we're done with sending/receiving the current
290 packet, which should be shortly. If however that takes too long,
291 and the user presses Ctrl-C again, we offer to disconnect. */
292 bool got_ctrlc_during_io
= false;
294 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
295 remote_open knows that we don't have a file open when the program
297 struct serial
*remote_desc
= nullptr;
299 /* These are the threads which we last sent to the remote system. The
300 TID member will be -1 for all or -2 for not sent yet. */
301 ptid_t general_thread
= null_ptid
;
302 ptid_t continue_thread
= null_ptid
;
304 /* This is the traceframe which we last selected on the remote system.
305 It will be -1 if no traceframe is selected. */
306 int remote_traceframe_number
= -1;
308 char *last_pass_packet
= nullptr;
310 /* The last QProgramSignals packet sent to the target. We bypass
311 sending a new program signals list down to the target if the new
312 packet is exactly the same as the last we sent. IOW, we only let
313 the target know about program signals list changes. */
314 char *last_program_signals_packet
= nullptr;
316 gdb_signal last_sent_signal
= GDB_SIGNAL_0
;
318 bool last_sent_step
= false;
320 /* The execution direction of the last resume we got. */
321 exec_direction_kind last_resume_exec_dir
= EXEC_FORWARD
;
323 char *finished_object
= nullptr;
324 char *finished_annex
= nullptr;
325 ULONGEST finished_offset
= 0;
327 /* Should we try the 'ThreadInfo' query packet?
329 This variable (NOT available to the user: auto-detect only!)
330 determines whether GDB will use the new, simpler "ThreadInfo"
331 query or the older, more complex syntax for thread queries.
332 This is an auto-detect variable (set to true at each connect,
333 and set to false when the target fails to recognize it). */
334 bool use_threadinfo_query
= false;
335 bool use_threadextra_query
= false;
337 threadref echo_nextthread
{};
338 threadref nextthread
{};
339 threadref resultthreadlist
[MAXTHREADLISTRESULTS
] {};
341 /* The state of remote notification. */
342 struct remote_notif_state
*notif_state
= nullptr;
344 /* The branch trace configuration. */
345 struct btrace_config btrace_config
{};
347 /* The argument to the last "vFile:setfs:" packet we sent, used
348 to avoid sending repeated unnecessary "vFile:setfs:" packets.
349 Initialized to -1 to indicate that no "vFile:setfs:" packet
350 has yet been sent. */
353 /* A readahead cache for vFile:pread. Often, reading a binary
354 involves a sequence of small reads. E.g., when parsing an ELF
355 file. A readahead cache helps mostly the case of remote
356 debugging on a connection with higher latency, due to the
357 request/reply nature of the RSP. We only cache data for a single
358 file descriptor at a time. */
359 struct readahead_cache readahead_cache
;
361 /* The list of already fetched and acknowledged stop events. This
362 queue is used for notification Stop, and other notifications
363 don't need queue for their events, because the notification
364 events of Stop can't be consumed immediately, so that events
365 should be queued first, and be consumed by remote_wait_{ns,as}
366 one per time. Other notifications can consume their events
367 immediately, so queue is not needed for them. */
368 std::vector
<stop_reply_up
> stop_reply_queue
;
370 /* Asynchronous signal handle registered as event loop source for
371 when we have pending events ready to be passed to the core. */
372 struct async_event_handler
*remote_async_inferior_event_token
= nullptr;
374 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
375 ``forever'' still use the normal timeout mechanism. This is
376 currently used by the ASYNC code to guarentee that target reads
377 during the initial connect always time-out. Once getpkt has been
378 modified to return a timeout indication and, in turn
379 remote_wait()/wait_for_inferior() have gained a timeout parameter
381 int wait_forever_enabled_p
= 1;
384 /* Mapping of remote protocol data for each gdbarch. Usually there
385 is only one entry here, though we may see more with stubs that
386 support multi-process. */
387 std::unordered_map
<struct gdbarch
*, remote_arch_state
>
391 static const target_info remote_target_info
= {
393 N_("Remote serial target in gdb-specific protocol"),
397 class remote_target
: public process_stratum_target
400 remote_target () = default;
401 ~remote_target () override
;
403 const target_info
&info () const override
404 { return remote_target_info
; }
406 thread_control_capabilities
get_thread_control_capabilities () override
407 { return tc_schedlock
; }
409 /* Open a remote connection. */
410 static void open (const char *, int);
412 void close () override
;
414 void detach (inferior
*, int) override
;
415 void disconnect (const char *, int) override
;
417 void commit_resume () override
;
418 void resume (ptid_t
, int, enum gdb_signal
) override
;
419 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
421 void fetch_registers (struct regcache
*, int) override
;
422 void store_registers (struct regcache
*, int) override
;
423 void prepare_to_store (struct regcache
*) override
;
425 void files_info () override
;
427 int insert_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
429 int remove_breakpoint (struct gdbarch
*, struct bp_target_info
*,
430 enum remove_bp_reason
) override
;
433 bool stopped_by_sw_breakpoint () override
;
434 bool supports_stopped_by_sw_breakpoint () override
;
436 bool stopped_by_hw_breakpoint () override
;
438 bool supports_stopped_by_hw_breakpoint () override
;
440 bool stopped_by_watchpoint () override
;
442 bool stopped_data_address (CORE_ADDR
*) override
;
444 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
446 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
448 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
450 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
452 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
454 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
455 struct expression
*) override
;
457 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
458 struct expression
*) override
;
460 void kill () override
;
462 void load (const char *, int) override
;
464 void mourn_inferior () override
;
466 void pass_signals (gdb::array_view
<const unsigned char>) override
;
468 int set_syscall_catchpoint (int, bool, int,
469 gdb::array_view
<const int>) override
;
471 void program_signals (gdb::array_view
<const unsigned char>) override
;
473 bool thread_alive (ptid_t ptid
) override
;
475 const char *thread_name (struct thread_info
*) override
;
477 void update_thread_list () override
;
479 std::string
pid_to_str (ptid_t
) override
;
481 const char *extra_thread_info (struct thread_info
*) override
;
483 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
485 thread_info
*thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
487 inferior
*inf
) override
;
489 gdb::byte_vector
thread_info_to_thread_handle (struct thread_info
*tp
)
492 void stop (ptid_t
) override
;
494 void interrupt () override
;
496 void pass_ctrlc () override
;
498 enum target_xfer_status
xfer_partial (enum target_object object
,
501 const gdb_byte
*writebuf
,
502 ULONGEST offset
, ULONGEST len
,
503 ULONGEST
*xfered_len
) override
;
505 ULONGEST
get_memory_xfer_limit () override
;
507 void rcmd (const char *command
, struct ui_file
*output
) override
;
509 char *pid_to_exec_file (int pid
) override
;
511 void log_command (const char *cmd
) override
513 serial_log_command (this, cmd
);
516 CORE_ADDR
get_thread_local_address (ptid_t ptid
,
517 CORE_ADDR load_module_addr
,
518 CORE_ADDR offset
) override
;
520 bool can_execute_reverse () override
;
522 std::vector
<mem_region
> memory_map () override
;
524 void flash_erase (ULONGEST address
, LONGEST length
) override
;
526 void flash_done () override
;
528 const struct target_desc
*read_description () override
;
530 int search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
531 const gdb_byte
*pattern
, ULONGEST pattern_len
,
532 CORE_ADDR
*found_addrp
) override
;
534 bool can_async_p () override
;
536 bool is_async_p () override
;
538 void async (int) override
;
540 void thread_events (int) override
;
542 int can_do_single_step () override
;
544 void terminal_inferior () override
;
546 void terminal_ours () override
;
548 bool supports_non_stop () override
;
550 bool supports_multi_process () override
;
552 bool supports_disable_randomization () override
;
554 bool filesystem_is_local () override
;
557 int fileio_open (struct inferior
*inf
, const char *filename
,
558 int flags
, int mode
, int warn_if_slow
,
559 int *target_errno
) override
;
561 int fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
562 ULONGEST offset
, int *target_errno
) override
;
564 int fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
565 ULONGEST offset
, int *target_errno
) override
;
567 int fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
) override
;
569 int fileio_close (int fd
, int *target_errno
) override
;
571 int fileio_unlink (struct inferior
*inf
,
572 const char *filename
,
573 int *target_errno
) override
;
575 gdb::optional
<std::string
>
576 fileio_readlink (struct inferior
*inf
,
577 const char *filename
,
578 int *target_errno
) override
;
580 bool supports_enable_disable_tracepoint () override
;
582 bool supports_string_tracing () override
;
584 bool supports_evaluation_of_breakpoint_conditions () override
;
586 bool can_run_breakpoint_commands () override
;
588 void trace_init () override
;
590 void download_tracepoint (struct bp_location
*location
) override
;
592 bool can_download_tracepoint () override
;
594 void download_trace_state_variable (const trace_state_variable
&tsv
) override
;
596 void enable_tracepoint (struct bp_location
*location
) override
;
598 void disable_tracepoint (struct bp_location
*location
) override
;
600 void trace_set_readonly_regions () override
;
602 void trace_start () override
;
604 int get_trace_status (struct trace_status
*ts
) override
;
606 void get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
609 void trace_stop () override
;
611 int trace_find (enum trace_find_type type
, int num
,
612 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
) override
;
614 bool get_trace_state_variable_value (int tsv
, LONGEST
*val
) override
;
616 int save_trace_data (const char *filename
) override
;
618 int upload_tracepoints (struct uploaded_tp
**utpp
) override
;
620 int upload_trace_state_variables (struct uploaded_tsv
**utsvp
) override
;
622 LONGEST
get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
) override
;
624 int get_min_fast_tracepoint_insn_len () override
;
626 void set_disconnected_tracing (int val
) override
;
628 void set_circular_trace_buffer (int val
) override
;
630 void set_trace_buffer_size (LONGEST val
) override
;
632 bool set_trace_notes (const char *user
, const char *notes
,
633 const char *stopnotes
) override
;
635 int core_of_thread (ptid_t ptid
) override
;
637 int verify_memory (const gdb_byte
*data
,
638 CORE_ADDR memaddr
, ULONGEST size
) override
;
641 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
643 void set_permissions () override
;
645 bool static_tracepoint_marker_at (CORE_ADDR
,
646 struct static_tracepoint_marker
*marker
)
649 std::vector
<static_tracepoint_marker
>
650 static_tracepoint_markers_by_strid (const char *id
) override
;
652 traceframe_info_up
traceframe_info () override
;
654 bool use_agent (bool use
) override
;
655 bool can_use_agent () override
;
657 struct btrace_target_info
*enable_btrace (ptid_t ptid
,
658 const struct btrace_config
*conf
) override
;
660 void disable_btrace (struct btrace_target_info
*tinfo
) override
;
662 void teardown_btrace (struct btrace_target_info
*tinfo
) override
;
664 enum btrace_error
read_btrace (struct btrace_data
*data
,
665 struct btrace_target_info
*btinfo
,
666 enum btrace_read_type type
) override
;
668 const struct btrace_config
*btrace_conf (const struct btrace_target_info
*) override
;
669 bool augmented_libraries_svr4_read () override
;
670 int follow_fork (int, int) override
;
671 void follow_exec (struct inferior
*, const char *) override
;
672 int insert_fork_catchpoint (int) override
;
673 int remove_fork_catchpoint (int) override
;
674 int insert_vfork_catchpoint (int) override
;
675 int remove_vfork_catchpoint (int) override
;
676 int insert_exec_catchpoint (int) override
;
677 int remove_exec_catchpoint (int) override
;
678 enum exec_direction_kind
execution_direction () override
;
680 public: /* Remote specific methods. */
682 void remote_download_command_source (int num
, ULONGEST addr
,
683 struct command_line
*cmds
);
685 void remote_file_put (const char *local_file
, const char *remote_file
,
687 void remote_file_get (const char *remote_file
, const char *local_file
,
689 void remote_file_delete (const char *remote_file
, int from_tty
);
691 int remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
692 ULONGEST offset
, int *remote_errno
);
693 int remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
694 ULONGEST offset
, int *remote_errno
);
695 int remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
696 ULONGEST offset
, int *remote_errno
);
698 int remote_hostio_send_command (int command_bytes
, int which_packet
,
699 int *remote_errno
, char **attachment
,
700 int *attachment_len
);
701 int remote_hostio_set_filesystem (struct inferior
*inf
,
703 /* We should get rid of this and use fileio_open directly. */
704 int remote_hostio_open (struct inferior
*inf
, const char *filename
,
705 int flags
, int mode
, int warn_if_slow
,
707 int remote_hostio_close (int fd
, int *remote_errno
);
709 int remote_hostio_unlink (inferior
*inf
, const char *filename
,
712 struct remote_state
*get_remote_state ();
714 long get_remote_packet_size (void);
715 long get_memory_packet_size (struct memory_packet_config
*config
);
717 long get_memory_write_packet_size ();
718 long get_memory_read_packet_size ();
720 char *append_pending_thread_resumptions (char *p
, char *endp
,
722 static void open_1 (const char *name
, int from_tty
, int extended_p
);
723 void start_remote (int from_tty
, int extended_p
);
724 void remote_detach_1 (struct inferior
*inf
, int from_tty
);
726 char *append_resumption (char *p
, char *endp
,
727 ptid_t ptid
, int step
, gdb_signal siggnal
);
728 int remote_resume_with_vcont (ptid_t ptid
, int step
,
731 void add_current_inferior_and_thread (char *wait_status
);
733 ptid_t
wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
735 ptid_t
wait_as (ptid_t ptid
, target_waitstatus
*status
,
738 ptid_t
process_stop_reply (struct stop_reply
*stop_reply
,
739 target_waitstatus
*status
);
741 void remote_notice_new_inferior (ptid_t currthread
, int executing
);
743 void process_initial_stop_replies (int from_tty
);
745 thread_info
*remote_add_thread (ptid_t ptid
, bool running
, bool executing
);
747 void btrace_sync_conf (const btrace_config
*conf
);
749 void remote_btrace_maybe_reopen ();
751 void remove_new_fork_children (threads_listing_context
*context
);
752 void kill_new_fork_children (int pid
);
753 void discard_pending_stop_replies (struct inferior
*inf
);
754 int stop_reply_queue_length ();
756 void check_pending_events_prevent_wildcard_vcont
757 (int *may_global_wildcard_vcont
);
759 void discard_pending_stop_replies_in_queue ();
760 struct stop_reply
*remote_notif_remove_queued_reply (ptid_t ptid
);
761 struct stop_reply
*queued_stop_reply (ptid_t ptid
);
762 int peek_stop_reply (ptid_t ptid
);
763 void remote_parse_stop_reply (const char *buf
, stop_reply
*event
);
765 void remote_stop_ns (ptid_t ptid
);
766 void remote_interrupt_as ();
767 void remote_interrupt_ns ();
769 char *remote_get_noisy_reply ();
770 int remote_query_attached (int pid
);
771 inferior
*remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
774 ptid_t
remote_current_thread (ptid_t oldpid
);
775 ptid_t
get_current_thread (char *wait_status
);
777 void set_thread (ptid_t ptid
, int gen
);
778 void set_general_thread (ptid_t ptid
);
779 void set_continue_thread (ptid_t ptid
);
780 void set_general_process ();
782 char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
784 int remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
785 gdb_ext_thread_info
*info
);
786 int remote_get_threadinfo (threadref
*threadid
, int fieldset
,
787 gdb_ext_thread_info
*info
);
789 int parse_threadlist_response (char *pkt
, int result_limit
,
790 threadref
*original_echo
,
791 threadref
*resultlist
,
793 int remote_get_threadlist (int startflag
, threadref
*nextthread
,
794 int result_limit
, int *done
, int *result_count
,
795 threadref
*threadlist
);
797 int remote_threadlist_iterator (rmt_thread_action stepfunction
,
798 void *context
, int looplimit
);
800 int remote_get_threads_with_ql (threads_listing_context
*context
);
801 int remote_get_threads_with_qxfer (threads_listing_context
*context
);
802 int remote_get_threads_with_qthreadinfo (threads_listing_context
*context
);
804 void extended_remote_restart ();
808 void remote_check_symbols ();
810 void remote_supported_packet (const struct protocol_feature
*feature
,
811 enum packet_support support
,
812 const char *argument
);
814 void remote_query_supported ();
816 void remote_packet_size (const protocol_feature
*feature
,
817 packet_support support
, const char *value
);
819 void remote_serial_quit_handler ();
821 void remote_detach_pid (int pid
);
823 void remote_vcont_probe ();
825 void remote_resume_with_hc (ptid_t ptid
, int step
,
828 void send_interrupt_sequence ();
829 void interrupt_query ();
831 void remote_notif_get_pending_events (notif_client
*nc
);
833 int fetch_register_using_p (struct regcache
*regcache
,
835 int send_g_packet ();
836 void process_g_packet (struct regcache
*regcache
);
837 void fetch_registers_using_g (struct regcache
*regcache
);
838 int store_register_using_P (const struct regcache
*regcache
,
840 void store_registers_using_G (const struct regcache
*regcache
);
842 void set_remote_traceframe ();
844 void check_binary_download (CORE_ADDR addr
);
846 target_xfer_status
remote_write_bytes_aux (const char *header
,
848 const gdb_byte
*myaddr
,
851 ULONGEST
*xfered_len_units
,
855 target_xfer_status
remote_write_bytes (CORE_ADDR memaddr
,
856 const gdb_byte
*myaddr
, ULONGEST len
,
857 int unit_size
, ULONGEST
*xfered_len
);
859 target_xfer_status
remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
861 int unit_size
, ULONGEST
*xfered_len_units
);
863 target_xfer_status
remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
867 ULONGEST
*xfered_len
);
869 target_xfer_status
remote_read_bytes (CORE_ADDR memaddr
,
870 gdb_byte
*myaddr
, ULONGEST len
,
872 ULONGEST
*xfered_len
);
874 packet_result
remote_send_printf (const char *format
, ...)
875 ATTRIBUTE_PRINTF (2, 3);
877 target_xfer_status
remote_flash_write (ULONGEST address
,
878 ULONGEST length
, ULONGEST
*xfered_len
,
879 const gdb_byte
*data
);
881 int readchar (int timeout
);
883 void remote_serial_write (const char *str
, int len
);
885 int putpkt (const char *buf
);
886 int putpkt_binary (const char *buf
, int cnt
);
888 int putpkt (const gdb::char_vector
&buf
)
890 return putpkt (buf
.data ());
894 long read_frame (gdb::char_vector
*buf_p
);
895 void getpkt (gdb::char_vector
*buf
, int forever
);
896 int getpkt_or_notif_sane_1 (gdb::char_vector
*buf
, int forever
,
897 int expecting_notif
, int *is_notif
);
898 int getpkt_sane (gdb::char_vector
*buf
, int forever
);
899 int getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
901 int remote_vkill (int pid
);
902 void remote_kill_k ();
904 void extended_remote_disable_randomization (int val
);
905 int extended_remote_run (const std::string
&args
);
907 void send_environment_packet (const char *action
,
911 void extended_remote_environment_support ();
912 void extended_remote_set_inferior_cwd ();
914 target_xfer_status
remote_write_qxfer (const char *object_name
,
916 const gdb_byte
*writebuf
,
917 ULONGEST offset
, LONGEST len
,
918 ULONGEST
*xfered_len
,
919 struct packet_config
*packet
);
921 target_xfer_status
remote_read_qxfer (const char *object_name
,
923 gdb_byte
*readbuf
, ULONGEST offset
,
925 ULONGEST
*xfered_len
,
926 struct packet_config
*packet
);
928 void push_stop_reply (struct stop_reply
*new_event
);
930 bool vcont_r_supported ();
932 void packet_command (const char *args
, int from_tty
);
934 private: /* data fields */
936 /* The remote state. Don't reference this directly. Use the
937 get_remote_state method instead. */
938 remote_state m_remote_state
;
941 static const target_info extended_remote_target_info
= {
943 N_("Extended remote serial target in gdb-specific protocol"),
947 /* Set up the extended remote target by extending the standard remote
948 target and adding to it. */
950 class extended_remote_target final
: public remote_target
953 const target_info
&info () const override
954 { return extended_remote_target_info
; }
956 /* Open an extended-remote connection. */
957 static void open (const char *, int);
959 bool can_create_inferior () override
{ return true; }
960 void create_inferior (const char *, const std::string
&,
961 char **, int) override
;
963 void detach (inferior
*, int) override
;
965 bool can_attach () override
{ return true; }
966 void attach (const char *, int) override
;
968 void post_attach (int) override
;
969 bool supports_disable_randomization () override
;
972 /* Per-program-space data key. */
973 static const struct program_space_key
<char, gdb::xfree_deleter
<char>>
976 /* The variable registered as the control variable used by the
977 remote exec-file commands. While the remote exec-file setting is
978 per-program-space, the set/show machinery uses this as the
979 location of the remote exec-file value. */
980 static char *remote_exec_file_var
;
982 /* The size to align memory write packets, when practical. The protocol
983 does not guarantee any alignment, and gdb will generate short
984 writes and unaligned writes, but even as a best-effort attempt this
985 can improve bulk transfers. For instance, if a write is misaligned
986 relative to the target's data bus, the stub may need to make an extra
987 round trip fetching data from the target. This doesn't make a
988 huge difference, but it's easy to do, so we try to be helpful.
990 The alignment chosen is arbitrary; usually data bus width is
991 important here, not the possibly larger cache line size. */
992 enum { REMOTE_ALIGN_WRITES
= 16 };
994 /* Prototypes for local functions. */
996 static int hexnumlen (ULONGEST num
);
998 static int stubhex (int ch
);
1000 static int hexnumstr (char *, ULONGEST
);
1002 static int hexnumnstr (char *, ULONGEST
, int);
1004 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
1006 static void print_packet (const char *);
1008 static int stub_unpack_int (char *buff
, int fieldlength
);
1010 struct packet_config
;
1012 static void show_packet_config_cmd (struct packet_config
*config
);
1014 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
1016 struct cmd_list_element
*c
,
1019 static ptid_t
read_ptid (const char *buf
, const char **obuf
);
1021 static void remote_async_inferior_event_handler (gdb_client_data
);
1023 static bool remote_read_description_p (struct target_ops
*target
);
1025 static void remote_console_output (const char *msg
);
1027 static void remote_btrace_reset (remote_state
*rs
);
1029 static void remote_unpush_and_throw (void);
1033 static struct cmd_list_element
*remote_cmdlist
;
1035 /* For "set remote" and "show remote". */
1037 static struct cmd_list_element
*remote_set_cmdlist
;
1038 static struct cmd_list_element
*remote_show_cmdlist
;
1040 /* Controls whether GDB is willing to use range stepping. */
1042 static bool use_range_stepping
= true;
1044 /* Private data that we'll store in (struct thread_info)->priv. */
1045 struct remote_thread_info
: public private_thread_info
1051 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1052 sequence of bytes. */
1053 gdb::byte_vector thread_handle
;
1055 /* Whether the target stopped for a breakpoint/watchpoint. */
1056 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1058 /* This is set to the data address of the access causing the target
1059 to stop for a watchpoint. */
1060 CORE_ADDR watch_data_address
= 0;
1062 /* Fields used by the vCont action coalescing implemented in
1063 remote_resume / remote_commit_resume. remote_resume stores each
1064 thread's last resume request in these fields, so that a later
1065 remote_commit_resume knows which is the proper action for this
1066 thread to include in the vCont packet. */
1068 /* True if the last target_resume call for this thread was a step
1069 request, false if a continue request. */
1070 int last_resume_step
= 0;
1072 /* The signal specified in the last target_resume call for this
1074 gdb_signal last_resume_sig
= GDB_SIGNAL_0
;
1076 /* Whether this thread was already vCont-resumed on the remote
1078 int vcont_resumed
= 0;
1081 remote_state::remote_state ()
1086 remote_state::~remote_state ()
1088 xfree (this->last_pass_packet
);
1089 xfree (this->last_program_signals_packet
);
1090 xfree (this->finished_object
);
1091 xfree (this->finished_annex
);
1094 /* Utility: generate error from an incoming stub packet. */
1096 trace_error (char *buf
)
1099 return; /* not an error msg */
1102 case '1': /* malformed packet error */
1103 if (*++buf
== '0') /* general case: */
1104 error (_("remote.c: error in outgoing packet."));
1106 error (_("remote.c: error in outgoing packet at field #%ld."),
1107 strtol (buf
, NULL
, 16));
1109 error (_("Target returns error code '%s'."), buf
);
1113 /* Utility: wait for reply from stub, while accepting "O" packets. */
1116 remote_target::remote_get_noisy_reply ()
1118 struct remote_state
*rs
= get_remote_state ();
1120 do /* Loop on reply from remote stub. */
1124 QUIT
; /* Allow user to bail out with ^C. */
1125 getpkt (&rs
->buf
, 0);
1126 buf
= rs
->buf
.data ();
1129 else if (startswith (buf
, "qRelocInsn:"))
1132 CORE_ADDR from
, to
, org_to
;
1134 int adjusted_size
= 0;
1137 p
= buf
+ strlen ("qRelocInsn:");
1138 pp
= unpack_varlen_hex (p
, &ul
);
1140 error (_("invalid qRelocInsn packet: %s"), buf
);
1144 unpack_varlen_hex (p
, &ul
);
1151 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1154 catch (const gdb_exception
&ex
)
1156 if (ex
.error
== MEMORY_ERROR
)
1158 /* Propagate memory errors silently back to the
1159 target. The stub may have limited the range of
1160 addresses we can write to, for example. */
1164 /* Something unexpectedly bad happened. Be verbose
1165 so we can tell what, and propagate the error back
1166 to the stub, so it doesn't get stuck waiting for
1168 exception_fprintf (gdb_stderr
, ex
,
1169 _("warning: relocating instruction: "));
1176 adjusted_size
= to
- org_to
;
1178 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1182 else if (buf
[0] == 'O' && buf
[1] != 'K')
1183 remote_console_output (buf
+ 1); /* 'O' message from stub */
1185 return buf
; /* Here's the actual reply. */
1190 struct remote_arch_state
*
1191 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1193 remote_arch_state
*rsa
;
1195 auto it
= this->m_arch_states
.find (gdbarch
);
1196 if (it
== this->m_arch_states
.end ())
1198 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1199 std::forward_as_tuple (gdbarch
),
1200 std::forward_as_tuple (gdbarch
));
1201 rsa
= &p
.first
->second
;
1203 /* Make sure that the packet buffer is plenty big enough for
1204 this architecture. */
1205 if (this->buf
.size () < rsa
->remote_packet_size
)
1206 this->buf
.resize (2 * rsa
->remote_packet_size
);
1214 /* Fetch the global remote target state. */
1217 remote_target::get_remote_state ()
1219 /* Make sure that the remote architecture state has been
1220 initialized, because doing so might reallocate rs->buf. Any
1221 function which calls getpkt also needs to be mindful of changes
1222 to rs->buf, but this call limits the number of places which run
1224 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1226 return &m_remote_state
;
1229 /* Fetch the remote exec-file from the current program space. */
1232 get_remote_exec_file (void)
1234 char *remote_exec_file
;
1236 remote_exec_file
= remote_pspace_data
.get (current_program_space
);
1237 if (remote_exec_file
== NULL
)
1240 return remote_exec_file
;
1243 /* Set the remote exec file for PSPACE. */
1246 set_pspace_remote_exec_file (struct program_space
*pspace
,
1247 const char *remote_exec_file
)
1249 char *old_file
= remote_pspace_data
.get (pspace
);
1252 remote_pspace_data
.set (pspace
, xstrdup (remote_exec_file
));
1255 /* The "set/show remote exec-file" set command hook. */
1258 set_remote_exec_file (const char *ignored
, int from_tty
,
1259 struct cmd_list_element
*c
)
1261 gdb_assert (remote_exec_file_var
!= NULL
);
1262 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
1265 /* The "set/show remote exec-file" show command hook. */
1268 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1269 struct cmd_list_element
*cmd
, const char *value
)
1271 fprintf_filtered (file
, "%s\n", get_remote_exec_file ());
1275 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1277 int regnum
, num_remote_regs
, offset
;
1278 struct packet_reg
**remote_regs
;
1280 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1282 struct packet_reg
*r
= ®s
[regnum
];
1284 if (register_size (gdbarch
, regnum
) == 0)
1285 /* Do not try to fetch zero-sized (placeholder) registers. */
1288 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1293 /* Define the g/G packet format as the contents of each register
1294 with a remote protocol number, in order of ascending protocol
1297 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1298 for (num_remote_regs
= 0, regnum
= 0;
1299 regnum
< gdbarch_num_regs (gdbarch
);
1301 if (regs
[regnum
].pnum
!= -1)
1302 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1304 std::sort (remote_regs
, remote_regs
+ num_remote_regs
,
1305 [] (const packet_reg
*a
, const packet_reg
*b
)
1306 { return a
->pnum
< b
->pnum
; });
1308 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1310 remote_regs
[regnum
]->in_g_packet
= 1;
1311 remote_regs
[regnum
]->offset
= offset
;
1312 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1318 /* Given the architecture described by GDBARCH, return the remote
1319 protocol register's number and the register's offset in the g/G
1320 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1321 If the target does not have a mapping for REGNUM, return false,
1322 otherwise, return true. */
1325 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1326 int *pnum
, int *poffset
)
1328 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1330 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1332 map_regcache_remote_table (gdbarch
, regs
.data ());
1334 *pnum
= regs
[regnum
].pnum
;
1335 *poffset
= regs
[regnum
].offset
;
1340 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1342 /* Use the architecture to build a regnum<->pnum table, which will be
1343 1:1 unless a feature set specifies otherwise. */
1344 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1346 /* Record the maximum possible size of the g packet - it may turn out
1348 this->sizeof_g_packet
1349 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1351 /* Default maximum number of characters in a packet body. Many
1352 remote stubs have a hardwired buffer size of 400 bytes
1353 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1354 as the maximum packet-size to ensure that the packet and an extra
1355 NUL character can always fit in the buffer. This stops GDB
1356 trashing stubs that try to squeeze an extra NUL into what is
1357 already a full buffer (As of 1999-12-04 that was most stubs). */
1358 this->remote_packet_size
= 400 - 1;
1360 /* This one is filled in when a ``g'' packet is received. */
1361 this->actual_register_packet_size
= 0;
1363 /* Should rsa->sizeof_g_packet needs more space than the
1364 default, adjust the size accordingly. Remember that each byte is
1365 encoded as two characters. 32 is the overhead for the packet
1366 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1367 (``$NN:G...#NN'') is a better guess, the below has been padded a
1369 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1370 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1373 /* Get a pointer to the current remote target. If not connected to a
1374 remote target, return NULL. */
1376 static remote_target
*
1377 get_current_remote_target ()
1379 target_ops
*proc_target
= find_target_at (process_stratum
);
1380 return dynamic_cast<remote_target
*> (proc_target
);
1383 /* Return the current allowed size of a remote packet. This is
1384 inferred from the current architecture, and should be used to
1385 limit the length of outgoing packets. */
1387 remote_target::get_remote_packet_size ()
1389 struct remote_state
*rs
= get_remote_state ();
1390 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1392 if (rs
->explicit_packet_size
)
1393 return rs
->explicit_packet_size
;
1395 return rsa
->remote_packet_size
;
1398 static struct packet_reg
*
1399 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1402 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1406 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1408 gdb_assert (r
->regnum
== regnum
);
1413 static struct packet_reg
*
1414 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1419 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1421 struct packet_reg
*r
= &rsa
->regs
[i
];
1423 if (r
->pnum
== pnum
)
1429 /* Allow the user to specify what sequence to send to the remote
1430 when he requests a program interruption: Although ^C is usually
1431 what remote systems expect (this is the default, here), it is
1432 sometimes preferable to send a break. On other systems such
1433 as the Linux kernel, a break followed by g, which is Magic SysRq g
1434 is required in order to interrupt the execution. */
1435 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1436 const char interrupt_sequence_break
[] = "BREAK";
1437 const char interrupt_sequence_break_g
[] = "BREAK-g";
1438 static const char *const interrupt_sequence_modes
[] =
1440 interrupt_sequence_control_c
,
1441 interrupt_sequence_break
,
1442 interrupt_sequence_break_g
,
1445 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1448 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1449 struct cmd_list_element
*c
,
1452 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1453 fprintf_filtered (file
,
1454 _("Send the ASCII ETX character (Ctrl-c) "
1455 "to the remote target to interrupt the "
1456 "execution of the program.\n"));
1457 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1458 fprintf_filtered (file
,
1459 _("send a break signal to the remote target "
1460 "to interrupt the execution of the program.\n"));
1461 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1462 fprintf_filtered (file
,
1463 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1464 "the remote target to interrupt the execution "
1465 "of Linux kernel.\n"));
1467 internal_error (__FILE__
, __LINE__
,
1468 _("Invalid value for interrupt_sequence_mode: %s."),
1469 interrupt_sequence_mode
);
1472 /* This boolean variable specifies whether interrupt_sequence is sent
1473 to the remote target when gdb connects to it.
1474 This is mostly needed when you debug the Linux kernel: The Linux kernel
1475 expects BREAK g which is Magic SysRq g for connecting gdb. */
1476 static bool interrupt_on_connect
= false;
1478 /* This variable is used to implement the "set/show remotebreak" commands.
1479 Since these commands are now deprecated in favor of "set/show remote
1480 interrupt-sequence", it no longer has any effect on the code. */
1481 static bool remote_break
;
1484 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1487 interrupt_sequence_mode
= interrupt_sequence_break
;
1489 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1493 show_remotebreak (struct ui_file
*file
, int from_tty
,
1494 struct cmd_list_element
*c
,
1499 /* This variable sets the number of bits in an address that are to be
1500 sent in a memory ("M" or "m") packet. Normally, after stripping
1501 leading zeros, the entire address would be sent. This variable
1502 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1503 initial implementation of remote.c restricted the address sent in
1504 memory packets to ``host::sizeof long'' bytes - (typically 32
1505 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1506 address was never sent. Since fixing this bug may cause a break in
1507 some remote targets this variable is principally provided to
1508 facilitate backward compatibility. */
1510 static unsigned int remote_address_size
;
1513 /* User configurable variables for the number of characters in a
1514 memory read/write packet. MIN (rsa->remote_packet_size,
1515 rsa->sizeof_g_packet) is the default. Some targets need smaller
1516 values (fifo overruns, et.al.) and some users need larger values
1517 (speed up transfers). The variables ``preferred_*'' (the user
1518 request), ``current_*'' (what was actually set) and ``forced_*''
1519 (Positive - a soft limit, negative - a hard limit). */
1521 struct memory_packet_config
1528 /* The default max memory-write-packet-size, when the setting is
1529 "fixed". The 16k is historical. (It came from older GDB's using
1530 alloca for buffers and the knowledge (folklore?) that some hosts
1531 don't cope very well with large alloca calls.) */
1532 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1534 /* The minimum remote packet size for memory transfers. Ensures we
1535 can write at least one byte. */
1536 #define MIN_MEMORY_PACKET_SIZE 20
1538 /* Get the memory packet size, assuming it is fixed. */
1541 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1543 gdb_assert (config
->fixed_p
);
1545 if (config
->size
<= 0)
1546 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1548 return config
->size
;
1551 /* Compute the current size of a read/write packet. Since this makes
1552 use of ``actual_register_packet_size'' the computation is dynamic. */
1555 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1557 struct remote_state
*rs
= get_remote_state ();
1558 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1561 if (config
->fixed_p
)
1562 what_they_get
= get_fixed_memory_packet_size (config
);
1565 what_they_get
= get_remote_packet_size ();
1566 /* Limit the packet to the size specified by the user. */
1567 if (config
->size
> 0
1568 && what_they_get
> config
->size
)
1569 what_they_get
= config
->size
;
1571 /* Limit it to the size of the targets ``g'' response unless we have
1572 permission from the stub to use a larger packet size. */
1573 if (rs
->explicit_packet_size
== 0
1574 && rsa
->actual_register_packet_size
> 0
1575 && what_they_get
> rsa
->actual_register_packet_size
)
1576 what_they_get
= rsa
->actual_register_packet_size
;
1578 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1579 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1581 /* Make sure there is room in the global buffer for this packet
1582 (including its trailing NUL byte). */
1583 if (rs
->buf
.size () < what_they_get
+ 1)
1584 rs
->buf
.resize (2 * what_they_get
);
1586 return what_they_get
;
1589 /* Update the size of a read/write packet. If they user wants
1590 something really big then do a sanity check. */
1593 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1595 int fixed_p
= config
->fixed_p
;
1596 long size
= config
->size
;
1599 error (_("Argument required (integer, `fixed' or `limited')."));
1600 else if (strcmp (args
, "hard") == 0
1601 || strcmp (args
, "fixed") == 0)
1603 else if (strcmp (args
, "soft") == 0
1604 || strcmp (args
, "limit") == 0)
1610 size
= strtoul (args
, &end
, 0);
1612 error (_("Invalid %s (bad syntax)."), config
->name
);
1614 /* Instead of explicitly capping the size of a packet to or
1615 disallowing it, the user is allowed to set the size to
1616 something arbitrarily large. */
1620 if (fixed_p
&& !config
->fixed_p
)
1622 /* So that the query shows the correct value. */
1623 long query_size
= (size
<= 0
1624 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1627 if (! query (_("The target may not be able to correctly handle a %s\n"
1628 "of %ld bytes. Change the packet size? "),
1629 config
->name
, query_size
))
1630 error (_("Packet size not changed."));
1632 /* Update the config. */
1633 config
->fixed_p
= fixed_p
;
1634 config
->size
= size
;
1638 show_memory_packet_size (struct memory_packet_config
*config
)
1640 if (config
->size
== 0)
1641 printf_filtered (_("The %s is 0 (default). "), config
->name
);
1643 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1644 if (config
->fixed_p
)
1645 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1646 get_fixed_memory_packet_size (config
));
1649 remote_target
*remote
= get_current_remote_target ();
1652 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1653 remote
->get_memory_packet_size (config
));
1655 puts_filtered ("The actual limit will be further reduced "
1656 "dependent on the target.\n");
1660 static struct memory_packet_config memory_write_packet_config
=
1662 "memory-write-packet-size",
1666 set_memory_write_packet_size (const char *args
, int from_tty
)
1668 set_memory_packet_size (args
, &memory_write_packet_config
);
1672 show_memory_write_packet_size (const char *args
, int from_tty
)
1674 show_memory_packet_size (&memory_write_packet_config
);
1677 /* Show the number of hardware watchpoints that can be used. */
1680 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1681 struct cmd_list_element
*c
,
1684 fprintf_filtered (file
, _("The maximum number of target hardware "
1685 "watchpoints is %s.\n"), value
);
1688 /* Show the length limit (in bytes) for hardware watchpoints. */
1691 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1692 struct cmd_list_element
*c
,
1695 fprintf_filtered (file
, _("The maximum length (in bytes) of a target "
1696 "hardware watchpoint is %s.\n"), value
);
1699 /* Show the number of hardware breakpoints that can be used. */
1702 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1703 struct cmd_list_element
*c
,
1706 fprintf_filtered (file
, _("The maximum number of target hardware "
1707 "breakpoints is %s.\n"), value
);
1710 /* Controls the maximum number of characters to display in the debug output
1711 for each remote packet. The remaining characters are omitted. */
1713 static int remote_packet_max_chars
= 512;
1715 /* Show the maximum number of characters to display for each remote packet
1716 when remote debugging is enabled. */
1719 show_remote_packet_max_chars (struct ui_file
*file
, int from_tty
,
1720 struct cmd_list_element
*c
,
1723 fprintf_filtered (file
, _("Number of remote packet characters to "
1724 "display is %s.\n"), value
);
1728 remote_target::get_memory_write_packet_size ()
1730 return get_memory_packet_size (&memory_write_packet_config
);
1733 static struct memory_packet_config memory_read_packet_config
=
1735 "memory-read-packet-size",
1739 set_memory_read_packet_size (const char *args
, int from_tty
)
1741 set_memory_packet_size (args
, &memory_read_packet_config
);
1745 show_memory_read_packet_size (const char *args
, int from_tty
)
1747 show_memory_packet_size (&memory_read_packet_config
);
1751 remote_target::get_memory_read_packet_size ()
1753 long size
= get_memory_packet_size (&memory_read_packet_config
);
1755 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1756 extra buffer size argument before the memory read size can be
1757 increased beyond this. */
1758 if (size
> get_remote_packet_size ())
1759 size
= get_remote_packet_size ();
1765 struct packet_config
1770 /* If auto, GDB auto-detects support for this packet or feature,
1771 either through qSupported, or by trying the packet and looking
1772 at the response. If true, GDB assumes the target supports this
1773 packet. If false, the packet is disabled. Configs that don't
1774 have an associated command always have this set to auto. */
1775 enum auto_boolean detect
;
1777 /* Does the target support this packet? */
1778 enum packet_support support
;
1781 static enum packet_support
packet_config_support (struct packet_config
*config
);
1782 static enum packet_support
packet_support (int packet
);
1785 show_packet_config_cmd (struct packet_config
*config
)
1787 const char *support
= "internal-error";
1789 switch (packet_config_support (config
))
1792 support
= "enabled";
1794 case PACKET_DISABLE
:
1795 support
= "disabled";
1797 case PACKET_SUPPORT_UNKNOWN
:
1798 support
= "unknown";
1801 switch (config
->detect
)
1803 case AUTO_BOOLEAN_AUTO
:
1804 printf_filtered (_("Support for the `%s' packet "
1805 "is auto-detected, currently %s.\n"),
1806 config
->name
, support
);
1808 case AUTO_BOOLEAN_TRUE
:
1809 case AUTO_BOOLEAN_FALSE
:
1810 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1811 config
->name
, support
);
1817 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1818 const char *title
, int legacy
)
1824 config
->name
= name
;
1825 config
->title
= title
;
1826 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1828 show_doc
= xstrprintf ("Show current use of remote "
1829 "protocol `%s' (%s) packet.",
1831 /* set/show TITLE-packet {auto,on,off} */
1832 cmd_name
= xstrprintf ("%s-packet", title
);
1833 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1834 &config
->detect
, set_doc
,
1835 show_doc
, NULL
, /* help_doc */
1837 show_remote_protocol_packet_cmd
,
1838 &remote_set_cmdlist
, &remote_show_cmdlist
);
1839 /* The command code copies the documentation strings. */
1842 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1847 legacy_name
= xstrprintf ("%s-packet", name
);
1848 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1849 &remote_set_cmdlist
);
1850 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1851 &remote_show_cmdlist
);
1855 static enum packet_result
1856 packet_check_result (const char *buf
)
1860 /* The stub recognized the packet request. Check that the
1861 operation succeeded. */
1863 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1865 /* "Enn" - definitely an error. */
1866 return PACKET_ERROR
;
1868 /* Always treat "E." as an error. This will be used for
1869 more verbose error messages, such as E.memtypes. */
1870 if (buf
[0] == 'E' && buf
[1] == '.')
1871 return PACKET_ERROR
;
1873 /* The packet may or may not be OK. Just assume it is. */
1877 /* The stub does not support the packet. */
1878 return PACKET_UNKNOWN
;
1881 static enum packet_result
1882 packet_check_result (const gdb::char_vector
&buf
)
1884 return packet_check_result (buf
.data ());
1887 static enum packet_result
1888 packet_ok (const char *buf
, struct packet_config
*config
)
1890 enum packet_result result
;
1892 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1893 && config
->support
== PACKET_DISABLE
)
1894 internal_error (__FILE__
, __LINE__
,
1895 _("packet_ok: attempt to use a disabled packet"));
1897 result
= packet_check_result (buf
);
1902 /* The stub recognized the packet request. */
1903 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1906 fprintf_unfiltered (gdb_stdlog
,
1907 "Packet %s (%s) is supported\n",
1908 config
->name
, config
->title
);
1909 config
->support
= PACKET_ENABLE
;
1912 case PACKET_UNKNOWN
:
1913 /* The stub does not support the packet. */
1914 if (config
->detect
== AUTO_BOOLEAN_AUTO
1915 && config
->support
== PACKET_ENABLE
)
1917 /* If the stub previously indicated that the packet was
1918 supported then there is a protocol error. */
1919 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1920 config
->name
, config
->title
);
1922 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
1924 /* The user set it wrong. */
1925 error (_("Enabled packet %s (%s) not recognized by stub"),
1926 config
->name
, config
->title
);
1930 fprintf_unfiltered (gdb_stdlog
,
1931 "Packet %s (%s) is NOT supported\n",
1932 config
->name
, config
->title
);
1933 config
->support
= PACKET_DISABLE
;
1940 static enum packet_result
1941 packet_ok (const gdb::char_vector
&buf
, struct packet_config
*config
)
1943 return packet_ok (buf
.data (), config
);
1960 PACKET_vFile_pwrite
,
1962 PACKET_vFile_unlink
,
1963 PACKET_vFile_readlink
,
1966 PACKET_qXfer_features
,
1967 PACKET_qXfer_exec_file
,
1968 PACKET_qXfer_libraries
,
1969 PACKET_qXfer_libraries_svr4
,
1970 PACKET_qXfer_memory_map
,
1971 PACKET_qXfer_osdata
,
1972 PACKET_qXfer_threads
,
1973 PACKET_qXfer_statictrace_read
,
1974 PACKET_qXfer_traceframe_info
,
1980 PACKET_QPassSignals
,
1981 PACKET_QCatchSyscalls
,
1982 PACKET_QProgramSignals
,
1983 PACKET_QSetWorkingDir
,
1984 PACKET_QStartupWithShell
,
1985 PACKET_QEnvironmentHexEncoded
,
1986 PACKET_QEnvironmentReset
,
1987 PACKET_QEnvironmentUnset
,
1989 PACKET_qSearch_memory
,
1992 PACKET_QStartNoAckMode
,
1994 PACKET_qXfer_siginfo_read
,
1995 PACKET_qXfer_siginfo_write
,
1998 /* Support for conditional tracepoints. */
1999 PACKET_ConditionalTracepoints
,
2001 /* Support for target-side breakpoint conditions. */
2002 PACKET_ConditionalBreakpoints
,
2004 /* Support for target-side breakpoint commands. */
2005 PACKET_BreakpointCommands
,
2007 /* Support for fast tracepoints. */
2008 PACKET_FastTracepoints
,
2010 /* Support for static tracepoints. */
2011 PACKET_StaticTracepoints
,
2013 /* Support for installing tracepoints while a trace experiment is
2015 PACKET_InstallInTrace
,
2019 PACKET_TracepointSource
,
2022 PACKET_QDisableRandomization
,
2024 PACKET_QTBuffer_size
,
2028 PACKET_qXfer_btrace
,
2030 /* Support for the QNonStop packet. */
2033 /* Support for the QThreadEvents packet. */
2034 PACKET_QThreadEvents
,
2036 /* Support for multi-process extensions. */
2037 PACKET_multiprocess_feature
,
2039 /* Support for enabling and disabling tracepoints while a trace
2040 experiment is running. */
2041 PACKET_EnableDisableTracepoints_feature
,
2043 /* Support for collecting strings using the tracenz bytecode. */
2044 PACKET_tracenz_feature
,
2046 /* Support for continuing to run a trace experiment while GDB is
2048 PACKET_DisconnectedTracing_feature
,
2050 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2051 PACKET_augmented_libraries_svr4_read_feature
,
2053 /* Support for the qXfer:btrace-conf:read packet. */
2054 PACKET_qXfer_btrace_conf
,
2056 /* Support for the Qbtrace-conf:bts:size packet. */
2057 PACKET_Qbtrace_conf_bts_size
,
2059 /* Support for swbreak+ feature. */
2060 PACKET_swbreak_feature
,
2062 /* Support for hwbreak+ feature. */
2063 PACKET_hwbreak_feature
,
2065 /* Support for fork events. */
2066 PACKET_fork_event_feature
,
2068 /* Support for vfork events. */
2069 PACKET_vfork_event_feature
,
2071 /* Support for the Qbtrace-conf:pt:size packet. */
2072 PACKET_Qbtrace_conf_pt_size
,
2074 /* Support for exec events. */
2075 PACKET_exec_event_feature
,
2077 /* Support for query supported vCont actions. */
2078 PACKET_vContSupported
,
2080 /* Support remote CTRL-C. */
2083 /* Support TARGET_WAITKIND_NO_RESUMED. */
2089 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
2091 /* Returns the packet's corresponding "set remote foo-packet" command
2092 state. See struct packet_config for more details. */
2094 static enum auto_boolean
2095 packet_set_cmd_state (int packet
)
2097 return remote_protocol_packets
[packet
].detect
;
2100 /* Returns whether a given packet or feature is supported. This takes
2101 into account the state of the corresponding "set remote foo-packet"
2102 command, which may be used to bypass auto-detection. */
2104 static enum packet_support
2105 packet_config_support (struct packet_config
*config
)
2107 switch (config
->detect
)
2109 case AUTO_BOOLEAN_TRUE
:
2110 return PACKET_ENABLE
;
2111 case AUTO_BOOLEAN_FALSE
:
2112 return PACKET_DISABLE
;
2113 case AUTO_BOOLEAN_AUTO
:
2114 return config
->support
;
2116 gdb_assert_not_reached (_("bad switch"));
2120 /* Same as packet_config_support, but takes the packet's enum value as
2123 static enum packet_support
2124 packet_support (int packet
)
2126 struct packet_config
*config
= &remote_protocol_packets
[packet
];
2128 return packet_config_support (config
);
2132 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
2133 struct cmd_list_element
*c
,
2136 struct packet_config
*packet
;
2138 for (packet
= remote_protocol_packets
;
2139 packet
< &remote_protocol_packets
[PACKET_MAX
];
2142 if (&packet
->detect
== c
->var
)
2144 show_packet_config_cmd (packet
);
2148 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
2152 /* Should we try one of the 'Z' requests? */
2156 Z_PACKET_SOFTWARE_BP
,
2157 Z_PACKET_HARDWARE_BP
,
2164 /* For compatibility with older distributions. Provide a ``set remote
2165 Z-packet ...'' command that updates all the Z packet types. */
2167 static enum auto_boolean remote_Z_packet_detect
;
2170 set_remote_protocol_Z_packet_cmd (const char *args
, int from_tty
,
2171 struct cmd_list_element
*c
)
2175 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2176 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
2180 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
2181 struct cmd_list_element
*c
,
2186 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2188 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
2192 /* Returns true if the multi-process extensions are in effect. */
2195 remote_multi_process_p (struct remote_state
*rs
)
2197 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
2200 /* Returns true if fork events are supported. */
2203 remote_fork_event_p (struct remote_state
*rs
)
2205 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
2208 /* Returns true if vfork events are supported. */
2211 remote_vfork_event_p (struct remote_state
*rs
)
2213 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
2216 /* Returns true if exec events are supported. */
2219 remote_exec_event_p (struct remote_state
*rs
)
2221 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
2224 /* Insert fork catchpoint target routine. If fork events are enabled
2225 then return success, nothing more to do. */
2228 remote_target::insert_fork_catchpoint (int pid
)
2230 struct remote_state
*rs
= get_remote_state ();
2232 return !remote_fork_event_p (rs
);
2235 /* Remove fork catchpoint target routine. Nothing to do, just
2239 remote_target::remove_fork_catchpoint (int pid
)
2244 /* Insert vfork catchpoint target routine. If vfork events are enabled
2245 then return success, nothing more to do. */
2248 remote_target::insert_vfork_catchpoint (int pid
)
2250 struct remote_state
*rs
= get_remote_state ();
2252 return !remote_vfork_event_p (rs
);
2255 /* Remove vfork catchpoint target routine. Nothing to do, just
2259 remote_target::remove_vfork_catchpoint (int pid
)
2264 /* Insert exec catchpoint target routine. If exec events are
2265 enabled, just return success. */
2268 remote_target::insert_exec_catchpoint (int pid
)
2270 struct remote_state
*rs
= get_remote_state ();
2272 return !remote_exec_event_p (rs
);
2275 /* Remove exec catchpoint target routine. Nothing to do, just
2279 remote_target::remove_exec_catchpoint (int pid
)
2286 /* Take advantage of the fact that the TID field is not used, to tag
2287 special ptids with it set to != 0. */
2288 static const ptid_t
magic_null_ptid (42000, -1, 1);
2289 static const ptid_t
not_sent_ptid (42000, -2, 1);
2290 static const ptid_t
any_thread_ptid (42000, 0, 1);
2292 /* Find out if the stub attached to PID (and hence GDB should offer to
2293 detach instead of killing it when bailing out). */
2296 remote_target::remote_query_attached (int pid
)
2298 struct remote_state
*rs
= get_remote_state ();
2299 size_t size
= get_remote_packet_size ();
2301 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
2304 if (remote_multi_process_p (rs
))
2305 xsnprintf (rs
->buf
.data (), size
, "qAttached:%x", pid
);
2307 xsnprintf (rs
->buf
.data (), size
, "qAttached");
2310 getpkt (&rs
->buf
, 0);
2312 switch (packet_ok (rs
->buf
,
2313 &remote_protocol_packets
[PACKET_qAttached
]))
2316 if (strcmp (rs
->buf
.data (), "1") == 0)
2320 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
2322 case PACKET_UNKNOWN
:
2329 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2330 has been invented by GDB, instead of reported by the target. Since
2331 we can be connected to a remote system before before knowing about
2332 any inferior, mark the target with execution when we find the first
2333 inferior. If ATTACHED is 1, then we had just attached to this
2334 inferior. If it is 0, then we just created this inferior. If it
2335 is -1, then try querying the remote stub to find out if it had
2336 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2337 attempt to open this inferior's executable as the main executable
2338 if no main executable is open already. */
2341 remote_target::remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
2344 struct inferior
*inf
;
2346 /* Check whether this process we're learning about is to be
2347 considered attached, or if is to be considered to have been
2348 spawned by the stub. */
2350 attached
= remote_query_attached (pid
);
2352 if (gdbarch_has_global_solist (target_gdbarch ()))
2354 /* If the target shares code across all inferiors, then every
2355 attach adds a new inferior. */
2356 inf
= add_inferior (pid
);
2358 /* ... and every inferior is bound to the same program space.
2359 However, each inferior may still have its own address
2361 inf
->aspace
= maybe_new_address_space ();
2362 inf
->pspace
= current_program_space
;
2366 /* In the traditional debugging scenario, there's a 1-1 match
2367 between program/address spaces. We simply bind the inferior
2368 to the program space's address space. */
2369 inf
= current_inferior ();
2370 inferior_appeared (inf
, pid
);
2373 inf
->attach_flag
= attached
;
2374 inf
->fake_pid_p
= fake_pid_p
;
2376 /* If no main executable is currently open then attempt to
2377 open the file that was executed to create this inferior. */
2378 if (try_open_exec
&& get_exec_file (0) == NULL
)
2379 exec_file_locate_attach (pid
, 0, 1);
2384 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2385 static remote_thread_info
*get_remote_thread_info (ptid_t ptid
);
2387 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2388 according to RUNNING. */
2391 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
)
2393 struct remote_state
*rs
= get_remote_state ();
2394 struct thread_info
*thread
;
2396 /* GDB historically didn't pull threads in the initial connection
2397 setup. If the remote target doesn't even have a concept of
2398 threads (e.g., a bare-metal target), even if internally we
2399 consider that a single-threaded target, mentioning a new thread
2400 might be confusing to the user. Be silent then, preserving the
2401 age old behavior. */
2402 if (rs
->starting_up
)
2403 thread
= add_thread_silent (ptid
);
2405 thread
= add_thread (ptid
);
2407 get_remote_thread_info (thread
)->vcont_resumed
= executing
;
2408 set_executing (ptid
, executing
);
2409 set_running (ptid
, running
);
2414 /* Come here when we learn about a thread id from the remote target.
2415 It may be the first time we hear about such thread, so take the
2416 opportunity to add it to GDB's thread list. In case this is the
2417 first time we're noticing its corresponding inferior, add it to
2418 GDB's inferior list as well. EXECUTING indicates whether the
2419 thread is (internally) executing or stopped. */
2422 remote_target::remote_notice_new_inferior (ptid_t currthread
, int executing
)
2424 /* In non-stop mode, we assume new found threads are (externally)
2425 running until proven otherwise with a stop reply. In all-stop,
2426 we can only get here if all threads are stopped. */
2427 int running
= target_is_non_stop_p () ? 1 : 0;
2429 /* If this is a new thread, add it to GDB's thread list.
2430 If we leave it up to WFI to do this, bad things will happen. */
2432 thread_info
*tp
= find_thread_ptid (currthread
);
2433 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2435 /* We're seeing an event on a thread id we knew had exited.
2436 This has to be a new thread reusing the old id. Add it. */
2437 remote_add_thread (currthread
, running
, executing
);
2441 if (!in_thread_list (currthread
))
2443 struct inferior
*inf
= NULL
;
2444 int pid
= currthread
.pid ();
2446 if (inferior_ptid
.is_pid ()
2447 && pid
== inferior_ptid
.pid ())
2449 /* inferior_ptid has no thread member yet. This can happen
2450 with the vAttach -> remote_wait,"TAAthread:" path if the
2451 stub doesn't support qC. This is the first stop reported
2452 after an attach, so this is the main thread. Update the
2453 ptid in the thread list. */
2454 if (in_thread_list (ptid_t (pid
)))
2455 thread_change_ptid (inferior_ptid
, currthread
);
2458 remote_add_thread (currthread
, running
, executing
);
2459 inferior_ptid
= currthread
;
2464 if (magic_null_ptid
== inferior_ptid
)
2466 /* inferior_ptid is not set yet. This can happen with the
2467 vRun -> remote_wait,"TAAthread:" path if the stub
2468 doesn't support qC. This is the first stop reported
2469 after an attach, so this is the main thread. Update the
2470 ptid in the thread list. */
2471 thread_change_ptid (inferior_ptid
, currthread
);
2475 /* When connecting to a target remote, or to a target
2476 extended-remote which already was debugging an inferior, we
2477 may not know about it yet. Add it before adding its child
2478 thread, so notifications are emitted in a sensible order. */
2479 if (find_inferior_pid (currthread
.pid ()) == NULL
)
2481 struct remote_state
*rs
= get_remote_state ();
2482 bool fake_pid_p
= !remote_multi_process_p (rs
);
2484 inf
= remote_add_inferior (fake_pid_p
,
2485 currthread
.pid (), -1, 1);
2488 /* This is really a new thread. Add it. */
2489 thread_info
*new_thr
2490 = remote_add_thread (currthread
, running
, executing
);
2492 /* If we found a new inferior, let the common code do whatever
2493 it needs to with it (e.g., read shared libraries, insert
2494 breakpoints), unless we're just setting up an all-stop
2498 struct remote_state
*rs
= get_remote_state ();
2500 if (!rs
->starting_up
)
2501 notice_new_inferior (new_thr
, executing
, 0);
2506 /* Return THREAD's private thread data, creating it if necessary. */
2508 static remote_thread_info
*
2509 get_remote_thread_info (thread_info
*thread
)
2511 gdb_assert (thread
!= NULL
);
2513 if (thread
->priv
== NULL
)
2514 thread
->priv
.reset (new remote_thread_info
);
2516 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2519 static remote_thread_info
*
2520 get_remote_thread_info (ptid_t ptid
)
2522 thread_info
*thr
= find_thread_ptid (ptid
);
2523 return get_remote_thread_info (thr
);
2526 /* Call this function as a result of
2527 1) A halt indication (T packet) containing a thread id
2528 2) A direct query of currthread
2529 3) Successful execution of set thread */
2532 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2534 rs
->general_thread
= currthread
;
2537 /* If 'QPassSignals' is supported, tell the remote stub what signals
2538 it can simply pass through to the inferior without reporting. */
2541 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2543 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2545 char *pass_packet
, *p
;
2547 struct remote_state
*rs
= get_remote_state ();
2549 gdb_assert (pass_signals
.size () < 256);
2550 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2552 if (pass_signals
[i
])
2555 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2556 strcpy (pass_packet
, "QPassSignals:");
2557 p
= pass_packet
+ strlen (pass_packet
);
2558 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2560 if (pass_signals
[i
])
2563 *p
++ = tohex (i
>> 4);
2564 *p
++ = tohex (i
& 15);
2573 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2575 putpkt (pass_packet
);
2576 getpkt (&rs
->buf
, 0);
2577 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2578 if (rs
->last_pass_packet
)
2579 xfree (rs
->last_pass_packet
);
2580 rs
->last_pass_packet
= pass_packet
;
2583 xfree (pass_packet
);
2587 /* If 'QCatchSyscalls' is supported, tell the remote stub
2588 to report syscalls to GDB. */
2591 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2592 gdb::array_view
<const int> syscall_counts
)
2594 const char *catch_packet
;
2595 enum packet_result result
;
2598 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2600 /* Not supported. */
2604 if (needed
&& any_count
== 0)
2606 /* Count how many syscalls are to be caught. */
2607 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2609 if (syscall_counts
[i
] != 0)
2616 fprintf_unfiltered (gdb_stdlog
,
2617 "remote_set_syscall_catchpoint "
2618 "pid %d needed %d any_count %d n_sysno %d\n",
2619 pid
, needed
, any_count
, n_sysno
);
2622 std::string built_packet
;
2625 /* Prepare a packet with the sysno list, assuming max 8+1
2626 characters for a sysno. If the resulting packet size is too
2627 big, fallback on the non-selective packet. */
2628 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2629 built_packet
.reserve (maxpktsz
);
2630 built_packet
= "QCatchSyscalls:1";
2633 /* Add in each syscall to be caught. */
2634 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2636 if (syscall_counts
[i
] != 0)
2637 string_appendf (built_packet
, ";%zx", i
);
2640 if (built_packet
.size () > get_remote_packet_size ())
2642 /* catch_packet too big. Fallback to less efficient
2643 non selective mode, with GDB doing the filtering. */
2644 catch_packet
= "QCatchSyscalls:1";
2647 catch_packet
= built_packet
.c_str ();
2650 catch_packet
= "QCatchSyscalls:0";
2652 struct remote_state
*rs
= get_remote_state ();
2654 putpkt (catch_packet
);
2655 getpkt (&rs
->buf
, 0);
2656 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2657 if (result
== PACKET_OK
)
2663 /* If 'QProgramSignals' is supported, tell the remote stub what
2664 signals it should pass through to the inferior when detaching. */
2667 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2669 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2673 struct remote_state
*rs
= get_remote_state ();
2675 gdb_assert (signals
.size () < 256);
2676 for (size_t i
= 0; i
< signals
.size (); i
++)
2681 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2682 strcpy (packet
, "QProgramSignals:");
2683 p
= packet
+ strlen (packet
);
2684 for (size_t i
= 0; i
< signals
.size (); i
++)
2686 if (signal_pass_state (i
))
2689 *p
++ = tohex (i
>> 4);
2690 *p
++ = tohex (i
& 15);
2699 if (!rs
->last_program_signals_packet
2700 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2703 getpkt (&rs
->buf
, 0);
2704 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2705 xfree (rs
->last_program_signals_packet
);
2706 rs
->last_program_signals_packet
= packet
;
2713 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2714 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2715 thread. If GEN is set, set the general thread, if not, then set
2716 the step/continue thread. */
2718 remote_target::set_thread (ptid_t ptid
, int gen
)
2720 struct remote_state
*rs
= get_remote_state ();
2721 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2722 char *buf
= rs
->buf
.data ();
2723 char *endbuf
= buf
+ get_remote_packet_size ();
2729 *buf
++ = gen
? 'g' : 'c';
2730 if (ptid
== magic_null_ptid
)
2731 xsnprintf (buf
, endbuf
- buf
, "0");
2732 else if (ptid
== any_thread_ptid
)
2733 xsnprintf (buf
, endbuf
- buf
, "0");
2734 else if (ptid
== minus_one_ptid
)
2735 xsnprintf (buf
, endbuf
- buf
, "-1");
2737 write_ptid (buf
, endbuf
, ptid
);
2739 getpkt (&rs
->buf
, 0);
2741 rs
->general_thread
= ptid
;
2743 rs
->continue_thread
= ptid
;
2747 remote_target::set_general_thread (ptid_t ptid
)
2749 set_thread (ptid
, 1);
2753 remote_target::set_continue_thread (ptid_t ptid
)
2755 set_thread (ptid
, 0);
2758 /* Change the remote current process. Which thread within the process
2759 ends up selected isn't important, as long as it is the same process
2760 as what INFERIOR_PTID points to.
2762 This comes from that fact that there is no explicit notion of
2763 "selected process" in the protocol. The selected process for
2764 general operations is the process the selected general thread
2768 remote_target::set_general_process ()
2770 struct remote_state
*rs
= get_remote_state ();
2772 /* If the remote can't handle multiple processes, don't bother. */
2773 if (!remote_multi_process_p (rs
))
2776 /* We only need to change the remote current thread if it's pointing
2777 at some other process. */
2778 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2779 set_general_thread (inferior_ptid
);
2783 /* Return nonzero if this is the main thread that we made up ourselves
2784 to model non-threaded targets as single-threaded. */
2787 remote_thread_always_alive (ptid_t ptid
)
2789 if (ptid
== magic_null_ptid
)
2790 /* The main thread is always alive. */
2793 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2794 /* The main thread is always alive. This can happen after a
2795 vAttach, if the remote side doesn't support
2802 /* Return nonzero if the thread PTID is still alive on the remote
2806 remote_target::thread_alive (ptid_t ptid
)
2808 struct remote_state
*rs
= get_remote_state ();
2811 /* Check if this is a thread that we made up ourselves to model
2812 non-threaded targets as single-threaded. */
2813 if (remote_thread_always_alive (ptid
))
2816 p
= rs
->buf
.data ();
2817 endp
= p
+ get_remote_packet_size ();
2820 write_ptid (p
, endp
, ptid
);
2823 getpkt (&rs
->buf
, 0);
2824 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2827 /* Return a pointer to a thread name if we know it and NULL otherwise.
2828 The thread_info object owns the memory for the name. */
2831 remote_target::thread_name (struct thread_info
*info
)
2833 if (info
->priv
!= NULL
)
2835 const std::string
&name
= get_remote_thread_info (info
)->name
;
2836 return !name
.empty () ? name
.c_str () : NULL
;
2842 /* About these extended threadlist and threadinfo packets. They are
2843 variable length packets but, the fields within them are often fixed
2844 length. They are redundant enough to send over UDP as is the
2845 remote protocol in general. There is a matching unit test module
2848 /* WARNING: This threadref data structure comes from the remote O.S.,
2849 libstub protocol encoding, and remote.c. It is not particularly
2852 /* Right now, the internal structure is int. We want it to be bigger.
2853 Plan to fix this. */
2855 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2857 /* gdb_ext_thread_info is an internal GDB data structure which is
2858 equivalent to the reply of the remote threadinfo packet. */
2860 struct gdb_ext_thread_info
2862 threadref threadid
; /* External form of thread reference. */
2863 int active
; /* Has state interesting to GDB?
2865 char display
[256]; /* Brief state display, name,
2866 blocked/suspended. */
2867 char shortname
[32]; /* To be used to name threads. */
2868 char more_display
[256]; /* Long info, statistics, queue depth,
2872 /* The volume of remote transfers can be limited by submitting
2873 a mask containing bits specifying the desired information.
2874 Use a union of these values as the 'selection' parameter to
2875 get_thread_info. FIXME: Make these TAG names more thread specific. */
2877 #define TAG_THREADID 1
2878 #define TAG_EXISTS 2
2879 #define TAG_DISPLAY 4
2880 #define TAG_THREADNAME 8
2881 #define TAG_MOREDISPLAY 16
2883 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2885 static char *unpack_nibble (char *buf
, int *val
);
2887 static char *unpack_byte (char *buf
, int *value
);
2889 static char *pack_int (char *buf
, int value
);
2891 static char *unpack_int (char *buf
, int *value
);
2893 static char *unpack_string (char *src
, char *dest
, int length
);
2895 static char *pack_threadid (char *pkt
, threadref
*id
);
2897 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2899 void int_to_threadref (threadref
*id
, int value
);
2901 static int threadref_to_int (threadref
*ref
);
2903 static void copy_threadref (threadref
*dest
, threadref
*src
);
2905 static int threadmatch (threadref
*dest
, threadref
*src
);
2907 static char *pack_threadinfo_request (char *pkt
, int mode
,
2910 static char *pack_threadlist_request (char *pkt
, int startflag
,
2912 threadref
*nextthread
);
2914 static int remote_newthread_step (threadref
*ref
, void *context
);
2917 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2918 buffer we're allowed to write to. Returns
2919 BUF+CHARACTERS_WRITTEN. */
2922 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2925 struct remote_state
*rs
= get_remote_state ();
2927 if (remote_multi_process_p (rs
))
2931 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2933 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2937 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2939 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2944 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2945 last parsed char. Returns null_ptid if no thread id is found, and
2946 throws an error if the thread id has an invalid format. */
2949 read_ptid (const char *buf
, const char **obuf
)
2951 const char *p
= buf
;
2953 ULONGEST pid
= 0, tid
= 0;
2957 /* Multi-process ptid. */
2958 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2960 error (_("invalid remote ptid: %s"), p
);
2963 pp
= unpack_varlen_hex (p
+ 1, &tid
);
2966 return ptid_t (pid
, tid
, 0);
2969 /* No multi-process. Just a tid. */
2970 pp
= unpack_varlen_hex (p
, &tid
);
2972 /* Return null_ptid when no thread id is found. */
2980 /* Since the stub is not sending a process id, then default to
2981 what's in inferior_ptid, unless it's null at this point. If so,
2982 then since there's no way to know the pid of the reported
2983 threads, use the magic number. */
2984 if (inferior_ptid
== null_ptid
)
2985 pid
= magic_null_ptid
.pid ();
2987 pid
= inferior_ptid
.pid ();
2991 return ptid_t (pid
, tid
, 0);
2997 if (ch
>= 'a' && ch
<= 'f')
2998 return ch
- 'a' + 10;
2999 if (ch
>= '0' && ch
<= '9')
3001 if (ch
>= 'A' && ch
<= 'F')
3002 return ch
- 'A' + 10;
3007 stub_unpack_int (char *buff
, int fieldlength
)
3014 nibble
= stubhex (*buff
++);
3018 retval
= retval
<< 4;
3024 unpack_nibble (char *buf
, int *val
)
3026 *val
= fromhex (*buf
++);
3031 unpack_byte (char *buf
, int *value
)
3033 *value
= stub_unpack_int (buf
, 2);
3038 pack_int (char *buf
, int value
)
3040 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3041 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3042 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3043 buf
= pack_hex_byte (buf
, (value
& 0xff));
3048 unpack_int (char *buf
, int *value
)
3050 *value
= stub_unpack_int (buf
, 8);
3054 #if 0 /* Currently unused, uncomment when needed. */
3055 static char *pack_string (char *pkt
, char *string
);
3058 pack_string (char *pkt
, char *string
)
3063 len
= strlen (string
);
3065 len
= 200; /* Bigger than most GDB packets, junk??? */
3066 pkt
= pack_hex_byte (pkt
, len
);
3070 if ((ch
== '\0') || (ch
== '#'))
3071 ch
= '*'; /* Protect encapsulation. */
3076 #endif /* 0 (unused) */
3079 unpack_string (char *src
, char *dest
, int length
)
3088 pack_threadid (char *pkt
, threadref
*id
)
3091 unsigned char *altid
;
3093 altid
= (unsigned char *) id
;
3094 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3096 pkt
= pack_hex_byte (pkt
, *altid
++);
3102 unpack_threadid (char *inbuf
, threadref
*id
)
3105 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3108 altref
= (char *) id
;
3110 while (inbuf
< limit
)
3112 x
= stubhex (*inbuf
++);
3113 y
= stubhex (*inbuf
++);
3114 *altref
++ = (x
<< 4) | y
;
3119 /* Externally, threadrefs are 64 bits but internally, they are still
3120 ints. This is due to a mismatch of specifications. We would like
3121 to use 64bit thread references internally. This is an adapter
3125 int_to_threadref (threadref
*id
, int value
)
3127 unsigned char *scan
;
3129 scan
= (unsigned char *) id
;
3135 *scan
++ = (value
>> 24) & 0xff;
3136 *scan
++ = (value
>> 16) & 0xff;
3137 *scan
++ = (value
>> 8) & 0xff;
3138 *scan
++ = (value
& 0xff);
3142 threadref_to_int (threadref
*ref
)
3145 unsigned char *scan
;
3151 value
= (value
<< 8) | ((*scan
++) & 0xff);
3156 copy_threadref (threadref
*dest
, threadref
*src
)
3159 unsigned char *csrc
, *cdest
;
3161 csrc
= (unsigned char *) src
;
3162 cdest
= (unsigned char *) dest
;
3169 threadmatch (threadref
*dest
, threadref
*src
)
3171 /* Things are broken right now, so just assume we got a match. */
3173 unsigned char *srcp
, *destp
;
3175 srcp
= (char *) src
;
3176 destp
= (char *) dest
;
3180 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3187 threadid:1, # always request threadid
3194 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3197 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3199 *pkt
++ = 'q'; /* Info Query */
3200 *pkt
++ = 'P'; /* process or thread info */
3201 pkt
= pack_int (pkt
, mode
); /* mode */
3202 pkt
= pack_threadid (pkt
, id
); /* threadid */
3203 *pkt
= '\0'; /* terminate */
3207 /* These values tag the fields in a thread info response packet. */
3208 /* Tagging the fields allows us to request specific fields and to
3209 add more fields as time goes by. */
3211 #define TAG_THREADID 1 /* Echo the thread identifier. */
3212 #define TAG_EXISTS 2 /* Is this process defined enough to
3213 fetch registers and its stack? */
3214 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3215 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3216 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3220 remote_target::remote_unpack_thread_info_response (char *pkt
,
3221 threadref
*expectedref
,
3222 gdb_ext_thread_info
*info
)
3224 struct remote_state
*rs
= get_remote_state ();
3228 char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3231 /* info->threadid = 0; FIXME: implement zero_threadref. */
3233 info
->display
[0] = '\0';
3234 info
->shortname
[0] = '\0';
3235 info
->more_display
[0] = '\0';
3237 /* Assume the characters indicating the packet type have been
3239 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3240 pkt
= unpack_threadid (pkt
, &ref
);
3243 warning (_("Incomplete response to threadinfo request."));
3244 if (!threadmatch (&ref
, expectedref
))
3245 { /* This is an answer to a different request. */
3246 warning (_("ERROR RMT Thread info mismatch."));
3249 copy_threadref (&info
->threadid
, &ref
);
3251 /* Loop on tagged fields , try to bail if something goes wrong. */
3253 /* Packets are terminated with nulls. */
3254 while ((pkt
< limit
) && mask
&& *pkt
)
3256 pkt
= unpack_int (pkt
, &tag
); /* tag */
3257 pkt
= unpack_byte (pkt
, &length
); /* length */
3258 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3260 warning (_("ERROR RMT: threadinfo tag mismatch."));
3264 if (tag
== TAG_THREADID
)
3268 warning (_("ERROR RMT: length of threadid is not 16."));
3272 pkt
= unpack_threadid (pkt
, &ref
);
3273 mask
= mask
& ~TAG_THREADID
;
3276 if (tag
== TAG_EXISTS
)
3278 info
->active
= stub_unpack_int (pkt
, length
);
3280 mask
= mask
& ~(TAG_EXISTS
);
3283 warning (_("ERROR RMT: 'exists' length too long."));
3289 if (tag
== TAG_THREADNAME
)
3291 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3292 mask
= mask
& ~TAG_THREADNAME
;
3295 if (tag
== TAG_DISPLAY
)
3297 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3298 mask
= mask
& ~TAG_DISPLAY
;
3301 if (tag
== TAG_MOREDISPLAY
)
3303 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3304 mask
= mask
& ~TAG_MOREDISPLAY
;
3307 warning (_("ERROR RMT: unknown thread info tag."));
3308 break; /* Not a tag we know about. */
3314 remote_target::remote_get_threadinfo (threadref
*threadid
,
3316 gdb_ext_thread_info
*info
)
3318 struct remote_state
*rs
= get_remote_state ();
3321 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3323 getpkt (&rs
->buf
, 0);
3325 if (rs
->buf
[0] == '\0')
3328 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3333 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3336 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3337 threadref
*nextthread
)
3339 *pkt
++ = 'q'; /* info query packet */
3340 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3341 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3342 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3343 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3348 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3351 remote_target::parse_threadlist_response (char *pkt
, int result_limit
,
3352 threadref
*original_echo
,
3353 threadref
*resultlist
,
3356 struct remote_state
*rs
= get_remote_state ();
3358 int count
, resultcount
, done
;
3361 /* Assume the 'q' and 'M chars have been stripped. */
3362 limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3363 /* done parse past here */
3364 pkt
= unpack_byte (pkt
, &count
); /* count field */
3365 pkt
= unpack_nibble (pkt
, &done
);
3366 /* The first threadid is the argument threadid. */
3367 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3368 while ((count
-- > 0) && (pkt
< limit
))
3370 pkt
= unpack_threadid (pkt
, resultlist
++);
3371 if (resultcount
++ >= result_limit
)
3379 /* Fetch the next batch of threads from the remote. Returns -1 if the
3380 qL packet is not supported, 0 on error and 1 on success. */
3383 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3384 int result_limit
, int *done
, int *result_count
,
3385 threadref
*threadlist
)
3387 struct remote_state
*rs
= get_remote_state ();
3390 /* Truncate result limit to be smaller than the packet size. */
3391 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3392 >= get_remote_packet_size ())
3393 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3395 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3398 getpkt (&rs
->buf
, 0);
3399 if (rs
->buf
[0] == '\0')
3401 /* Packet not supported. */
3406 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3407 &rs
->echo_nextthread
, threadlist
, done
);
3409 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3411 /* FIXME: This is a good reason to drop the packet. */
3412 /* Possibly, there is a duplicate response. */
3414 retransmit immediatly - race conditions
3415 retransmit after timeout - yes
3417 wait for packet, then exit
3419 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3420 return 0; /* I choose simply exiting. */
3422 if (*result_count
<= 0)
3426 warning (_("RMT ERROR : failed to get remote thread list."));
3429 return result
; /* break; */
3431 if (*result_count
> result_limit
)
3434 warning (_("RMT ERROR: threadlist response longer than requested."));
3440 /* Fetch the list of remote threads, with the qL packet, and call
3441 STEPFUNCTION for each thread found. Stops iterating and returns 1
3442 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3443 STEPFUNCTION returns false. If the packet is not supported,
3447 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3448 void *context
, int looplimit
)
3450 struct remote_state
*rs
= get_remote_state ();
3451 int done
, i
, result_count
;
3459 if (loopcount
++ > looplimit
)
3462 warning (_("Remote fetch threadlist -infinite loop-."));
3465 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3466 MAXTHREADLISTRESULTS
,
3467 &done
, &result_count
,
3468 rs
->resultthreadlist
);
3471 /* Clear for later iterations. */
3473 /* Setup to resume next batch of thread references, set nextthread. */
3474 if (result_count
>= 1)
3475 copy_threadref (&rs
->nextthread
,
3476 &rs
->resultthreadlist
[result_count
- 1]);
3478 while (result_count
--)
3480 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3490 /* A thread found on the remote target. */
3494 explicit thread_item (ptid_t ptid_
)
3498 thread_item (thread_item
&&other
) = default;
3499 thread_item
&operator= (thread_item
&&other
) = default;
3501 DISABLE_COPY_AND_ASSIGN (thread_item
);
3503 /* The thread's PTID. */
3506 /* The thread's extra info. */
3509 /* The thread's name. */
3512 /* The core the thread was running on. -1 if not known. */
3515 /* The thread handle associated with the thread. */
3516 gdb::byte_vector thread_handle
;
3519 /* Context passed around to the various methods listing remote
3520 threads. As new threads are found, they're added to the ITEMS
3523 struct threads_listing_context
3525 /* Return true if this object contains an entry for a thread with ptid
3528 bool contains_thread (ptid_t ptid
) const
3530 auto match_ptid
= [&] (const thread_item
&item
)
3532 return item
.ptid
== ptid
;
3535 auto it
= std::find_if (this->items
.begin (),
3539 return it
!= this->items
.end ();
3542 /* Remove the thread with ptid PTID. */
3544 void remove_thread (ptid_t ptid
)
3546 auto match_ptid
= [&] (const thread_item
&item
)
3548 return item
.ptid
== ptid
;
3551 auto it
= std::remove_if (this->items
.begin (),
3555 if (it
!= this->items
.end ())
3556 this->items
.erase (it
);
3559 /* The threads found on the remote target. */
3560 std::vector
<thread_item
> items
;
3564 remote_newthread_step (threadref
*ref
, void *data
)
3566 struct threads_listing_context
*context
3567 = (struct threads_listing_context
*) data
;
3568 int pid
= inferior_ptid
.pid ();
3569 int lwp
= threadref_to_int (ref
);
3570 ptid_t
ptid (pid
, lwp
);
3572 context
->items
.emplace_back (ptid
);
3574 return 1; /* continue iterator */
3577 #define CRAZY_MAX_THREADS 1000
3580 remote_target::remote_current_thread (ptid_t oldpid
)
3582 struct remote_state
*rs
= get_remote_state ();
3585 getpkt (&rs
->buf
, 0);
3586 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3591 result
= read_ptid (&rs
->buf
[2], &obuf
);
3592 if (*obuf
!= '\0' && remote_debug
)
3593 fprintf_unfiltered (gdb_stdlog
,
3594 "warning: garbage in qC reply\n");
3602 /* List remote threads using the deprecated qL packet. */
3605 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3607 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3608 CRAZY_MAX_THREADS
) >= 0)
3614 #if defined(HAVE_LIBEXPAT)
3617 start_thread (struct gdb_xml_parser
*parser
,
3618 const struct gdb_xml_element
*element
,
3620 std::vector
<gdb_xml_value
> &attributes
)
3622 struct threads_listing_context
*data
3623 = (struct threads_listing_context
*) user_data
;
3624 struct gdb_xml_value
*attr
;
3626 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3627 ptid_t ptid
= read_ptid (id
, NULL
);
3629 data
->items
.emplace_back (ptid
);
3630 thread_item
&item
= data
->items
.back ();
3632 attr
= xml_find_attribute (attributes
, "core");
3634 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3636 attr
= xml_find_attribute (attributes
, "name");
3638 item
.name
= (const char *) attr
->value
.get ();
3640 attr
= xml_find_attribute (attributes
, "handle");
3642 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3646 end_thread (struct gdb_xml_parser
*parser
,
3647 const struct gdb_xml_element
*element
,
3648 void *user_data
, const char *body_text
)
3650 struct threads_listing_context
*data
3651 = (struct threads_listing_context
*) user_data
;
3653 if (body_text
!= NULL
&& *body_text
!= '\0')
3654 data
->items
.back ().extra
= body_text
;
3657 const struct gdb_xml_attribute thread_attributes
[] = {
3658 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3659 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3660 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3661 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3662 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3665 const struct gdb_xml_element thread_children
[] = {
3666 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3669 const struct gdb_xml_element threads_children
[] = {
3670 { "thread", thread_attributes
, thread_children
,
3671 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3672 start_thread
, end_thread
},
3673 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3676 const struct gdb_xml_element threads_elements
[] = {
3677 { "threads", NULL
, threads_children
,
3678 GDB_XML_EF_NONE
, NULL
, NULL
},
3679 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3684 /* List remote threads using qXfer:threads:read. */
3687 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3689 #if defined(HAVE_LIBEXPAT)
3690 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3692 gdb::optional
<gdb::char_vector
> xml
3693 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3695 if (xml
&& (*xml
)[0] != '\0')
3697 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3698 threads_elements
, xml
->data (), context
);
3708 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3711 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3713 struct remote_state
*rs
= get_remote_state ();
3715 if (rs
->use_threadinfo_query
)
3719 putpkt ("qfThreadInfo");
3720 getpkt (&rs
->buf
, 0);
3721 bufp
= rs
->buf
.data ();
3722 if (bufp
[0] != '\0') /* q packet recognized */
3724 while (*bufp
++ == 'm') /* reply contains one or more TID */
3728 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3729 context
->items
.emplace_back (ptid
);
3731 while (*bufp
++ == ','); /* comma-separated list */
3732 putpkt ("qsThreadInfo");
3733 getpkt (&rs
->buf
, 0);
3734 bufp
= rs
->buf
.data ();
3740 /* Packet not recognized. */
3741 rs
->use_threadinfo_query
= 0;
3748 /* Implement the to_update_thread_list function for the remote
3752 remote_target::update_thread_list ()
3754 struct threads_listing_context context
;
3757 /* We have a few different mechanisms to fetch the thread list. Try
3758 them all, starting with the most preferred one first, falling
3759 back to older methods. */
3760 if (remote_get_threads_with_qxfer (&context
)
3761 || remote_get_threads_with_qthreadinfo (&context
)
3762 || remote_get_threads_with_ql (&context
))
3766 if (context
.items
.empty ()
3767 && remote_thread_always_alive (inferior_ptid
))
3769 /* Some targets don't really support threads, but still
3770 reply an (empty) thread list in response to the thread
3771 listing packets, instead of replying "packet not
3772 supported". Exit early so we don't delete the main
3777 /* CONTEXT now holds the current thread list on the remote
3778 target end. Delete GDB-side threads no longer found on the
3780 for (thread_info
*tp
: all_threads_safe ())
3782 if (!context
.contains_thread (tp
->ptid
))
3789 /* Remove any unreported fork child threads from CONTEXT so
3790 that we don't interfere with follow fork, which is where
3791 creation of such threads is handled. */
3792 remove_new_fork_children (&context
);
3794 /* And now add threads we don't know about yet to our list. */
3795 for (thread_item
&item
: context
.items
)
3797 if (item
.ptid
!= null_ptid
)
3799 /* In non-stop mode, we assume new found threads are
3800 executing until proven otherwise with a stop reply.
3801 In all-stop, we can only get here if all threads are
3803 int executing
= target_is_non_stop_p () ? 1 : 0;
3805 remote_notice_new_inferior (item
.ptid
, executing
);
3807 thread_info
*tp
= find_thread_ptid (item
.ptid
);
3808 remote_thread_info
*info
= get_remote_thread_info (tp
);
3809 info
->core
= item
.core
;
3810 info
->extra
= std::move (item
.extra
);
3811 info
->name
= std::move (item
.name
);
3812 info
->thread_handle
= std::move (item
.thread_handle
);
3819 /* If no thread listing method is supported, then query whether
3820 each known thread is alive, one by one, with the T packet.
3821 If the target doesn't support threads at all, then this is a
3822 no-op. See remote_thread_alive. */
3828 * Collect a descriptive string about the given thread.
3829 * The target may say anything it wants to about the thread
3830 * (typically info about its blocked / runnable state, name, etc.).
3831 * This string will appear in the info threads display.
3833 * Optional: targets are not required to implement this function.
3837 remote_target::extra_thread_info (thread_info
*tp
)
3839 struct remote_state
*rs
= get_remote_state ();
3842 struct gdb_ext_thread_info threadinfo
;
3844 if (rs
->remote_desc
== 0) /* paranoia */
3845 internal_error (__FILE__
, __LINE__
,
3846 _("remote_threads_extra_info"));
3848 if (tp
->ptid
== magic_null_ptid
3849 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
3850 /* This is the main thread which was added by GDB. The remote
3851 server doesn't know about it. */
3854 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
3856 /* If already have cached info, use it. */
3857 if (!extra
.empty ())
3858 return extra
.c_str ();
3860 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3862 /* If we're using qXfer:threads:read, then the extra info is
3863 included in the XML. So if we didn't have anything cached,
3864 it's because there's really no extra info. */
3868 if (rs
->use_threadextra_query
)
3870 char *b
= rs
->buf
.data ();
3871 char *endb
= b
+ get_remote_packet_size ();
3873 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3875 write_ptid (b
, endb
, tp
->ptid
);
3878 getpkt (&rs
->buf
, 0);
3879 if (rs
->buf
[0] != 0)
3881 extra
.resize (strlen (rs
->buf
.data ()) / 2);
3882 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
3883 return extra
.c_str ();
3887 /* If the above query fails, fall back to the old method. */
3888 rs
->use_threadextra_query
= 0;
3889 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3890 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3891 int_to_threadref (&id
, tp
->ptid
.lwp ());
3892 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3893 if (threadinfo
.active
)
3895 if (*threadinfo
.shortname
)
3896 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
3897 if (*threadinfo
.display
)
3899 if (!extra
.empty ())
3901 string_appendf (extra
, " State: %s", threadinfo
.display
);
3903 if (*threadinfo
.more_display
)
3905 if (!extra
.empty ())
3907 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
3909 return extra
.c_str ();
3916 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
3917 struct static_tracepoint_marker
*marker
)
3919 struct remote_state
*rs
= get_remote_state ();
3920 char *p
= rs
->buf
.data ();
3922 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3924 p
+= hexnumstr (p
, addr
);
3926 getpkt (&rs
->buf
, 0);
3927 p
= rs
->buf
.data ();
3930 error (_("Remote failure reply: %s"), p
);
3934 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
3941 std::vector
<static_tracepoint_marker
>
3942 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
3944 struct remote_state
*rs
= get_remote_state ();
3945 std::vector
<static_tracepoint_marker
> markers
;
3947 static_tracepoint_marker marker
;
3949 /* Ask for a first packet of static tracepoint marker
3952 getpkt (&rs
->buf
, 0);
3953 p
= rs
->buf
.data ();
3955 error (_("Remote failure reply: %s"), p
);
3961 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
3963 if (strid
== NULL
|| marker
.str_id
== strid
)
3964 markers
.push_back (std::move (marker
));
3966 while (*p
++ == ','); /* comma-separated list */
3967 /* Ask for another packet of static tracepoint definition. */
3969 getpkt (&rs
->buf
, 0);
3970 p
= rs
->buf
.data ();
3977 /* Implement the to_get_ada_task_ptid function for the remote targets. */
3980 remote_target::get_ada_task_ptid (long lwp
, long thread
)
3982 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3986 /* Restart the remote side; this is an extended protocol operation. */
3989 remote_target::extended_remote_restart ()
3991 struct remote_state
*rs
= get_remote_state ();
3993 /* Send the restart command; for reasons I don't understand the
3994 remote side really expects a number after the "R". */
3995 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
3998 remote_fileio_reset ();
4001 /* Clean up connection to a remote debugger. */
4004 remote_target::close ()
4006 /* Make sure we leave stdin registered in the event loop. */
4009 /* We don't have a connection to the remote stub anymore. Get rid
4010 of all the inferiors and their threads we were controlling.
4011 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
4012 will be unable to find the thread corresponding to (pid, 0, 0). */
4013 inferior_ptid
= null_ptid
;
4014 discard_all_inferiors ();
4016 trace_reset_local_state ();
4021 remote_target::~remote_target ()
4023 struct remote_state
*rs
= get_remote_state ();
4025 /* Check for NULL because we may get here with a partially
4026 constructed target/connection. */
4027 if (rs
->remote_desc
== nullptr)
4030 serial_close (rs
->remote_desc
);
4032 /* We are destroying the remote target, so we should discard
4033 everything of this target. */
4034 discard_pending_stop_replies_in_queue ();
4036 if (rs
->remote_async_inferior_event_token
)
4037 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4039 delete rs
->notif_state
;
4042 /* Query the remote side for the text, data and bss offsets. */
4045 remote_target::get_offsets ()
4047 struct remote_state
*rs
= get_remote_state ();
4050 int lose
, num_segments
= 0, do_sections
, do_segments
;
4051 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4052 struct symfile_segment_data
*data
;
4054 if (symfile_objfile
== NULL
)
4057 putpkt ("qOffsets");
4058 getpkt (&rs
->buf
, 0);
4059 buf
= rs
->buf
.data ();
4061 if (buf
[0] == '\000')
4062 return; /* Return silently. Stub doesn't support
4066 warning (_("Remote failure reply: %s"), buf
);
4070 /* Pick up each field in turn. This used to be done with scanf, but
4071 scanf will make trouble if CORE_ADDR size doesn't match
4072 conversion directives correctly. The following code will work
4073 with any size of CORE_ADDR. */
4074 text_addr
= data_addr
= bss_addr
= 0;
4078 if (startswith (ptr
, "Text="))
4081 /* Don't use strtol, could lose on big values. */
4082 while (*ptr
&& *ptr
!= ';')
4083 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4085 if (startswith (ptr
, ";Data="))
4088 while (*ptr
&& *ptr
!= ';')
4089 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4094 if (!lose
&& startswith (ptr
, ";Bss="))
4097 while (*ptr
&& *ptr
!= ';')
4098 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4100 if (bss_addr
!= data_addr
)
4101 warning (_("Target reported unsupported offsets: %s"), buf
);
4106 else if (startswith (ptr
, "TextSeg="))
4109 /* Don't use strtol, could lose on big values. */
4110 while (*ptr
&& *ptr
!= ';')
4111 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4114 if (startswith (ptr
, ";DataSeg="))
4117 while (*ptr
&& *ptr
!= ';')
4118 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4126 error (_("Malformed response to offset query, %s"), buf
);
4127 else if (*ptr
!= '\0')
4128 warning (_("Target reported unsupported offsets: %s"), buf
);
4130 section_offsets offs
= symfile_objfile
->section_offsets
;
4132 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
4133 do_segments
= (data
!= NULL
);
4134 do_sections
= num_segments
== 0;
4136 if (num_segments
> 0)
4138 segments
[0] = text_addr
;
4139 segments
[1] = data_addr
;
4141 /* If we have two segments, we can still try to relocate everything
4142 by assuming that the .text and .data offsets apply to the whole
4143 text and data segments. Convert the offsets given in the packet
4144 to base addresses for symfile_map_offsets_to_segments. */
4145 else if (data
&& data
->num_segments
== 2)
4147 segments
[0] = data
->segment_bases
[0] + text_addr
;
4148 segments
[1] = data
->segment_bases
[1] + data_addr
;
4151 /* If the object file has only one segment, assume that it is text
4152 rather than data; main programs with no writable data are rare,
4153 but programs with no code are useless. Of course the code might
4154 have ended up in the data segment... to detect that we would need
4155 the permissions here. */
4156 else if (data
&& data
->num_segments
== 1)
4158 segments
[0] = data
->segment_bases
[0] + text_addr
;
4161 /* There's no way to relocate by segment. */
4167 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
4168 offs
, num_segments
, segments
);
4170 if (ret
== 0 && !do_sections
)
4171 error (_("Can not handle qOffsets TextSeg "
4172 "response with this symbol file"));
4179 free_symfile_segment_data (data
);
4183 offs
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
4185 /* This is a temporary kludge to force data and bss to use the
4186 same offsets because that's what nlmconv does now. The real
4187 solution requires changes to the stub and remote.c that I
4188 don't have time to do right now. */
4190 offs
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
4191 offs
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
4194 objfile_relocate (symfile_objfile
, offs
);
4197 /* Send interrupt_sequence to remote target. */
4200 remote_target::send_interrupt_sequence ()
4202 struct remote_state
*rs
= get_remote_state ();
4204 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4205 remote_serial_write ("\x03", 1);
4206 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4207 serial_send_break (rs
->remote_desc
);
4208 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4210 serial_send_break (rs
->remote_desc
);
4211 remote_serial_write ("g", 1);
4214 internal_error (__FILE__
, __LINE__
,
4215 _("Invalid value for interrupt_sequence_mode: %s."),
4216 interrupt_sequence_mode
);
4220 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4221 and extract the PTID. Returns NULL_PTID if not found. */
4224 stop_reply_extract_thread (char *stop_reply
)
4226 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4230 /* Txx r:val ; r:val (...) */
4233 /* Look for "register" named "thread". */
4238 p1
= strchr (p
, ':');
4242 if (strncmp (p
, "thread", p1
- p
) == 0)
4243 return read_ptid (++p1
, &p
);
4245 p1
= strchr (p
, ';');
4257 /* Determine the remote side's current thread. If we have a stop
4258 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4259 "thread" register we can extract the current thread from. If not,
4260 ask the remote which is the current thread with qC. The former
4261 method avoids a roundtrip. */
4264 remote_target::get_current_thread (char *wait_status
)
4266 ptid_t ptid
= null_ptid
;
4268 /* Note we don't use remote_parse_stop_reply as that makes use of
4269 the target architecture, which we haven't yet fully determined at
4271 if (wait_status
!= NULL
)
4272 ptid
= stop_reply_extract_thread (wait_status
);
4273 if (ptid
== null_ptid
)
4274 ptid
= remote_current_thread (inferior_ptid
);
4279 /* Query the remote target for which is the current thread/process,
4280 add it to our tables, and update INFERIOR_PTID. The caller is
4281 responsible for setting the state such that the remote end is ready
4282 to return the current thread.
4284 This function is called after handling the '?' or 'vRun' packets,
4285 whose response is a stop reply from which we can also try
4286 extracting the thread. If the target doesn't support the explicit
4287 qC query, we infer the current thread from that stop reply, passed
4288 in in WAIT_STATUS, which may be NULL. */
4291 remote_target::add_current_inferior_and_thread (char *wait_status
)
4293 struct remote_state
*rs
= get_remote_state ();
4294 bool fake_pid_p
= false;
4296 inferior_ptid
= null_ptid
;
4298 /* Now, if we have thread information, update inferior_ptid. */
4299 ptid_t curr_ptid
= get_current_thread (wait_status
);
4301 if (curr_ptid
!= null_ptid
)
4303 if (!remote_multi_process_p (rs
))
4308 /* Without this, some commands which require an active target
4309 (such as kill) won't work. This variable serves (at least)
4310 double duty as both the pid of the target process (if it has
4311 such), and as a flag indicating that a target is active. */
4312 curr_ptid
= magic_null_ptid
;
4316 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4318 /* Add the main thread and switch to it. Don't try reading
4319 registers yet, since we haven't fetched the target description
4321 thread_info
*tp
= add_thread_silent (curr_ptid
);
4322 switch_to_thread_no_regs (tp
);
4325 /* Print info about a thread that was found already stopped on
4329 print_one_stopped_thread (struct thread_info
*thread
)
4331 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4333 switch_to_thread (thread
);
4334 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4335 set_current_sal_from_frame (get_current_frame ());
4337 thread
->suspend
.waitstatus_pending_p
= 0;
4339 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4341 enum gdb_signal sig
= ws
->value
.sig
;
4343 if (signal_print_state (sig
))
4344 gdb::observers::signal_received
.notify (sig
);
4346 gdb::observers::normal_stop
.notify (NULL
, 1);
4349 /* Process all initial stop replies the remote side sent in response
4350 to the ? packet. These indicate threads that were already stopped
4351 on initial connection. We mark these threads as stopped and print
4352 their current frame before giving the user the prompt. */
4355 remote_target::process_initial_stop_replies (int from_tty
)
4357 int pending_stop_replies
= stop_reply_queue_length ();
4358 struct thread_info
*selected
= NULL
;
4359 struct thread_info
*lowest_stopped
= NULL
;
4360 struct thread_info
*first
= NULL
;
4362 /* Consume the initial pending events. */
4363 while (pending_stop_replies
-- > 0)
4365 ptid_t waiton_ptid
= minus_one_ptid
;
4367 struct target_waitstatus ws
;
4368 int ignore_event
= 0;
4370 memset (&ws
, 0, sizeof (ws
));
4371 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4373 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4377 case TARGET_WAITKIND_IGNORE
:
4378 case TARGET_WAITKIND_NO_RESUMED
:
4379 case TARGET_WAITKIND_SIGNALLED
:
4380 case TARGET_WAITKIND_EXITED
:
4381 /* We shouldn't see these, but if we do, just ignore. */
4383 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
4387 case TARGET_WAITKIND_EXECD
:
4388 xfree (ws
.value
.execd_pathname
);
4397 struct thread_info
*evthread
= find_thread_ptid (event_ptid
);
4399 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4401 enum gdb_signal sig
= ws
.value
.sig
;
4403 /* Stubs traditionally report SIGTRAP as initial signal,
4404 instead of signal 0. Suppress it. */
4405 if (sig
== GDB_SIGNAL_TRAP
)
4407 evthread
->suspend
.stop_signal
= sig
;
4411 evthread
->suspend
.waitstatus
= ws
;
4413 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4414 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4415 evthread
->suspend
.waitstatus_pending_p
= 1;
4417 set_executing (event_ptid
, 0);
4418 set_running (event_ptid
, 0);
4419 get_remote_thread_info (evthread
)->vcont_resumed
= 0;
4422 /* "Notice" the new inferiors before anything related to
4423 registers/memory. */
4424 for (inferior
*inf
: all_non_exited_inferiors ())
4426 inf
->needs_setup
= 1;
4430 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4431 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4436 /* If all-stop on top of non-stop, pause all threads. Note this
4437 records the threads' stop pc, so must be done after "noticing"
4441 stop_all_threads ();
4443 /* If all threads of an inferior were already stopped, we
4444 haven't setup the inferior yet. */
4445 for (inferior
*inf
: all_non_exited_inferiors ())
4447 if (inf
->needs_setup
)
4449 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4450 switch_to_thread_no_regs (thread
);
4456 /* Now go over all threads that are stopped, and print their current
4457 frame. If all-stop, then if there's a signalled thread, pick
4459 for (thread_info
*thread
: all_non_exited_threads ())
4465 thread
->set_running (false);
4466 else if (thread
->state
!= THREAD_STOPPED
)
4469 if (selected
== NULL
4470 && thread
->suspend
.waitstatus_pending_p
)
4473 if (lowest_stopped
== NULL
4474 || thread
->inf
->num
< lowest_stopped
->inf
->num
4475 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4476 lowest_stopped
= thread
;
4479 print_one_stopped_thread (thread
);
4482 /* In all-stop, we only print the status of one thread, and leave
4483 others with their status pending. */
4486 thread_info
*thread
= selected
;
4488 thread
= lowest_stopped
;
4492 print_one_stopped_thread (thread
);
4495 /* For "info program". */
4496 thread_info
*thread
= inferior_thread ();
4497 if (thread
->state
== THREAD_STOPPED
)
4498 set_last_target_status (inferior_ptid
, thread
->suspend
.waitstatus
);
4501 /* Start the remote connection and sync state. */
4504 remote_target::start_remote (int from_tty
, int extended_p
)
4506 struct remote_state
*rs
= get_remote_state ();
4507 struct packet_config
*noack_config
;
4508 char *wait_status
= NULL
;
4510 /* Signal other parts that we're going through the initial setup,
4511 and so things may not be stable yet. E.g., we don't try to
4512 install tracepoints until we've relocated symbols. Also, a
4513 Ctrl-C before we're connected and synced up can't interrupt the
4514 target. Instead, it offers to drop the (potentially wedged)
4516 rs
->starting_up
= 1;
4520 if (interrupt_on_connect
)
4521 send_interrupt_sequence ();
4523 /* Ack any packet which the remote side has already sent. */
4524 remote_serial_write ("+", 1);
4526 /* The first packet we send to the target is the optional "supported
4527 packets" request. If the target can answer this, it will tell us
4528 which later probes to skip. */
4529 remote_query_supported ();
4531 /* If the stub wants to get a QAllow, compose one and send it. */
4532 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4535 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4536 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4537 as a reply to known packet. For packet "vFile:setfs:" it is an
4538 invalid reply and GDB would return error in
4539 remote_hostio_set_filesystem, making remote files access impossible.
4540 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4541 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4543 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4545 putpkt (v_mustreplyempty
);
4546 getpkt (&rs
->buf
, 0);
4547 if (strcmp (rs
->buf
.data (), "OK") == 0)
4548 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4549 else if (strcmp (rs
->buf
.data (), "") != 0)
4550 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4554 /* Next, we possibly activate noack mode.
4556 If the QStartNoAckMode packet configuration is set to AUTO,
4557 enable noack mode if the stub reported a wish for it with
4560 If set to TRUE, then enable noack mode even if the stub didn't
4561 report it in qSupported. If the stub doesn't reply OK, the
4562 session ends with an error.
4564 If FALSE, then don't activate noack mode, regardless of what the
4565 stub claimed should be the default with qSupported. */
4567 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4568 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4570 putpkt ("QStartNoAckMode");
4571 getpkt (&rs
->buf
, 0);
4572 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4578 /* Tell the remote that we are using the extended protocol. */
4580 getpkt (&rs
->buf
, 0);
4583 /* Let the target know which signals it is allowed to pass down to
4585 update_signals_program_target ();
4587 /* Next, if the target can specify a description, read it. We do
4588 this before anything involving memory or registers. */
4589 target_find_description ();
4591 /* Next, now that we know something about the target, update the
4592 address spaces in the program spaces. */
4593 update_address_spaces ();
4595 /* On OSs where the list of libraries is global to all
4596 processes, we fetch them early. */
4597 if (gdbarch_has_global_solist (target_gdbarch ()))
4598 solib_add (NULL
, from_tty
, auto_solib_add
);
4600 if (target_is_non_stop_p ())
4602 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4603 error (_("Non-stop mode requested, but remote "
4604 "does not support non-stop"));
4606 putpkt ("QNonStop:1");
4607 getpkt (&rs
->buf
, 0);
4609 if (strcmp (rs
->buf
.data (), "OK") != 0)
4610 error (_("Remote refused setting non-stop mode with: %s"),
4613 /* Find about threads and processes the stub is already
4614 controlling. We default to adding them in the running state.
4615 The '?' query below will then tell us about which threads are
4617 this->update_thread_list ();
4619 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4621 /* Don't assume that the stub can operate in all-stop mode.
4622 Request it explicitly. */
4623 putpkt ("QNonStop:0");
4624 getpkt (&rs
->buf
, 0);
4626 if (strcmp (rs
->buf
.data (), "OK") != 0)
4627 error (_("Remote refused setting all-stop mode with: %s"),
4631 /* Upload TSVs regardless of whether the target is running or not. The
4632 remote stub, such as GDBserver, may have some predefined or builtin
4633 TSVs, even if the target is not running. */
4634 if (get_trace_status (current_trace_status ()) != -1)
4636 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4638 upload_trace_state_variables (&uploaded_tsvs
);
4639 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4642 /* Check whether the target is running now. */
4644 getpkt (&rs
->buf
, 0);
4646 if (!target_is_non_stop_p ())
4648 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4651 error (_("The target is not running (try extended-remote?)"));
4653 /* We're connected, but not running. Drop out before we
4654 call start_remote. */
4655 rs
->starting_up
= 0;
4660 /* Save the reply for later. */
4661 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4662 strcpy (wait_status
, rs
->buf
.data ());
4665 /* Fetch thread list. */
4666 target_update_thread_list ();
4668 /* Let the stub know that we want it to return the thread. */
4669 set_continue_thread (minus_one_ptid
);
4671 if (thread_count () == 0)
4673 /* Target has no concept of threads at all. GDB treats
4674 non-threaded target as single-threaded; add a main
4676 add_current_inferior_and_thread (wait_status
);
4680 /* We have thread information; select the thread the target
4681 says should be current. If we're reconnecting to a
4682 multi-threaded program, this will ideally be the thread
4683 that last reported an event before GDB disconnected. */
4684 inferior_ptid
= get_current_thread (wait_status
);
4685 if (inferior_ptid
== null_ptid
)
4687 /* Odd... The target was able to list threads, but not
4688 tell us which thread was current (no "thread"
4689 register in T stop reply?). Just pick the first
4690 thread in the thread list then. */
4693 fprintf_unfiltered (gdb_stdlog
,
4694 "warning: couldn't determine remote "
4695 "current thread; picking first in list.\n");
4697 inferior_ptid
= inferior_list
->thread_list
->ptid
;
4701 /* init_wait_for_inferior should be called before get_offsets in order
4702 to manage `inserted' flag in bp loc in a correct state.
4703 breakpoint_init_inferior, called from init_wait_for_inferior, set
4704 `inserted' flag to 0, while before breakpoint_re_set, called from
4705 start_remote, set `inserted' flag to 1. In the initialization of
4706 inferior, breakpoint_init_inferior should be called first, and then
4707 breakpoint_re_set can be called. If this order is broken, state of
4708 `inserted' flag is wrong, and cause some problems on breakpoint
4710 init_wait_for_inferior ();
4712 get_offsets (); /* Get text, data & bss offsets. */
4714 /* If we could not find a description using qXfer, and we know
4715 how to do it some other way, try again. This is not
4716 supported for non-stop; it could be, but it is tricky if
4717 there are no stopped threads when we connect. */
4718 if (remote_read_description_p (this)
4719 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4721 target_clear_description ();
4722 target_find_description ();
4725 /* Use the previously fetched status. */
4726 gdb_assert (wait_status
!= NULL
);
4727 strcpy (rs
->buf
.data (), wait_status
);
4728 rs
->cached_wait_status
= 1;
4730 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4734 /* Clear WFI global state. Do this before finding about new
4735 threads and inferiors, and setting the current inferior.
4736 Otherwise we would clear the proceed status of the current
4737 inferior when we want its stop_soon state to be preserved
4738 (see notice_new_inferior). */
4739 init_wait_for_inferior ();
4741 /* In non-stop, we will either get an "OK", meaning that there
4742 are no stopped threads at this time; or, a regular stop
4743 reply. In the latter case, there may be more than one thread
4744 stopped --- we pull them all out using the vStopped
4746 if (strcmp (rs
->buf
.data (), "OK") != 0)
4748 struct notif_client
*notif
= ¬if_client_stop
;
4750 /* remote_notif_get_pending_replies acks this one, and gets
4752 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4753 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4754 remote_notif_get_pending_events (notif
);
4757 if (thread_count () == 0)
4760 error (_("The target is not running (try extended-remote?)"));
4762 /* We're connected, but not running. Drop out before we
4763 call start_remote. */
4764 rs
->starting_up
= 0;
4768 /* In non-stop mode, any cached wait status will be stored in
4769 the stop reply queue. */
4770 gdb_assert (wait_status
== NULL
);
4772 /* Report all signals during attach/startup. */
4775 /* If there are already stopped threads, mark them stopped and
4776 report their stops before giving the prompt to the user. */
4777 process_initial_stop_replies (from_tty
);
4779 if (target_can_async_p ())
4783 /* If we connected to a live target, do some additional setup. */
4784 if (target_has_execution
)
4786 if (symfile_objfile
) /* No use without a symbol-file. */
4787 remote_check_symbols ();
4790 /* Possibly the target has been engaged in a trace run started
4791 previously; find out where things are at. */
4792 if (get_trace_status (current_trace_status ()) != -1)
4794 struct uploaded_tp
*uploaded_tps
= NULL
;
4796 if (current_trace_status ()->running
)
4797 printf_filtered (_("Trace is already running on the target.\n"));
4799 upload_tracepoints (&uploaded_tps
);
4801 merge_uploaded_tracepoints (&uploaded_tps
);
4804 /* Possibly the target has been engaged in a btrace record started
4805 previously; find out where things are at. */
4806 remote_btrace_maybe_reopen ();
4808 /* The thread and inferior lists are now synchronized with the
4809 target, our symbols have been relocated, and we're merged the
4810 target's tracepoints with ours. We're done with basic start
4812 rs
->starting_up
= 0;
4814 /* Maybe breakpoints are global and need to be inserted now. */
4815 if (breakpoints_should_be_inserted_now ())
4816 insert_breakpoints ();
4819 /* Open a connection to a remote debugger.
4820 NAME is the filename used for communication. */
4823 remote_target::open (const char *name
, int from_tty
)
4825 open_1 (name
, from_tty
, 0);
4828 /* Open a connection to a remote debugger using the extended
4829 remote gdb protocol. NAME is the filename used for communication. */
4832 extended_remote_target::open (const char *name
, int from_tty
)
4834 open_1 (name
, from_tty
, 1 /*extended_p */);
4837 /* Reset all packets back to "unknown support". Called when opening a
4838 new connection to a remote target. */
4841 reset_all_packet_configs_support (void)
4845 for (i
= 0; i
< PACKET_MAX
; i
++)
4846 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4849 /* Initialize all packet configs. */
4852 init_all_packet_configs (void)
4856 for (i
= 0; i
< PACKET_MAX
; i
++)
4858 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4859 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4863 /* Symbol look-up. */
4866 remote_target::remote_check_symbols ()
4871 /* The remote side has no concept of inferiors that aren't running
4872 yet, it only knows about running processes. If we're connected
4873 but our current inferior is not running, we should not invite the
4874 remote target to request symbol lookups related to its
4875 (unrelated) current process. */
4876 if (!target_has_execution
)
4879 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4882 /* Make sure the remote is pointing at the right process. Note
4883 there's no way to select "no process". */
4884 set_general_process ();
4886 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4887 because we need both at the same time. */
4888 gdb::char_vector
msg (get_remote_packet_size ());
4889 gdb::char_vector
reply (get_remote_packet_size ());
4891 /* Invite target to request symbol lookups. */
4893 putpkt ("qSymbol::");
4895 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4897 while (startswith (reply
.data (), "qSymbol:"))
4899 struct bound_minimal_symbol sym
;
4902 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
4905 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
4906 if (sym
.minsym
== NULL
)
4907 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
4911 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4912 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4914 /* If this is a function address, return the start of code
4915 instead of any data function descriptor. */
4916 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4918 current_top_target ());
4920 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4921 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4924 putpkt (msg
.data ());
4929 static struct serial
*
4930 remote_serial_open (const char *name
)
4932 static int udp_warning
= 0;
4934 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4935 of in ser-tcp.c, because it is the remote protocol assuming that the
4936 serial connection is reliable and not the serial connection promising
4938 if (!udp_warning
&& startswith (name
, "udp:"))
4940 warning (_("The remote protocol may be unreliable over UDP.\n"
4941 "Some events may be lost, rendering further debugging "
4946 return serial_open (name
);
4949 /* Inform the target of our permission settings. The permission flags
4950 work without this, but if the target knows the settings, it can do
4951 a couple things. First, it can add its own check, to catch cases
4952 that somehow manage to get by the permissions checks in target
4953 methods. Second, if the target is wired to disallow particular
4954 settings (for instance, a system in the field that is not set up to
4955 be able to stop at a breakpoint), it can object to any unavailable
4959 remote_target::set_permissions ()
4961 struct remote_state
*rs
= get_remote_state ();
4963 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
4964 "WriteReg:%x;WriteMem:%x;"
4965 "InsertBreak:%x;InsertTrace:%x;"
4966 "InsertFastTrace:%x;Stop:%x",
4967 may_write_registers
, may_write_memory
,
4968 may_insert_breakpoints
, may_insert_tracepoints
,
4969 may_insert_fast_tracepoints
, may_stop
);
4971 getpkt (&rs
->buf
, 0);
4973 /* If the target didn't like the packet, warn the user. Do not try
4974 to undo the user's settings, that would just be maddening. */
4975 if (strcmp (rs
->buf
.data (), "OK") != 0)
4976 warning (_("Remote refused setting permissions with: %s"),
4980 /* This type describes each known response to the qSupported
4982 struct protocol_feature
4984 /* The name of this protocol feature. */
4987 /* The default for this protocol feature. */
4988 enum packet_support default_support
;
4990 /* The function to call when this feature is reported, or after
4991 qSupported processing if the feature is not supported.
4992 The first argument points to this structure. The second
4993 argument indicates whether the packet requested support be
4994 enabled, disabled, or probed (or the default, if this function
4995 is being called at the end of processing and this feature was
4996 not reported). The third argument may be NULL; if not NULL, it
4997 is a NUL-terminated string taken from the packet following
4998 this feature's name and an equals sign. */
4999 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5000 enum packet_support
, const char *);
5002 /* The corresponding packet for this feature. Only used if
5003 FUNC is remote_supported_packet. */
5008 remote_supported_packet (remote_target
*remote
,
5009 const struct protocol_feature
*feature
,
5010 enum packet_support support
,
5011 const char *argument
)
5015 warning (_("Remote qSupported response supplied an unexpected value for"
5016 " \"%s\"."), feature
->name
);
5020 remote_protocol_packets
[feature
->packet
].support
= support
;
5024 remote_target::remote_packet_size (const protocol_feature
*feature
,
5025 enum packet_support support
, const char *value
)
5027 struct remote_state
*rs
= get_remote_state ();
5032 if (support
!= PACKET_ENABLE
)
5035 if (value
== NULL
|| *value
== '\0')
5037 warning (_("Remote target reported \"%s\" without a size."),
5043 packet_size
= strtol (value
, &value_end
, 16);
5044 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5046 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5047 feature
->name
, value
);
5051 /* Record the new maximum packet size. */
5052 rs
->explicit_packet_size
= packet_size
;
5056 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5057 enum packet_support support
, const char *value
)
5059 remote
->remote_packet_size (feature
, support
, value
);
5062 static const struct protocol_feature remote_protocol_features
[] = {
5063 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5064 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5065 PACKET_qXfer_auxv
},
5066 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5067 PACKET_qXfer_exec_file
},
5068 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5069 PACKET_qXfer_features
},
5070 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5071 PACKET_qXfer_libraries
},
5072 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5073 PACKET_qXfer_libraries_svr4
},
5074 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5075 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5076 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5077 PACKET_qXfer_memory_map
},
5078 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5079 PACKET_qXfer_osdata
},
5080 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5081 PACKET_qXfer_threads
},
5082 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5083 PACKET_qXfer_traceframe_info
},
5084 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5085 PACKET_QPassSignals
},
5086 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5087 PACKET_QCatchSyscalls
},
5088 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5089 PACKET_QProgramSignals
},
5090 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5091 PACKET_QSetWorkingDir
},
5092 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5093 PACKET_QStartupWithShell
},
5094 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5095 PACKET_QEnvironmentHexEncoded
},
5096 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5097 PACKET_QEnvironmentReset
},
5098 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5099 PACKET_QEnvironmentUnset
},
5100 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5101 PACKET_QStartNoAckMode
},
5102 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5103 PACKET_multiprocess_feature
},
5104 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5105 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5106 PACKET_qXfer_siginfo_read
},
5107 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5108 PACKET_qXfer_siginfo_write
},
5109 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5110 PACKET_ConditionalTracepoints
},
5111 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5112 PACKET_ConditionalBreakpoints
},
5113 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5114 PACKET_BreakpointCommands
},
5115 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5116 PACKET_FastTracepoints
},
5117 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5118 PACKET_StaticTracepoints
},
5119 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5120 PACKET_InstallInTrace
},
5121 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5122 PACKET_DisconnectedTracing_feature
},
5123 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5125 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5127 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5128 PACKET_TracepointSource
},
5129 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5131 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5132 PACKET_EnableDisableTracepoints_feature
},
5133 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5134 PACKET_qXfer_fdpic
},
5135 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5137 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5138 PACKET_QDisableRandomization
},
5139 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5140 { "QTBuffer:size", PACKET_DISABLE
,
5141 remote_supported_packet
, PACKET_QTBuffer_size
},
5142 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5143 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5144 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5145 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5146 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5147 PACKET_qXfer_btrace
},
5148 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5149 PACKET_qXfer_btrace_conf
},
5150 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5151 PACKET_Qbtrace_conf_bts_size
},
5152 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5153 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5154 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5155 PACKET_fork_event_feature
},
5156 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5157 PACKET_vfork_event_feature
},
5158 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5159 PACKET_exec_event_feature
},
5160 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5161 PACKET_Qbtrace_conf_pt_size
},
5162 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5163 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5164 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5167 static char *remote_support_xml
;
5169 /* Register string appended to "xmlRegisters=" in qSupported query. */
5172 register_remote_support_xml (const char *xml
)
5174 #if defined(HAVE_LIBEXPAT)
5175 if (remote_support_xml
== NULL
)
5176 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5179 char *copy
= xstrdup (remote_support_xml
+ 13);
5181 char *p
= strtok_r (copy
, ",", &saveptr
);
5185 if (strcmp (p
, xml
) == 0)
5192 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5195 remote_support_xml
= reconcat (remote_support_xml
,
5196 remote_support_xml
, ",", xml
,
5203 remote_query_supported_append (std::string
*msg
, const char *append
)
5207 msg
->append (append
);
5211 remote_target::remote_query_supported ()
5213 struct remote_state
*rs
= get_remote_state ();
5216 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5218 /* The packet support flags are handled differently for this packet
5219 than for most others. We treat an error, a disabled packet, and
5220 an empty response identically: any features which must be reported
5221 to be used will be automatically disabled. An empty buffer
5222 accomplishes this, since that is also the representation for a list
5223 containing no features. */
5226 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5230 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5231 remote_query_supported_append (&q
, "multiprocess+");
5233 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5234 remote_query_supported_append (&q
, "swbreak+");
5235 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5236 remote_query_supported_append (&q
, "hwbreak+");
5238 remote_query_supported_append (&q
, "qRelocInsn+");
5240 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5241 != AUTO_BOOLEAN_FALSE
)
5242 remote_query_supported_append (&q
, "fork-events+");
5243 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5244 != AUTO_BOOLEAN_FALSE
)
5245 remote_query_supported_append (&q
, "vfork-events+");
5246 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5247 != AUTO_BOOLEAN_FALSE
)
5248 remote_query_supported_append (&q
, "exec-events+");
5250 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5251 remote_query_supported_append (&q
, "vContSupported+");
5253 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5254 remote_query_supported_append (&q
, "QThreadEvents+");
5256 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5257 remote_query_supported_append (&q
, "no-resumed+");
5259 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5260 the qSupported:xmlRegisters=i386 handling. */
5261 if (remote_support_xml
!= NULL
5262 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5263 remote_query_supported_append (&q
, remote_support_xml
);
5265 q
= "qSupported:" + q
;
5266 putpkt (q
.c_str ());
5268 getpkt (&rs
->buf
, 0);
5270 /* If an error occured, warn, but do not return - just reset the
5271 buffer to empty and go on to disable features. */
5272 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5275 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5280 memset (seen
, 0, sizeof (seen
));
5282 next
= rs
->buf
.data ();
5285 enum packet_support is_supported
;
5286 char *p
, *end
, *name_end
, *value
;
5288 /* First separate out this item from the rest of the packet. If
5289 there's another item after this, we overwrite the separator
5290 (terminated strings are much easier to work with). */
5292 end
= strchr (p
, ';');
5295 end
= p
+ strlen (p
);
5305 warning (_("empty item in \"qSupported\" response"));
5310 name_end
= strchr (p
, '=');
5313 /* This is a name=value entry. */
5314 is_supported
= PACKET_ENABLE
;
5315 value
= name_end
+ 1;
5324 is_supported
= PACKET_ENABLE
;
5328 is_supported
= PACKET_DISABLE
;
5332 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5336 warning (_("unrecognized item \"%s\" "
5337 "in \"qSupported\" response"), p
);
5343 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5344 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5346 const struct protocol_feature
*feature
;
5349 feature
= &remote_protocol_features
[i
];
5350 feature
->func (this, feature
, is_supported
, value
);
5355 /* If we increased the packet size, make sure to increase the global
5356 buffer size also. We delay this until after parsing the entire
5357 qSupported packet, because this is the same buffer we were
5359 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5360 rs
->buf
.resize (rs
->explicit_packet_size
);
5362 /* Handle the defaults for unmentioned features. */
5363 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5366 const struct protocol_feature
*feature
;
5368 feature
= &remote_protocol_features
[i
];
5369 feature
->func (this, feature
, feature
->default_support
, NULL
);
5373 /* Serial QUIT handler for the remote serial descriptor.
5375 Defers handling a Ctrl-C until we're done with the current
5376 command/response packet sequence, unless:
5378 - We're setting up the connection. Don't send a remote interrupt
5379 request, as we're not fully synced yet. Quit immediately
5382 - The target has been resumed in the foreground
5383 (target_terminal::is_ours is false) with a synchronous resume
5384 packet, and we're blocked waiting for the stop reply, thus a
5385 Ctrl-C should be immediately sent to the target.
5387 - We get a second Ctrl-C while still within the same serial read or
5388 write. In that case the serial is seemingly wedged --- offer to
5391 - We see a second Ctrl-C without target response, after having
5392 previously interrupted the target. In that case the target/stub
5393 is probably wedged --- offer to quit/disconnect.
5397 remote_target::remote_serial_quit_handler ()
5399 struct remote_state
*rs
= get_remote_state ();
5401 if (check_quit_flag ())
5403 /* If we're starting up, we're not fully synced yet. Quit
5405 if (rs
->starting_up
)
5407 else if (rs
->got_ctrlc_during_io
)
5409 if (query (_("The target is not responding to GDB commands.\n"
5410 "Stop debugging it? ")))
5411 remote_unpush_and_throw ();
5413 /* If ^C has already been sent once, offer to disconnect. */
5414 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5416 /* All-stop protocol, and blocked waiting for stop reply. Send
5417 an interrupt request. */
5418 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5419 target_interrupt ();
5421 rs
->got_ctrlc_during_io
= 1;
5425 /* The remote_target that is current while the quit handler is
5426 overridden with remote_serial_quit_handler. */
5427 static remote_target
*curr_quit_handler_target
;
5430 remote_serial_quit_handler ()
5432 curr_quit_handler_target
->remote_serial_quit_handler ();
5435 /* Remove any of the remote.c targets from target stack. Upper targets depend
5436 on it so remove them first. */
5439 remote_unpush_target (void)
5441 pop_all_targets_at_and_above (process_stratum
);
5445 remote_unpush_and_throw (void)
5447 remote_unpush_target ();
5448 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5452 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5454 remote_target
*curr_remote
= get_current_remote_target ();
5457 error (_("To open a remote debug connection, you need to specify what\n"
5458 "serial device is attached to the remote system\n"
5459 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5461 /* If we're connected to a running target, target_preopen will kill it.
5462 Ask this question first, before target_preopen has a chance to kill
5464 if (curr_remote
!= NULL
&& !have_inferiors ())
5467 && !query (_("Already connected to a remote target. Disconnect? ")))
5468 error (_("Still connected."));
5471 /* Here the possibly existing remote target gets unpushed. */
5472 target_preopen (from_tty
);
5474 remote_fileio_reset ();
5475 reopen_exec_file ();
5478 remote_target
*remote
5479 = (extended_p
? new extended_remote_target () : new remote_target ());
5480 target_ops_up
target_holder (remote
);
5482 remote_state
*rs
= remote
->get_remote_state ();
5484 /* See FIXME above. */
5485 if (!target_async_permitted
)
5486 rs
->wait_forever_enabled_p
= 1;
5488 rs
->remote_desc
= remote_serial_open (name
);
5489 if (!rs
->remote_desc
)
5490 perror_with_name (name
);
5492 if (baud_rate
!= -1)
5494 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5496 /* The requested speed could not be set. Error out to
5497 top level after closing remote_desc. Take care to
5498 set remote_desc to NULL to avoid closing remote_desc
5500 serial_close (rs
->remote_desc
);
5501 rs
->remote_desc
= NULL
;
5502 perror_with_name (name
);
5506 serial_setparity (rs
->remote_desc
, serial_parity
);
5507 serial_raw (rs
->remote_desc
);
5509 /* If there is something sitting in the buffer we might take it as a
5510 response to a command, which would be bad. */
5511 serial_flush_input (rs
->remote_desc
);
5515 puts_filtered ("Remote debugging using ");
5516 puts_filtered (name
);
5517 puts_filtered ("\n");
5520 /* Switch to using the remote target now. */
5521 push_target (std::move (target_holder
));
5523 /* Register extra event sources in the event loop. */
5524 rs
->remote_async_inferior_event_token
5525 = create_async_event_handler (remote_async_inferior_event_handler
,
5527 rs
->notif_state
= remote_notif_state_allocate (remote
);
5529 /* Reset the target state; these things will be queried either by
5530 remote_query_supported or as they are needed. */
5531 reset_all_packet_configs_support ();
5532 rs
->cached_wait_status
= 0;
5533 rs
->explicit_packet_size
= 0;
5535 rs
->extended
= extended_p
;
5536 rs
->waiting_for_stop_reply
= 0;
5537 rs
->ctrlc_pending_p
= 0;
5538 rs
->got_ctrlc_during_io
= 0;
5540 rs
->general_thread
= not_sent_ptid
;
5541 rs
->continue_thread
= not_sent_ptid
;
5542 rs
->remote_traceframe_number
= -1;
5544 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5546 /* Probe for ability to use "ThreadInfo" query, as required. */
5547 rs
->use_threadinfo_query
= 1;
5548 rs
->use_threadextra_query
= 1;
5550 rs
->readahead_cache
.invalidate ();
5552 if (target_async_permitted
)
5554 /* FIXME: cagney/1999-09-23: During the initial connection it is
5555 assumed that the target is already ready and able to respond to
5556 requests. Unfortunately remote_start_remote() eventually calls
5557 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5558 around this. Eventually a mechanism that allows
5559 wait_for_inferior() to expect/get timeouts will be
5561 rs
->wait_forever_enabled_p
= 0;
5564 /* First delete any symbols previously loaded from shared libraries. */
5565 no_shared_libraries (NULL
, 0);
5567 /* Start the remote connection. If error() or QUIT, discard this
5568 target (we'd otherwise be in an inconsistent state) and then
5569 propogate the error on up the exception chain. This ensures that
5570 the caller doesn't stumble along blindly assuming that the
5571 function succeeded. The CLI doesn't have this problem but other
5572 UI's, such as MI do.
5574 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5575 this function should return an error indication letting the
5576 caller restore the previous state. Unfortunately the command
5577 ``target remote'' is directly wired to this function making that
5578 impossible. On a positive note, the CLI side of this problem has
5579 been fixed - the function set_cmd_context() makes it possible for
5580 all the ``target ....'' commands to share a common callback
5581 function. See cli-dump.c. */
5586 remote
->start_remote (from_tty
, extended_p
);
5588 catch (const gdb_exception
&ex
)
5590 /* Pop the partially set up target - unless something else did
5591 already before throwing the exception. */
5592 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5593 remote_unpush_target ();
5598 remote_btrace_reset (rs
);
5600 if (target_async_permitted
)
5601 rs
->wait_forever_enabled_p
= 1;
5604 /* Detach the specified process. */
5607 remote_target::remote_detach_pid (int pid
)
5609 struct remote_state
*rs
= get_remote_state ();
5611 /* This should not be necessary, but the handling for D;PID in
5612 GDBserver versions prior to 8.2 incorrectly assumes that the
5613 selected process points to the same process we're detaching,
5614 leading to misbehavior (and possibly GDBserver crashing) when it
5615 does not. Since it's easy and cheap, work around it by forcing
5616 GDBserver to select GDB's current process. */
5617 set_general_process ();
5619 if (remote_multi_process_p (rs
))
5620 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5622 strcpy (rs
->buf
.data (), "D");
5625 getpkt (&rs
->buf
, 0);
5627 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5629 else if (rs
->buf
[0] == '\0')
5630 error (_("Remote doesn't know how to detach"));
5632 error (_("Can't detach process."));
5635 /* This detaches a program to which we previously attached, using
5636 inferior_ptid to identify the process. After this is done, GDB
5637 can be used to debug some other program. We better not have left
5638 any breakpoints in the target program or it'll die when it hits
5642 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5644 int pid
= inferior_ptid
.pid ();
5645 struct remote_state
*rs
= get_remote_state ();
5648 if (!target_has_execution
)
5649 error (_("No process to detach from."));
5651 target_announce_detach (from_tty
);
5653 /* Tell the remote target to detach. */
5654 remote_detach_pid (pid
);
5656 /* Exit only if this is the only active inferior. */
5657 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors () == 1)
5658 puts_filtered (_("Ending remote debugging.\n"));
5660 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
5662 /* Check to see if we are detaching a fork parent. Note that if we
5663 are detaching a fork child, tp == NULL. */
5664 is_fork_parent
= (tp
!= NULL
5665 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5667 /* If doing detach-on-fork, we don't mourn, because that will delete
5668 breakpoints that should be available for the followed inferior. */
5669 if (!is_fork_parent
)
5671 /* Save the pid as a string before mourning, since that will
5672 unpush the remote target, and we need the string after. */
5673 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5675 target_mourn_inferior (inferior_ptid
);
5676 if (print_inferior_events
)
5677 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5678 inf
->num
, infpid
.c_str ());
5682 inferior_ptid
= null_ptid
;
5683 detach_inferior (current_inferior ());
5688 remote_target::detach (inferior
*inf
, int from_tty
)
5690 remote_detach_1 (inf
, from_tty
);
5694 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5696 remote_detach_1 (inf
, from_tty
);
5699 /* Target follow-fork function for remote targets. On entry, and
5700 at return, the current inferior is the fork parent.
5702 Note that although this is currently only used for extended-remote,
5703 it is named remote_follow_fork in anticipation of using it for the
5704 remote target as well. */
5707 remote_target::follow_fork (int follow_child
, int detach_fork
)
5709 struct remote_state
*rs
= get_remote_state ();
5710 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5712 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5713 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5715 /* When following the parent and detaching the child, we detach
5716 the child here. For the case of following the child and
5717 detaching the parent, the detach is done in the target-
5718 independent follow fork code in infrun.c. We can't use
5719 target_detach when detaching an unfollowed child because
5720 the client side doesn't know anything about the child. */
5721 if (detach_fork
&& !follow_child
)
5723 /* Detach the fork child. */
5727 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5728 child_pid
= child_ptid
.pid ();
5730 remote_detach_pid (child_pid
);
5736 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5737 in the program space of the new inferior. On entry and at return the
5738 current inferior is the exec'ing inferior. INF is the new exec'd
5739 inferior, which may be the same as the exec'ing inferior unless
5740 follow-exec-mode is "new". */
5743 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5745 /* We know that this is a target file name, so if it has the "target:"
5746 prefix we strip it off before saving it in the program space. */
5747 if (is_target_filename (execd_pathname
))
5748 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5750 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5753 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5756 remote_target::disconnect (const char *args
, int from_tty
)
5759 error (_("Argument given to \"disconnect\" when remotely debugging."));
5761 /* Make sure we unpush even the extended remote targets. Calling
5762 target_mourn_inferior won't unpush, and remote_mourn won't
5763 unpush if there is more than one inferior left. */
5764 unpush_target (this);
5765 generic_mourn_inferior ();
5768 puts_filtered ("Ending remote debugging.\n");
5771 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5772 be chatty about it. */
5775 extended_remote_target::attach (const char *args
, int from_tty
)
5777 struct remote_state
*rs
= get_remote_state ();
5779 char *wait_status
= NULL
;
5781 pid
= parse_pid_to_attach (args
);
5783 /* Remote PID can be freely equal to getpid, do not check it here the same
5784 way as in other targets. */
5786 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5787 error (_("This target does not support attaching to a process"));
5791 const char *exec_file
= get_exec_file (0);
5794 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5795 target_pid_to_str (ptid_t (pid
)).c_str ());
5797 printf_unfiltered (_("Attaching to %s\n"),
5798 target_pid_to_str (ptid_t (pid
)).c_str ());
5801 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5803 getpkt (&rs
->buf
, 0);
5805 switch (packet_ok (rs
->buf
,
5806 &remote_protocol_packets
[PACKET_vAttach
]))
5809 if (!target_is_non_stop_p ())
5811 /* Save the reply for later. */
5812 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5813 strcpy (wait_status
, rs
->buf
.data ());
5815 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5816 error (_("Attaching to %s failed with: %s"),
5817 target_pid_to_str (ptid_t (pid
)).c_str (),
5820 case PACKET_UNKNOWN
:
5821 error (_("This target does not support attaching to a process"));
5823 error (_("Attaching to %s failed"),
5824 target_pid_to_str (ptid_t (pid
)).c_str ());
5827 set_current_inferior (remote_add_inferior (false, pid
, 1, 0));
5829 inferior_ptid
= ptid_t (pid
);
5831 if (target_is_non_stop_p ())
5833 struct thread_info
*thread
;
5835 /* Get list of threads. */
5836 update_thread_list ();
5838 thread
= first_thread_of_inferior (current_inferior ());
5840 inferior_ptid
= thread
->ptid
;
5842 inferior_ptid
= ptid_t (pid
);
5844 /* Invalidate our notion of the remote current thread. */
5845 record_currthread (rs
, minus_one_ptid
);
5849 /* Now, if we have thread information, update inferior_ptid. */
5850 inferior_ptid
= remote_current_thread (inferior_ptid
);
5852 /* Add the main thread to the thread list. */
5853 thread_info
*thr
= add_thread_silent (inferior_ptid
);
5854 /* Don't consider the thread stopped until we've processed the
5855 saved stop reply. */
5856 set_executing (thr
->ptid
, true);
5859 /* Next, if the target can specify a description, read it. We do
5860 this before anything involving memory or registers. */
5861 target_find_description ();
5863 if (!target_is_non_stop_p ())
5865 /* Use the previously fetched status. */
5866 gdb_assert (wait_status
!= NULL
);
5868 if (target_can_async_p ())
5870 struct notif_event
*reply
5871 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
5873 push_stop_reply ((struct stop_reply
*) reply
);
5879 gdb_assert (wait_status
!= NULL
);
5880 strcpy (rs
->buf
.data (), wait_status
);
5881 rs
->cached_wait_status
= 1;
5885 gdb_assert (wait_status
== NULL
);
5888 /* Implementation of the to_post_attach method. */
5891 extended_remote_target::post_attach (int pid
)
5893 /* Get text, data & bss offsets. */
5896 /* In certain cases GDB might not have had the chance to start
5897 symbol lookup up until now. This could happen if the debugged
5898 binary is not using shared libraries, the vsyscall page is not
5899 present (on Linux) and the binary itself hadn't changed since the
5900 debugging process was started. */
5901 if (symfile_objfile
!= NULL
)
5902 remote_check_symbols();
5906 /* Check for the availability of vCont. This function should also check
5910 remote_target::remote_vcont_probe ()
5912 remote_state
*rs
= get_remote_state ();
5915 strcpy (rs
->buf
.data (), "vCont?");
5917 getpkt (&rs
->buf
, 0);
5918 buf
= rs
->buf
.data ();
5920 /* Make sure that the features we assume are supported. */
5921 if (startswith (buf
, "vCont"))
5924 int support_c
, support_C
;
5926 rs
->supports_vCont
.s
= 0;
5927 rs
->supports_vCont
.S
= 0;
5930 rs
->supports_vCont
.t
= 0;
5931 rs
->supports_vCont
.r
= 0;
5932 while (p
&& *p
== ';')
5935 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5936 rs
->supports_vCont
.s
= 1;
5937 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5938 rs
->supports_vCont
.S
= 1;
5939 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5941 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5943 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5944 rs
->supports_vCont
.t
= 1;
5945 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5946 rs
->supports_vCont
.r
= 1;
5948 p
= strchr (p
, ';');
5951 /* If c, and C are not all supported, we can't use vCont. Clearing
5952 BUF will make packet_ok disable the packet. */
5953 if (!support_c
|| !support_C
)
5957 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
5960 /* Helper function for building "vCont" resumptions. Write a
5961 resumption to P. ENDP points to one-passed-the-end of the buffer
5962 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
5963 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5964 resumed thread should be single-stepped and/or signalled. If PTID
5965 equals minus_one_ptid, then all threads are resumed; if PTID
5966 represents a process, then all threads of the process are resumed;
5967 the thread to be stepped and/or signalled is given in the global
5971 remote_target::append_resumption (char *p
, char *endp
,
5972 ptid_t ptid
, int step
, gdb_signal siggnal
)
5974 struct remote_state
*rs
= get_remote_state ();
5976 if (step
&& siggnal
!= GDB_SIGNAL_0
)
5977 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
5979 /* GDB is willing to range step. */
5980 && use_range_stepping
5981 /* Target supports range stepping. */
5982 && rs
->supports_vCont
.r
5983 /* We don't currently support range stepping multiple
5984 threads with a wildcard (though the protocol allows it,
5985 so stubs shouldn't make an active effort to forbid
5987 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
5989 struct thread_info
*tp
;
5991 if (ptid
== minus_one_ptid
)
5993 /* If we don't know about the target thread's tid, then
5994 we're resuming magic_null_ptid (see caller). */
5995 tp
= find_thread_ptid (magic_null_ptid
);
5998 tp
= find_thread_ptid (ptid
);
5999 gdb_assert (tp
!= NULL
);
6001 if (tp
->control
.may_range_step
)
6003 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6005 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6006 phex_nz (tp
->control
.step_range_start
,
6008 phex_nz (tp
->control
.step_range_end
,
6012 p
+= xsnprintf (p
, endp
- p
, ";s");
6015 p
+= xsnprintf (p
, endp
- p
, ";s");
6016 else if (siggnal
!= GDB_SIGNAL_0
)
6017 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6019 p
+= xsnprintf (p
, endp
- p
, ";c");
6021 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6025 /* All (-1) threads of process. */
6026 nptid
= ptid_t (ptid
.pid (), -1, 0);
6028 p
+= xsnprintf (p
, endp
- p
, ":");
6029 p
= write_ptid (p
, endp
, nptid
);
6031 else if (ptid
!= minus_one_ptid
)
6033 p
+= xsnprintf (p
, endp
- p
, ":");
6034 p
= write_ptid (p
, endp
, ptid
);
6040 /* Clear the thread's private info on resume. */
6043 resume_clear_thread_private_info (struct thread_info
*thread
)
6045 if (thread
->priv
!= NULL
)
6047 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6049 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6050 priv
->watch_data_address
= 0;
6054 /* Append a vCont continue-with-signal action for threads that have a
6055 non-zero stop signal. */
6058 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6061 for (thread_info
*thread
: all_non_exited_threads (ptid
))
6062 if (inferior_ptid
!= thread
->ptid
6063 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6065 p
= append_resumption (p
, endp
, thread
->ptid
,
6066 0, thread
->suspend
.stop_signal
);
6067 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6068 resume_clear_thread_private_info (thread
);
6074 /* Set the target running, using the packets that use Hc
6078 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6081 struct remote_state
*rs
= get_remote_state ();
6084 rs
->last_sent_signal
= siggnal
;
6085 rs
->last_sent_step
= step
;
6087 /* The c/s/C/S resume packets use Hc, so set the continue
6089 if (ptid
== minus_one_ptid
)
6090 set_continue_thread (any_thread_ptid
);
6092 set_continue_thread (ptid
);
6094 for (thread_info
*thread
: all_non_exited_threads ())
6095 resume_clear_thread_private_info (thread
);
6097 buf
= rs
->buf
.data ();
6098 if (::execution_direction
== EXEC_REVERSE
)
6100 /* We don't pass signals to the target in reverse exec mode. */
6101 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6102 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6105 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6106 error (_("Remote reverse-step not supported."));
6107 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6108 error (_("Remote reverse-continue not supported."));
6110 strcpy (buf
, step
? "bs" : "bc");
6112 else if (siggnal
!= GDB_SIGNAL_0
)
6114 buf
[0] = step
? 'S' : 'C';
6115 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6116 buf
[2] = tohex (((int) siggnal
) & 0xf);
6120 strcpy (buf
, step
? "s" : "c");
6125 /* Resume the remote inferior by using a "vCont" packet. The thread
6126 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6127 resumed thread should be single-stepped and/or signalled. If PTID
6128 equals minus_one_ptid, then all threads are resumed; the thread to
6129 be stepped and/or signalled is given in the global INFERIOR_PTID.
6130 This function returns non-zero iff it resumes the inferior.
6132 This function issues a strict subset of all possible vCont commands
6136 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6137 enum gdb_signal siggnal
)
6139 struct remote_state
*rs
= get_remote_state ();
6143 /* No reverse execution actions defined for vCont. */
6144 if (::execution_direction
== EXEC_REVERSE
)
6147 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6148 remote_vcont_probe ();
6150 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6153 p
= rs
->buf
.data ();
6154 endp
= p
+ get_remote_packet_size ();
6156 /* If we could generate a wider range of packets, we'd have to worry
6157 about overflowing BUF. Should there be a generic
6158 "multi-part-packet" packet? */
6160 p
+= xsnprintf (p
, endp
- p
, "vCont");
6162 if (ptid
== magic_null_ptid
)
6164 /* MAGIC_NULL_PTID means that we don't have any active threads,
6165 so we don't have any TID numbers the inferior will
6166 understand. Make sure to only send forms that do not specify
6168 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6170 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6172 /* Resume all threads (of all processes, or of a single
6173 process), with preference for INFERIOR_PTID. This assumes
6174 inferior_ptid belongs to the set of all threads we are about
6176 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6178 /* Step inferior_ptid, with or without signal. */
6179 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6182 /* Also pass down any pending signaled resumption for other
6183 threads not the current. */
6184 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6186 /* And continue others without a signal. */
6187 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6191 /* Scheduler locking; resume only PTID. */
6192 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6195 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6198 if (target_is_non_stop_p ())
6200 /* In non-stop, the stub replies to vCont with "OK". The stop
6201 reply will be reported asynchronously by means of a `%Stop'
6203 getpkt (&rs
->buf
, 0);
6204 if (strcmp (rs
->buf
.data (), "OK") != 0)
6205 error (_("Unexpected vCont reply in non-stop mode: %s"),
6212 /* Tell the remote machine to resume. */
6215 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6217 struct remote_state
*rs
= get_remote_state ();
6219 /* When connected in non-stop mode, the core resumes threads
6220 individually. Resuming remote threads directly in target_resume
6221 would thus result in sending one packet per thread. Instead, to
6222 minimize roundtrip latency, here we just store the resume
6223 request; the actual remote resumption will be done in
6224 target_commit_resume / remote_commit_resume, where we'll be able
6225 to do vCont action coalescing. */
6226 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6228 remote_thread_info
*remote_thr
;
6230 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6231 remote_thr
= get_remote_thread_info (inferior_ptid
);
6233 remote_thr
= get_remote_thread_info (ptid
);
6235 remote_thr
->last_resume_step
= step
;
6236 remote_thr
->last_resume_sig
= siggnal
;
6240 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6241 (explained in remote-notif.c:handle_notification) so
6242 remote_notif_process is not called. We need find a place where
6243 it is safe to start a 'vNotif' sequence. It is good to do it
6244 before resuming inferior, because inferior was stopped and no RSP
6245 traffic at that moment. */
6246 if (!target_is_non_stop_p ())
6247 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6249 rs
->last_resume_exec_dir
= ::execution_direction
;
6251 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6252 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6253 remote_resume_with_hc (ptid
, step
, siggnal
);
6255 /* We are about to start executing the inferior, let's register it
6256 with the event loop. NOTE: this is the one place where all the
6257 execution commands end up. We could alternatively do this in each
6258 of the execution commands in infcmd.c. */
6259 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6260 into infcmd.c in order to allow inferior function calls to work
6261 NOT asynchronously. */
6262 if (target_can_async_p ())
6265 /* We've just told the target to resume. The remote server will
6266 wait for the inferior to stop, and then send a stop reply. In
6267 the mean time, we can't start another command/query ourselves
6268 because the stub wouldn't be ready to process it. This applies
6269 only to the base all-stop protocol, however. In non-stop (which
6270 only supports vCont), the stub replies with an "OK", and is
6271 immediate able to process further serial input. */
6272 if (!target_is_non_stop_p ())
6273 rs
->waiting_for_stop_reply
= 1;
6276 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6278 /* Private per-inferior info for target remote processes. */
6280 struct remote_inferior
: public private_inferior
6282 /* Whether we can send a wildcard vCont for this process. */
6283 bool may_wildcard_vcont
= true;
6286 /* Get the remote private inferior data associated to INF. */
6288 static remote_inferior
*
6289 get_remote_inferior (inferior
*inf
)
6291 if (inf
->priv
== NULL
)
6292 inf
->priv
.reset (new remote_inferior
);
6294 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6297 /* Class used to track the construction of a vCont packet in the
6298 outgoing packet buffer. This is used to send multiple vCont
6299 packets if we have more actions than would fit a single packet. */
6304 explicit vcont_builder (remote_target
*remote
)
6311 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6316 /* The remote target. */
6317 remote_target
*m_remote
;
6319 /* Pointer to the first action. P points here if no action has been
6321 char *m_first_action
;
6323 /* Where the next action will be appended. */
6326 /* The end of the buffer. Must never write past this. */
6330 /* Prepare the outgoing buffer for a new vCont packet. */
6333 vcont_builder::restart ()
6335 struct remote_state
*rs
= m_remote
->get_remote_state ();
6337 m_p
= rs
->buf
.data ();
6338 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6339 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6340 m_first_action
= m_p
;
6343 /* If the vCont packet being built has any action, send it to the
6347 vcont_builder::flush ()
6349 struct remote_state
*rs
;
6351 if (m_p
== m_first_action
)
6354 rs
= m_remote
->get_remote_state ();
6355 m_remote
->putpkt (rs
->buf
);
6356 m_remote
->getpkt (&rs
->buf
, 0);
6357 if (strcmp (rs
->buf
.data (), "OK") != 0)
6358 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6361 /* The largest action is range-stepping, with its two addresses. This
6362 is more than sufficient. If a new, bigger action is created, it'll
6363 quickly trigger a failed assertion in append_resumption (and we'll
6365 #define MAX_ACTION_SIZE 200
6367 /* Append a new vCont action in the outgoing packet being built. If
6368 the action doesn't fit the packet along with previous actions, push
6369 what we've got so far to the remote end and start over a new vCont
6370 packet (with the new action). */
6373 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6375 char buf
[MAX_ACTION_SIZE
+ 1];
6377 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6378 ptid
, step
, siggnal
);
6380 /* Check whether this new action would fit in the vCont packet along
6381 with previous actions. If not, send what we've got so far and
6382 start a new vCont packet. */
6383 size_t rsize
= endp
- buf
;
6384 if (rsize
> m_endp
- m_p
)
6389 /* Should now fit. */
6390 gdb_assert (rsize
<= m_endp
- m_p
);
6393 memcpy (m_p
, buf
, rsize
);
6398 /* to_commit_resume implementation. */
6401 remote_target::commit_resume ()
6403 int any_process_wildcard
;
6404 int may_global_wildcard_vcont
;
6406 /* If connected in all-stop mode, we'd send the remote resume
6407 request directly from remote_resume. Likewise if
6408 reverse-debugging, as there are no defined vCont actions for
6409 reverse execution. */
6410 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6413 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6414 instead of resuming all threads of each process individually.
6415 However, if any thread of a process must remain halted, we can't
6416 send wildcard resumes and must send one action per thread.
6418 Care must be taken to not resume threads/processes the server
6419 side already told us are stopped, but the core doesn't know about
6420 yet, because the events are still in the vStopped notification
6423 #1 => vCont s:p1.1;c
6425 #3 <= %Stopped T05 p1.1
6430 #8 (infrun handles the stop for p1.1 and continues stepping)
6431 #9 => vCont s:p1.1;c
6433 The last vCont above would resume thread p1.2 by mistake, because
6434 the server has no idea that the event for p1.2 had not been
6437 The server side must similarly ignore resume actions for the
6438 thread that has a pending %Stopped notification (and any other
6439 threads with events pending), until GDB acks the notification
6440 with vStopped. Otherwise, e.g., the following case is
6443 #1 => g (or any other packet)
6445 #3 <= %Stopped T05 p1.2
6446 #4 => vCont s:p1.1;c
6449 Above, the server must not resume thread p1.2. GDB can't know
6450 that p1.2 stopped until it acks the %Stopped notification, and
6451 since from GDB's perspective all threads should be running, it
6454 Finally, special care must also be given to handling fork/vfork
6455 events. A (v)fork event actually tells us that two processes
6456 stopped -- the parent and the child. Until we follow the fork,
6457 we must not resume the child. Therefore, if we have a pending
6458 fork follow, we must not send a global wildcard resume action
6459 (vCont;c). We can still send process-wide wildcards though. */
6461 /* Start by assuming a global wildcard (vCont;c) is possible. */
6462 may_global_wildcard_vcont
= 1;
6464 /* And assume every process is individually wildcard-able too. */
6465 for (inferior
*inf
: all_non_exited_inferiors ())
6467 remote_inferior
*priv
= get_remote_inferior (inf
);
6469 priv
->may_wildcard_vcont
= true;
6472 /* Check for any pending events (not reported or processed yet) and
6473 disable process and global wildcard resumes appropriately. */
6474 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6476 for (thread_info
*tp
: all_non_exited_threads ())
6478 /* If a thread of a process is not meant to be resumed, then we
6479 can't wildcard that process. */
6482 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6484 /* And if we can't wildcard a process, we can't wildcard
6485 everything either. */
6486 may_global_wildcard_vcont
= 0;
6490 /* If a thread is the parent of an unfollowed fork, then we
6491 can't do a global wildcard, as that would resume the fork
6493 if (is_pending_fork_parent_thread (tp
))
6494 may_global_wildcard_vcont
= 0;
6497 /* Now let's build the vCont packet(s). Actions must be appended
6498 from narrower to wider scopes (thread -> process -> global). If
6499 we end up with too many actions for a single packet vcont_builder
6500 flushes the current vCont packet to the remote side and starts a
6502 struct vcont_builder
vcont_builder (this);
6504 /* Threads first. */
6505 for (thread_info
*tp
: all_non_exited_threads ())
6507 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6509 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6512 gdb_assert (!thread_is_in_step_over_chain (tp
));
6514 if (!remote_thr
->last_resume_step
6515 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6516 && get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6518 /* We'll send a wildcard resume instead. */
6519 remote_thr
->vcont_resumed
= 1;
6523 vcont_builder
.push_action (tp
->ptid
,
6524 remote_thr
->last_resume_step
,
6525 remote_thr
->last_resume_sig
);
6526 remote_thr
->vcont_resumed
= 1;
6529 /* Now check whether we can send any process-wide wildcard. This is
6530 to avoid sending a global wildcard in the case nothing is
6531 supposed to be resumed. */
6532 any_process_wildcard
= 0;
6534 for (inferior
*inf
: all_non_exited_inferiors ())
6536 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6538 any_process_wildcard
= 1;
6543 if (any_process_wildcard
)
6545 /* If all processes are wildcard-able, then send a single "c"
6546 action, otherwise, send an "all (-1) threads of process"
6547 continue action for each running process, if any. */
6548 if (may_global_wildcard_vcont
)
6550 vcont_builder
.push_action (minus_one_ptid
,
6551 false, GDB_SIGNAL_0
);
6555 for (inferior
*inf
: all_non_exited_inferiors ())
6557 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6559 vcont_builder
.push_action (ptid_t (inf
->pid
),
6560 false, GDB_SIGNAL_0
);
6566 vcont_builder
.flush ();
6571 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6572 thread, all threads of a remote process, or all threads of all
6576 remote_target::remote_stop_ns (ptid_t ptid
)
6578 struct remote_state
*rs
= get_remote_state ();
6579 char *p
= rs
->buf
.data ();
6580 char *endp
= p
+ get_remote_packet_size ();
6582 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6583 remote_vcont_probe ();
6585 if (!rs
->supports_vCont
.t
)
6586 error (_("Remote server does not support stopping threads"));
6588 if (ptid
== minus_one_ptid
6589 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6590 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6595 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6598 /* All (-1) threads of process. */
6599 nptid
= ptid_t (ptid
.pid (), -1, 0);
6602 /* Small optimization: if we already have a stop reply for
6603 this thread, no use in telling the stub we want this
6605 if (peek_stop_reply (ptid
))
6611 write_ptid (p
, endp
, nptid
);
6614 /* In non-stop, we get an immediate OK reply. The stop reply will
6615 come in asynchronously by notification. */
6617 getpkt (&rs
->buf
, 0);
6618 if (strcmp (rs
->buf
.data (), "OK") != 0)
6619 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6623 /* All-stop version of target_interrupt. Sends a break or a ^C to
6624 interrupt the remote target. It is undefined which thread of which
6625 process reports the interrupt. */
6628 remote_target::remote_interrupt_as ()
6630 struct remote_state
*rs
= get_remote_state ();
6632 rs
->ctrlc_pending_p
= 1;
6634 /* If the inferior is stopped already, but the core didn't know
6635 about it yet, just ignore the request. The cached wait status
6636 will be collected in remote_wait. */
6637 if (rs
->cached_wait_status
)
6640 /* Send interrupt_sequence to remote target. */
6641 send_interrupt_sequence ();
6644 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6645 the remote target. It is undefined which thread of which process
6646 reports the interrupt. Throws an error if the packet is not
6647 supported by the server. */
6650 remote_target::remote_interrupt_ns ()
6652 struct remote_state
*rs
= get_remote_state ();
6653 char *p
= rs
->buf
.data ();
6654 char *endp
= p
+ get_remote_packet_size ();
6656 xsnprintf (p
, endp
- p
, "vCtrlC");
6658 /* In non-stop, we get an immediate OK reply. The stop reply will
6659 come in asynchronously by notification. */
6661 getpkt (&rs
->buf
, 0);
6663 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6667 case PACKET_UNKNOWN
:
6668 error (_("No support for interrupting the remote target."));
6670 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6674 /* Implement the to_stop function for the remote targets. */
6677 remote_target::stop (ptid_t ptid
)
6680 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6682 if (target_is_non_stop_p ())
6683 remote_stop_ns (ptid
);
6686 /* We don't currently have a way to transparently pause the
6687 remote target in all-stop mode. Interrupt it instead. */
6688 remote_interrupt_as ();
6692 /* Implement the to_interrupt function for the remote targets. */
6695 remote_target::interrupt ()
6698 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6700 if (target_is_non_stop_p ())
6701 remote_interrupt_ns ();
6703 remote_interrupt_as ();
6706 /* Implement the to_pass_ctrlc function for the remote targets. */
6709 remote_target::pass_ctrlc ()
6711 struct remote_state
*rs
= get_remote_state ();
6714 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6716 /* If we're starting up, we're not fully synced yet. Quit
6718 if (rs
->starting_up
)
6720 /* If ^C has already been sent once, offer to disconnect. */
6721 else if (rs
->ctrlc_pending_p
)
6724 target_interrupt ();
6727 /* Ask the user what to do when an interrupt is received. */
6730 remote_target::interrupt_query ()
6732 struct remote_state
*rs
= get_remote_state ();
6734 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6736 if (query (_("The target is not responding to interrupt requests.\n"
6737 "Stop debugging it? ")))
6739 remote_unpush_target ();
6740 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6745 if (query (_("Interrupted while waiting for the program.\n"
6746 "Give up waiting? ")))
6751 /* Enable/disable target terminal ownership. Most targets can use
6752 terminal groups to control terminal ownership. Remote targets are
6753 different in that explicit transfer of ownership to/from GDB/target
6757 remote_target::terminal_inferior ()
6759 /* NOTE: At this point we could also register our selves as the
6760 recipient of all input. Any characters typed could then be
6761 passed on down to the target. */
6765 remote_target::terminal_ours ()
6770 remote_console_output (const char *msg
)
6774 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6777 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6781 fputs_unfiltered (tb
, gdb_stdtarg
);
6783 gdb_flush (gdb_stdtarg
);
6786 struct stop_reply
: public notif_event
6790 /* The identifier of the thread about this event */
6793 /* The remote state this event is associated with. When the remote
6794 connection, represented by a remote_state object, is closed,
6795 all the associated stop_reply events should be released. */
6796 struct remote_state
*rs
;
6798 struct target_waitstatus ws
;
6800 /* The architecture associated with the expedited registers. */
6803 /* Expedited registers. This makes remote debugging a bit more
6804 efficient for those targets that provide critical registers as
6805 part of their normal status mechanism (as another roundtrip to
6806 fetch them is avoided). */
6807 std::vector
<cached_reg_t
> regcache
;
6809 enum target_stop_reason stop_reason
;
6811 CORE_ADDR watch_data_address
;
6816 /* Return the length of the stop reply queue. */
6819 remote_target::stop_reply_queue_length ()
6821 remote_state
*rs
= get_remote_state ();
6822 return rs
->stop_reply_queue
.size ();
6826 remote_notif_stop_parse (remote_target
*remote
,
6827 struct notif_client
*self
, const char *buf
,
6828 struct notif_event
*event
)
6830 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6834 remote_notif_stop_ack (remote_target
*remote
,
6835 struct notif_client
*self
, const char *buf
,
6836 struct notif_event
*event
)
6838 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6841 putpkt (remote
, self
->ack_command
);
6843 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6845 /* We got an unknown stop reply. */
6846 error (_("Unknown stop reply"));
6849 remote
->push_stop_reply (stop_reply
);
6853 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
6854 struct notif_client
*self
)
6856 /* We can't get pending events in remote_notif_process for
6857 notification stop, and we have to do this in remote_wait_ns
6858 instead. If we fetch all queued events from stub, remote stub
6859 may exit and we have no chance to process them back in
6861 remote_state
*rs
= remote
->get_remote_state ();
6862 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
6866 stop_reply::~stop_reply ()
6868 for (cached_reg_t
®
: regcache
)
6872 static notif_event_up
6873 remote_notif_stop_alloc_reply ()
6875 return notif_event_up (new struct stop_reply ());
6878 /* A client of notification Stop. */
6880 struct notif_client notif_client_stop
=
6884 remote_notif_stop_parse
,
6885 remote_notif_stop_ack
,
6886 remote_notif_stop_can_get_pending_events
,
6887 remote_notif_stop_alloc_reply
,
6891 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6892 the pid of the process that owns the threads we want to check, or
6893 -1 if we want to check all threads. */
6896 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6899 if (ws
->kind
== TARGET_WAITKIND_FORKED
6900 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6902 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
6909 /* Return the thread's pending status used to determine whether the
6910 thread is a fork parent stopped at a fork event. */
6912 static struct target_waitstatus
*
6913 thread_pending_fork_status (struct thread_info
*thread
)
6915 if (thread
->suspend
.waitstatus_pending_p
)
6916 return &thread
->suspend
.waitstatus
;
6918 return &thread
->pending_follow
;
6921 /* Determine if THREAD is a pending fork parent thread. */
6924 is_pending_fork_parent_thread (struct thread_info
*thread
)
6926 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6929 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6932 /* If CONTEXT contains any fork child threads that have not been
6933 reported yet, remove them from the CONTEXT list. If such a
6934 thread exists it is because we are stopped at a fork catchpoint
6935 and have not yet called follow_fork, which will set up the
6936 host-side data structures for the new process. */
6939 remote_target::remove_new_fork_children (threads_listing_context
*context
)
6942 struct notif_client
*notif
= ¬if_client_stop
;
6944 /* For any threads stopped at a fork event, remove the corresponding
6945 fork child threads from the CONTEXT list. */
6946 for (thread_info
*thread
: all_non_exited_threads ())
6948 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6950 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
6951 context
->remove_thread (ws
->value
.related_pid
);
6954 /* Check for any pending fork events (not reported or processed yet)
6955 in process PID and remove those fork child threads from the
6956 CONTEXT list as well. */
6957 remote_notif_get_pending_events (notif
);
6958 for (auto &event
: get_remote_state ()->stop_reply_queue
)
6959 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6960 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
6961 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
6962 context
->remove_thread (event
->ws
.value
.related_pid
);
6965 /* Check whether any event pending in the vStopped queue would prevent
6966 a global or process wildcard vCont action. Clear
6967 *may_global_wildcard if we can't do a global wildcard (vCont;c),
6968 and clear the event inferior's may_wildcard_vcont flag if we can't
6969 do a process-wide wildcard resume (vCont;c:pPID.-1). */
6972 remote_target::check_pending_events_prevent_wildcard_vcont
6973 (int *may_global_wildcard
)
6975 struct notif_client
*notif
= ¬if_client_stop
;
6977 remote_notif_get_pending_events (notif
);
6978 for (auto &event
: get_remote_state ()->stop_reply_queue
)
6980 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
6981 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
6984 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6985 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
6986 *may_global_wildcard
= 0;
6988 struct inferior
*inf
= find_inferior_ptid (event
->ptid
);
6990 /* This may be the first time we heard about this process.
6991 Regardless, we must not do a global wildcard resume, otherwise
6992 we'd resume this process too. */
6993 *may_global_wildcard
= 0;
6995 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
6999 /* Discard all pending stop replies of inferior INF. */
7002 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7004 struct stop_reply
*reply
;
7005 struct remote_state
*rs
= get_remote_state ();
7006 struct remote_notif_state
*rns
= rs
->notif_state
;
7008 /* This function can be notified when an inferior exists. When the
7009 target is not remote, the notification state is NULL. */
7010 if (rs
->remote_desc
== NULL
)
7013 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7015 /* Discard the in-flight notification. */
7016 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7019 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7022 /* Discard the stop replies we have already pulled with
7024 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7025 rs
->stop_reply_queue
.end (),
7026 [=] (const stop_reply_up
&event
)
7028 return event
->ptid
.pid () == inf
->pid
;
7030 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7033 /* Discard the stop replies for RS in stop_reply_queue. */
7036 remote_target::discard_pending_stop_replies_in_queue ()
7038 remote_state
*rs
= get_remote_state ();
7040 /* Discard the stop replies we have already pulled with
7042 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7043 rs
->stop_reply_queue
.end (),
7044 [=] (const stop_reply_up
&event
)
7046 return event
->rs
== rs
;
7048 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7051 /* Remove the first reply in 'stop_reply_queue' which matches
7055 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7057 remote_state
*rs
= get_remote_state ();
7059 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7060 rs
->stop_reply_queue
.end (),
7061 [=] (const stop_reply_up
&event
)
7063 return event
->ptid
.matches (ptid
);
7065 struct stop_reply
*result
;
7066 if (iter
== rs
->stop_reply_queue
.end ())
7070 result
= iter
->release ();
7071 rs
->stop_reply_queue
.erase (iter
);
7075 fprintf_unfiltered (gdb_stdlog
,
7076 "notif: discard queued event: 'Stop' in %s\n",
7077 target_pid_to_str (ptid
).c_str ());
7082 /* Look for a queued stop reply belonging to PTID. If one is found,
7083 remove it from the queue, and return it. Returns NULL if none is
7084 found. If there are still queued events left to process, tell the
7085 event loop to get back to target_wait soon. */
7088 remote_target::queued_stop_reply (ptid_t ptid
)
7090 remote_state
*rs
= get_remote_state ();
7091 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7093 if (!rs
->stop_reply_queue
.empty ())
7095 /* There's still at least an event left. */
7096 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7102 /* Push a fully parsed stop reply in the stop reply queue. Since we
7103 know that we now have at least one queued event left to pass to the
7104 core side, tell the event loop to get back to target_wait soon. */
7107 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7109 remote_state
*rs
= get_remote_state ();
7110 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7113 fprintf_unfiltered (gdb_stdlog
,
7114 "notif: push 'Stop' %s to queue %d\n",
7115 target_pid_to_str (new_event
->ptid
).c_str (),
7116 int (rs
->stop_reply_queue
.size ()));
7118 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7121 /* Returns true if we have a stop reply for PTID. */
7124 remote_target::peek_stop_reply (ptid_t ptid
)
7126 remote_state
*rs
= get_remote_state ();
7127 for (auto &event
: rs
->stop_reply_queue
)
7128 if (ptid
== event
->ptid
7129 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7134 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7135 starting with P and ending with PEND matches PREFIX. */
7138 strprefix (const char *p
, const char *pend
, const char *prefix
)
7140 for ( ; p
< pend
; p
++, prefix
++)
7143 return *prefix
== '\0';
7146 /* Parse the stop reply in BUF. Either the function succeeds, and the
7147 result is stored in EVENT, or throws an error. */
7150 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7152 remote_arch_state
*rsa
= NULL
;
7157 event
->ptid
= null_ptid
;
7158 event
->rs
= get_remote_state ();
7159 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7160 event
->ws
.value
.integer
= 0;
7161 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7162 event
->regcache
.clear ();
7167 case 'T': /* Status with PC, SP, FP, ... */
7168 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7169 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7171 n... = register number
7172 r... = register contents
7175 p
= &buf
[3]; /* after Txx */
7181 p1
= strchr (p
, ':');
7183 error (_("Malformed packet(a) (missing colon): %s\n\
7187 error (_("Malformed packet(a) (missing register number): %s\n\
7191 /* Some "registers" are actually extended stop information.
7192 Note if you're adding a new entry here: GDB 7.9 and
7193 earlier assume that all register "numbers" that start
7194 with an hex digit are real register numbers. Make sure
7195 the server only sends such a packet if it knows the
7196 client understands it. */
7198 if (strprefix (p
, p1
, "thread"))
7199 event
->ptid
= read_ptid (++p1
, &p
);
7200 else if (strprefix (p
, p1
, "syscall_entry"))
7204 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7205 p
= unpack_varlen_hex (++p1
, &sysno
);
7206 event
->ws
.value
.syscall_number
= (int) sysno
;
7208 else if (strprefix (p
, p1
, "syscall_return"))
7212 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7213 p
= unpack_varlen_hex (++p1
, &sysno
);
7214 event
->ws
.value
.syscall_number
= (int) sysno
;
7216 else if (strprefix (p
, p1
, "watch")
7217 || strprefix (p
, p1
, "rwatch")
7218 || strprefix (p
, p1
, "awatch"))
7220 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7221 p
= unpack_varlen_hex (++p1
, &addr
);
7222 event
->watch_data_address
= (CORE_ADDR
) addr
;
7224 else if (strprefix (p
, p1
, "swbreak"))
7226 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7228 /* Make sure the stub doesn't forget to indicate support
7230 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7231 error (_("Unexpected swbreak stop reason"));
7233 /* The value part is documented as "must be empty",
7234 though we ignore it, in case we ever decide to make
7235 use of it in a backward compatible way. */
7236 p
= strchrnul (p1
+ 1, ';');
7238 else if (strprefix (p
, p1
, "hwbreak"))
7240 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7242 /* Make sure the stub doesn't forget to indicate support
7244 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7245 error (_("Unexpected hwbreak stop reason"));
7248 p
= strchrnul (p1
+ 1, ';');
7250 else if (strprefix (p
, p1
, "library"))
7252 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7253 p
= strchrnul (p1
+ 1, ';');
7255 else if (strprefix (p
, p1
, "replaylog"))
7257 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7258 /* p1 will indicate "begin" or "end", but it makes
7259 no difference for now, so ignore it. */
7260 p
= strchrnul (p1
+ 1, ';');
7262 else if (strprefix (p
, p1
, "core"))
7266 p
= unpack_varlen_hex (++p1
, &c
);
7269 else if (strprefix (p
, p1
, "fork"))
7271 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7272 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7274 else if (strprefix (p
, p1
, "vfork"))
7276 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7277 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7279 else if (strprefix (p
, p1
, "vforkdone"))
7281 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7282 p
= strchrnul (p1
+ 1, ';');
7284 else if (strprefix (p
, p1
, "exec"))
7289 /* Determine the length of the execd pathname. */
7290 p
= unpack_varlen_hex (++p1
, &ignored
);
7291 pathlen
= (p
- p1
) / 2;
7293 /* Save the pathname for event reporting and for
7294 the next run command. */
7295 gdb::unique_xmalloc_ptr
<char[]> pathname
7296 ((char *) xmalloc (pathlen
+ 1));
7297 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7298 pathname
[pathlen
] = '\0';
7300 /* This is freed during event handling. */
7301 event
->ws
.value
.execd_pathname
= pathname
.release ();
7302 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7304 /* Skip the registers included in this packet, since
7305 they may be for an architecture different from the
7306 one used by the original program. */
7309 else if (strprefix (p
, p1
, "create"))
7311 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7312 p
= strchrnul (p1
+ 1, ';');
7321 p
= strchrnul (p1
+ 1, ';');
7326 /* Maybe a real ``P'' register number. */
7327 p_temp
= unpack_varlen_hex (p
, &pnum
);
7328 /* If the first invalid character is the colon, we got a
7329 register number. Otherwise, it's an unknown stop
7333 /* If we haven't parsed the event's thread yet, find
7334 it now, in order to find the architecture of the
7335 reported expedited registers. */
7336 if (event
->ptid
== null_ptid
)
7338 const char *thr
= strstr (p1
+ 1, ";thread:");
7340 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7344 /* Either the current thread hasn't changed,
7345 or the inferior is not multi-threaded.
7346 The event must be for the thread we last
7347 set as (or learned as being) current. */
7348 event
->ptid
= event
->rs
->general_thread
;
7354 inferior
*inf
= (event
->ptid
== null_ptid
7356 : find_inferior_ptid (event
->ptid
));
7357 /* If this is the first time we learn anything
7358 about this process, skip the registers
7359 included in this packet, since we don't yet
7360 know which architecture to use to parse them.
7361 We'll determine the architecture later when
7362 we process the stop reply and retrieve the
7363 target description, via
7364 remote_notice_new_inferior ->
7365 post_create_inferior. */
7368 p
= strchrnul (p1
+ 1, ';');
7373 event
->arch
= inf
->gdbarch
;
7374 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7378 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7379 cached_reg_t cached_reg
;
7382 error (_("Remote sent bad register number %s: %s\n\
7384 hex_string (pnum
), p
, buf
);
7386 cached_reg
.num
= reg
->regnum
;
7387 cached_reg
.data
= (gdb_byte
*)
7388 xmalloc (register_size (event
->arch
, reg
->regnum
));
7391 fieldsize
= hex2bin (p
, cached_reg
.data
,
7392 register_size (event
->arch
, reg
->regnum
));
7394 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7395 warning (_("Remote reply is too short: %s"), buf
);
7397 event
->regcache
.push_back (cached_reg
);
7401 /* Not a number. Silently skip unknown optional
7403 p
= strchrnul (p1
+ 1, ';');
7408 error (_("Remote register badly formatted: %s\nhere: %s"),
7413 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7417 case 'S': /* Old style status, just signal only. */
7421 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7422 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7423 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7424 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7426 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7429 case 'w': /* Thread exited. */
7433 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7434 p
= unpack_varlen_hex (&buf
[1], &value
);
7435 event
->ws
.value
.integer
= value
;
7437 error (_("stop reply packet badly formatted: %s"), buf
);
7438 event
->ptid
= read_ptid (++p
, NULL
);
7441 case 'W': /* Target exited. */
7446 /* GDB used to accept only 2 hex chars here. Stubs should
7447 only send more if they detect GDB supports multi-process
7449 p
= unpack_varlen_hex (&buf
[1], &value
);
7453 /* The remote process exited. */
7454 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7455 event
->ws
.value
.integer
= value
;
7459 /* The remote process exited with a signal. */
7460 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7461 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7462 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7464 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7467 /* If no process is specified, return null_ptid, and let the
7468 caller figure out the right process to use. */
7478 else if (startswith (p
, "process:"))
7482 p
+= sizeof ("process:") - 1;
7483 unpack_varlen_hex (p
, &upid
);
7487 error (_("unknown stop reply packet: %s"), buf
);
7490 error (_("unknown stop reply packet: %s"), buf
);
7491 event
->ptid
= ptid_t (pid
);
7495 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7496 event
->ptid
= minus_one_ptid
;
7500 if (target_is_non_stop_p () && event
->ptid
== null_ptid
)
7501 error (_("No process or thread specified in stop reply: %s"), buf
);
7504 /* When the stub wants to tell GDB about a new notification reply, it
7505 sends a notification (%Stop, for example). Those can come it at
7506 any time, hence, we have to make sure that any pending
7507 putpkt/getpkt sequence we're making is finished, before querying
7508 the stub for more events with the corresponding ack command
7509 (vStopped, for example). E.g., if we started a vStopped sequence
7510 immediately upon receiving the notification, something like this
7518 1.6) <-- (registers reply to step #1.3)
7520 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7523 To solve this, whenever we parse a %Stop notification successfully,
7524 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7525 doing whatever we were doing:
7531 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7532 2.5) <-- (registers reply to step #2.3)
7534 Eventually after step #2.5, we return to the event loop, which
7535 notices there's an event on the
7536 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7537 associated callback --- the function below. At this point, we're
7538 always safe to start a vStopped sequence. :
7541 2.7) <-- T05 thread:2
7547 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7549 struct remote_state
*rs
= get_remote_state ();
7551 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7554 fprintf_unfiltered (gdb_stdlog
,
7555 "notif: process: '%s' ack pending event\n",
7559 nc
->ack (this, nc
, rs
->buf
.data (),
7560 rs
->notif_state
->pending_event
[nc
->id
]);
7561 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7565 getpkt (&rs
->buf
, 0);
7566 if (strcmp (rs
->buf
.data (), "OK") == 0)
7569 remote_notif_ack (this, nc
, rs
->buf
.data ());
7575 fprintf_unfiltered (gdb_stdlog
,
7576 "notif: process: '%s' no pending reply\n",
7581 /* Wrapper around remote_target::remote_notif_get_pending_events to
7582 avoid having to export the whole remote_target class. */
7585 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7587 remote
->remote_notif_get_pending_events (nc
);
7590 /* Called when it is decided that STOP_REPLY holds the info of the
7591 event that is to be returned to the core. This function always
7592 destroys STOP_REPLY. */
7595 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7596 struct target_waitstatus
*status
)
7600 *status
= stop_reply
->ws
;
7601 ptid
= stop_reply
->ptid
;
7603 /* If no thread/process was reported by the stub, assume the current
7605 if (ptid
== null_ptid
)
7606 ptid
= inferior_ptid
;
7608 if (status
->kind
!= TARGET_WAITKIND_EXITED
7609 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7610 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7612 /* Expedited registers. */
7613 if (!stop_reply
->regcache
.empty ())
7615 struct regcache
*regcache
7616 = get_thread_arch_regcache (ptid
, stop_reply
->arch
);
7618 for (cached_reg_t
®
: stop_reply
->regcache
)
7620 regcache
->raw_supply (reg
.num
, reg
.data
);
7624 stop_reply
->regcache
.clear ();
7627 remote_notice_new_inferior (ptid
, 0);
7628 remote_thread_info
*remote_thr
= get_remote_thread_info (ptid
);
7629 remote_thr
->core
= stop_reply
->core
;
7630 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7631 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7632 remote_thr
->vcont_resumed
= 0;
7639 /* The non-stop mode version of target_wait. */
7642 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7644 struct remote_state
*rs
= get_remote_state ();
7645 struct stop_reply
*stop_reply
;
7649 /* If in non-stop mode, get out of getpkt even if a
7650 notification is received. */
7652 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7655 if (ret
!= -1 && !is_notif
)
7658 case 'E': /* Error of some sort. */
7659 /* We're out of sync with the target now. Did it continue
7660 or not? We can't tell which thread it was in non-stop,
7661 so just ignore this. */
7662 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7664 case 'O': /* Console output. */
7665 remote_console_output (&rs
->buf
[1]);
7668 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7672 /* Acknowledge a pending stop reply that may have arrived in the
7674 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7675 remote_notif_get_pending_events (¬if_client_stop
);
7677 /* If indeed we noticed a stop reply, we're done. */
7678 stop_reply
= queued_stop_reply (ptid
);
7679 if (stop_reply
!= NULL
)
7680 return process_stop_reply (stop_reply
, status
);
7682 /* Still no event. If we're just polling for an event, then
7683 return to the event loop. */
7684 if (options
& TARGET_WNOHANG
)
7686 status
->kind
= TARGET_WAITKIND_IGNORE
;
7687 return minus_one_ptid
;
7690 /* Otherwise do a blocking wait. */
7691 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7695 /* Return the first resumed thread. */
7698 first_remote_resumed_thread ()
7700 for (thread_info
*tp
: all_non_exited_threads (minus_one_ptid
))
7706 /* Wait until the remote machine stops, then return, storing status in
7707 STATUS just as `wait' would. */
7710 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
, int options
)
7712 struct remote_state
*rs
= get_remote_state ();
7713 ptid_t event_ptid
= null_ptid
;
7715 struct stop_reply
*stop_reply
;
7719 status
->kind
= TARGET_WAITKIND_IGNORE
;
7720 status
->value
.integer
= 0;
7722 stop_reply
= queued_stop_reply (ptid
);
7723 if (stop_reply
!= NULL
)
7724 return process_stop_reply (stop_reply
, status
);
7726 if (rs
->cached_wait_status
)
7727 /* Use the cached wait status, but only once. */
7728 rs
->cached_wait_status
= 0;
7733 int forever
= ((options
& TARGET_WNOHANG
) == 0
7734 && rs
->wait_forever_enabled_p
);
7736 if (!rs
->waiting_for_stop_reply
)
7738 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7739 return minus_one_ptid
;
7742 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7743 _never_ wait for ever -> test on target_is_async_p().
7744 However, before we do that we need to ensure that the caller
7745 knows how to take the target into/out of async mode. */
7746 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
7748 /* GDB gets a notification. Return to core as this event is
7750 if (ret
!= -1 && is_notif
)
7751 return minus_one_ptid
;
7753 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7754 return minus_one_ptid
;
7757 buf
= rs
->buf
.data ();
7759 /* Assume that the target has acknowledged Ctrl-C unless we receive
7760 an 'F' or 'O' packet. */
7761 if (buf
[0] != 'F' && buf
[0] != 'O')
7762 rs
->ctrlc_pending_p
= 0;
7766 case 'E': /* Error of some sort. */
7767 /* We're out of sync with the target now. Did it continue or
7768 not? Not is more likely, so report a stop. */
7769 rs
->waiting_for_stop_reply
= 0;
7771 warning (_("Remote failure reply: %s"), buf
);
7772 status
->kind
= TARGET_WAITKIND_STOPPED
;
7773 status
->value
.sig
= GDB_SIGNAL_0
;
7775 case 'F': /* File-I/O request. */
7776 /* GDB may access the inferior memory while handling the File-I/O
7777 request, but we don't want GDB accessing memory while waiting
7778 for a stop reply. See the comments in putpkt_binary. Set
7779 waiting_for_stop_reply to 0 temporarily. */
7780 rs
->waiting_for_stop_reply
= 0;
7781 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
7782 rs
->ctrlc_pending_p
= 0;
7783 /* GDB handled the File-I/O request, and the target is running
7784 again. Keep waiting for events. */
7785 rs
->waiting_for_stop_reply
= 1;
7787 case 'N': case 'T': case 'S': case 'X': case 'W':
7789 /* There is a stop reply to handle. */
7790 rs
->waiting_for_stop_reply
= 0;
7793 = (struct stop_reply
*) remote_notif_parse (this,
7797 event_ptid
= process_stop_reply (stop_reply
, status
);
7800 case 'O': /* Console output. */
7801 remote_console_output (buf
+ 1);
7804 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7806 /* Zero length reply means that we tried 'S' or 'C' and the
7807 remote system doesn't support it. */
7808 target_terminal::ours_for_output ();
7810 ("Can't send signals to this remote system. %s not sent.\n",
7811 gdb_signal_to_name (rs
->last_sent_signal
));
7812 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7813 target_terminal::inferior ();
7815 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7821 warning (_("Invalid remote reply: %s"), buf
);
7825 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7826 return minus_one_ptid
;
7827 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7829 /* Nothing interesting happened. If we're doing a non-blocking
7830 poll, we're done. Otherwise, go back to waiting. */
7831 if (options
& TARGET_WNOHANG
)
7832 return minus_one_ptid
;
7836 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7837 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7839 if (event_ptid
!= null_ptid
)
7840 record_currthread (rs
, event_ptid
);
7842 event_ptid
= first_remote_resumed_thread ();
7846 /* A process exit. Invalidate our notion of current thread. */
7847 record_currthread (rs
, minus_one_ptid
);
7848 /* It's possible that the packet did not include a pid. */
7849 if (event_ptid
== null_ptid
)
7850 event_ptid
= first_remote_resumed_thread ();
7851 /* EVENT_PTID could still be NULL_PTID. Double-check. */
7852 if (event_ptid
== null_ptid
)
7853 event_ptid
= magic_null_ptid
;
7859 /* Wait until the remote machine stops, then return, storing status in
7860 STATUS just as `wait' would. */
7863 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7867 if (target_is_non_stop_p ())
7868 event_ptid
= wait_ns (ptid
, status
, options
);
7870 event_ptid
= wait_as (ptid
, status
, options
);
7872 if (target_is_async_p ())
7874 remote_state
*rs
= get_remote_state ();
7876 /* If there are are events left in the queue tell the event loop
7878 if (!rs
->stop_reply_queue
.empty ())
7879 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7885 /* Fetch a single register using a 'p' packet. */
7888 remote_target::fetch_register_using_p (struct regcache
*regcache
,
7891 struct gdbarch
*gdbarch
= regcache
->arch ();
7892 struct remote_state
*rs
= get_remote_state ();
7894 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7897 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7900 if (reg
->pnum
== -1)
7903 p
= rs
->buf
.data ();
7905 p
+= hexnumstr (p
, reg
->pnum
);
7908 getpkt (&rs
->buf
, 0);
7910 buf
= rs
->buf
.data ();
7912 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
7916 case PACKET_UNKNOWN
:
7919 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7920 gdbarch_register_name (regcache
->arch (),
7925 /* If this register is unfetchable, tell the regcache. */
7928 regcache
->raw_supply (reg
->regnum
, NULL
);
7932 /* Otherwise, parse and supply the value. */
7938 error (_("fetch_register_using_p: early buf termination"));
7940 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7943 regcache
->raw_supply (reg
->regnum
, regp
);
7947 /* Fetch the registers included in the target's 'g' packet. */
7950 remote_target::send_g_packet ()
7952 struct remote_state
*rs
= get_remote_state ();
7955 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
7957 getpkt (&rs
->buf
, 0);
7958 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
7959 error (_("Could not read registers; remote failure reply '%s'"),
7962 /* We can get out of synch in various cases. If the first character
7963 in the buffer is not a hex character, assume that has happened
7964 and try to fetch another packet to read. */
7965 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
7966 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
7967 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
7968 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
7971 fprintf_unfiltered (gdb_stdlog
,
7972 "Bad register packet; fetching a new packet\n");
7973 getpkt (&rs
->buf
, 0);
7976 buf_len
= strlen (rs
->buf
.data ());
7978 /* Sanity check the received packet. */
7979 if (buf_len
% 2 != 0)
7980 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
7986 remote_target::process_g_packet (struct regcache
*regcache
)
7988 struct gdbarch
*gdbarch
= regcache
->arch ();
7989 struct remote_state
*rs
= get_remote_state ();
7990 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
7995 buf_len
= strlen (rs
->buf
.data ());
7997 /* Further sanity checks, with knowledge of the architecture. */
7998 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
7999 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8001 rsa
->sizeof_g_packet
, buf_len
/ 2,
8004 /* Save the size of the packet sent to us by the target. It is used
8005 as a heuristic when determining the max size of packets that the
8006 target can safely receive. */
8007 if (rsa
->actual_register_packet_size
== 0)
8008 rsa
->actual_register_packet_size
= buf_len
;
8010 /* If this is smaller than we guessed the 'g' packet would be,
8011 update our records. A 'g' reply that doesn't include a register's
8012 value implies either that the register is not available, or that
8013 the 'p' packet must be used. */
8014 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8016 long sizeof_g_packet
= buf_len
/ 2;
8018 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8020 long offset
= rsa
->regs
[i
].offset
;
8021 long reg_size
= register_size (gdbarch
, i
);
8023 if (rsa
->regs
[i
].pnum
== -1)
8026 if (offset
>= sizeof_g_packet
)
8027 rsa
->regs
[i
].in_g_packet
= 0;
8028 else if (offset
+ reg_size
> sizeof_g_packet
)
8029 error (_("Truncated register %d in remote 'g' packet"), i
);
8031 rsa
->regs
[i
].in_g_packet
= 1;
8034 /* Looks valid enough, we can assume this is the correct length
8035 for a 'g' packet. It's important not to adjust
8036 rsa->sizeof_g_packet if we have truncated registers otherwise
8037 this "if" won't be run the next time the method is called
8038 with a packet of the same size and one of the internal errors
8039 below will trigger instead. */
8040 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8043 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8045 /* Unimplemented registers read as all bits zero. */
8046 memset (regs
, 0, rsa
->sizeof_g_packet
);
8048 /* Reply describes registers byte by byte, each byte encoded as two
8049 hex characters. Suck them all up, then supply them to the
8050 register cacheing/storage mechanism. */
8052 p
= rs
->buf
.data ();
8053 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8055 if (p
[0] == 0 || p
[1] == 0)
8056 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8057 internal_error (__FILE__
, __LINE__
,
8058 _("unexpected end of 'g' packet reply"));
8060 if (p
[0] == 'x' && p
[1] == 'x')
8061 regs
[i
] = 0; /* 'x' */
8063 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8067 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8069 struct packet_reg
*r
= &rsa
->regs
[i
];
8070 long reg_size
= register_size (gdbarch
, i
);
8074 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8075 /* This shouldn't happen - we adjusted in_g_packet above. */
8076 internal_error (__FILE__
, __LINE__
,
8077 _("unexpected end of 'g' packet reply"));
8078 else if (rs
->buf
[r
->offset
* 2] == 'x')
8080 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8081 /* The register isn't available, mark it as such (at
8082 the same time setting the value to zero). */
8083 regcache
->raw_supply (r
->regnum
, NULL
);
8086 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8092 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8095 process_g_packet (regcache
);
8098 /* Make the remote selected traceframe match GDB's selected
8102 remote_target::set_remote_traceframe ()
8105 struct remote_state
*rs
= get_remote_state ();
8107 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8110 /* Avoid recursion, remote_trace_find calls us again. */
8111 rs
->remote_traceframe_number
= get_traceframe_number ();
8113 newnum
= target_trace_find (tfind_number
,
8114 get_traceframe_number (), 0, 0, NULL
);
8116 /* Should not happen. If it does, all bets are off. */
8117 if (newnum
!= get_traceframe_number ())
8118 warning (_("could not set remote traceframe"));
8122 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8124 struct gdbarch
*gdbarch
= regcache
->arch ();
8125 struct remote_state
*rs
= get_remote_state ();
8126 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8129 set_remote_traceframe ();
8130 set_general_thread (regcache
->ptid ());
8134 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8136 gdb_assert (reg
!= NULL
);
8138 /* If this register might be in the 'g' packet, try that first -
8139 we are likely to read more than one register. If this is the
8140 first 'g' packet, we might be overly optimistic about its
8141 contents, so fall back to 'p'. */
8142 if (reg
->in_g_packet
)
8144 fetch_registers_using_g (regcache
);
8145 if (reg
->in_g_packet
)
8149 if (fetch_register_using_p (regcache
, reg
))
8152 /* This register is not available. */
8153 regcache
->raw_supply (reg
->regnum
, NULL
);
8158 fetch_registers_using_g (regcache
);
8160 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8161 if (!rsa
->regs
[i
].in_g_packet
)
8162 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8164 /* This register is not available. */
8165 regcache
->raw_supply (i
, NULL
);
8169 /* Prepare to store registers. Since we may send them all (using a
8170 'G' request), we have to read out the ones we don't want to change
8174 remote_target::prepare_to_store (struct regcache
*regcache
)
8176 struct remote_state
*rs
= get_remote_state ();
8177 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8180 /* Make sure the entire registers array is valid. */
8181 switch (packet_support (PACKET_P
))
8183 case PACKET_DISABLE
:
8184 case PACKET_SUPPORT_UNKNOWN
:
8185 /* Make sure all the necessary registers are cached. */
8186 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8187 if (rsa
->regs
[i
].in_g_packet
)
8188 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8195 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8196 packet was not recognized. */
8199 remote_target::store_register_using_P (const struct regcache
*regcache
,
8202 struct gdbarch
*gdbarch
= regcache
->arch ();
8203 struct remote_state
*rs
= get_remote_state ();
8204 /* Try storing a single register. */
8205 char *buf
= rs
->buf
.data ();
8206 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8209 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8212 if (reg
->pnum
== -1)
8215 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8216 p
= buf
+ strlen (buf
);
8217 regcache
->raw_collect (reg
->regnum
, regp
);
8218 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8220 getpkt (&rs
->buf
, 0);
8222 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8227 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8228 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8229 case PACKET_UNKNOWN
:
8232 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8236 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8237 contents of the register cache buffer. FIXME: ignores errors. */
8240 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8242 struct remote_state
*rs
= get_remote_state ();
8243 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8247 /* Extract all the registers in the regcache copying them into a
8252 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8253 memset (regs
, 0, rsa
->sizeof_g_packet
);
8254 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8256 struct packet_reg
*r
= &rsa
->regs
[i
];
8259 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8263 /* Command describes registers byte by byte,
8264 each byte encoded as two hex characters. */
8265 p
= rs
->buf
.data ();
8267 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8269 getpkt (&rs
->buf
, 0);
8270 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8271 error (_("Could not write registers; remote failure reply '%s'"),
8275 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8276 of the register cache buffer. FIXME: ignores errors. */
8279 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8281 struct gdbarch
*gdbarch
= regcache
->arch ();
8282 struct remote_state
*rs
= get_remote_state ();
8283 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8286 set_remote_traceframe ();
8287 set_general_thread (regcache
->ptid ());
8291 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8293 gdb_assert (reg
!= NULL
);
8295 /* Always prefer to store registers using the 'P' packet if
8296 possible; we often change only a small number of registers.
8297 Sometimes we change a larger number; we'd need help from a
8298 higher layer to know to use 'G'. */
8299 if (store_register_using_P (regcache
, reg
))
8302 /* For now, don't complain if we have no way to write the
8303 register. GDB loses track of unavailable registers too
8304 easily. Some day, this may be an error. We don't have
8305 any way to read the register, either... */
8306 if (!reg
->in_g_packet
)
8309 store_registers_using_G (regcache
);
8313 store_registers_using_G (regcache
);
8315 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8316 if (!rsa
->regs
[i
].in_g_packet
)
8317 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8318 /* See above for why we do not issue an error here. */
8323 /* Return the number of hex digits in num. */
8326 hexnumlen (ULONGEST num
)
8330 for (i
= 0; num
!= 0; i
++)
8333 return std::max (i
, 1);
8336 /* Set BUF to the minimum number of hex digits representing NUM. */
8339 hexnumstr (char *buf
, ULONGEST num
)
8341 int len
= hexnumlen (num
);
8343 return hexnumnstr (buf
, num
, len
);
8347 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8350 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8356 for (i
= width
- 1; i
>= 0; i
--)
8358 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8365 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8368 remote_address_masked (CORE_ADDR addr
)
8370 unsigned int address_size
= remote_address_size
;
8372 /* If "remoteaddresssize" was not set, default to target address size. */
8374 address_size
= gdbarch_addr_bit (target_gdbarch ());
8376 if (address_size
> 0
8377 && address_size
< (sizeof (ULONGEST
) * 8))
8379 /* Only create a mask when that mask can safely be constructed
8380 in a ULONGEST variable. */
8383 mask
= (mask
<< address_size
) - 1;
8389 /* Determine whether the remote target supports binary downloading.
8390 This is accomplished by sending a no-op memory write of zero length
8391 to the target at the specified address. It does not suffice to send
8392 the whole packet, since many stubs strip the eighth bit and
8393 subsequently compute a wrong checksum, which causes real havoc with
8396 NOTE: This can still lose if the serial line is not eight-bit
8397 clean. In cases like this, the user should clear "remote
8401 remote_target::check_binary_download (CORE_ADDR addr
)
8403 struct remote_state
*rs
= get_remote_state ();
8405 switch (packet_support (PACKET_X
))
8407 case PACKET_DISABLE
:
8411 case PACKET_SUPPORT_UNKNOWN
:
8415 p
= rs
->buf
.data ();
8417 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8419 p
+= hexnumstr (p
, (ULONGEST
) 0);
8423 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8424 getpkt (&rs
->buf
, 0);
8426 if (rs
->buf
[0] == '\0')
8429 fprintf_unfiltered (gdb_stdlog
,
8430 "binary downloading NOT "
8431 "supported by target\n");
8432 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8437 fprintf_unfiltered (gdb_stdlog
,
8438 "binary downloading supported by target\n");
8439 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8446 /* Helper function to resize the payload in order to try to get a good
8447 alignment. We try to write an amount of data such that the next write will
8448 start on an address aligned on REMOTE_ALIGN_WRITES. */
8451 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8453 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8456 /* Write memory data directly to the remote machine.
8457 This does not inform the data cache; the data cache uses this.
8458 HEADER is the starting part of the packet.
8459 MEMADDR is the address in the remote memory space.
8460 MYADDR is the address of the buffer in our space.
8461 LEN_UNITS is the number of addressable units to write.
8462 UNIT_SIZE is the length in bytes of an addressable unit.
8463 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8464 should send data as binary ('X'), or hex-encoded ('M').
8466 The function creates packet of the form
8467 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8469 where encoding of <DATA> is terminated by PACKET_FORMAT.
8471 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8474 Return the transferred status, error or OK (an
8475 'enum target_xfer_status' value). Save the number of addressable units
8476 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8478 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8479 exchange between gdb and the stub could look like (?? in place of the
8485 -> $M1000,3:eeeeffffeeee#??
8489 <- eeeeffffeeeedddd */
8492 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8493 const gdb_byte
*myaddr
,
8496 ULONGEST
*xfered_len_units
,
8497 char packet_format
, int use_length
)
8499 struct remote_state
*rs
= get_remote_state ();
8505 int payload_capacity_bytes
;
8506 int payload_length_bytes
;
8508 if (packet_format
!= 'X' && packet_format
!= 'M')
8509 internal_error (__FILE__
, __LINE__
,
8510 _("remote_write_bytes_aux: bad packet format"));
8513 return TARGET_XFER_EOF
;
8515 payload_capacity_bytes
= get_memory_write_packet_size ();
8517 /* The packet buffer will be large enough for the payload;
8518 get_memory_packet_size ensures this. */
8521 /* Compute the size of the actual payload by subtracting out the
8522 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8524 payload_capacity_bytes
-= strlen ("$,:#NN");
8526 /* The comma won't be used. */
8527 payload_capacity_bytes
+= 1;
8528 payload_capacity_bytes
-= strlen (header
);
8529 payload_capacity_bytes
-= hexnumlen (memaddr
);
8531 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8533 strcat (rs
->buf
.data (), header
);
8534 p
= rs
->buf
.data () + strlen (header
);
8536 /* Compute a best guess of the number of bytes actually transfered. */
8537 if (packet_format
== 'X')
8539 /* Best guess at number of bytes that will fit. */
8540 todo_units
= std::min (len_units
,
8541 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8543 payload_capacity_bytes
-= hexnumlen (todo_units
);
8544 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8548 /* Number of bytes that will fit. */
8550 = std::min (len_units
,
8551 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8553 payload_capacity_bytes
-= hexnumlen (todo_units
);
8554 todo_units
= std::min (todo_units
,
8555 (payload_capacity_bytes
/ unit_size
) / 2);
8558 if (todo_units
<= 0)
8559 internal_error (__FILE__
, __LINE__
,
8560 _("minimum packet size too small to write data"));
8562 /* If we already need another packet, then try to align the end
8563 of this packet to a useful boundary. */
8564 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8565 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8567 /* Append "<memaddr>". */
8568 memaddr
= remote_address_masked (memaddr
);
8569 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8576 /* Append the length and retain its location and size. It may need to be
8577 adjusted once the packet body has been created. */
8579 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8587 /* Append the packet body. */
8588 if (packet_format
== 'X')
8590 /* Binary mode. Send target system values byte by byte, in
8591 increasing byte addresses. Only escape certain critical
8593 payload_length_bytes
=
8594 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8595 &units_written
, payload_capacity_bytes
);
8597 /* If not all TODO units fit, then we'll need another packet. Make
8598 a second try to keep the end of the packet aligned. Don't do
8599 this if the packet is tiny. */
8600 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8604 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8606 if (new_todo_units
!= units_written
)
8607 payload_length_bytes
=
8608 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8609 (gdb_byte
*) p
, &units_written
,
8610 payload_capacity_bytes
);
8613 p
+= payload_length_bytes
;
8614 if (use_length
&& units_written
< todo_units
)
8616 /* Escape chars have filled up the buffer prematurely,
8617 and we have actually sent fewer units than planned.
8618 Fix-up the length field of the packet. Use the same
8619 number of characters as before. */
8620 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8622 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8627 /* Normal mode: Send target system values byte by byte, in
8628 increasing byte addresses. Each byte is encoded as a two hex
8630 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8631 units_written
= todo_units
;
8634 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8635 getpkt (&rs
->buf
, 0);
8637 if (rs
->buf
[0] == 'E')
8638 return TARGET_XFER_E_IO
;
8640 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8641 send fewer units than we'd planned. */
8642 *xfered_len_units
= (ULONGEST
) units_written
;
8643 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8646 /* Write memory data directly to the remote machine.
8647 This does not inform the data cache; the data cache uses this.
8648 MEMADDR is the address in the remote memory space.
8649 MYADDR is the address of the buffer in our space.
8650 LEN is the number of bytes.
8652 Return the transferred status, error or OK (an
8653 'enum target_xfer_status' value). Save the number of bytes
8654 transferred in *XFERED_LEN. Only transfer a single packet. */
8657 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8658 ULONGEST len
, int unit_size
,
8659 ULONGEST
*xfered_len
)
8661 const char *packet_format
= NULL
;
8663 /* Check whether the target supports binary download. */
8664 check_binary_download (memaddr
);
8666 switch (packet_support (PACKET_X
))
8669 packet_format
= "X";
8671 case PACKET_DISABLE
:
8672 packet_format
= "M";
8674 case PACKET_SUPPORT_UNKNOWN
:
8675 internal_error (__FILE__
, __LINE__
,
8676 _("remote_write_bytes: bad internal state"));
8678 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8681 return remote_write_bytes_aux (packet_format
,
8682 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8683 packet_format
[0], 1);
8686 /* Read memory data directly from the remote machine.
8687 This does not use the data cache; the data cache uses this.
8688 MEMADDR is the address in the remote memory space.
8689 MYADDR is the address of the buffer in our space.
8690 LEN_UNITS is the number of addressable memory units to read..
8691 UNIT_SIZE is the length in bytes of an addressable unit.
8693 Return the transferred status, error or OK (an
8694 'enum target_xfer_status' value). Save the number of bytes
8695 transferred in *XFERED_LEN_UNITS.
8697 See the comment of remote_write_bytes_aux for an example of
8698 memory read/write exchange between gdb and the stub. */
8701 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8703 int unit_size
, ULONGEST
*xfered_len_units
)
8705 struct remote_state
*rs
= get_remote_state ();
8706 int buf_size_bytes
; /* Max size of packet output buffer. */
8711 buf_size_bytes
= get_memory_read_packet_size ();
8712 /* The packet buffer will be large enough for the payload;
8713 get_memory_packet_size ensures this. */
8715 /* Number of units that will fit. */
8716 todo_units
= std::min (len_units
,
8717 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8719 /* Construct "m"<memaddr>","<len>". */
8720 memaddr
= remote_address_masked (memaddr
);
8721 p
= rs
->buf
.data ();
8723 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8725 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8728 getpkt (&rs
->buf
, 0);
8729 if (rs
->buf
[0] == 'E'
8730 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8731 && rs
->buf
[3] == '\0')
8732 return TARGET_XFER_E_IO
;
8733 /* Reply describes memory byte by byte, each byte encoded as two hex
8735 p
= rs
->buf
.data ();
8736 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8737 /* Return what we have. Let higher layers handle partial reads. */
8738 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8739 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8742 /* Using the set of read-only target sections of remote, read live
8745 For interface/parameters/return description see target.h,
8749 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
8753 ULONGEST
*xfered_len
)
8755 struct target_section
*secp
;
8756 struct target_section_table
*table
;
8758 secp
= target_section_by_addr (this, memaddr
);
8760 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
8762 struct target_section
*p
;
8763 ULONGEST memend
= memaddr
+ len
;
8765 table
= target_get_section_table (this);
8767 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8769 if (memaddr
>= p
->addr
)
8771 if (memend
<= p
->endaddr
)
8773 /* Entire transfer is within this section. */
8774 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8777 else if (memaddr
>= p
->endaddr
)
8779 /* This section ends before the transfer starts. */
8784 /* This section overlaps the transfer. Just do half. */
8785 len
= p
->endaddr
- memaddr
;
8786 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8793 return TARGET_XFER_EOF
;
8796 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8797 first if the requested memory is unavailable in traceframe.
8798 Otherwise, fall back to remote_read_bytes_1. */
8801 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
8802 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8803 ULONGEST
*xfered_len
)
8806 return TARGET_XFER_EOF
;
8808 if (get_traceframe_number () != -1)
8810 std::vector
<mem_range
> available
;
8812 /* If we fail to get the set of available memory, then the
8813 target does not support querying traceframe info, and so we
8814 attempt reading from the traceframe anyway (assuming the
8815 target implements the old QTro packet then). */
8816 if (traceframe_available_memory (&available
, memaddr
, len
))
8818 if (available
.empty () || available
[0].start
!= memaddr
)
8820 enum target_xfer_status res
;
8822 /* Don't read into the traceframe's available
8824 if (!available
.empty ())
8826 LONGEST oldlen
= len
;
8828 len
= available
[0].start
- memaddr
;
8829 gdb_assert (len
<= oldlen
);
8832 /* This goes through the topmost target again. */
8833 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
8834 len
, unit_size
, xfered_len
);
8835 if (res
== TARGET_XFER_OK
)
8836 return TARGET_XFER_OK
;
8839 /* No use trying further, we know some memory starting
8840 at MEMADDR isn't available. */
8842 return (*xfered_len
!= 0) ?
8843 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
8847 /* Don't try to read more than how much is available, in
8848 case the target implements the deprecated QTro packet to
8849 cater for older GDBs (the target's knowledge of read-only
8850 sections may be outdated by now). */
8851 len
= available
[0].length
;
8855 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8860 /* Sends a packet with content determined by the printf format string
8861 FORMAT and the remaining arguments, then gets the reply. Returns
8862 whether the packet was a success, a failure, or unknown. */
8865 remote_target::remote_send_printf (const char *format
, ...)
8867 struct remote_state
*rs
= get_remote_state ();
8868 int max_size
= get_remote_packet_size ();
8871 va_start (ap
, format
);
8874 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
8878 if (size
>= max_size
)
8879 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8881 if (putpkt (rs
->buf
) < 0)
8882 error (_("Communication problem with target."));
8885 getpkt (&rs
->buf
, 0);
8887 return packet_check_result (rs
->buf
);
8890 /* Flash writing can take quite some time. We'll set
8891 effectively infinite timeout for flash operations.
8892 In future, we'll need to decide on a better approach. */
8893 static const int remote_flash_timeout
= 1000;
8896 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
8898 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8899 enum packet_result ret
;
8900 scoped_restore restore_timeout
8901 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8903 ret
= remote_send_printf ("vFlashErase:%s,%s",
8904 phex (address
, addr_size
),
8908 case PACKET_UNKNOWN
:
8909 error (_("Remote target does not support flash erase"));
8911 error (_("Error erasing flash with vFlashErase packet"));
8918 remote_target::remote_flash_write (ULONGEST address
,
8919 ULONGEST length
, ULONGEST
*xfered_len
,
8920 const gdb_byte
*data
)
8922 scoped_restore restore_timeout
8923 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8924 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8929 remote_target::flash_done ()
8933 scoped_restore restore_timeout
8934 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8936 ret
= remote_send_printf ("vFlashDone");
8940 case PACKET_UNKNOWN
:
8941 error (_("Remote target does not support vFlashDone"));
8943 error (_("Error finishing flash operation"));
8950 remote_target::files_info ()
8952 puts_filtered ("Debugging a target over a serial line.\n");
8955 /* Stuff for dealing with the packets which are part of this protocol.
8956 See comment at top of file for details. */
8958 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8959 error to higher layers. Called when a serial error is detected.
8960 The exception message is STRING, followed by a colon and a blank,
8961 the system error message for errno at function entry and final dot
8962 for output compatibility with throw_perror_with_name. */
8965 unpush_and_perror (const char *string
)
8967 int saved_errno
= errno
;
8969 remote_unpush_target ();
8970 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
8971 safe_strerror (saved_errno
));
8974 /* Read a single character from the remote end. The current quit
8975 handler is overridden to avoid quitting in the middle of packet
8976 sequence, as that would break communication with the remote server.
8977 See remote_serial_quit_handler for more detail. */
8980 remote_target::readchar (int timeout
)
8983 struct remote_state
*rs
= get_remote_state ();
8986 scoped_restore restore_quit_target
8987 = make_scoped_restore (&curr_quit_handler_target
, this);
8988 scoped_restore restore_quit
8989 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
8991 rs
->got_ctrlc_during_io
= 0;
8993 ch
= serial_readchar (rs
->remote_desc
, timeout
);
8995 if (rs
->got_ctrlc_during_io
)
9002 switch ((enum serial_rc
) ch
)
9005 remote_unpush_target ();
9006 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9009 unpush_and_perror (_("Remote communication error. "
9010 "Target disconnected."));
9012 case SERIAL_TIMEOUT
:
9018 /* Wrapper for serial_write that closes the target and throws if
9019 writing fails. The current quit handler is overridden to avoid
9020 quitting in the middle of packet sequence, as that would break
9021 communication with the remote server. See
9022 remote_serial_quit_handler for more detail. */
9025 remote_target::remote_serial_write (const char *str
, int len
)
9027 struct remote_state
*rs
= get_remote_state ();
9029 scoped_restore restore_quit_target
9030 = make_scoped_restore (&curr_quit_handler_target
, this);
9031 scoped_restore restore_quit
9032 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9034 rs
->got_ctrlc_during_io
= 0;
9036 if (serial_write (rs
->remote_desc
, str
, len
))
9038 unpush_and_perror (_("Remote communication error. "
9039 "Target disconnected."));
9042 if (rs
->got_ctrlc_during_io
)
9046 /* Return a string representing an escaped version of BUF, of len N.
9047 E.g. \n is converted to \\n, \t to \\t, etc. */
9050 escape_buffer (const char *buf
, int n
)
9054 stb
.putstrn (buf
, n
, '\\');
9055 return std::move (stb
.string ());
9058 /* Display a null-terminated packet on stdout, for debugging, using C
9062 print_packet (const char *buf
)
9064 puts_filtered ("\"");
9065 fputstr_filtered (buf
, '"', gdb_stdout
);
9066 puts_filtered ("\"");
9070 remote_target::putpkt (const char *buf
)
9072 return putpkt_binary (buf
, strlen (buf
));
9075 /* Wrapper around remote_target::putpkt to avoid exporting
9079 putpkt (remote_target
*remote
, const char *buf
)
9081 return remote
->putpkt (buf
);
9084 /* Send a packet to the remote machine, with error checking. The data
9085 of the packet is in BUF. The string in BUF can be at most
9086 get_remote_packet_size () - 5 to account for the $, # and checksum,
9087 and for a possible /0 if we are debugging (remote_debug) and want
9088 to print the sent packet as a string. */
9091 remote_target::putpkt_binary (const char *buf
, int cnt
)
9093 struct remote_state
*rs
= get_remote_state ();
9095 unsigned char csum
= 0;
9096 gdb::def_vector
<char> data (cnt
+ 6);
9097 char *buf2
= data
.data ();
9103 /* Catch cases like trying to read memory or listing threads while
9104 we're waiting for a stop reply. The remote server wouldn't be
9105 ready to handle this request, so we'd hang and timeout. We don't
9106 have to worry about this in synchronous mode, because in that
9107 case it's not possible to issue a command while the target is
9108 running. This is not a problem in non-stop mode, because in that
9109 case, the stub is always ready to process serial input. */
9110 if (!target_is_non_stop_p ()
9111 && target_is_async_p ()
9112 && rs
->waiting_for_stop_reply
)
9114 error (_("Cannot execute this command while the target is running.\n"
9115 "Use the \"interrupt\" command to stop the target\n"
9116 "and then try again."));
9119 /* We're sending out a new packet. Make sure we don't look at a
9120 stale cached response. */
9121 rs
->cached_wait_status
= 0;
9123 /* Copy the packet into buffer BUF2, encapsulating it
9124 and giving it a checksum. */
9129 for (i
= 0; i
< cnt
; i
++)
9135 *p
++ = tohex ((csum
>> 4) & 0xf);
9136 *p
++ = tohex (csum
& 0xf);
9138 /* Send it over and over until we get a positive ack. */
9142 int started_error_output
= 0;
9148 int len
= (int) (p
- buf2
);
9151 if (remote_packet_max_chars
< 0)
9154 max_chars
= remote_packet_max_chars
;
9157 = escape_buffer (buf2
, std::min (len
, max_chars
));
9159 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9161 if (len
> max_chars
)
9162 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9165 fprintf_unfiltered (gdb_stdlog
, "...");
9167 gdb_flush (gdb_stdlog
);
9169 remote_serial_write (buf2
, p
- buf2
);
9171 /* If this is a no acks version of the remote protocol, send the
9172 packet and move on. */
9176 /* Read until either a timeout occurs (-2) or '+' is read.
9177 Handle any notification that arrives in the mean time. */
9180 ch
= readchar (remote_timeout
);
9188 case SERIAL_TIMEOUT
:
9191 if (started_error_output
)
9193 putchar_unfiltered ('\n');
9194 started_error_output
= 0;
9203 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9207 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9209 case SERIAL_TIMEOUT
:
9213 break; /* Retransmit buffer. */
9217 fprintf_unfiltered (gdb_stdlog
,
9218 "Packet instead of Ack, ignoring it\n");
9219 /* It's probably an old response sent because an ACK
9220 was lost. Gobble up the packet and ack it so it
9221 doesn't get retransmitted when we resend this
9224 remote_serial_write ("+", 1);
9225 continue; /* Now, go look for +. */
9232 /* If we got a notification, handle it, and go back to looking
9234 /* We've found the start of a notification. Now
9235 collect the data. */
9236 val
= read_frame (&rs
->buf
);
9241 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9243 fprintf_unfiltered (gdb_stdlog
,
9244 " Notification received: %s\n",
9247 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9248 /* We're in sync now, rewait for the ack. */
9255 if (!started_error_output
)
9257 started_error_output
= 1;
9258 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9260 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9261 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9270 if (!started_error_output
)
9272 started_error_output
= 1;
9273 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9275 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9279 break; /* Here to retransmit. */
9283 /* This is wrong. If doing a long backtrace, the user should be
9284 able to get out next time we call QUIT, without anything as
9285 violent as interrupt_query. If we want to provide a way out of
9286 here without getting to the next QUIT, it should be based on
9287 hitting ^C twice as in remote_wait. */
9299 /* Come here after finding the start of a frame when we expected an
9300 ack. Do our best to discard the rest of this packet. */
9303 remote_target::skip_frame ()
9309 c
= readchar (remote_timeout
);
9312 case SERIAL_TIMEOUT
:
9313 /* Nothing we can do. */
9316 /* Discard the two bytes of checksum and stop. */
9317 c
= readchar (remote_timeout
);
9319 c
= readchar (remote_timeout
);
9322 case '*': /* Run length encoding. */
9323 /* Discard the repeat count. */
9324 c
= readchar (remote_timeout
);
9329 /* A regular character. */
9335 /* Come here after finding the start of the frame. Collect the rest
9336 into *BUF, verifying the checksum, length, and handling run-length
9337 compression. NUL terminate the buffer. If there is not enough room,
9340 Returns -1 on error, number of characters in buffer (ignoring the
9341 trailing NULL) on success. (could be extended to return one of the
9342 SERIAL status indications). */
9345 remote_target::read_frame (gdb::char_vector
*buf_p
)
9350 char *buf
= buf_p
->data ();
9351 struct remote_state
*rs
= get_remote_state ();
9358 c
= readchar (remote_timeout
);
9361 case SERIAL_TIMEOUT
:
9363 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9367 fputs_filtered ("Saw new packet start in middle of old one\n",
9369 return -1; /* Start a new packet, count retries. */
9372 unsigned char pktcsum
;
9378 check_0
= readchar (remote_timeout
);
9380 check_1
= readchar (remote_timeout
);
9382 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9385 fputs_filtered ("Timeout in checksum, retrying\n",
9389 else if (check_0
< 0 || check_1
< 0)
9392 fputs_filtered ("Communication error in checksum\n",
9397 /* Don't recompute the checksum; with no ack packets we
9398 don't have any way to indicate a packet retransmission
9403 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9404 if (csum
== pktcsum
)
9409 std::string str
= escape_buffer (buf
, bc
);
9411 fprintf_unfiltered (gdb_stdlog
,
9412 "Bad checksum, sentsum=0x%x, "
9413 "csum=0x%x, buf=%s\n",
9414 pktcsum
, csum
, str
.c_str ());
9416 /* Number of characters in buffer ignoring trailing
9420 case '*': /* Run length encoding. */
9425 c
= readchar (remote_timeout
);
9427 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9429 /* The character before ``*'' is repeated. */
9431 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9433 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9435 /* Make some more room in the buffer. */
9436 buf_p
->resize (buf_p
->size () + repeat
);
9437 buf
= buf_p
->data ();
9440 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9446 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9450 if (bc
>= buf_p
->size () - 1)
9452 /* Make some more room in the buffer. */
9453 buf_p
->resize (buf_p
->size () * 2);
9454 buf
= buf_p
->data ();
9464 /* Set this to the maximum number of seconds to wait instead of waiting forever
9465 in target_wait(). If this timer times out, then it generates an error and
9466 the command is aborted. This replaces most of the need for timeouts in the
9467 GDB test suite, and makes it possible to distinguish between a hung target
9468 and one with slow communications. */
9470 static int watchdog
= 0;
9472 show_watchdog (struct ui_file
*file
, int from_tty
,
9473 struct cmd_list_element
*c
, const char *value
)
9475 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9478 /* Read a packet from the remote machine, with error checking, and
9479 store it in *BUF. Resize *BUF if necessary to hold the result. If
9480 FOREVER, wait forever rather than timing out; this is used (in
9481 synchronous mode) to wait for a target that is is executing user
9483 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9484 don't have to change all the calls to getpkt to deal with the
9485 return value, because at the moment I don't know what the right
9486 thing to do it for those. */
9489 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9491 getpkt_sane (buf
, forever
);
9495 /* Read a packet from the remote machine, with error checking, and
9496 store it in *BUF. Resize *BUF if necessary to hold the result. If
9497 FOREVER, wait forever rather than timing out; this is used (in
9498 synchronous mode) to wait for a target that is is executing user
9499 code to stop. If FOREVER == 0, this function is allowed to time
9500 out gracefully and return an indication of this to the caller.
9501 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9502 consider receiving a notification enough reason to return to the
9503 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9504 holds a notification or not (a regular packet). */
9507 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9508 int forever
, int expecting_notif
,
9511 struct remote_state
*rs
= get_remote_state ();
9517 /* We're reading a new response. Make sure we don't look at a
9518 previously cached response. */
9519 rs
->cached_wait_status
= 0;
9521 strcpy (buf
->data (), "timeout");
9524 timeout
= watchdog
> 0 ? watchdog
: -1;
9525 else if (expecting_notif
)
9526 timeout
= 0; /* There should already be a char in the buffer. If
9529 timeout
= remote_timeout
;
9533 /* Process any number of notifications, and then return when
9537 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9539 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9541 /* This can loop forever if the remote side sends us
9542 characters continuously, but if it pauses, we'll get
9543 SERIAL_TIMEOUT from readchar because of timeout. Then
9544 we'll count that as a retry.
9546 Note that even when forever is set, we will only wait
9547 forever prior to the start of a packet. After that, we
9548 expect characters to arrive at a brisk pace. They should
9549 show up within remote_timeout intervals. */
9551 c
= readchar (timeout
);
9552 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9554 if (c
== SERIAL_TIMEOUT
)
9556 if (expecting_notif
)
9557 return -1; /* Don't complain, it's normal to not get
9558 anything in this case. */
9560 if (forever
) /* Watchdog went off? Kill the target. */
9562 remote_unpush_target ();
9563 throw_error (TARGET_CLOSE_ERROR
,
9564 _("Watchdog timeout has expired. "
9565 "Target detached."));
9568 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9572 /* We've found the start of a packet or notification.
9573 Now collect the data. */
9574 val
= read_frame (buf
);
9579 remote_serial_write ("-", 1);
9582 if (tries
> MAX_TRIES
)
9584 /* We have tried hard enough, and just can't receive the
9585 packet/notification. Give up. */
9586 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9588 /* Skip the ack char if we're in no-ack mode. */
9589 if (!rs
->noack_mode
)
9590 remote_serial_write ("+", 1);
9594 /* If we got an ordinary packet, return that to our caller. */
9601 if (remote_packet_max_chars
< 0)
9604 max_chars
= remote_packet_max_chars
;
9607 = escape_buffer (buf
->data (),
9608 std::min (val
, max_chars
));
9610 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9613 if (val
> max_chars
)
9614 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9617 fprintf_unfiltered (gdb_stdlog
, "\n");
9620 /* Skip the ack char if we're in no-ack mode. */
9621 if (!rs
->noack_mode
)
9622 remote_serial_write ("+", 1);
9623 if (is_notif
!= NULL
)
9628 /* If we got a notification, handle it, and go back to looking
9632 gdb_assert (c
== '%');
9636 std::string str
= escape_buffer (buf
->data (), val
);
9638 fprintf_unfiltered (gdb_stdlog
,
9639 " Notification received: %s\n",
9642 if (is_notif
!= NULL
)
9645 handle_notification (rs
->notif_state
, buf
->data ());
9647 /* Notifications require no acknowledgement. */
9649 if (expecting_notif
)
9656 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9658 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9662 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9665 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9668 /* Kill any new fork children of process PID that haven't been
9669 processed by follow_fork. */
9672 remote_target::kill_new_fork_children (int pid
)
9674 remote_state
*rs
= get_remote_state ();
9675 struct notif_client
*notif
= ¬if_client_stop
;
9677 /* Kill the fork child threads of any threads in process PID
9678 that are stopped at a fork event. */
9679 for (thread_info
*thread
: all_non_exited_threads ())
9681 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9683 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9685 int child_pid
= ws
->value
.related_pid
.pid ();
9688 res
= remote_vkill (child_pid
);
9690 error (_("Can't kill fork child process %d"), child_pid
);
9694 /* Check for any pending fork events (not reported or processed yet)
9695 in process PID and kill those fork child threads as well. */
9696 remote_notif_get_pending_events (notif
);
9697 for (auto &event
: rs
->stop_reply_queue
)
9698 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9700 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9703 res
= remote_vkill (child_pid
);
9705 error (_("Can't kill fork child process %d"), child_pid
);
9710 /* Target hook to kill the current inferior. */
9713 remote_target::kill ()
9716 int pid
= inferior_ptid
.pid ();
9717 struct remote_state
*rs
= get_remote_state ();
9719 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9721 /* If we're stopped while forking and we haven't followed yet,
9722 kill the child task. We need to do this before killing the
9723 parent task because if this is a vfork then the parent will
9725 kill_new_fork_children (pid
);
9727 res
= remote_vkill (pid
);
9730 target_mourn_inferior (inferior_ptid
);
9735 /* If we are in 'target remote' mode and we are killing the only
9736 inferior, then we will tell gdbserver to exit and unpush the
9738 if (res
== -1 && !remote_multi_process_p (rs
)
9739 && number_of_live_inferiors () == 1)
9743 /* We've killed the remote end, we get to mourn it. If we are
9744 not in extended mode, mourning the inferior also unpushes
9745 remote_ops from the target stack, which closes the remote
9747 target_mourn_inferior (inferior_ptid
);
9752 error (_("Can't kill process"));
9755 /* Send a kill request to the target using the 'vKill' packet. */
9758 remote_target::remote_vkill (int pid
)
9760 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9763 remote_state
*rs
= get_remote_state ();
9765 /* Tell the remote target to detach. */
9766 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
9768 getpkt (&rs
->buf
, 0);
9770 switch (packet_ok (rs
->buf
,
9771 &remote_protocol_packets
[PACKET_vKill
]))
9777 case PACKET_UNKNOWN
:
9780 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9784 /* Send a kill request to the target using the 'k' packet. */
9787 remote_target::remote_kill_k ()
9789 /* Catch errors so the user can quit from gdb even when we
9790 aren't on speaking terms with the remote system. */
9795 catch (const gdb_exception_error
&ex
)
9797 if (ex
.error
== TARGET_CLOSE_ERROR
)
9799 /* If we got an (EOF) error that caused the target
9800 to go away, then we're done, that's what we wanted.
9801 "k" is susceptible to cause a premature EOF, given
9802 that the remote server isn't actually required to
9803 reply to "k", and it can happen that it doesn't
9804 even get to reply ACK to the "k". */
9808 /* Otherwise, something went wrong. We didn't actually kill
9809 the target. Just propagate the exception, and let the
9810 user or higher layers decide what to do. */
9816 remote_target::mourn_inferior ()
9818 struct remote_state
*rs
= get_remote_state ();
9820 /* We're no longer interested in notification events of an inferior
9821 that exited or was killed/detached. */
9822 discard_pending_stop_replies (current_inferior ());
9824 /* In 'target remote' mode with one inferior, we close the connection. */
9825 if (!rs
->extended
&& number_of_live_inferiors () <= 1)
9827 unpush_target (this);
9829 /* remote_close takes care of doing most of the clean up. */
9830 generic_mourn_inferior ();
9834 /* In case we got here due to an error, but we're going to stay
9836 rs
->waiting_for_stop_reply
= 0;
9838 /* If the current general thread belonged to the process we just
9839 detached from or has exited, the remote side current general
9840 thread becomes undefined. Considering a case like this:
9842 - We just got here due to a detach.
9843 - The process that we're detaching from happens to immediately
9844 report a global breakpoint being hit in non-stop mode, in the
9845 same thread we had selected before.
9846 - GDB attaches to this process again.
9847 - This event happens to be the next event we handle.
9849 GDB would consider that the current general thread didn't need to
9850 be set on the stub side (with Hg), since for all it knew,
9851 GENERAL_THREAD hadn't changed.
9853 Notice that although in all-stop mode, the remote server always
9854 sets the current thread to the thread reporting the stop event,
9855 that doesn't happen in non-stop mode; in non-stop, the stub *must
9856 not* change the current thread when reporting a breakpoint hit,
9857 due to the decoupling of event reporting and event handling.
9859 To keep things simple, we always invalidate our notion of the
9861 record_currthread (rs
, minus_one_ptid
);
9863 /* Call common code to mark the inferior as not running. */
9864 generic_mourn_inferior ();
9868 extended_remote_target::supports_disable_randomization ()
9870 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9874 remote_target::extended_remote_disable_randomization (int val
)
9876 struct remote_state
*rs
= get_remote_state ();
9879 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9880 "QDisableRandomization:%x", val
);
9882 reply
= remote_get_noisy_reply ();
9884 error (_("Target does not support QDisableRandomization."));
9885 if (strcmp (reply
, "OK") != 0)
9886 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9890 remote_target::extended_remote_run (const std::string
&args
)
9892 struct remote_state
*rs
= get_remote_state ();
9894 const char *remote_exec_file
= get_remote_exec_file ();
9896 /* If the user has disabled vRun support, or we have detected that
9897 support is not available, do not try it. */
9898 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9901 strcpy (rs
->buf
.data (), "vRun;");
9902 len
= strlen (rs
->buf
.data ());
9904 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9905 error (_("Remote file name too long for run packet"));
9906 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
9907 strlen (remote_exec_file
));
9913 gdb_argv
argv (args
.c_str ());
9914 for (i
= 0; argv
[i
] != NULL
; i
++)
9916 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9917 error (_("Argument list too long for run packet"));
9918 rs
->buf
[len
++] = ';';
9919 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
9924 rs
->buf
[len
++] = '\0';
9927 getpkt (&rs
->buf
, 0);
9929 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9932 /* We have a wait response. All is well. */
9934 case PACKET_UNKNOWN
:
9937 if (remote_exec_file
[0] == '\0')
9938 error (_("Running the default executable on the remote target failed; "
9939 "try \"set remote exec-file\"?"));
9941 error (_("Running \"%s\" on the remote target failed"),
9944 gdb_assert_not_reached (_("bad switch"));
9948 /* Helper function to send set/unset environment packets. ACTION is
9949 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
9950 or "QEnvironmentUnsetVariable". VALUE is the variable to be
9954 remote_target::send_environment_packet (const char *action
,
9958 remote_state
*rs
= get_remote_state ();
9960 /* Convert the environment variable to an hex string, which
9961 is the best format to be transmitted over the wire. */
9962 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
9965 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9966 "%s:%s", packet
, encoded_value
.c_str ());
9969 getpkt (&rs
->buf
, 0);
9970 if (strcmp (rs
->buf
.data (), "OK") != 0)
9971 warning (_("Unable to %s environment variable '%s' on remote."),
9975 /* Helper function to handle the QEnvironment* packets. */
9978 remote_target::extended_remote_environment_support ()
9980 remote_state
*rs
= get_remote_state ();
9982 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
9984 putpkt ("QEnvironmentReset");
9985 getpkt (&rs
->buf
, 0);
9986 if (strcmp (rs
->buf
.data (), "OK") != 0)
9987 warning (_("Unable to reset environment on remote."));
9990 gdb_environ
*e
= ¤t_inferior ()->environment
;
9992 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
9993 for (const std::string
&el
: e
->user_set_env ())
9994 send_environment_packet ("set", "QEnvironmentHexEncoded",
9997 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
9998 for (const std::string
&el
: e
->user_unset_env ())
9999 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10002 /* Helper function to set the current working directory for the
10003 inferior in the remote target. */
10006 remote_target::extended_remote_set_inferior_cwd ()
10008 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10010 const char *inferior_cwd
= get_inferior_cwd ();
10011 remote_state
*rs
= get_remote_state ();
10013 if (inferior_cwd
!= NULL
)
10015 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10016 strlen (inferior_cwd
));
10018 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10019 "QSetWorkingDir:%s", hexpath
.c_str ());
10023 /* An empty inferior_cwd means that the user wants us to
10024 reset the remote server's inferior's cwd. */
10025 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10026 "QSetWorkingDir:");
10030 getpkt (&rs
->buf
, 0);
10031 if (packet_ok (rs
->buf
,
10032 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10035 Remote replied unexpectedly while setting the inferior's working\n\
10042 /* In the extended protocol we want to be able to do things like
10043 "run" and have them basically work as expected. So we need
10044 a special create_inferior function. We support changing the
10045 executable file and the command line arguments, but not the
10049 extended_remote_target::create_inferior (const char *exec_file
,
10050 const std::string
&args
,
10051 char **env
, int from_tty
)
10055 struct remote_state
*rs
= get_remote_state ();
10056 const char *remote_exec_file
= get_remote_exec_file ();
10058 /* If running asynchronously, register the target file descriptor
10059 with the event loop. */
10060 if (target_can_async_p ())
10063 /* Disable address space randomization if requested (and supported). */
10064 if (supports_disable_randomization ())
10065 extended_remote_disable_randomization (disable_randomization
);
10067 /* If startup-with-shell is on, we inform gdbserver to start the
10068 remote inferior using a shell. */
10069 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10071 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10072 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10074 getpkt (&rs
->buf
, 0);
10075 if (strcmp (rs
->buf
.data (), "OK") != 0)
10077 Remote replied unexpectedly while setting startup-with-shell: %s"),
10081 extended_remote_environment_support ();
10083 extended_remote_set_inferior_cwd ();
10085 /* Now restart the remote server. */
10086 run_worked
= extended_remote_run (args
) != -1;
10089 /* vRun was not supported. Fail if we need it to do what the
10091 if (remote_exec_file
[0])
10092 error (_("Remote target does not support \"set remote exec-file\""));
10093 if (!args
.empty ())
10094 error (_("Remote target does not support \"set args\" or run ARGS"));
10096 /* Fall back to "R". */
10097 extended_remote_restart ();
10100 /* vRun's success return is a stop reply. */
10101 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10102 add_current_inferior_and_thread (stop_reply
);
10104 /* Get updated offsets, if the stub uses qOffsets. */
10109 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10110 the list of conditions (in agent expression bytecode format), if any, the
10111 target needs to evaluate. The output is placed into the packet buffer
10112 started from BUF and ended at BUF_END. */
10115 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10116 struct bp_target_info
*bp_tgt
, char *buf
,
10119 if (bp_tgt
->conditions
.empty ())
10122 buf
+= strlen (buf
);
10123 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10126 /* Send conditions to the target. */
10127 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10129 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10130 buf
+= strlen (buf
);
10131 for (int i
= 0; i
< aexpr
->len
; ++i
)
10132 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10139 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10140 struct bp_target_info
*bp_tgt
, char *buf
)
10142 if (bp_tgt
->tcommands
.empty ())
10145 buf
+= strlen (buf
);
10147 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10148 buf
+= strlen (buf
);
10150 /* Concatenate all the agent expressions that are commands into the
10152 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10154 sprintf (buf
, "X%x,", aexpr
->len
);
10155 buf
+= strlen (buf
);
10156 for (int i
= 0; i
< aexpr
->len
; ++i
)
10157 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10162 /* Insert a breakpoint. On targets that have software breakpoint
10163 support, we ask the remote target to do the work; on targets
10164 which don't, we insert a traditional memory breakpoint. */
10167 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10168 struct bp_target_info
*bp_tgt
)
10170 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10171 If it succeeds, then set the support to PACKET_ENABLE. If it
10172 fails, and the user has explicitly requested the Z support then
10173 report an error, otherwise, mark it disabled and go on. */
10175 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10177 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10178 struct remote_state
*rs
;
10181 /* Make sure the remote is pointing at the right process, if
10183 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10184 set_general_process ();
10186 rs
= get_remote_state ();
10187 p
= rs
->buf
.data ();
10188 endbuf
= p
+ get_remote_packet_size ();
10193 addr
= (ULONGEST
) remote_address_masked (addr
);
10194 p
+= hexnumstr (p
, addr
);
10195 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10197 if (supports_evaluation_of_breakpoint_conditions ())
10198 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10200 if (can_run_breakpoint_commands ())
10201 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10204 getpkt (&rs
->buf
, 0);
10206 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10212 case PACKET_UNKNOWN
:
10217 /* If this breakpoint has target-side commands but this stub doesn't
10218 support Z0 packets, throw error. */
10219 if (!bp_tgt
->tcommands
.empty ())
10220 throw_error (NOT_SUPPORTED_ERROR
, _("\
10221 Target doesn't support breakpoints that have target side commands."));
10223 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10227 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10228 struct bp_target_info
*bp_tgt
,
10229 enum remove_bp_reason reason
)
10231 CORE_ADDR addr
= bp_tgt
->placed_address
;
10232 struct remote_state
*rs
= get_remote_state ();
10234 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10236 char *p
= rs
->buf
.data ();
10237 char *endbuf
= p
+ get_remote_packet_size ();
10239 /* Make sure the remote is pointing at the right process, if
10241 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10242 set_general_process ();
10248 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10249 p
+= hexnumstr (p
, addr
);
10250 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10253 getpkt (&rs
->buf
, 0);
10255 return (rs
->buf
[0] == 'E');
10258 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10261 static enum Z_packet_type
10262 watchpoint_to_Z_packet (int type
)
10267 return Z_PACKET_WRITE_WP
;
10270 return Z_PACKET_READ_WP
;
10273 return Z_PACKET_ACCESS_WP
;
10276 internal_error (__FILE__
, __LINE__
,
10277 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10282 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10283 enum target_hw_bp_type type
, struct expression
*cond
)
10285 struct remote_state
*rs
= get_remote_state ();
10286 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10288 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10290 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10293 /* Make sure the remote is pointing at the right process, if
10295 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10296 set_general_process ();
10298 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10299 p
= strchr (rs
->buf
.data (), '\0');
10300 addr
= remote_address_masked (addr
);
10301 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10302 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10305 getpkt (&rs
->buf
, 0);
10307 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10311 case PACKET_UNKNOWN
:
10316 internal_error (__FILE__
, __LINE__
,
10317 _("remote_insert_watchpoint: reached end of function"));
10321 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10322 CORE_ADDR start
, int length
)
10324 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10326 return diff
< length
;
10331 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10332 enum target_hw_bp_type type
, struct expression
*cond
)
10334 struct remote_state
*rs
= get_remote_state ();
10335 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10337 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10339 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10342 /* Make sure the remote is pointing at the right process, if
10344 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10345 set_general_process ();
10347 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10348 p
= strchr (rs
->buf
.data (), '\0');
10349 addr
= remote_address_masked (addr
);
10350 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10351 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10353 getpkt (&rs
->buf
, 0);
10355 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10358 case PACKET_UNKNOWN
:
10363 internal_error (__FILE__
, __LINE__
,
10364 _("remote_remove_watchpoint: reached end of function"));
10368 static int remote_hw_watchpoint_limit
= -1;
10369 static int remote_hw_watchpoint_length_limit
= -1;
10370 static int remote_hw_breakpoint_limit
= -1;
10373 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10375 if (remote_hw_watchpoint_length_limit
== 0)
10377 else if (remote_hw_watchpoint_length_limit
< 0)
10379 else if (len
<= remote_hw_watchpoint_length_limit
)
10386 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10388 if (type
== bp_hardware_breakpoint
)
10390 if (remote_hw_breakpoint_limit
== 0)
10392 else if (remote_hw_breakpoint_limit
< 0)
10394 else if (cnt
<= remote_hw_breakpoint_limit
)
10399 if (remote_hw_watchpoint_limit
== 0)
10401 else if (remote_hw_watchpoint_limit
< 0)
10405 else if (cnt
<= remote_hw_watchpoint_limit
)
10411 /* The to_stopped_by_sw_breakpoint method of target remote. */
10414 remote_target::stopped_by_sw_breakpoint ()
10416 struct thread_info
*thread
= inferior_thread ();
10418 return (thread
->priv
!= NULL
10419 && (get_remote_thread_info (thread
)->stop_reason
10420 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10423 /* The to_supports_stopped_by_sw_breakpoint method of target
10427 remote_target::supports_stopped_by_sw_breakpoint ()
10429 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10432 /* The to_stopped_by_hw_breakpoint method of target remote. */
10435 remote_target::stopped_by_hw_breakpoint ()
10437 struct thread_info
*thread
= inferior_thread ();
10439 return (thread
->priv
!= NULL
10440 && (get_remote_thread_info (thread
)->stop_reason
10441 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10444 /* The to_supports_stopped_by_hw_breakpoint method of target
10448 remote_target::supports_stopped_by_hw_breakpoint ()
10450 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10454 remote_target::stopped_by_watchpoint ()
10456 struct thread_info
*thread
= inferior_thread ();
10458 return (thread
->priv
!= NULL
10459 && (get_remote_thread_info (thread
)->stop_reason
10460 == TARGET_STOPPED_BY_WATCHPOINT
));
10464 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10466 struct thread_info
*thread
= inferior_thread ();
10468 if (thread
->priv
!= NULL
10469 && (get_remote_thread_info (thread
)->stop_reason
10470 == TARGET_STOPPED_BY_WATCHPOINT
))
10472 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10481 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10482 struct bp_target_info
*bp_tgt
)
10484 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10485 struct remote_state
*rs
;
10489 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10492 /* Make sure the remote is pointing at the right process, if
10494 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10495 set_general_process ();
10497 rs
= get_remote_state ();
10498 p
= rs
->buf
.data ();
10499 endbuf
= p
+ get_remote_packet_size ();
10505 addr
= remote_address_masked (addr
);
10506 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10507 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10509 if (supports_evaluation_of_breakpoint_conditions ())
10510 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10512 if (can_run_breakpoint_commands ())
10513 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10516 getpkt (&rs
->buf
, 0);
10518 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10521 if (rs
->buf
[1] == '.')
10523 message
= strchr (&rs
->buf
[2], '.');
10525 error (_("Remote failure reply: %s"), message
+ 1);
10528 case PACKET_UNKNOWN
:
10533 internal_error (__FILE__
, __LINE__
,
10534 _("remote_insert_hw_breakpoint: reached end of function"));
10539 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10540 struct bp_target_info
*bp_tgt
)
10543 struct remote_state
*rs
= get_remote_state ();
10544 char *p
= rs
->buf
.data ();
10545 char *endbuf
= p
+ get_remote_packet_size ();
10547 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10550 /* Make sure the remote is pointing at the right process, if
10552 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10553 set_general_process ();
10559 addr
= remote_address_masked (bp_tgt
->placed_address
);
10560 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10561 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10564 getpkt (&rs
->buf
, 0);
10566 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10569 case PACKET_UNKNOWN
:
10574 internal_error (__FILE__
, __LINE__
,
10575 _("remote_remove_hw_breakpoint: reached end of function"));
10578 /* Verify memory using the "qCRC:" request. */
10581 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10583 struct remote_state
*rs
= get_remote_state ();
10584 unsigned long host_crc
, target_crc
;
10587 /* It doesn't make sense to use qCRC if the remote target is
10588 connected but not running. */
10589 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10591 enum packet_result result
;
10593 /* Make sure the remote is pointing at the right process. */
10594 set_general_process ();
10596 /* FIXME: assumes lma can fit into long. */
10597 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10598 (long) lma
, (long) size
);
10601 /* Be clever; compute the host_crc before waiting for target
10603 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10605 getpkt (&rs
->buf
, 0);
10607 result
= packet_ok (rs
->buf
,
10608 &remote_protocol_packets
[PACKET_qCRC
]);
10609 if (result
== PACKET_ERROR
)
10611 else if (result
== PACKET_OK
)
10613 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10614 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10616 return (host_crc
== target_crc
);
10620 return simple_verify_memory (this, data
, lma
, size
);
10623 /* compare-sections command
10625 With no arguments, compares each loadable section in the exec bfd
10626 with the same memory range on the target, and reports mismatches.
10627 Useful for verifying the image on the target against the exec file. */
10630 compare_sections_command (const char *args
, int from_tty
)
10633 const char *sectname
;
10634 bfd_size_type size
;
10637 int mismatched
= 0;
10642 error (_("command cannot be used without an exec file"));
10644 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10650 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10652 if (!(s
->flags
& SEC_LOAD
))
10653 continue; /* Skip non-loadable section. */
10655 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10656 continue; /* Skip writeable sections */
10658 size
= bfd_section_size (s
);
10660 continue; /* Skip zero-length section. */
10662 sectname
= bfd_section_name (s
);
10663 if (args
&& strcmp (args
, sectname
) != 0)
10664 continue; /* Not the section selected by user. */
10666 matched
= 1; /* Do this section. */
10669 gdb::byte_vector
sectdata (size
);
10670 bfd_get_section_contents (exec_bfd
, s
, sectdata
.data (), 0, size
);
10672 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10675 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10676 paddress (target_gdbarch (), lma
),
10677 paddress (target_gdbarch (), lma
+ size
));
10679 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10680 paddress (target_gdbarch (), lma
),
10681 paddress (target_gdbarch (), lma
+ size
));
10683 printf_filtered ("matched.\n");
10686 printf_filtered ("MIS-MATCHED!\n");
10690 if (mismatched
> 0)
10691 warning (_("One or more sections of the target image does not match\n\
10692 the loaded file\n"));
10693 if (args
&& !matched
)
10694 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10697 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10698 into remote target. The number of bytes written to the remote
10699 target is returned, or -1 for error. */
10702 remote_target::remote_write_qxfer (const char *object_name
,
10703 const char *annex
, const gdb_byte
*writebuf
,
10704 ULONGEST offset
, LONGEST len
,
10705 ULONGEST
*xfered_len
,
10706 struct packet_config
*packet
)
10710 struct remote_state
*rs
= get_remote_state ();
10711 int max_size
= get_memory_write_packet_size ();
10713 if (packet_config_support (packet
) == PACKET_DISABLE
)
10714 return TARGET_XFER_E_IO
;
10716 /* Insert header. */
10717 i
= snprintf (rs
->buf
.data (), max_size
,
10718 "qXfer:%s:write:%s:%s:",
10719 object_name
, annex
? annex
: "",
10720 phex_nz (offset
, sizeof offset
));
10721 max_size
-= (i
+ 1);
10723 /* Escape as much data as fits into rs->buf. */
10724 buf_len
= remote_escape_output
10725 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10727 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10728 || getpkt_sane (&rs
->buf
, 0) < 0
10729 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10730 return TARGET_XFER_E_IO
;
10732 unpack_varlen_hex (rs
->buf
.data (), &n
);
10735 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10738 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10739 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10740 number of bytes read is returned, or 0 for EOF, or -1 for error.
10741 The number of bytes read may be less than LEN without indicating an
10742 EOF. PACKET is checked and updated to indicate whether the remote
10743 target supports this object. */
10746 remote_target::remote_read_qxfer (const char *object_name
,
10748 gdb_byte
*readbuf
, ULONGEST offset
,
10750 ULONGEST
*xfered_len
,
10751 struct packet_config
*packet
)
10753 struct remote_state
*rs
= get_remote_state ();
10754 LONGEST i
, n
, packet_len
;
10756 if (packet_config_support (packet
) == PACKET_DISABLE
)
10757 return TARGET_XFER_E_IO
;
10759 /* Check whether we've cached an end-of-object packet that matches
10761 if (rs
->finished_object
)
10763 if (strcmp (object_name
, rs
->finished_object
) == 0
10764 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10765 && offset
== rs
->finished_offset
)
10766 return TARGET_XFER_EOF
;
10769 /* Otherwise, we're now reading something different. Discard
10771 xfree (rs
->finished_object
);
10772 xfree (rs
->finished_annex
);
10773 rs
->finished_object
= NULL
;
10774 rs
->finished_annex
= NULL
;
10777 /* Request only enough to fit in a single packet. The actual data
10778 may not, since we don't know how much of it will need to be escaped;
10779 the target is free to respond with slightly less data. We subtract
10780 five to account for the response type and the protocol frame. */
10781 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10782 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
10783 "qXfer:%s:read:%s:%s,%s",
10784 object_name
, annex
? annex
: "",
10785 phex_nz (offset
, sizeof offset
),
10786 phex_nz (n
, sizeof n
));
10787 i
= putpkt (rs
->buf
);
10789 return TARGET_XFER_E_IO
;
10792 packet_len
= getpkt_sane (&rs
->buf
, 0);
10793 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10794 return TARGET_XFER_E_IO
;
10796 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10797 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
10799 /* 'm' means there is (or at least might be) more data after this
10800 batch. That does not make sense unless there's at least one byte
10801 of data in this reply. */
10802 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10803 error (_("Remote qXfer reply contained no data."));
10805 /* Got some data. */
10806 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
10807 packet_len
- 1, readbuf
, n
);
10809 /* 'l' is an EOF marker, possibly including a final block of data,
10810 or possibly empty. If we have the final block of a non-empty
10811 object, record this fact to bypass a subsequent partial read. */
10812 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10814 rs
->finished_object
= xstrdup (object_name
);
10815 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10816 rs
->finished_offset
= offset
+ i
;
10820 return TARGET_XFER_EOF
;
10824 return TARGET_XFER_OK
;
10828 enum target_xfer_status
10829 remote_target::xfer_partial (enum target_object object
,
10830 const char *annex
, gdb_byte
*readbuf
,
10831 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10832 ULONGEST
*xfered_len
)
10834 struct remote_state
*rs
;
10838 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10840 set_remote_traceframe ();
10841 set_general_thread (inferior_ptid
);
10843 rs
= get_remote_state ();
10845 /* Handle memory using the standard memory routines. */
10846 if (object
== TARGET_OBJECT_MEMORY
)
10848 /* If the remote target is connected but not running, we should
10849 pass this request down to a lower stratum (e.g. the executable
10851 if (!target_has_execution
)
10852 return TARGET_XFER_EOF
;
10854 if (writebuf
!= NULL
)
10855 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10858 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
10862 /* Handle extra signal info using qxfer packets. */
10863 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10866 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
10867 xfered_len
, &remote_protocol_packets
10868 [PACKET_qXfer_siginfo_read
]);
10870 return remote_write_qxfer ("siginfo", annex
,
10871 writebuf
, offset
, len
, xfered_len
,
10872 &remote_protocol_packets
10873 [PACKET_qXfer_siginfo_write
]);
10876 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10879 return remote_read_qxfer ("statictrace", annex
,
10880 readbuf
, offset
, len
, xfered_len
,
10881 &remote_protocol_packets
10882 [PACKET_qXfer_statictrace_read
]);
10884 return TARGET_XFER_E_IO
;
10887 /* Only handle flash writes. */
10888 if (writebuf
!= NULL
)
10892 case TARGET_OBJECT_FLASH
:
10893 return remote_flash_write (offset
, len
, xfered_len
,
10897 return TARGET_XFER_E_IO
;
10901 /* Map pre-existing objects onto letters. DO NOT do this for new
10902 objects!!! Instead specify new query packets. */
10905 case TARGET_OBJECT_AVR
:
10909 case TARGET_OBJECT_AUXV
:
10910 gdb_assert (annex
== NULL
);
10911 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
10913 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10915 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10916 return remote_read_qxfer
10917 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
10918 &remote_protocol_packets
[PACKET_qXfer_features
]);
10920 case TARGET_OBJECT_LIBRARIES
:
10921 return remote_read_qxfer
10922 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10923 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10925 case TARGET_OBJECT_LIBRARIES_SVR4
:
10926 return remote_read_qxfer
10927 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10928 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10930 case TARGET_OBJECT_MEMORY_MAP
:
10931 gdb_assert (annex
== NULL
);
10932 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
10934 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10936 case TARGET_OBJECT_OSDATA
:
10937 /* Should only get here if we're connected. */
10938 gdb_assert (rs
->remote_desc
);
10939 return remote_read_qxfer
10940 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
10941 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
10943 case TARGET_OBJECT_THREADS
:
10944 gdb_assert (annex
== NULL
);
10945 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
10947 &remote_protocol_packets
[PACKET_qXfer_threads
]);
10949 case TARGET_OBJECT_TRACEFRAME_INFO
:
10950 gdb_assert (annex
== NULL
);
10951 return remote_read_qxfer
10952 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
10953 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
10955 case TARGET_OBJECT_FDPIC
:
10956 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
10958 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
10960 case TARGET_OBJECT_OPENVMS_UIB
:
10961 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
10963 &remote_protocol_packets
[PACKET_qXfer_uib
]);
10965 case TARGET_OBJECT_BTRACE
:
10966 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
10968 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
10970 case TARGET_OBJECT_BTRACE_CONF
:
10971 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
10973 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
10975 case TARGET_OBJECT_EXEC_FILE
:
10976 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
10978 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
10981 return TARGET_XFER_E_IO
;
10984 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
10985 large enough let the caller deal with it. */
10986 if (len
< get_remote_packet_size ())
10987 return TARGET_XFER_E_IO
;
10988 len
= get_remote_packet_size ();
10990 /* Except for querying the minimum buffer size, target must be open. */
10991 if (!rs
->remote_desc
)
10992 error (_("remote query is only available after target open"));
10994 gdb_assert (annex
!= NULL
);
10995 gdb_assert (readbuf
!= NULL
);
10997 p2
= rs
->buf
.data ();
10999 *p2
++ = query_type
;
11001 /* We used one buffer char for the remote protocol q command and
11002 another for the query type. As the remote protocol encapsulation
11003 uses 4 chars plus one extra in case we are debugging
11004 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11007 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11009 /* Bad caller may have sent forbidden characters. */
11010 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11015 gdb_assert (annex
[i
] == '\0');
11017 i
= putpkt (rs
->buf
);
11019 return TARGET_XFER_E_IO
;
11021 getpkt (&rs
->buf
, 0);
11022 strcpy ((char *) readbuf
, rs
->buf
.data ());
11024 *xfered_len
= strlen ((char *) readbuf
);
11025 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11028 /* Implementation of to_get_memory_xfer_limit. */
11031 remote_target::get_memory_xfer_limit ()
11033 return get_memory_write_packet_size ();
11037 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11038 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11039 CORE_ADDR
*found_addrp
)
11041 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11042 struct remote_state
*rs
= get_remote_state ();
11043 int max_size
= get_memory_write_packet_size ();
11044 struct packet_config
*packet
=
11045 &remote_protocol_packets
[PACKET_qSearch_memory
];
11046 /* Number of packet bytes used to encode the pattern;
11047 this could be more than PATTERN_LEN due to escape characters. */
11048 int escaped_pattern_len
;
11049 /* Amount of pattern that was encodable in the packet. */
11050 int used_pattern_len
;
11053 ULONGEST found_addr
;
11055 /* Don't go to the target if we don't have to. This is done before
11056 checking packet_config_support to avoid the possibility that a
11057 success for this edge case means the facility works in
11059 if (pattern_len
> search_space_len
)
11061 if (pattern_len
== 0)
11063 *found_addrp
= start_addr
;
11067 /* If we already know the packet isn't supported, fall back to the simple
11068 way of searching memory. */
11070 if (packet_config_support (packet
) == PACKET_DISABLE
)
11072 /* Target doesn't provided special support, fall back and use the
11073 standard support (copy memory and do the search here). */
11074 return simple_search_memory (this, start_addr
, search_space_len
,
11075 pattern
, pattern_len
, found_addrp
);
11078 /* Make sure the remote is pointing at the right process. */
11079 set_general_process ();
11081 /* Insert header. */
11082 i
= snprintf (rs
->buf
.data (), max_size
,
11083 "qSearch:memory:%s;%s;",
11084 phex_nz (start_addr
, addr_size
),
11085 phex_nz (search_space_len
, sizeof (search_space_len
)));
11086 max_size
-= (i
+ 1);
11088 /* Escape as much data as fits into rs->buf. */
11089 escaped_pattern_len
=
11090 remote_escape_output (pattern
, pattern_len
, 1,
11091 (gdb_byte
*) rs
->buf
.data () + i
,
11092 &used_pattern_len
, max_size
);
11094 /* Bail if the pattern is too large. */
11095 if (used_pattern_len
!= pattern_len
)
11096 error (_("Pattern is too large to transmit to remote target."));
11098 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11099 || getpkt_sane (&rs
->buf
, 0) < 0
11100 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11102 /* The request may not have worked because the command is not
11103 supported. If so, fall back to the simple way. */
11104 if (packet_config_support (packet
) == PACKET_DISABLE
)
11106 return simple_search_memory (this, start_addr
, search_space_len
,
11107 pattern
, pattern_len
, found_addrp
);
11112 if (rs
->buf
[0] == '0')
11114 else if (rs
->buf
[0] == '1')
11117 if (rs
->buf
[1] != ',')
11118 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11119 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11120 *found_addrp
= found_addr
;
11123 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11129 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11131 struct remote_state
*rs
= get_remote_state ();
11132 char *p
= rs
->buf
.data ();
11134 if (!rs
->remote_desc
)
11135 error (_("remote rcmd is only available after target open"));
11137 /* Send a NULL command across as an empty command. */
11138 if (command
== NULL
)
11141 /* The query prefix. */
11142 strcpy (rs
->buf
.data (), "qRcmd,");
11143 p
= strchr (rs
->buf
.data (), '\0');
11145 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11146 > get_remote_packet_size ())
11147 error (_("\"monitor\" command ``%s'' is too long."), command
);
11149 /* Encode the actual command. */
11150 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11152 if (putpkt (rs
->buf
) < 0)
11153 error (_("Communication problem with target."));
11155 /* get/display the response */
11160 /* XXX - see also remote_get_noisy_reply(). */
11161 QUIT
; /* Allow user to bail out with ^C. */
11163 if (getpkt_sane (&rs
->buf
, 0) == -1)
11165 /* Timeout. Continue to (try to) read responses.
11166 This is better than stopping with an error, assuming the stub
11167 is still executing the (long) monitor command.
11168 If needed, the user can interrupt gdb using C-c, obtaining
11169 an effect similar to stop on timeout. */
11172 buf
= rs
->buf
.data ();
11173 if (buf
[0] == '\0')
11174 error (_("Target does not support this command."));
11175 if (buf
[0] == 'O' && buf
[1] != 'K')
11177 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11180 if (strcmp (buf
, "OK") == 0)
11182 if (strlen (buf
) == 3 && buf
[0] == 'E'
11183 && isdigit (buf
[1]) && isdigit (buf
[2]))
11185 error (_("Protocol error with Rcmd"));
11187 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11189 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11191 fputc_unfiltered (c
, outbuf
);
11197 std::vector
<mem_region
>
11198 remote_target::memory_map ()
11200 std::vector
<mem_region
> result
;
11201 gdb::optional
<gdb::char_vector
> text
11202 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11205 result
= parse_memory_map (text
->data ());
11211 packet_command (const char *args
, int from_tty
)
11213 remote_target
*remote
= get_current_remote_target ();
11215 if (remote
== nullptr)
11216 error (_("command can only be used with remote target"));
11218 remote
->packet_command (args
, from_tty
);
11222 remote_target::packet_command (const char *args
, int from_tty
)
11225 error (_("remote-packet command requires packet text as argument"));
11227 puts_filtered ("sending: ");
11228 print_packet (args
);
11229 puts_filtered ("\n");
11232 remote_state
*rs
= get_remote_state ();
11234 getpkt (&rs
->buf
, 0);
11235 puts_filtered ("received: ");
11236 print_packet (rs
->buf
.data ());
11237 puts_filtered ("\n");
11241 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11243 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11245 static void threadset_test_cmd (char *cmd
, int tty
);
11247 static void threadalive_test (char *cmd
, int tty
);
11249 static void threadlist_test_cmd (char *cmd
, int tty
);
11251 int get_and_display_threadinfo (threadref
*ref
);
11253 static void threadinfo_test_cmd (char *cmd
, int tty
);
11255 static int thread_display_step (threadref
*ref
, void *context
);
11257 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11259 static void init_remote_threadtests (void);
11261 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11264 threadset_test_cmd (const char *cmd
, int tty
)
11266 int sample_thread
= SAMPLE_THREAD
;
11268 printf_filtered (_("Remote threadset test\n"));
11269 set_general_thread (sample_thread
);
11274 threadalive_test (const char *cmd
, int tty
)
11276 int sample_thread
= SAMPLE_THREAD
;
11277 int pid
= inferior_ptid
.pid ();
11278 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11280 if (remote_thread_alive (ptid
))
11281 printf_filtered ("PASS: Thread alive test\n");
11283 printf_filtered ("FAIL: Thread alive test\n");
11286 void output_threadid (char *title
, threadref
*ref
);
11289 output_threadid (char *title
, threadref
*ref
)
11293 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11295 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11299 threadlist_test_cmd (const char *cmd
, int tty
)
11302 threadref nextthread
;
11303 int done
, result_count
;
11304 threadref threadlist
[3];
11306 printf_filtered ("Remote Threadlist test\n");
11307 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11308 &result_count
, &threadlist
[0]))
11309 printf_filtered ("FAIL: threadlist test\n");
11312 threadref
*scan
= threadlist
;
11313 threadref
*limit
= scan
+ result_count
;
11315 while (scan
< limit
)
11316 output_threadid (" thread ", scan
++);
11321 display_thread_info (struct gdb_ext_thread_info
*info
)
11323 output_threadid ("Threadid: ", &info
->threadid
);
11324 printf_filtered ("Name: %s\n ", info
->shortname
);
11325 printf_filtered ("State: %s\n", info
->display
);
11326 printf_filtered ("other: %s\n\n", info
->more_display
);
11330 get_and_display_threadinfo (threadref
*ref
)
11334 struct gdb_ext_thread_info threadinfo
;
11336 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11337 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11338 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11339 display_thread_info (&threadinfo
);
11344 threadinfo_test_cmd (const char *cmd
, int tty
)
11346 int athread
= SAMPLE_THREAD
;
11350 int_to_threadref (&thread
, athread
);
11351 printf_filtered ("Remote Threadinfo test\n");
11352 if (!get_and_display_threadinfo (&thread
))
11353 printf_filtered ("FAIL cannot get thread info\n");
11357 thread_display_step (threadref
*ref
, void *context
)
11359 /* output_threadid(" threadstep ",ref); *//* simple test */
11360 return get_and_display_threadinfo (ref
);
11364 threadlist_update_test_cmd (const char *cmd
, int tty
)
11366 printf_filtered ("Remote Threadlist update test\n");
11367 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11371 init_remote_threadtests (void)
11373 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11374 _("Fetch and print the remote list of "
11375 "thread identifiers, one pkt only."));
11376 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11377 _("Fetch and display info about one thread."));
11378 add_com ("tset", class_obscure
, threadset_test_cmd
,
11379 _("Test setting to a different thread."));
11380 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11381 _("Iterate through updating all remote thread info."));
11382 add_com ("talive", class_obscure
, threadalive_test
,
11383 _("Remote thread alive test."));
11388 /* Convert a thread ID to a string. */
11391 remote_target::pid_to_str (ptid_t ptid
)
11393 struct remote_state
*rs
= get_remote_state ();
11395 if (ptid
== null_ptid
)
11396 return normal_pid_to_str (ptid
);
11397 else if (ptid
.is_pid ())
11399 /* Printing an inferior target id. */
11401 /* When multi-process extensions are off, there's no way in the
11402 remote protocol to know the remote process id, if there's any
11403 at all. There's one exception --- when we're connected with
11404 target extended-remote, and we manually attached to a process
11405 with "attach PID". We don't record anywhere a flag that
11406 allows us to distinguish that case from the case of
11407 connecting with extended-remote and the stub already being
11408 attached to a process, and reporting yes to qAttached, hence
11409 no smart special casing here. */
11410 if (!remote_multi_process_p (rs
))
11411 return "Remote target";
11413 return normal_pid_to_str (ptid
);
11417 if (magic_null_ptid
== ptid
)
11418 return "Thread <main>";
11419 else if (remote_multi_process_p (rs
))
11420 if (ptid
.lwp () == 0)
11421 return normal_pid_to_str (ptid
);
11423 return string_printf ("Thread %d.%ld",
11424 ptid
.pid (), ptid
.lwp ());
11426 return string_printf ("Thread %ld", ptid
.lwp ());
11430 /* Get the address of the thread local variable in OBJFILE which is
11431 stored at OFFSET within the thread local storage for thread PTID. */
11434 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11437 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11439 struct remote_state
*rs
= get_remote_state ();
11440 char *p
= rs
->buf
.data ();
11441 char *endp
= p
+ get_remote_packet_size ();
11442 enum packet_result result
;
11444 strcpy (p
, "qGetTLSAddr:");
11446 p
= write_ptid (p
, endp
, ptid
);
11448 p
+= hexnumstr (p
, offset
);
11450 p
+= hexnumstr (p
, lm
);
11454 getpkt (&rs
->buf
, 0);
11455 result
= packet_ok (rs
->buf
,
11456 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11457 if (result
== PACKET_OK
)
11461 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11464 else if (result
== PACKET_UNKNOWN
)
11465 throw_error (TLS_GENERIC_ERROR
,
11466 _("Remote target doesn't support qGetTLSAddr packet"));
11468 throw_error (TLS_GENERIC_ERROR
,
11469 _("Remote target failed to process qGetTLSAddr request"));
11472 throw_error (TLS_GENERIC_ERROR
,
11473 _("TLS not supported or disabled on this target"));
11478 /* Provide thread local base, i.e. Thread Information Block address.
11479 Returns 1 if ptid is found and thread_local_base is non zero. */
11482 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11484 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11486 struct remote_state
*rs
= get_remote_state ();
11487 char *p
= rs
->buf
.data ();
11488 char *endp
= p
+ get_remote_packet_size ();
11489 enum packet_result result
;
11491 strcpy (p
, "qGetTIBAddr:");
11493 p
= write_ptid (p
, endp
, ptid
);
11497 getpkt (&rs
->buf
, 0);
11498 result
= packet_ok (rs
->buf
,
11499 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11500 if (result
== PACKET_OK
)
11503 unpack_varlen_hex (rs
->buf
.data (), &val
);
11505 *addr
= (CORE_ADDR
) val
;
11508 else if (result
== PACKET_UNKNOWN
)
11509 error (_("Remote target doesn't support qGetTIBAddr packet"));
11511 error (_("Remote target failed to process qGetTIBAddr request"));
11514 error (_("qGetTIBAddr not supported or disabled on this target"));
11519 /* Support for inferring a target description based on the current
11520 architecture and the size of a 'g' packet. While the 'g' packet
11521 can have any size (since optional registers can be left off the
11522 end), some sizes are easily recognizable given knowledge of the
11523 approximate architecture. */
11525 struct remote_g_packet_guess
11527 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11534 const struct target_desc
*tdesc
;
11537 struct remote_g_packet_data
: public allocate_on_obstack
11539 std::vector
<remote_g_packet_guess
> guesses
;
11542 static struct gdbarch_data
*remote_g_packet_data_handle
;
11545 remote_g_packet_data_init (struct obstack
*obstack
)
11547 return new (obstack
) remote_g_packet_data
;
11551 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11552 const struct target_desc
*tdesc
)
11554 struct remote_g_packet_data
*data
11555 = ((struct remote_g_packet_data
*)
11556 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11558 gdb_assert (tdesc
!= NULL
);
11560 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11561 if (guess
.bytes
== bytes
)
11562 internal_error (__FILE__
, __LINE__
,
11563 _("Duplicate g packet description added for size %d"),
11566 data
->guesses
.emplace_back (bytes
, tdesc
);
11569 /* Return true if remote_read_description would do anything on this target
11570 and architecture, false otherwise. */
11573 remote_read_description_p (struct target_ops
*target
)
11575 struct remote_g_packet_data
*data
11576 = ((struct remote_g_packet_data
*)
11577 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11579 return !data
->guesses
.empty ();
11582 const struct target_desc
*
11583 remote_target::read_description ()
11585 struct remote_g_packet_data
*data
11586 = ((struct remote_g_packet_data
*)
11587 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11589 /* Do not try this during initial connection, when we do not know
11590 whether there is a running but stopped thread. */
11591 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
11592 return beneath ()->read_description ();
11594 if (!data
->guesses
.empty ())
11596 int bytes
= send_g_packet ();
11598 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11599 if (guess
.bytes
== bytes
)
11600 return guess
.tdesc
;
11602 /* We discard the g packet. A minor optimization would be to
11603 hold on to it, and fill the register cache once we have selected
11604 an architecture, but it's too tricky to do safely. */
11607 return beneath ()->read_description ();
11610 /* Remote file transfer support. This is host-initiated I/O, not
11611 target-initiated; for target-initiated, see remote-fileio.c. */
11613 /* If *LEFT is at least the length of STRING, copy STRING to
11614 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11615 decrease *LEFT. Otherwise raise an error. */
11618 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11620 int len
= strlen (string
);
11623 error (_("Packet too long for target."));
11625 memcpy (*buffer
, string
, len
);
11629 /* NUL-terminate the buffer as a convenience, if there is
11635 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11636 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11637 decrease *LEFT. Otherwise raise an error. */
11640 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11643 if (2 * len
> *left
)
11644 error (_("Packet too long for target."));
11646 bin2hex (bytes
, *buffer
, len
);
11647 *buffer
+= 2 * len
;
11650 /* NUL-terminate the buffer as a convenience, if there is
11656 /* If *LEFT is large enough, convert VALUE to hex and add it to
11657 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11658 decrease *LEFT. Otherwise raise an error. */
11661 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11663 int len
= hexnumlen (value
);
11666 error (_("Packet too long for target."));
11668 hexnumstr (*buffer
, value
);
11672 /* NUL-terminate the buffer as a convenience, if there is
11678 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11679 value, *REMOTE_ERRNO to the remote error number or zero if none
11680 was included, and *ATTACHMENT to point to the start of the annex
11681 if any. The length of the packet isn't needed here; there may
11682 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11684 Return 0 if the packet could be parsed, -1 if it could not. If
11685 -1 is returned, the other variables may not be initialized. */
11688 remote_hostio_parse_result (char *buffer
, int *retcode
,
11689 int *remote_errno
, char **attachment
)
11694 *attachment
= NULL
;
11696 if (buffer
[0] != 'F')
11700 *retcode
= strtol (&buffer
[1], &p
, 16);
11701 if (errno
!= 0 || p
== &buffer
[1])
11704 /* Check for ",errno". */
11708 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11709 if (errno
!= 0 || p
+ 1 == p2
)
11714 /* Check for ";attachment". If there is no attachment, the
11715 packet should end here. */
11718 *attachment
= p
+ 1;
11721 else if (*p
== '\0')
11727 /* Send a prepared I/O packet to the target and read its response.
11728 The prepared packet is in the global RS->BUF before this function
11729 is called, and the answer is there when we return.
11731 COMMAND_BYTES is the length of the request to send, which may include
11732 binary data. WHICH_PACKET is the packet configuration to check
11733 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11734 is set to the error number and -1 is returned. Otherwise the value
11735 returned by the function is returned.
11737 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11738 attachment is expected; an error will be reported if there's a
11739 mismatch. If one is found, *ATTACHMENT will be set to point into
11740 the packet buffer and *ATTACHMENT_LEN will be set to the
11741 attachment's length. */
11744 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11745 int *remote_errno
, char **attachment
,
11746 int *attachment_len
)
11748 struct remote_state
*rs
= get_remote_state ();
11749 int ret
, bytes_read
;
11750 char *attachment_tmp
;
11752 if (packet_support (which_packet
) == PACKET_DISABLE
)
11754 *remote_errno
= FILEIO_ENOSYS
;
11758 putpkt_binary (rs
->buf
.data (), command_bytes
);
11759 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11761 /* If it timed out, something is wrong. Don't try to parse the
11763 if (bytes_read
< 0)
11765 *remote_errno
= FILEIO_EINVAL
;
11769 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11772 *remote_errno
= FILEIO_EINVAL
;
11774 case PACKET_UNKNOWN
:
11775 *remote_errno
= FILEIO_ENOSYS
;
11781 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
11784 *remote_errno
= FILEIO_EINVAL
;
11788 /* Make sure we saw an attachment if and only if we expected one. */
11789 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11790 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11792 *remote_errno
= FILEIO_EINVAL
;
11796 /* If an attachment was found, it must point into the packet buffer;
11797 work out how many bytes there were. */
11798 if (attachment_tmp
!= NULL
)
11800 *attachment
= attachment_tmp
;
11801 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
11807 /* See declaration.h. */
11810 readahead_cache::invalidate ()
11815 /* See declaration.h. */
11818 readahead_cache::invalidate_fd (int fd
)
11820 if (this->fd
== fd
)
11824 /* Set the filesystem remote_hostio functions that take FILENAME
11825 arguments will use. Return 0 on success, or -1 if an error
11826 occurs (and set *REMOTE_ERRNO). */
11829 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
11832 struct remote_state
*rs
= get_remote_state ();
11833 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11834 char *p
= rs
->buf
.data ();
11835 int left
= get_remote_packet_size () - 1;
11839 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11842 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11845 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11847 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11848 remote_buffer_add_string (&p
, &left
, arg
);
11850 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
11851 remote_errno
, NULL
, NULL
);
11853 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11857 rs
->fs_pid
= required_pid
;
11862 /* Implementation of to_fileio_open. */
11865 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
11866 int flags
, int mode
, int warn_if_slow
,
11869 struct remote_state
*rs
= get_remote_state ();
11870 char *p
= rs
->buf
.data ();
11871 int left
= get_remote_packet_size () - 1;
11875 static int warning_issued
= 0;
11877 printf_unfiltered (_("Reading %s from remote target...\n"),
11880 if (!warning_issued
)
11882 warning (_("File transfers from remote targets can be slow."
11883 " Use \"set sysroot\" to access files locally"
11885 warning_issued
= 1;
11889 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11892 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11894 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11895 strlen (filename
));
11896 remote_buffer_add_string (&p
, &left
, ",");
11898 remote_buffer_add_int (&p
, &left
, flags
);
11899 remote_buffer_add_string (&p
, &left
, ",");
11901 remote_buffer_add_int (&p
, &left
, mode
);
11903 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
11904 remote_errno
, NULL
, NULL
);
11908 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
11909 int flags
, int mode
, int warn_if_slow
,
11912 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
11916 /* Implementation of to_fileio_pwrite. */
11919 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11920 ULONGEST offset
, int *remote_errno
)
11922 struct remote_state
*rs
= get_remote_state ();
11923 char *p
= rs
->buf
.data ();
11924 int left
= get_remote_packet_size ();
11927 rs
->readahead_cache
.invalidate_fd (fd
);
11929 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11931 remote_buffer_add_int (&p
, &left
, fd
);
11932 remote_buffer_add_string (&p
, &left
, ",");
11934 remote_buffer_add_int (&p
, &left
, offset
);
11935 remote_buffer_add_string (&p
, &left
, ",");
11937 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
11938 (get_remote_packet_size ()
11939 - (p
- rs
->buf
.data ())));
11941 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
11942 remote_errno
, NULL
, NULL
);
11946 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11947 ULONGEST offset
, int *remote_errno
)
11949 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
11952 /* Helper for the implementation of to_fileio_pread. Read the file
11953 from the remote side with vFile:pread. */
11956 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
11957 ULONGEST offset
, int *remote_errno
)
11959 struct remote_state
*rs
= get_remote_state ();
11960 char *p
= rs
->buf
.data ();
11962 int left
= get_remote_packet_size ();
11963 int ret
, attachment_len
;
11966 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
11968 remote_buffer_add_int (&p
, &left
, fd
);
11969 remote_buffer_add_string (&p
, &left
, ",");
11971 remote_buffer_add_int (&p
, &left
, len
);
11972 remote_buffer_add_string (&p
, &left
, ",");
11974 remote_buffer_add_int (&p
, &left
, offset
);
11976 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
11977 remote_errno
, &attachment
,
11983 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11985 if (read_len
!= ret
)
11986 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
11991 /* See declaration.h. */
11994 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
11998 && this->offset
<= offset
11999 && offset
< this->offset
+ this->bufsize
)
12001 ULONGEST max
= this->offset
+ this->bufsize
;
12003 if (offset
+ len
> max
)
12004 len
= max
- offset
;
12006 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12013 /* Implementation of to_fileio_pread. */
12016 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12017 ULONGEST offset
, int *remote_errno
)
12020 struct remote_state
*rs
= get_remote_state ();
12021 readahead_cache
*cache
= &rs
->readahead_cache
;
12023 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12026 cache
->hit_count
++;
12029 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12030 pulongest (cache
->hit_count
));
12034 cache
->miss_count
++;
12036 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12037 pulongest (cache
->miss_count
));
12040 cache
->offset
= offset
;
12041 cache
->bufsize
= get_remote_packet_size ();
12042 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12044 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12045 cache
->offset
, remote_errno
);
12048 cache
->invalidate_fd (fd
);
12052 cache
->bufsize
= ret
;
12053 return cache
->pread (fd
, read_buf
, len
, offset
);
12057 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12058 ULONGEST offset
, int *remote_errno
)
12060 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12063 /* Implementation of to_fileio_close. */
12066 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12068 struct remote_state
*rs
= get_remote_state ();
12069 char *p
= rs
->buf
.data ();
12070 int left
= get_remote_packet_size () - 1;
12072 rs
->readahead_cache
.invalidate_fd (fd
);
12074 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12076 remote_buffer_add_int (&p
, &left
, fd
);
12078 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12079 remote_errno
, NULL
, NULL
);
12083 remote_target::fileio_close (int fd
, int *remote_errno
)
12085 return remote_hostio_close (fd
, remote_errno
);
12088 /* Implementation of to_fileio_unlink. */
12091 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12094 struct remote_state
*rs
= get_remote_state ();
12095 char *p
= rs
->buf
.data ();
12096 int left
= get_remote_packet_size () - 1;
12098 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12101 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12103 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12104 strlen (filename
));
12106 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12107 remote_errno
, NULL
, NULL
);
12111 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12114 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12117 /* Implementation of to_fileio_readlink. */
12119 gdb::optional
<std::string
>
12120 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12123 struct remote_state
*rs
= get_remote_state ();
12124 char *p
= rs
->buf
.data ();
12126 int left
= get_remote_packet_size ();
12127 int len
, attachment_len
;
12130 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12133 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12135 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12136 strlen (filename
));
12138 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12139 remote_errno
, &attachment
,
12145 std::string
ret (len
, '\0');
12147 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12148 (gdb_byte
*) &ret
[0], len
);
12149 if (read_len
!= len
)
12150 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12155 /* Implementation of to_fileio_fstat. */
12158 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12160 struct remote_state
*rs
= get_remote_state ();
12161 char *p
= rs
->buf
.data ();
12162 int left
= get_remote_packet_size ();
12163 int attachment_len
, ret
;
12165 struct fio_stat fst
;
12168 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12170 remote_buffer_add_int (&p
, &left
, fd
);
12172 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12173 remote_errno
, &attachment
,
12177 if (*remote_errno
!= FILEIO_ENOSYS
)
12180 /* Strictly we should return -1, ENOSYS here, but when
12181 "set sysroot remote:" was implemented in August 2008
12182 BFD's need for a stat function was sidestepped with
12183 this hack. This was not remedied until March 2015
12184 so we retain the previous behavior to avoid breaking
12187 Note that the memset is a March 2015 addition; older
12188 GDBs set st_size *and nothing else* so the structure
12189 would have garbage in all other fields. This might
12190 break something but retaining the previous behavior
12191 here would be just too wrong. */
12193 memset (st
, 0, sizeof (struct stat
));
12194 st
->st_size
= INT_MAX
;
12198 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12199 (gdb_byte
*) &fst
, sizeof (fst
));
12201 if (read_len
!= ret
)
12202 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12204 if (read_len
!= sizeof (fst
))
12205 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12206 read_len
, (int) sizeof (fst
));
12208 remote_fileio_to_host_stat (&fst
, st
);
12213 /* Implementation of to_filesystem_is_local. */
12216 remote_target::filesystem_is_local ()
12218 /* Valgrind GDB presents itself as a remote target but works
12219 on the local filesystem: it does not implement remote get
12220 and users are not expected to set a sysroot. To handle
12221 this case we treat the remote filesystem as local if the
12222 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12223 does not support vFile:open. */
12224 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12226 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12228 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12230 int fd
, remote_errno
;
12232 /* Try opening a file to probe support. The supplied
12233 filename is irrelevant, we only care about whether
12234 the stub recognizes the packet or not. */
12235 fd
= remote_hostio_open (NULL
, "just probing",
12236 FILEIO_O_RDONLY
, 0700, 0,
12240 remote_hostio_close (fd
, &remote_errno
);
12242 ps
= packet_support (PACKET_vFile_open
);
12245 if (ps
== PACKET_DISABLE
)
12247 static int warning_issued
= 0;
12249 if (!warning_issued
)
12251 warning (_("remote target does not support file"
12252 " transfer, attempting to access files"
12253 " from local filesystem."));
12254 warning_issued
= 1;
12265 remote_fileio_errno_to_host (int errnum
)
12271 case FILEIO_ENOENT
:
12279 case FILEIO_EACCES
:
12281 case FILEIO_EFAULT
:
12285 case FILEIO_EEXIST
:
12287 case FILEIO_ENODEV
:
12289 case FILEIO_ENOTDIR
:
12291 case FILEIO_EISDIR
:
12293 case FILEIO_EINVAL
:
12295 case FILEIO_ENFILE
:
12297 case FILEIO_EMFILE
:
12301 case FILEIO_ENOSPC
:
12303 case FILEIO_ESPIPE
:
12307 case FILEIO_ENOSYS
:
12309 case FILEIO_ENAMETOOLONG
:
12310 return ENAMETOOLONG
;
12316 remote_hostio_error (int errnum
)
12318 int host_error
= remote_fileio_errno_to_host (errnum
);
12320 if (host_error
== -1)
12321 error (_("Unknown remote I/O error %d"), errnum
);
12323 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12326 /* A RAII wrapper around a remote file descriptor. */
12328 class scoped_remote_fd
12331 scoped_remote_fd (remote_target
*remote
, int fd
)
12332 : m_remote (remote
), m_fd (fd
)
12336 ~scoped_remote_fd ()
12343 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12347 /* Swallow exception before it escapes the dtor. If
12348 something goes wrong, likely the connection is gone,
12349 and there's nothing else that can be done. */
12354 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12356 /* Release ownership of the file descriptor, and return it. */
12357 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12364 /* Return the owned file descriptor. */
12365 int get () const noexcept
12371 /* The remote target. */
12372 remote_target
*m_remote
;
12374 /* The owned remote I/O file descriptor. */
12379 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12381 remote_target
*remote
= get_current_remote_target ();
12383 if (remote
== nullptr)
12384 error (_("command can only be used with remote target"));
12386 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12390 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12393 int retcode
, remote_errno
, bytes
, io_size
;
12394 int bytes_in_buffer
;
12398 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12400 perror_with_name (local_file
);
12402 scoped_remote_fd fd
12403 (this, remote_hostio_open (NULL
,
12404 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12406 0700, 0, &remote_errno
));
12407 if (fd
.get () == -1)
12408 remote_hostio_error (remote_errno
);
12410 /* Send up to this many bytes at once. They won't all fit in the
12411 remote packet limit, so we'll transfer slightly fewer. */
12412 io_size
= get_remote_packet_size ();
12413 gdb::byte_vector
buffer (io_size
);
12415 bytes_in_buffer
= 0;
12418 while (bytes_in_buffer
|| !saw_eof
)
12422 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12423 io_size
- bytes_in_buffer
,
12427 if (ferror (file
.get ()))
12428 error (_("Error reading %s."), local_file
);
12431 /* EOF. Unless there is something still in the
12432 buffer from the last iteration, we are done. */
12434 if (bytes_in_buffer
== 0)
12442 bytes
+= bytes_in_buffer
;
12443 bytes_in_buffer
= 0;
12445 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12446 offset
, &remote_errno
);
12449 remote_hostio_error (remote_errno
);
12450 else if (retcode
== 0)
12451 error (_("Remote write of %d bytes returned 0!"), bytes
);
12452 else if (retcode
< bytes
)
12454 /* Short write. Save the rest of the read data for the next
12456 bytes_in_buffer
= bytes
- retcode
;
12457 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12463 if (remote_hostio_close (fd
.release (), &remote_errno
))
12464 remote_hostio_error (remote_errno
);
12467 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12471 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12473 remote_target
*remote
= get_current_remote_target ();
12475 if (remote
== nullptr)
12476 error (_("command can only be used with remote target"));
12478 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12482 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12485 int remote_errno
, bytes
, io_size
;
12488 scoped_remote_fd fd
12489 (this, remote_hostio_open (NULL
,
12490 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12492 if (fd
.get () == -1)
12493 remote_hostio_error (remote_errno
);
12495 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12497 perror_with_name (local_file
);
12499 /* Send up to this many bytes at once. They won't all fit in the
12500 remote packet limit, so we'll transfer slightly fewer. */
12501 io_size
= get_remote_packet_size ();
12502 gdb::byte_vector
buffer (io_size
);
12507 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12510 /* Success, but no bytes, means end-of-file. */
12513 remote_hostio_error (remote_errno
);
12517 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12519 perror_with_name (local_file
);
12522 if (remote_hostio_close (fd
.release (), &remote_errno
))
12523 remote_hostio_error (remote_errno
);
12526 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12530 remote_file_delete (const char *remote_file
, int from_tty
)
12532 remote_target
*remote
= get_current_remote_target ();
12534 if (remote
== nullptr)
12535 error (_("command can only be used with remote target"));
12537 remote
->remote_file_delete (remote_file
, from_tty
);
12541 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12543 int retcode
, remote_errno
;
12545 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12547 remote_hostio_error (remote_errno
);
12550 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12554 remote_put_command (const char *args
, int from_tty
)
12557 error_no_arg (_("file to put"));
12559 gdb_argv
argv (args
);
12560 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12561 error (_("Invalid parameters to remote put"));
12563 remote_file_put (argv
[0], argv
[1], from_tty
);
12567 remote_get_command (const char *args
, int from_tty
)
12570 error_no_arg (_("file to get"));
12572 gdb_argv
argv (args
);
12573 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12574 error (_("Invalid parameters to remote get"));
12576 remote_file_get (argv
[0], argv
[1], from_tty
);
12580 remote_delete_command (const char *args
, int from_tty
)
12583 error_no_arg (_("file to delete"));
12585 gdb_argv
argv (args
);
12586 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12587 error (_("Invalid parameters to remote delete"));
12589 remote_file_delete (argv
[0], from_tty
);
12593 remote_command (const char *args
, int from_tty
)
12595 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12599 remote_target::can_execute_reverse ()
12601 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12602 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12609 remote_target::supports_non_stop ()
12615 remote_target::supports_disable_randomization ()
12617 /* Only supported in extended mode. */
12622 remote_target::supports_multi_process ()
12624 struct remote_state
*rs
= get_remote_state ();
12626 return remote_multi_process_p (rs
);
12630 remote_supports_cond_tracepoints ()
12632 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12636 remote_target::supports_evaluation_of_breakpoint_conditions ()
12638 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12642 remote_supports_fast_tracepoints ()
12644 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12648 remote_supports_static_tracepoints ()
12650 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12654 remote_supports_install_in_trace ()
12656 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12660 remote_target::supports_enable_disable_tracepoint ()
12662 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12667 remote_target::supports_string_tracing ()
12669 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12673 remote_target::can_run_breakpoint_commands ()
12675 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12679 remote_target::trace_init ()
12681 struct remote_state
*rs
= get_remote_state ();
12684 remote_get_noisy_reply ();
12685 if (strcmp (rs
->buf
.data (), "OK") != 0)
12686 error (_("Target does not support this command."));
12689 /* Recursive routine to walk through command list including loops, and
12690 download packets for each command. */
12693 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12694 struct command_line
*cmds
)
12696 struct remote_state
*rs
= get_remote_state ();
12697 struct command_line
*cmd
;
12699 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12701 QUIT
; /* Allow user to bail out with ^C. */
12702 strcpy (rs
->buf
.data (), "QTDPsrc:");
12703 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12704 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12705 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12707 remote_get_noisy_reply ();
12708 if (strcmp (rs
->buf
.data (), "OK"))
12709 warning (_("Target does not support source download."));
12711 if (cmd
->control_type
== while_control
12712 || cmd
->control_type
== while_stepping_control
)
12714 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12716 QUIT
; /* Allow user to bail out with ^C. */
12717 strcpy (rs
->buf
.data (), "QTDPsrc:");
12718 encode_source_string (num
, addr
, "cmd", "end",
12719 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12720 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12722 remote_get_noisy_reply ();
12723 if (strcmp (rs
->buf
.data (), "OK"))
12724 warning (_("Target does not support source download."));
12730 remote_target::download_tracepoint (struct bp_location
*loc
)
12734 std::vector
<std::string
> tdp_actions
;
12735 std::vector
<std::string
> stepping_actions
;
12737 struct breakpoint
*b
= loc
->owner
;
12738 struct tracepoint
*t
= (struct tracepoint
*) b
;
12739 struct remote_state
*rs
= get_remote_state ();
12741 const char *err_msg
= _("Tracepoint packet too large for target.");
12744 /* We use a buffer other than rs->buf because we'll build strings
12745 across multiple statements, and other statements in between could
12747 gdb::char_vector
buf (get_remote_packet_size ());
12749 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12751 tpaddr
= loc
->address
;
12752 sprintf_vma (addrbuf
, tpaddr
);
12753 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12754 b
->number
, addrbuf
, /* address */
12755 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12756 t
->step_count
, t
->pass_count
);
12758 if (ret
< 0 || ret
>= buf
.size ())
12759 error ("%s", err_msg
);
12761 /* Fast tracepoints are mostly handled by the target, but we can
12762 tell the target how big of an instruction block should be moved
12764 if (b
->type
== bp_fast_tracepoint
)
12766 /* Only test for support at download time; we may not know
12767 target capabilities at definition time. */
12768 if (remote_supports_fast_tracepoints ())
12770 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12773 size_left
= buf
.size () - strlen (buf
.data ());
12774 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12776 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12778 if (ret
< 0 || ret
>= size_left
)
12779 error ("%s", err_msg
);
12782 /* If it passed validation at definition but fails now,
12783 something is very wrong. */
12784 internal_error (__FILE__
, __LINE__
,
12785 _("Fast tracepoint not "
12786 "valid during download"));
12789 /* Fast tracepoints are functionally identical to regular
12790 tracepoints, so don't take lack of support as a reason to
12791 give up on the trace run. */
12792 warning (_("Target does not support fast tracepoints, "
12793 "downloading %d as regular tracepoint"), b
->number
);
12795 else if (b
->type
== bp_static_tracepoint
)
12797 /* Only test for support at download time; we may not know
12798 target capabilities at definition time. */
12799 if (remote_supports_static_tracepoints ())
12801 struct static_tracepoint_marker marker
;
12803 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12805 size_left
= buf
.size () - strlen (buf
.data ());
12806 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12809 if (ret
< 0 || ret
>= size_left
)
12810 error ("%s", err_msg
);
12813 error (_("Static tracepoint not valid during download"));
12816 /* Fast tracepoints are functionally identical to regular
12817 tracepoints, so don't take lack of support as a reason
12818 to give up on the trace run. */
12819 error (_("Target does not support static tracepoints"));
12821 /* If the tracepoint has a conditional, make it into an agent
12822 expression and append to the definition. */
12825 /* Only test support at download time, we may not know target
12826 capabilities at definition time. */
12827 if (remote_supports_cond_tracepoints ())
12829 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
12832 size_left
= buf
.size () - strlen (buf
.data ());
12834 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12835 size_left
, ":X%x,", aexpr
->len
);
12837 if (ret
< 0 || ret
>= size_left
)
12838 error ("%s", err_msg
);
12840 size_left
= buf
.size () - strlen (buf
.data ());
12842 /* Two bytes to encode each aexpr byte, plus the terminating
12844 if (aexpr
->len
* 2 + 1 > size_left
)
12845 error ("%s", err_msg
);
12847 pkt
= buf
.data () + strlen (buf
.data ());
12849 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12850 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12854 warning (_("Target does not support conditional tracepoints, "
12855 "ignoring tp %d cond"), b
->number
);
12858 if (b
->commands
|| *default_collect
)
12860 size_left
= buf
.size () - strlen (buf
.data ());
12862 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12865 if (ret
< 0 || ret
>= size_left
)
12866 error ("%s", err_msg
);
12869 putpkt (buf
.data ());
12870 remote_get_noisy_reply ();
12871 if (strcmp (rs
->buf
.data (), "OK"))
12872 error (_("Target does not support tracepoints."));
12874 /* do_single_steps (t); */
12875 for (auto action_it
= tdp_actions
.begin ();
12876 action_it
!= tdp_actions
.end (); action_it
++)
12878 QUIT
; /* Allow user to bail out with ^C. */
12880 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
12881 || !stepping_actions
.empty ());
12883 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
12884 b
->number
, addrbuf
, /* address */
12885 action_it
->c_str (),
12886 has_more
? '-' : 0);
12888 if (ret
< 0 || ret
>= buf
.size ())
12889 error ("%s", err_msg
);
12891 putpkt (buf
.data ());
12892 remote_get_noisy_reply ();
12893 if (strcmp (rs
->buf
.data (), "OK"))
12894 error (_("Error on target while setting tracepoints."));
12897 for (auto action_it
= stepping_actions
.begin ();
12898 action_it
!= stepping_actions
.end (); action_it
++)
12900 QUIT
; /* Allow user to bail out with ^C. */
12902 bool is_first
= action_it
== stepping_actions
.begin ();
12903 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
12905 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
12906 b
->number
, addrbuf
, /* address */
12907 is_first
? "S" : "",
12908 action_it
->c_str (),
12909 has_more
? "-" : "");
12911 if (ret
< 0 || ret
>= buf
.size ())
12912 error ("%s", err_msg
);
12914 putpkt (buf
.data ());
12915 remote_get_noisy_reply ();
12916 if (strcmp (rs
->buf
.data (), "OK"))
12917 error (_("Error on target while setting tracepoints."));
12920 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12922 if (b
->location
!= NULL
)
12924 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12926 if (ret
< 0 || ret
>= buf
.size ())
12927 error ("%s", err_msg
);
12929 encode_source_string (b
->number
, loc
->address
, "at",
12930 event_location_to_string (b
->location
.get ()),
12931 buf
.data () + strlen (buf
.data ()),
12932 buf
.size () - strlen (buf
.data ()));
12933 putpkt (buf
.data ());
12934 remote_get_noisy_reply ();
12935 if (strcmp (rs
->buf
.data (), "OK"))
12936 warning (_("Target does not support source download."));
12938 if (b
->cond_string
)
12940 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12942 if (ret
< 0 || ret
>= buf
.size ())
12943 error ("%s", err_msg
);
12945 encode_source_string (b
->number
, loc
->address
,
12946 "cond", b
->cond_string
,
12947 buf
.data () + strlen (buf
.data ()),
12948 buf
.size () - strlen (buf
.data ()));
12949 putpkt (buf
.data ());
12950 remote_get_noisy_reply ();
12951 if (strcmp (rs
->buf
.data (), "OK"))
12952 warning (_("Target does not support source download."));
12954 remote_download_command_source (b
->number
, loc
->address
,
12955 breakpoint_commands (b
));
12960 remote_target::can_download_tracepoint ()
12962 struct remote_state
*rs
= get_remote_state ();
12963 struct trace_status
*ts
;
12966 /* Don't try to install tracepoints until we've relocated our
12967 symbols, and fetched and merged the target's tracepoint list with
12969 if (rs
->starting_up
)
12972 ts
= current_trace_status ();
12973 status
= get_trace_status (ts
);
12975 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
12978 /* If we are in a tracing experiment, but remote stub doesn't support
12979 installing tracepoint in trace, we have to return. */
12980 if (!remote_supports_install_in_trace ())
12988 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
12990 struct remote_state
*rs
= get_remote_state ();
12993 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
12994 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
12996 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
12997 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
12998 >= get_remote_packet_size ())
12999 error (_("Trace state variable name too long for tsv definition packet"));
13000 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13003 remote_get_noisy_reply ();
13004 if (rs
->buf
[0] == '\0')
13005 error (_("Target does not support this command."));
13006 if (strcmp (rs
->buf
.data (), "OK") != 0)
13007 error (_("Error on target while downloading trace state variable."));
13011 remote_target::enable_tracepoint (struct bp_location
*location
)
13013 struct remote_state
*rs
= get_remote_state ();
13016 sprintf_vma (addr_buf
, location
->address
);
13017 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13018 location
->owner
->number
, addr_buf
);
13020 remote_get_noisy_reply ();
13021 if (rs
->buf
[0] == '\0')
13022 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13023 if (strcmp (rs
->buf
.data (), "OK") != 0)
13024 error (_("Error on target while enabling tracepoint."));
13028 remote_target::disable_tracepoint (struct bp_location
*location
)
13030 struct remote_state
*rs
= get_remote_state ();
13033 sprintf_vma (addr_buf
, location
->address
);
13034 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13035 location
->owner
->number
, addr_buf
);
13037 remote_get_noisy_reply ();
13038 if (rs
->buf
[0] == '\0')
13039 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13040 if (strcmp (rs
->buf
.data (), "OK") != 0)
13041 error (_("Error on target while disabling tracepoint."));
13045 remote_target::trace_set_readonly_regions ()
13048 bfd_size_type size
;
13054 return; /* No information to give. */
13056 struct remote_state
*rs
= get_remote_state ();
13058 strcpy (rs
->buf
.data (), "QTro");
13059 offset
= strlen (rs
->buf
.data ());
13060 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
13062 char tmp1
[40], tmp2
[40];
13065 if ((s
->flags
& SEC_LOAD
) == 0 ||
13066 /* (s->flags & SEC_CODE) == 0 || */
13067 (s
->flags
& SEC_READONLY
) == 0)
13071 vma
= bfd_section_vma (s
);
13072 size
= bfd_section_size (s
);
13073 sprintf_vma (tmp1
, vma
);
13074 sprintf_vma (tmp2
, vma
+ size
);
13075 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13076 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13078 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13080 Too many sections for read-only sections definition packet."));
13083 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13085 offset
+= sec_length
;
13090 getpkt (&rs
->buf
, 0);
13095 remote_target::trace_start ()
13097 struct remote_state
*rs
= get_remote_state ();
13099 putpkt ("QTStart");
13100 remote_get_noisy_reply ();
13101 if (rs
->buf
[0] == '\0')
13102 error (_("Target does not support this command."));
13103 if (strcmp (rs
->buf
.data (), "OK") != 0)
13104 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13108 remote_target::get_trace_status (struct trace_status
*ts
)
13110 /* Initialize it just to avoid a GCC false warning. */
13112 enum packet_result result
;
13113 struct remote_state
*rs
= get_remote_state ();
13115 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13118 /* FIXME we need to get register block size some other way. */
13119 trace_regblock_size
13120 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13122 putpkt ("qTStatus");
13126 p
= remote_get_noisy_reply ();
13128 catch (const gdb_exception_error
&ex
)
13130 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13132 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13138 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13140 /* If the remote target doesn't do tracing, flag it. */
13141 if (result
== PACKET_UNKNOWN
)
13144 /* We're working with a live target. */
13145 ts
->filename
= NULL
;
13148 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13150 /* Function 'parse_trace_status' sets default value of each field of
13151 'ts' at first, so we don't have to do it here. */
13152 parse_trace_status (p
, ts
);
13154 return ts
->running
;
13158 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13159 struct uploaded_tp
*utp
)
13161 struct remote_state
*rs
= get_remote_state ();
13163 struct bp_location
*loc
;
13164 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13165 size_t size
= get_remote_packet_size ();
13170 tp
->traceframe_usage
= 0;
13171 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13173 /* If the tracepoint was never downloaded, don't go asking for
13175 if (tp
->number_on_target
== 0)
13177 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13178 phex_nz (loc
->address
, 0));
13180 reply
= remote_get_noisy_reply ();
13181 if (reply
&& *reply
)
13184 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13190 utp
->hit_count
= 0;
13191 utp
->traceframe_usage
= 0;
13192 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13193 phex_nz (utp
->addr
, 0));
13195 reply
= remote_get_noisy_reply ();
13196 if (reply
&& *reply
)
13199 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13205 remote_target::trace_stop ()
13207 struct remote_state
*rs
= get_remote_state ();
13210 remote_get_noisy_reply ();
13211 if (rs
->buf
[0] == '\0')
13212 error (_("Target does not support this command."));
13213 if (strcmp (rs
->buf
.data (), "OK") != 0)
13214 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13218 remote_target::trace_find (enum trace_find_type type
, int num
,
13219 CORE_ADDR addr1
, CORE_ADDR addr2
,
13222 struct remote_state
*rs
= get_remote_state ();
13223 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13225 int target_frameno
= -1, target_tracept
= -1;
13227 /* Lookups other than by absolute frame number depend on the current
13228 trace selected, so make sure it is correct on the remote end
13230 if (type
!= tfind_number
)
13231 set_remote_traceframe ();
13233 p
= rs
->buf
.data ();
13234 strcpy (p
, "QTFrame:");
13235 p
= strchr (p
, '\0');
13239 xsnprintf (p
, endbuf
- p
, "%x", num
);
13242 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13245 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13248 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13249 phex_nz (addr2
, 0));
13251 case tfind_outside
:
13252 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13253 phex_nz (addr2
, 0));
13256 error (_("Unknown trace find type %d"), type
);
13260 reply
= remote_get_noisy_reply ();
13261 if (*reply
== '\0')
13262 error (_("Target does not support this command."));
13264 while (reply
&& *reply
)
13269 target_frameno
= (int) strtol (p
, &reply
, 16);
13271 error (_("Unable to parse trace frame number"));
13272 /* Don't update our remote traceframe number cache on failure
13273 to select a remote traceframe. */
13274 if (target_frameno
== -1)
13279 target_tracept
= (int) strtol (p
, &reply
, 16);
13281 error (_("Unable to parse tracepoint number"));
13283 case 'O': /* "OK"? */
13284 if (reply
[1] == 'K' && reply
[2] == '\0')
13287 error (_("Bogus reply from target: %s"), reply
);
13290 error (_("Bogus reply from target: %s"), reply
);
13293 *tpp
= target_tracept
;
13295 rs
->remote_traceframe_number
= target_frameno
;
13296 return target_frameno
;
13300 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13302 struct remote_state
*rs
= get_remote_state ();
13306 set_remote_traceframe ();
13308 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13310 reply
= remote_get_noisy_reply ();
13311 if (reply
&& *reply
)
13315 unpack_varlen_hex (reply
+ 1, &uval
);
13316 *val
= (LONGEST
) uval
;
13324 remote_target::save_trace_data (const char *filename
)
13326 struct remote_state
*rs
= get_remote_state ();
13329 p
= rs
->buf
.data ();
13330 strcpy (p
, "QTSave:");
13332 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13333 >= get_remote_packet_size ())
13334 error (_("Remote file name too long for trace save packet"));
13335 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13338 reply
= remote_get_noisy_reply ();
13339 if (*reply
== '\0')
13340 error (_("Target does not support this command."));
13341 if (strcmp (reply
, "OK") != 0)
13342 error (_("Bogus reply from target: %s"), reply
);
13346 /* This is basically a memory transfer, but needs to be its own packet
13347 because we don't know how the target actually organizes its trace
13348 memory, plus we want to be able to ask for as much as possible, but
13349 not be unhappy if we don't get as much as we ask for. */
13352 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13354 struct remote_state
*rs
= get_remote_state ();
13359 p
= rs
->buf
.data ();
13360 strcpy (p
, "qTBuffer:");
13362 p
+= hexnumstr (p
, offset
);
13364 p
+= hexnumstr (p
, len
);
13368 reply
= remote_get_noisy_reply ();
13369 if (reply
&& *reply
)
13371 /* 'l' by itself means we're at the end of the buffer and
13372 there is nothing more to get. */
13376 /* Convert the reply into binary. Limit the number of bytes to
13377 convert according to our passed-in buffer size, rather than
13378 what was returned in the packet; if the target is
13379 unexpectedly generous and gives us a bigger reply than we
13380 asked for, we don't want to crash. */
13381 rslt
= hex2bin (reply
, buf
, len
);
13385 /* Something went wrong, flag as an error. */
13390 remote_target::set_disconnected_tracing (int val
)
13392 struct remote_state
*rs
= get_remote_state ();
13394 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13398 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13399 "QTDisconnected:%x", val
);
13401 reply
= remote_get_noisy_reply ();
13402 if (*reply
== '\0')
13403 error (_("Target does not support this command."));
13404 if (strcmp (reply
, "OK") != 0)
13405 error (_("Bogus reply from target: %s"), reply
);
13408 warning (_("Target does not support disconnected tracing."));
13412 remote_target::core_of_thread (ptid_t ptid
)
13414 struct thread_info
*info
= find_thread_ptid (ptid
);
13416 if (info
!= NULL
&& info
->priv
!= NULL
)
13417 return get_remote_thread_info (info
)->core
;
13423 remote_target::set_circular_trace_buffer (int val
)
13425 struct remote_state
*rs
= get_remote_state ();
13428 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13429 "QTBuffer:circular:%x", val
);
13431 reply
= remote_get_noisy_reply ();
13432 if (*reply
== '\0')
13433 error (_("Target does not support this command."));
13434 if (strcmp (reply
, "OK") != 0)
13435 error (_("Bogus reply from target: %s"), reply
);
13439 remote_target::traceframe_info ()
13441 gdb::optional
<gdb::char_vector
> text
13442 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13445 return parse_traceframe_info (text
->data ());
13450 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13451 instruction on which a fast tracepoint may be placed. Returns -1
13452 if the packet is not supported, and 0 if the minimum instruction
13453 length is unknown. */
13456 remote_target::get_min_fast_tracepoint_insn_len ()
13458 struct remote_state
*rs
= get_remote_state ();
13461 /* If we're not debugging a process yet, the IPA can't be
13463 if (!target_has_execution
)
13466 /* Make sure the remote is pointing at the right process. */
13467 set_general_process ();
13469 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13471 reply
= remote_get_noisy_reply ();
13472 if (*reply
== '\0')
13476 ULONGEST min_insn_len
;
13478 unpack_varlen_hex (reply
, &min_insn_len
);
13480 return (int) min_insn_len
;
13485 remote_target::set_trace_buffer_size (LONGEST val
)
13487 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13489 struct remote_state
*rs
= get_remote_state ();
13490 char *buf
= rs
->buf
.data ();
13491 char *endbuf
= buf
+ get_remote_packet_size ();
13492 enum packet_result result
;
13494 gdb_assert (val
>= 0 || val
== -1);
13495 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13496 /* Send -1 as literal "-1" to avoid host size dependency. */
13500 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13503 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13506 remote_get_noisy_reply ();
13507 result
= packet_ok (rs
->buf
,
13508 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13510 if (result
!= PACKET_OK
)
13511 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13516 remote_target::set_trace_notes (const char *user
, const char *notes
,
13517 const char *stop_notes
)
13519 struct remote_state
*rs
= get_remote_state ();
13521 char *buf
= rs
->buf
.data ();
13522 char *endbuf
= buf
+ get_remote_packet_size ();
13525 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13528 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13529 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13535 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13536 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13542 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13543 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13547 /* Ensure the buffer is terminated. */
13551 reply
= remote_get_noisy_reply ();
13552 if (*reply
== '\0')
13555 if (strcmp (reply
, "OK") != 0)
13556 error (_("Bogus reply from target: %s"), reply
);
13562 remote_target::use_agent (bool use
)
13564 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13566 struct remote_state
*rs
= get_remote_state ();
13568 /* If the stub supports QAgent. */
13569 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13571 getpkt (&rs
->buf
, 0);
13573 if (strcmp (rs
->buf
.data (), "OK") == 0)
13584 remote_target::can_use_agent ()
13586 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13589 struct btrace_target_info
13591 /* The ptid of the traced thread. */
13594 /* The obtained branch trace configuration. */
13595 struct btrace_config conf
;
13598 /* Reset our idea of our target's btrace configuration. */
13601 remote_btrace_reset (remote_state
*rs
)
13603 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13606 /* Synchronize the configuration with the target. */
13609 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13611 struct packet_config
*packet
;
13612 struct remote_state
*rs
;
13613 char *buf
, *pos
, *endbuf
;
13615 rs
= get_remote_state ();
13616 buf
= rs
->buf
.data ();
13617 endbuf
= buf
+ get_remote_packet_size ();
13619 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13620 if (packet_config_support (packet
) == PACKET_ENABLE
13621 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13624 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13628 getpkt (&rs
->buf
, 0);
13630 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13632 if (buf
[0] == 'E' && buf
[1] == '.')
13633 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13635 error (_("Failed to configure the BTS buffer size."));
13638 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13641 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13642 if (packet_config_support (packet
) == PACKET_ENABLE
13643 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13646 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13650 getpkt (&rs
->buf
, 0);
13652 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13654 if (buf
[0] == 'E' && buf
[1] == '.')
13655 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13657 error (_("Failed to configure the trace buffer size."));
13660 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13664 /* Read the current thread's btrace configuration from the target and
13665 store it into CONF. */
13668 btrace_read_config (struct btrace_config
*conf
)
13670 gdb::optional
<gdb::char_vector
> xml
13671 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13673 parse_xml_btrace_conf (conf
, xml
->data ());
13676 /* Maybe reopen target btrace. */
13679 remote_target::remote_btrace_maybe_reopen ()
13681 struct remote_state
*rs
= get_remote_state ();
13682 int btrace_target_pushed
= 0;
13683 #if !defined (HAVE_LIBIPT)
13687 /* Don't bother walking the entirety of the remote thread list when
13688 we know the feature isn't supported by the remote. */
13689 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13692 scoped_restore_current_thread restore_thread
;
13694 for (thread_info
*tp
: all_non_exited_threads ())
13696 set_general_thread (tp
->ptid
);
13698 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13699 btrace_read_config (&rs
->btrace_config
);
13701 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13704 #if !defined (HAVE_LIBIPT)
13705 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13710 warning (_("Target is recording using Intel Processor Trace "
13711 "but support was disabled at compile time."));
13716 #endif /* !defined (HAVE_LIBIPT) */
13718 /* Push target, once, but before anything else happens. This way our
13719 changes to the threads will be cleaned up by unpushing the target
13720 in case btrace_read_config () throws. */
13721 if (!btrace_target_pushed
)
13723 btrace_target_pushed
= 1;
13724 record_btrace_push_target ();
13725 printf_filtered (_("Target is recording using %s.\n"),
13726 btrace_format_string (rs
->btrace_config
.format
));
13729 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13730 tp
->btrace
.target
->ptid
= tp
->ptid
;
13731 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13735 /* Enable branch tracing. */
13737 struct btrace_target_info
*
13738 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13740 struct btrace_target_info
*tinfo
= NULL
;
13741 struct packet_config
*packet
= NULL
;
13742 struct remote_state
*rs
= get_remote_state ();
13743 char *buf
= rs
->buf
.data ();
13744 char *endbuf
= buf
+ get_remote_packet_size ();
13746 switch (conf
->format
)
13748 case BTRACE_FORMAT_BTS
:
13749 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13752 case BTRACE_FORMAT_PT
:
13753 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13757 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13758 error (_("Target does not support branch tracing."));
13760 btrace_sync_conf (conf
);
13762 set_general_thread (ptid
);
13764 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13766 getpkt (&rs
->buf
, 0);
13768 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13770 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13771 error (_("Could not enable branch tracing for %s: %s"),
13772 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
13774 error (_("Could not enable branch tracing for %s."),
13775 target_pid_to_str (ptid
).c_str ());
13778 tinfo
= XCNEW (struct btrace_target_info
);
13779 tinfo
->ptid
= ptid
;
13781 /* If we fail to read the configuration, we lose some information, but the
13782 tracing itself is not impacted. */
13785 btrace_read_config (&tinfo
->conf
);
13787 catch (const gdb_exception_error
&err
)
13789 if (err
.message
!= NULL
)
13790 warning ("%s", err
.what ());
13796 /* Disable branch tracing. */
13799 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
13801 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13802 struct remote_state
*rs
= get_remote_state ();
13803 char *buf
= rs
->buf
.data ();
13804 char *endbuf
= buf
+ get_remote_packet_size ();
13806 if (packet_config_support (packet
) != PACKET_ENABLE
)
13807 error (_("Target does not support branch tracing."));
13809 set_general_thread (tinfo
->ptid
);
13811 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13813 getpkt (&rs
->buf
, 0);
13815 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13817 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13818 error (_("Could not disable branch tracing for %s: %s"),
13819 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
13821 error (_("Could not disable branch tracing for %s."),
13822 target_pid_to_str (tinfo
->ptid
).c_str ());
13828 /* Teardown branch tracing. */
13831 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
13833 /* We must not talk to the target during teardown. */
13837 /* Read the branch trace. */
13840 remote_target::read_btrace (struct btrace_data
*btrace
,
13841 struct btrace_target_info
*tinfo
,
13842 enum btrace_read_type type
)
13844 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13847 if (packet_config_support (packet
) != PACKET_ENABLE
)
13848 error (_("Target does not support branch tracing."));
13850 #if !defined(HAVE_LIBEXPAT)
13851 error (_("Cannot process branch tracing result. XML parsing not supported."));
13856 case BTRACE_READ_ALL
:
13859 case BTRACE_READ_NEW
:
13862 case BTRACE_READ_DELTA
:
13866 internal_error (__FILE__
, __LINE__
,
13867 _("Bad branch tracing read type: %u."),
13868 (unsigned int) type
);
13871 gdb::optional
<gdb::char_vector
> xml
13872 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
13874 return BTRACE_ERR_UNKNOWN
;
13876 parse_xml_btrace (btrace
, xml
->data ());
13878 return BTRACE_ERR_NONE
;
13881 const struct btrace_config
*
13882 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
13884 return &tinfo
->conf
;
13888 remote_target::augmented_libraries_svr4_read ()
13890 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13894 /* Implementation of to_load. */
13897 remote_target::load (const char *name
, int from_tty
)
13899 generic_load (name
, from_tty
);
13902 /* Accepts an integer PID; returns a string representing a file that
13903 can be opened on the remote side to get the symbols for the child
13904 process. Returns NULL if the operation is not supported. */
13907 remote_target::pid_to_exec_file (int pid
)
13909 static gdb::optional
<gdb::char_vector
> filename
;
13910 struct inferior
*inf
;
13911 char *annex
= NULL
;
13913 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13916 inf
= find_inferior_pid (pid
);
13918 internal_error (__FILE__
, __LINE__
,
13919 _("not currently attached to process %d"), pid
);
13921 if (!inf
->fake_pid_p
)
13923 const int annex_size
= 9;
13925 annex
= (char *) alloca (annex_size
);
13926 xsnprintf (annex
, annex_size
, "%x", pid
);
13929 filename
= target_read_stralloc (current_top_target (),
13930 TARGET_OBJECT_EXEC_FILE
, annex
);
13932 return filename
? filename
->data () : nullptr;
13935 /* Implement the to_can_do_single_step target_ops method. */
13938 remote_target::can_do_single_step ()
13940 /* We can only tell whether target supports single step or not by
13941 supported s and S vCont actions if the stub supports vContSupported
13942 feature. If the stub doesn't support vContSupported feature,
13943 we have conservatively to think target doesn't supports single
13945 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
13947 struct remote_state
*rs
= get_remote_state ();
13949 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13950 remote_vcont_probe ();
13952 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
13958 /* Implementation of the to_execution_direction method for the remote
13961 enum exec_direction_kind
13962 remote_target::execution_direction ()
13964 struct remote_state
*rs
= get_remote_state ();
13966 return rs
->last_resume_exec_dir
;
13969 /* Return pointer to the thread_info struct which corresponds to
13970 THREAD_HANDLE (having length HANDLE_LEN). */
13973 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
13977 for (thread_info
*tp
: all_non_exited_threads ())
13979 remote_thread_info
*priv
= get_remote_thread_info (tp
);
13981 if (tp
->inf
== inf
&& priv
!= NULL
)
13983 if (handle_len
!= priv
->thread_handle
.size ())
13984 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
13985 handle_len
, priv
->thread_handle
.size ());
13986 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
13996 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
13998 remote_thread_info
*priv
= get_remote_thread_info (tp
);
13999 return priv
->thread_handle
;
14003 remote_target::can_async_p ()
14005 struct remote_state
*rs
= get_remote_state ();
14007 /* We don't go async if the user has explicitly prevented it with the
14008 "maint set target-async" command. */
14009 if (!target_async_permitted
)
14012 /* We're async whenever the serial device is. */
14013 return serial_can_async_p (rs
->remote_desc
);
14017 remote_target::is_async_p ()
14019 struct remote_state
*rs
= get_remote_state ();
14021 if (!target_async_permitted
)
14022 /* We only enable async when the user specifically asks for it. */
14025 /* We're async whenever the serial device is. */
14026 return serial_is_async_p (rs
->remote_desc
);
14029 /* Pass the SERIAL event on and up to the client. One day this code
14030 will be able to delay notifying the client of an event until the
14031 point where an entire packet has been received. */
14033 static serial_event_ftype remote_async_serial_handler
;
14036 remote_async_serial_handler (struct serial
*scb
, void *context
)
14038 /* Don't propogate error information up to the client. Instead let
14039 the client find out about the error by querying the target. */
14040 inferior_event_handler (INF_REG_EVENT
, NULL
);
14044 remote_async_inferior_event_handler (gdb_client_data data
)
14046 inferior_event_handler (INF_REG_EVENT
, data
);
14050 remote_target::async (int enable
)
14052 struct remote_state
*rs
= get_remote_state ();
14056 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14058 /* If there are pending events in the stop reply queue tell the
14059 event loop to process them. */
14060 if (!rs
->stop_reply_queue
.empty ())
14061 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14062 /* For simplicity, below we clear the pending events token
14063 without remembering whether it is marked, so here we always
14064 mark it. If there's actually no pending notification to
14065 process, this ends up being a no-op (other than a spurious
14066 event-loop wakeup). */
14067 if (target_is_non_stop_p ())
14068 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14072 serial_async (rs
->remote_desc
, NULL
, NULL
);
14073 /* If the core is disabling async, it doesn't want to be
14074 disturbed with target events. Clear all async event sources
14076 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14077 if (target_is_non_stop_p ())
14078 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14082 /* Implementation of the to_thread_events method. */
14085 remote_target::thread_events (int enable
)
14087 struct remote_state
*rs
= get_remote_state ();
14088 size_t size
= get_remote_packet_size ();
14090 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14093 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14095 getpkt (&rs
->buf
, 0);
14097 switch (packet_ok (rs
->buf
,
14098 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14101 if (strcmp (rs
->buf
.data (), "OK") != 0)
14102 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14105 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14107 case PACKET_UNKNOWN
:
14113 set_remote_cmd (const char *args
, int from_tty
)
14115 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
14119 show_remote_cmd (const char *args
, int from_tty
)
14121 /* We can't just use cmd_show_list here, because we want to skip
14122 the redundant "show remote Z-packet" and the legacy aliases. */
14123 struct cmd_list_element
*list
= remote_show_cmdlist
;
14124 struct ui_out
*uiout
= current_uiout
;
14126 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14127 for (; list
!= NULL
; list
= list
->next
)
14128 if (strcmp (list
->name
, "Z-packet") == 0)
14130 else if (list
->type
== not_set_cmd
)
14131 /* Alias commands are exactly like the original, except they
14132 don't have the normal type. */
14136 ui_out_emit_tuple
option_emitter (uiout
, "option");
14138 uiout
->field_string ("name", list
->name
);
14139 uiout
->text (": ");
14140 if (list
->type
== show_cmd
)
14141 do_show_command (NULL
, from_tty
, list
);
14143 cmd_func (list
, NULL
, from_tty
);
14148 /* Function to be called whenever a new objfile (shlib) is detected. */
14150 remote_new_objfile (struct objfile
*objfile
)
14152 remote_target
*remote
= get_current_remote_target ();
14154 if (remote
!= NULL
) /* Have a remote connection. */
14155 remote
->remote_check_symbols ();
14158 /* Pull all the tracepoints defined on the target and create local
14159 data structures representing them. We don't want to create real
14160 tracepoints yet, we don't want to mess up the user's existing
14164 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14166 struct remote_state
*rs
= get_remote_state ();
14169 /* Ask for a first packet of tracepoint definition. */
14171 getpkt (&rs
->buf
, 0);
14172 p
= rs
->buf
.data ();
14173 while (*p
&& *p
!= 'l')
14175 parse_tracepoint_definition (p
, utpp
);
14176 /* Ask for another packet of tracepoint definition. */
14178 getpkt (&rs
->buf
, 0);
14179 p
= rs
->buf
.data ();
14185 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14187 struct remote_state
*rs
= get_remote_state ();
14190 /* Ask for a first packet of variable definition. */
14192 getpkt (&rs
->buf
, 0);
14193 p
= rs
->buf
.data ();
14194 while (*p
&& *p
!= 'l')
14196 parse_tsv_definition (p
, utsvp
);
14197 /* Ask for another packet of variable definition. */
14199 getpkt (&rs
->buf
, 0);
14200 p
= rs
->buf
.data ();
14205 /* The "set/show range-stepping" show hook. */
14208 show_range_stepping (struct ui_file
*file
, int from_tty
,
14209 struct cmd_list_element
*c
,
14212 fprintf_filtered (file
,
14213 _("Debugger's willingness to use range stepping "
14214 "is %s.\n"), value
);
14217 /* Return true if the vCont;r action is supported by the remote
14221 remote_target::vcont_r_supported ()
14223 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14224 remote_vcont_probe ();
14226 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14227 && get_remote_state ()->supports_vCont
.r
);
14230 /* The "set/show range-stepping" set hook. */
14233 set_range_stepping (const char *ignore_args
, int from_tty
,
14234 struct cmd_list_element
*c
)
14236 /* When enabling, check whether range stepping is actually supported
14237 by the target, and warn if not. */
14238 if (use_range_stepping
)
14240 remote_target
*remote
= get_current_remote_target ();
14242 || !remote
->vcont_r_supported ())
14243 warning (_("Range stepping is not supported by the current target"));
14248 _initialize_remote (void)
14250 struct cmd_list_element
*cmd
;
14251 const char *cmd_name
;
14253 /* architecture specific data */
14254 remote_g_packet_data_handle
=
14255 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14257 add_target (remote_target_info
, remote_target::open
);
14258 add_target (extended_remote_target_info
, extended_remote_target::open
);
14260 /* Hook into new objfile notification. */
14261 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14264 init_remote_threadtests ();
14267 /* set/show remote ... */
14269 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14270 Remote protocol specific variables.\n\
14271 Configure various remote-protocol specific variables such as\n\
14272 the packets being used."),
14273 &remote_set_cmdlist
, "set remote ",
14274 0 /* allow-unknown */, &setlist
);
14275 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14276 Remote protocol specific variables.\n\
14277 Configure various remote-protocol specific variables such as\n\
14278 the packets being used."),
14279 &remote_show_cmdlist
, "show remote ",
14280 0 /* allow-unknown */, &showlist
);
14282 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14283 Compare section data on target to the exec file.\n\
14284 Argument is a single section name (default: all loaded sections).\n\
14285 To compare only read-only loaded sections, specify the -r option."),
14288 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14289 Send an arbitrary packet to a remote target.\n\
14290 maintenance packet TEXT\n\
14291 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14292 this command sends the string TEXT to the inferior, and displays the\n\
14293 response packet. GDB supplies the initial `$' character, and the\n\
14294 terminating `#' character and checksum."),
14297 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14298 Set whether to send break if interrupted."), _("\
14299 Show whether to send break if interrupted."), _("\
14300 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14301 set_remotebreak
, show_remotebreak
,
14302 &setlist
, &showlist
);
14303 cmd_name
= "remotebreak";
14304 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14305 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14306 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14307 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14308 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14310 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14311 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14313 Set interrupt sequence to remote target."), _("\
14314 Show interrupt sequence to remote target."), _("\
14315 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14316 NULL
, show_interrupt_sequence
,
14317 &remote_set_cmdlist
,
14318 &remote_show_cmdlist
);
14320 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14321 &interrupt_on_connect
, _("\
14322 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14323 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14324 If set, interrupt sequence is sent to remote target."),
14326 &remote_set_cmdlist
, &remote_show_cmdlist
);
14328 /* Install commands for configuring memory read/write packets. */
14330 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14331 Set the maximum number of bytes per memory write packet (deprecated)."),
14333 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14334 Show the maximum number of bytes per memory write packet (deprecated)."),
14336 add_cmd ("memory-write-packet-size", no_class
,
14337 set_memory_write_packet_size
, _("\
14338 Set the maximum number of bytes per memory-write packet.\n\
14339 Specify the number of bytes in a packet or 0 (zero) for the\n\
14340 default packet size. The actual limit is further reduced\n\
14341 dependent on the target. Specify ``fixed'' to disable the\n\
14342 further restriction and ``limit'' to enable that restriction."),
14343 &remote_set_cmdlist
);
14344 add_cmd ("memory-read-packet-size", no_class
,
14345 set_memory_read_packet_size
, _("\
14346 Set the maximum number of bytes per memory-read packet.\n\
14347 Specify the number of bytes in a packet or 0 (zero) for the\n\
14348 default packet size. The actual limit is further reduced\n\
14349 dependent on the target. Specify ``fixed'' to disable the\n\
14350 further restriction and ``limit'' to enable that restriction."),
14351 &remote_set_cmdlist
);
14352 add_cmd ("memory-write-packet-size", no_class
,
14353 show_memory_write_packet_size
,
14354 _("Show the maximum number of bytes per memory-write packet."),
14355 &remote_show_cmdlist
);
14356 add_cmd ("memory-read-packet-size", no_class
,
14357 show_memory_read_packet_size
,
14358 _("Show the maximum number of bytes per memory-read packet."),
14359 &remote_show_cmdlist
);
14361 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14362 &remote_hw_watchpoint_limit
, _("\
14363 Set the maximum number of target hardware watchpoints."), _("\
14364 Show the maximum number of target hardware watchpoints."), _("\
14365 Specify \"unlimited\" for unlimited hardware watchpoints."),
14366 NULL
, show_hardware_watchpoint_limit
,
14367 &remote_set_cmdlist
,
14368 &remote_show_cmdlist
);
14369 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14371 &remote_hw_watchpoint_length_limit
, _("\
14372 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14373 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14374 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14375 NULL
, show_hardware_watchpoint_length_limit
,
14376 &remote_set_cmdlist
, &remote_show_cmdlist
);
14377 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14378 &remote_hw_breakpoint_limit
, _("\
14379 Set the maximum number of target hardware breakpoints."), _("\
14380 Show the maximum number of target hardware breakpoints."), _("\
14381 Specify \"unlimited\" for unlimited hardware breakpoints."),
14382 NULL
, show_hardware_breakpoint_limit
,
14383 &remote_set_cmdlist
, &remote_show_cmdlist
);
14385 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14386 &remote_address_size
, _("\
14387 Set the maximum size of the address (in bits) in a memory packet."), _("\
14388 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14390 NULL
, /* FIXME: i18n: */
14391 &setlist
, &showlist
);
14393 init_all_packet_configs ();
14395 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14396 "X", "binary-download", 1);
14398 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14399 "vCont", "verbose-resume", 0);
14401 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14402 "QPassSignals", "pass-signals", 0);
14404 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14405 "QCatchSyscalls", "catch-syscalls", 0);
14407 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14408 "QProgramSignals", "program-signals", 0);
14410 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14411 "QSetWorkingDir", "set-working-dir", 0);
14413 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14414 "QStartupWithShell", "startup-with-shell", 0);
14416 add_packet_config_cmd (&remote_protocol_packets
14417 [PACKET_QEnvironmentHexEncoded
],
14418 "QEnvironmentHexEncoded", "environment-hex-encoded",
14421 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14422 "QEnvironmentReset", "environment-reset",
14425 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14426 "QEnvironmentUnset", "environment-unset",
14429 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14430 "qSymbol", "symbol-lookup", 0);
14432 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14433 "P", "set-register", 1);
14435 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14436 "p", "fetch-register", 1);
14438 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14439 "Z0", "software-breakpoint", 0);
14441 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14442 "Z1", "hardware-breakpoint", 0);
14444 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14445 "Z2", "write-watchpoint", 0);
14447 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14448 "Z3", "read-watchpoint", 0);
14450 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14451 "Z4", "access-watchpoint", 0);
14453 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14454 "qXfer:auxv:read", "read-aux-vector", 0);
14456 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14457 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14459 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14460 "qXfer:features:read", "target-features", 0);
14462 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14463 "qXfer:libraries:read", "library-info", 0);
14465 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14466 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14468 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14469 "qXfer:memory-map:read", "memory-map", 0);
14471 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14472 "qXfer:osdata:read", "osdata", 0);
14474 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14475 "qXfer:threads:read", "threads", 0);
14477 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14478 "qXfer:siginfo:read", "read-siginfo-object", 0);
14480 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14481 "qXfer:siginfo:write", "write-siginfo-object", 0);
14483 add_packet_config_cmd
14484 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14485 "qXfer:traceframe-info:read", "traceframe-info", 0);
14487 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14488 "qXfer:uib:read", "unwind-info-block", 0);
14490 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14491 "qGetTLSAddr", "get-thread-local-storage-address",
14494 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14495 "qGetTIBAddr", "get-thread-information-block-address",
14498 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14499 "bc", "reverse-continue", 0);
14501 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14502 "bs", "reverse-step", 0);
14504 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14505 "qSupported", "supported-packets", 0);
14507 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14508 "qSearch:memory", "search-memory", 0);
14510 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14511 "qTStatus", "trace-status", 0);
14513 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14514 "vFile:setfs", "hostio-setfs", 0);
14516 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14517 "vFile:open", "hostio-open", 0);
14519 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14520 "vFile:pread", "hostio-pread", 0);
14522 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14523 "vFile:pwrite", "hostio-pwrite", 0);
14525 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14526 "vFile:close", "hostio-close", 0);
14528 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14529 "vFile:unlink", "hostio-unlink", 0);
14531 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14532 "vFile:readlink", "hostio-readlink", 0);
14534 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14535 "vFile:fstat", "hostio-fstat", 0);
14537 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14538 "vAttach", "attach", 0);
14540 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14543 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14544 "QStartNoAckMode", "noack", 0);
14546 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14547 "vKill", "kill", 0);
14549 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14550 "qAttached", "query-attached", 0);
14552 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14553 "ConditionalTracepoints",
14554 "conditional-tracepoints", 0);
14556 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14557 "ConditionalBreakpoints",
14558 "conditional-breakpoints", 0);
14560 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14561 "BreakpointCommands",
14562 "breakpoint-commands", 0);
14564 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14565 "FastTracepoints", "fast-tracepoints", 0);
14567 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14568 "TracepointSource", "TracepointSource", 0);
14570 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14571 "QAllow", "allow", 0);
14573 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14574 "StaticTracepoints", "static-tracepoints", 0);
14576 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14577 "InstallInTrace", "install-in-trace", 0);
14579 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14580 "qXfer:statictrace:read", "read-sdata-object", 0);
14582 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14583 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14585 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14586 "QDisableRandomization", "disable-randomization", 0);
14588 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14589 "QAgent", "agent", 0);
14591 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14592 "QTBuffer:size", "trace-buffer-size", 0);
14594 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14595 "Qbtrace:off", "disable-btrace", 0);
14597 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14598 "Qbtrace:bts", "enable-btrace-bts", 0);
14600 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14601 "Qbtrace:pt", "enable-btrace-pt", 0);
14603 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14604 "qXfer:btrace", "read-btrace", 0);
14606 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14607 "qXfer:btrace-conf", "read-btrace-conf", 0);
14609 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14610 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14612 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14613 "multiprocess-feature", "multiprocess-feature", 0);
14615 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14616 "swbreak-feature", "swbreak-feature", 0);
14618 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14619 "hwbreak-feature", "hwbreak-feature", 0);
14621 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14622 "fork-event-feature", "fork-event-feature", 0);
14624 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14625 "vfork-event-feature", "vfork-event-feature", 0);
14627 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14628 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14630 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14631 "vContSupported", "verbose-resume-supported", 0);
14633 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14634 "exec-event-feature", "exec-event-feature", 0);
14636 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14637 "vCtrlC", "ctrl-c", 0);
14639 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14640 "QThreadEvents", "thread-events", 0);
14642 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14643 "N stop reply", "no-resumed-stop-reply", 0);
14645 /* Assert that we've registered "set remote foo-packet" commands
14646 for all packet configs. */
14650 for (i
= 0; i
< PACKET_MAX
; i
++)
14652 /* Ideally all configs would have a command associated. Some
14653 still don't though. */
14658 case PACKET_QNonStop
:
14659 case PACKET_EnableDisableTracepoints_feature
:
14660 case PACKET_tracenz_feature
:
14661 case PACKET_DisconnectedTracing_feature
:
14662 case PACKET_augmented_libraries_svr4_read_feature
:
14664 /* Additions to this list need to be well justified:
14665 pre-existing packets are OK; new packets are not. */
14673 /* This catches both forgetting to add a config command, and
14674 forgetting to remove a packet from the exception list. */
14675 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14679 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14680 Z sub-packet has its own set and show commands, but users may
14681 have sets to this variable in their .gdbinit files (or in their
14683 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14684 &remote_Z_packet_detect
, _("\
14685 Set use of remote protocol `Z' packets."), _("\
14686 Show use of remote protocol `Z' packets."), _("\
14687 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14689 set_remote_protocol_Z_packet_cmd
,
14690 show_remote_protocol_Z_packet_cmd
,
14691 /* FIXME: i18n: Use of remote protocol
14692 `Z' packets is %s. */
14693 &remote_set_cmdlist
, &remote_show_cmdlist
);
14695 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14696 Manipulate files on the remote system.\n\
14697 Transfer files to and from the remote target system."),
14698 &remote_cmdlist
, "remote ",
14699 0 /* allow-unknown */, &cmdlist
);
14701 add_cmd ("put", class_files
, remote_put_command
,
14702 _("Copy a local file to the remote system."),
14705 add_cmd ("get", class_files
, remote_get_command
,
14706 _("Copy a remote file to the local system."),
14709 add_cmd ("delete", class_files
, remote_delete_command
,
14710 _("Delete a remote file."),
14713 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14714 &remote_exec_file_var
, _("\
14715 Set the remote pathname for \"run\"."), _("\
14716 Show the remote pathname for \"run\"."), NULL
,
14717 set_remote_exec_file
,
14718 show_remote_exec_file
,
14719 &remote_set_cmdlist
,
14720 &remote_show_cmdlist
);
14722 add_setshow_boolean_cmd ("range-stepping", class_run
,
14723 &use_range_stepping
, _("\
14724 Enable or disable range stepping."), _("\
14725 Show whether target-assisted range stepping is enabled."), _("\
14726 If on, and the target supports it, when stepping a source line, GDB\n\
14727 tells the target to step the corresponding range of addresses itself instead\n\
14728 of issuing multiple single-steps. This speeds up source level\n\
14729 stepping. If off, GDB always issues single-steps, even if range\n\
14730 stepping is supported by the target. The default is on."),
14731 set_range_stepping
,
14732 show_range_stepping
,
14736 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
14737 Set watchdog timer."), _("\
14738 Show watchdog timer."), _("\
14739 When non-zero, this timeout is used instead of waiting forever for a target\n\
14740 to finish a low-level step or continue operation. If the specified amount\n\
14741 of time passes without a response from the target, an error occurs."),
14744 &setlist
, &showlist
);
14746 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
14747 &remote_packet_max_chars
, _("\
14748 Set the maximum number of characters to display for each remote packet."), _("\
14749 Show the maximum number of characters to display for each remote packet."), _("\
14750 Specify \"unlimited\" to display all the characters."),
14751 NULL
, show_remote_packet_max_chars
,
14752 &setdebuglist
, &showdebuglist
);
14754 /* Eventually initialize fileio. See fileio.c */
14755 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);