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
;
281 /* Whether vCont support was probed already. This is a workaround
282 until packet_support is per-connection. */
283 bool supports_vCont_probed
;
285 /* True if the user has pressed Ctrl-C, but the target hasn't
286 responded to that. */
287 bool ctrlc_pending_p
= false;
289 /* True if we saw a Ctrl-C while reading or writing from/to the
290 remote descriptor. At that point it is not safe to send a remote
291 interrupt packet, so we instead remember we saw the Ctrl-C and
292 process it once we're done with sending/receiving the current
293 packet, which should be shortly. If however that takes too long,
294 and the user presses Ctrl-C again, we offer to disconnect. */
295 bool got_ctrlc_during_io
= false;
297 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
298 remote_open knows that we don't have a file open when the program
300 struct serial
*remote_desc
= nullptr;
302 /* These are the threads which we last sent to the remote system. The
303 TID member will be -1 for all or -2 for not sent yet. */
304 ptid_t general_thread
= null_ptid
;
305 ptid_t continue_thread
= null_ptid
;
307 /* This is the traceframe which we last selected on the remote system.
308 It will be -1 if no traceframe is selected. */
309 int remote_traceframe_number
= -1;
311 char *last_pass_packet
= nullptr;
313 /* The last QProgramSignals packet sent to the target. We bypass
314 sending a new program signals list down to the target if the new
315 packet is exactly the same as the last we sent. IOW, we only let
316 the target know about program signals list changes. */
317 char *last_program_signals_packet
= nullptr;
319 gdb_signal last_sent_signal
= GDB_SIGNAL_0
;
321 bool last_sent_step
= false;
323 /* The execution direction of the last resume we got. */
324 exec_direction_kind last_resume_exec_dir
= EXEC_FORWARD
;
326 char *finished_object
= nullptr;
327 char *finished_annex
= nullptr;
328 ULONGEST finished_offset
= 0;
330 /* Should we try the 'ThreadInfo' query packet?
332 This variable (NOT available to the user: auto-detect only!)
333 determines whether GDB will use the new, simpler "ThreadInfo"
334 query or the older, more complex syntax for thread queries.
335 This is an auto-detect variable (set to true at each connect,
336 and set to false when the target fails to recognize it). */
337 bool use_threadinfo_query
= false;
338 bool use_threadextra_query
= false;
340 threadref echo_nextthread
{};
341 threadref nextthread
{};
342 threadref resultthreadlist
[MAXTHREADLISTRESULTS
] {};
344 /* The state of remote notification. */
345 struct remote_notif_state
*notif_state
= nullptr;
347 /* The branch trace configuration. */
348 struct btrace_config btrace_config
{};
350 /* The argument to the last "vFile:setfs:" packet we sent, used
351 to avoid sending repeated unnecessary "vFile:setfs:" packets.
352 Initialized to -1 to indicate that no "vFile:setfs:" packet
353 has yet been sent. */
356 /* A readahead cache for vFile:pread. Often, reading a binary
357 involves a sequence of small reads. E.g., when parsing an ELF
358 file. A readahead cache helps mostly the case of remote
359 debugging on a connection with higher latency, due to the
360 request/reply nature of the RSP. We only cache data for a single
361 file descriptor at a time. */
362 struct readahead_cache readahead_cache
;
364 /* The list of already fetched and acknowledged stop events. This
365 queue is used for notification Stop, and other notifications
366 don't need queue for their events, because the notification
367 events of Stop can't be consumed immediately, so that events
368 should be queued first, and be consumed by remote_wait_{ns,as}
369 one per time. Other notifications can consume their events
370 immediately, so queue is not needed for them. */
371 std::vector
<stop_reply_up
> stop_reply_queue
;
373 /* Asynchronous signal handle registered as event loop source for
374 when we have pending events ready to be passed to the core. */
375 struct async_event_handler
*remote_async_inferior_event_token
= nullptr;
377 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
378 ``forever'' still use the normal timeout mechanism. This is
379 currently used by the ASYNC code to guarentee that target reads
380 during the initial connect always time-out. Once getpkt has been
381 modified to return a timeout indication and, in turn
382 remote_wait()/wait_for_inferior() have gained a timeout parameter
384 int wait_forever_enabled_p
= 1;
387 /* Mapping of remote protocol data for each gdbarch. Usually there
388 is only one entry here, though we may see more with stubs that
389 support multi-process. */
390 std::unordered_map
<struct gdbarch
*, remote_arch_state
>
394 static const target_info remote_target_info
= {
396 N_("Remote serial target in gdb-specific protocol"),
400 class remote_target
: public process_stratum_target
403 remote_target () = default;
404 ~remote_target () override
;
406 const target_info
&info () const override
407 { return remote_target_info
; }
409 const char *connection_string () override
;
411 thread_control_capabilities
get_thread_control_capabilities () override
412 { return tc_schedlock
; }
414 /* Open a remote connection. */
415 static void open (const char *, int);
417 void close () override
;
419 void detach (inferior
*, int) override
;
420 void disconnect (const char *, int) override
;
422 void commit_resume () override
;
423 void resume (ptid_t
, int, enum gdb_signal
) override
;
424 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
426 void fetch_registers (struct regcache
*, int) override
;
427 void store_registers (struct regcache
*, int) override
;
428 void prepare_to_store (struct regcache
*) override
;
430 void files_info () override
;
432 int insert_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
434 int remove_breakpoint (struct gdbarch
*, struct bp_target_info
*,
435 enum remove_bp_reason
) override
;
438 bool stopped_by_sw_breakpoint () override
;
439 bool supports_stopped_by_sw_breakpoint () override
;
441 bool stopped_by_hw_breakpoint () override
;
443 bool supports_stopped_by_hw_breakpoint () override
;
445 bool stopped_by_watchpoint () override
;
447 bool stopped_data_address (CORE_ADDR
*) override
;
449 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
451 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
453 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
455 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
457 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
459 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
460 struct expression
*) override
;
462 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
463 struct expression
*) override
;
465 void kill () override
;
467 void load (const char *, int) override
;
469 void mourn_inferior () override
;
471 void pass_signals (gdb::array_view
<const unsigned char>) override
;
473 int set_syscall_catchpoint (int, bool, int,
474 gdb::array_view
<const int>) override
;
476 void program_signals (gdb::array_view
<const unsigned char>) override
;
478 bool thread_alive (ptid_t ptid
) override
;
480 const char *thread_name (struct thread_info
*) override
;
482 void update_thread_list () override
;
484 std::string
pid_to_str (ptid_t
) override
;
486 const char *extra_thread_info (struct thread_info
*) override
;
488 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
490 thread_info
*thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
492 inferior
*inf
) override
;
494 gdb::byte_vector
thread_info_to_thread_handle (struct thread_info
*tp
)
497 void stop (ptid_t
) override
;
499 void interrupt () override
;
501 void pass_ctrlc () override
;
503 enum target_xfer_status
xfer_partial (enum target_object object
,
506 const gdb_byte
*writebuf
,
507 ULONGEST offset
, ULONGEST len
,
508 ULONGEST
*xfered_len
) override
;
510 ULONGEST
get_memory_xfer_limit () override
;
512 void rcmd (const char *command
, struct ui_file
*output
) override
;
514 char *pid_to_exec_file (int pid
) override
;
516 void log_command (const char *cmd
) override
518 serial_log_command (this, cmd
);
521 CORE_ADDR
get_thread_local_address (ptid_t ptid
,
522 CORE_ADDR load_module_addr
,
523 CORE_ADDR offset
) override
;
525 bool can_execute_reverse () override
;
527 std::vector
<mem_region
> memory_map () override
;
529 void flash_erase (ULONGEST address
, LONGEST length
) override
;
531 void flash_done () override
;
533 const struct target_desc
*read_description () override
;
535 int search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
536 const gdb_byte
*pattern
, ULONGEST pattern_len
,
537 CORE_ADDR
*found_addrp
) override
;
539 bool can_async_p () override
;
541 bool is_async_p () override
;
543 void async (int) override
;
545 int async_wait_fd () override
;
547 void thread_events (int) override
;
549 int can_do_single_step () override
;
551 void terminal_inferior () override
;
553 void terminal_ours () override
;
555 bool supports_non_stop () override
;
557 bool supports_multi_process () override
;
559 bool supports_disable_randomization () override
;
561 bool filesystem_is_local () override
;
564 int fileio_open (struct inferior
*inf
, const char *filename
,
565 int flags
, int mode
, int warn_if_slow
,
566 int *target_errno
) override
;
568 int fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
569 ULONGEST offset
, int *target_errno
) override
;
571 int fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
572 ULONGEST offset
, int *target_errno
) override
;
574 int fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
) override
;
576 int fileio_close (int fd
, int *target_errno
) override
;
578 int fileio_unlink (struct inferior
*inf
,
579 const char *filename
,
580 int *target_errno
) override
;
582 gdb::optional
<std::string
>
583 fileio_readlink (struct inferior
*inf
,
584 const char *filename
,
585 int *target_errno
) override
;
587 bool supports_enable_disable_tracepoint () override
;
589 bool supports_string_tracing () override
;
591 bool supports_evaluation_of_breakpoint_conditions () override
;
593 bool can_run_breakpoint_commands () override
;
595 void trace_init () override
;
597 void download_tracepoint (struct bp_location
*location
) override
;
599 bool can_download_tracepoint () override
;
601 void download_trace_state_variable (const trace_state_variable
&tsv
) override
;
603 void enable_tracepoint (struct bp_location
*location
) override
;
605 void disable_tracepoint (struct bp_location
*location
) override
;
607 void trace_set_readonly_regions () override
;
609 void trace_start () override
;
611 int get_trace_status (struct trace_status
*ts
) override
;
613 void get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
616 void trace_stop () override
;
618 int trace_find (enum trace_find_type type
, int num
,
619 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
) override
;
621 bool get_trace_state_variable_value (int tsv
, LONGEST
*val
) override
;
623 int save_trace_data (const char *filename
) override
;
625 int upload_tracepoints (struct uploaded_tp
**utpp
) override
;
627 int upload_trace_state_variables (struct uploaded_tsv
**utsvp
) override
;
629 LONGEST
get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
) override
;
631 int get_min_fast_tracepoint_insn_len () override
;
633 void set_disconnected_tracing (int val
) override
;
635 void set_circular_trace_buffer (int val
) override
;
637 void set_trace_buffer_size (LONGEST val
) override
;
639 bool set_trace_notes (const char *user
, const char *notes
,
640 const char *stopnotes
) override
;
642 int core_of_thread (ptid_t ptid
) override
;
644 int verify_memory (const gdb_byte
*data
,
645 CORE_ADDR memaddr
, ULONGEST size
) override
;
648 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
650 void set_permissions () override
;
652 bool static_tracepoint_marker_at (CORE_ADDR
,
653 struct static_tracepoint_marker
*marker
)
656 std::vector
<static_tracepoint_marker
>
657 static_tracepoint_markers_by_strid (const char *id
) override
;
659 traceframe_info_up
traceframe_info () override
;
661 bool use_agent (bool use
) override
;
662 bool can_use_agent () override
;
664 struct btrace_target_info
*enable_btrace (ptid_t ptid
,
665 const struct btrace_config
*conf
) override
;
667 void disable_btrace (struct btrace_target_info
*tinfo
) override
;
669 void teardown_btrace (struct btrace_target_info
*tinfo
) override
;
671 enum btrace_error
read_btrace (struct btrace_data
*data
,
672 struct btrace_target_info
*btinfo
,
673 enum btrace_read_type type
) override
;
675 const struct btrace_config
*btrace_conf (const struct btrace_target_info
*) override
;
676 bool augmented_libraries_svr4_read () override
;
677 int follow_fork (int, int) override
;
678 void follow_exec (struct inferior
*, const char *) override
;
679 int insert_fork_catchpoint (int) override
;
680 int remove_fork_catchpoint (int) override
;
681 int insert_vfork_catchpoint (int) override
;
682 int remove_vfork_catchpoint (int) override
;
683 int insert_exec_catchpoint (int) override
;
684 int remove_exec_catchpoint (int) override
;
685 enum exec_direction_kind
execution_direction () override
;
687 public: /* Remote specific methods. */
689 void remote_download_command_source (int num
, ULONGEST addr
,
690 struct command_line
*cmds
);
692 void remote_file_put (const char *local_file
, const char *remote_file
,
694 void remote_file_get (const char *remote_file
, const char *local_file
,
696 void remote_file_delete (const char *remote_file
, int from_tty
);
698 int remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
699 ULONGEST offset
, int *remote_errno
);
700 int remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
701 ULONGEST offset
, int *remote_errno
);
702 int remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
703 ULONGEST offset
, int *remote_errno
);
705 int remote_hostio_send_command (int command_bytes
, int which_packet
,
706 int *remote_errno
, char **attachment
,
707 int *attachment_len
);
708 int remote_hostio_set_filesystem (struct inferior
*inf
,
710 /* We should get rid of this and use fileio_open directly. */
711 int remote_hostio_open (struct inferior
*inf
, const char *filename
,
712 int flags
, int mode
, int warn_if_slow
,
714 int remote_hostio_close (int fd
, int *remote_errno
);
716 int remote_hostio_unlink (inferior
*inf
, const char *filename
,
719 struct remote_state
*get_remote_state ();
721 long get_remote_packet_size (void);
722 long get_memory_packet_size (struct memory_packet_config
*config
);
724 long get_memory_write_packet_size ();
725 long get_memory_read_packet_size ();
727 char *append_pending_thread_resumptions (char *p
, char *endp
,
729 static void open_1 (const char *name
, int from_tty
, int extended_p
);
730 void start_remote (int from_tty
, int extended_p
);
731 void remote_detach_1 (struct inferior
*inf
, int from_tty
);
733 char *append_resumption (char *p
, char *endp
,
734 ptid_t ptid
, int step
, gdb_signal siggnal
);
735 int remote_resume_with_vcont (ptid_t ptid
, int step
,
738 void add_current_inferior_and_thread (char *wait_status
);
740 ptid_t
wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
742 ptid_t
wait_as (ptid_t ptid
, target_waitstatus
*status
,
745 ptid_t
process_stop_reply (struct stop_reply
*stop_reply
,
746 target_waitstatus
*status
);
748 void remote_notice_new_inferior (ptid_t currthread
, int executing
);
750 void process_initial_stop_replies (int from_tty
);
752 thread_info
*remote_add_thread (ptid_t ptid
, bool running
, bool executing
);
754 void btrace_sync_conf (const btrace_config
*conf
);
756 void remote_btrace_maybe_reopen ();
758 void remove_new_fork_children (threads_listing_context
*context
);
759 void kill_new_fork_children (int pid
);
760 void discard_pending_stop_replies (struct inferior
*inf
);
761 int stop_reply_queue_length ();
763 void check_pending_events_prevent_wildcard_vcont
764 (int *may_global_wildcard_vcont
);
766 void discard_pending_stop_replies_in_queue ();
767 struct stop_reply
*remote_notif_remove_queued_reply (ptid_t ptid
);
768 struct stop_reply
*queued_stop_reply (ptid_t ptid
);
769 int peek_stop_reply (ptid_t ptid
);
770 void remote_parse_stop_reply (const char *buf
, stop_reply
*event
);
772 void remote_stop_ns (ptid_t ptid
);
773 void remote_interrupt_as ();
774 void remote_interrupt_ns ();
776 char *remote_get_noisy_reply ();
777 int remote_query_attached (int pid
);
778 inferior
*remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
781 ptid_t
remote_current_thread (ptid_t oldpid
);
782 ptid_t
get_current_thread (char *wait_status
);
784 void set_thread (ptid_t ptid
, int gen
);
785 void set_general_thread (ptid_t ptid
);
786 void set_continue_thread (ptid_t ptid
);
787 void set_general_process ();
789 char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
791 int remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
792 gdb_ext_thread_info
*info
);
793 int remote_get_threadinfo (threadref
*threadid
, int fieldset
,
794 gdb_ext_thread_info
*info
);
796 int parse_threadlist_response (char *pkt
, int result_limit
,
797 threadref
*original_echo
,
798 threadref
*resultlist
,
800 int remote_get_threadlist (int startflag
, threadref
*nextthread
,
801 int result_limit
, int *done
, int *result_count
,
802 threadref
*threadlist
);
804 int remote_threadlist_iterator (rmt_thread_action stepfunction
,
805 void *context
, int looplimit
);
807 int remote_get_threads_with_ql (threads_listing_context
*context
);
808 int remote_get_threads_with_qxfer (threads_listing_context
*context
);
809 int remote_get_threads_with_qthreadinfo (threads_listing_context
*context
);
811 void extended_remote_restart ();
815 void remote_check_symbols ();
817 void remote_supported_packet (const struct protocol_feature
*feature
,
818 enum packet_support support
,
819 const char *argument
);
821 void remote_query_supported ();
823 void remote_packet_size (const protocol_feature
*feature
,
824 packet_support support
, const char *value
);
826 void remote_serial_quit_handler ();
828 void remote_detach_pid (int pid
);
830 void remote_vcont_probe ();
832 void remote_resume_with_hc (ptid_t ptid
, int step
,
835 void send_interrupt_sequence ();
836 void interrupt_query ();
838 void remote_notif_get_pending_events (notif_client
*nc
);
840 int fetch_register_using_p (struct regcache
*regcache
,
842 int send_g_packet ();
843 void process_g_packet (struct regcache
*regcache
);
844 void fetch_registers_using_g (struct regcache
*regcache
);
845 int store_register_using_P (const struct regcache
*regcache
,
847 void store_registers_using_G (const struct regcache
*regcache
);
849 void set_remote_traceframe ();
851 void check_binary_download (CORE_ADDR addr
);
853 target_xfer_status
remote_write_bytes_aux (const char *header
,
855 const gdb_byte
*myaddr
,
858 ULONGEST
*xfered_len_units
,
862 target_xfer_status
remote_write_bytes (CORE_ADDR memaddr
,
863 const gdb_byte
*myaddr
, ULONGEST len
,
864 int unit_size
, ULONGEST
*xfered_len
);
866 target_xfer_status
remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
868 int unit_size
, ULONGEST
*xfered_len_units
);
870 target_xfer_status
remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
874 ULONGEST
*xfered_len
);
876 target_xfer_status
remote_read_bytes (CORE_ADDR memaddr
,
877 gdb_byte
*myaddr
, ULONGEST len
,
879 ULONGEST
*xfered_len
);
881 packet_result
remote_send_printf (const char *format
, ...)
882 ATTRIBUTE_PRINTF (2, 3);
884 target_xfer_status
remote_flash_write (ULONGEST address
,
885 ULONGEST length
, ULONGEST
*xfered_len
,
886 const gdb_byte
*data
);
888 int readchar (int timeout
);
890 void remote_serial_write (const char *str
, int len
);
892 int putpkt (const char *buf
);
893 int putpkt_binary (const char *buf
, int cnt
);
895 int putpkt (const gdb::char_vector
&buf
)
897 return putpkt (buf
.data ());
901 long read_frame (gdb::char_vector
*buf_p
);
902 void getpkt (gdb::char_vector
*buf
, int forever
);
903 int getpkt_or_notif_sane_1 (gdb::char_vector
*buf
, int forever
,
904 int expecting_notif
, int *is_notif
);
905 int getpkt_sane (gdb::char_vector
*buf
, int forever
);
906 int getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
908 int remote_vkill (int pid
);
909 void remote_kill_k ();
911 void extended_remote_disable_randomization (int val
);
912 int extended_remote_run (const std::string
&args
);
914 void send_environment_packet (const char *action
,
918 void extended_remote_environment_support ();
919 void extended_remote_set_inferior_cwd ();
921 target_xfer_status
remote_write_qxfer (const char *object_name
,
923 const gdb_byte
*writebuf
,
924 ULONGEST offset
, LONGEST len
,
925 ULONGEST
*xfered_len
,
926 struct packet_config
*packet
);
928 target_xfer_status
remote_read_qxfer (const char *object_name
,
930 gdb_byte
*readbuf
, ULONGEST offset
,
932 ULONGEST
*xfered_len
,
933 struct packet_config
*packet
);
935 void push_stop_reply (struct stop_reply
*new_event
);
937 bool vcont_r_supported ();
939 void packet_command (const char *args
, int from_tty
);
941 private: /* data fields */
943 /* The remote state. Don't reference this directly. Use the
944 get_remote_state method instead. */
945 remote_state m_remote_state
;
948 static const target_info extended_remote_target_info
= {
950 N_("Extended remote serial target in gdb-specific protocol"),
954 /* Set up the extended remote target by extending the standard remote
955 target and adding to it. */
957 class extended_remote_target final
: public remote_target
960 const target_info
&info () const override
961 { return extended_remote_target_info
; }
963 /* Open an extended-remote connection. */
964 static void open (const char *, int);
966 bool can_create_inferior () override
{ return true; }
967 void create_inferior (const char *, const std::string
&,
968 char **, int) override
;
970 void detach (inferior
*, int) override
;
972 bool can_attach () override
{ return true; }
973 void attach (const char *, int) override
;
975 void post_attach (int) override
;
976 bool supports_disable_randomization () override
;
979 /* Per-program-space data key. */
980 static const struct program_space_key
<char, gdb::xfree_deleter
<char>>
983 /* The variable registered as the control variable used by the
984 remote exec-file commands. While the remote exec-file setting is
985 per-program-space, the set/show machinery uses this as the
986 location of the remote exec-file value. */
987 static char *remote_exec_file_var
;
989 /* The size to align memory write packets, when practical. The protocol
990 does not guarantee any alignment, and gdb will generate short
991 writes and unaligned writes, but even as a best-effort attempt this
992 can improve bulk transfers. For instance, if a write is misaligned
993 relative to the target's data bus, the stub may need to make an extra
994 round trip fetching data from the target. This doesn't make a
995 huge difference, but it's easy to do, so we try to be helpful.
997 The alignment chosen is arbitrary; usually data bus width is
998 important here, not the possibly larger cache line size. */
999 enum { REMOTE_ALIGN_WRITES
= 16 };
1001 /* Prototypes for local functions. */
1003 static int hexnumlen (ULONGEST num
);
1005 static int stubhex (int ch
);
1007 static int hexnumstr (char *, ULONGEST
);
1009 static int hexnumnstr (char *, ULONGEST
, int);
1011 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
1013 static void print_packet (const char *);
1015 static int stub_unpack_int (char *buff
, int fieldlength
);
1017 struct packet_config
;
1019 static void show_packet_config_cmd (struct packet_config
*config
);
1021 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
1023 struct cmd_list_element
*c
,
1026 static ptid_t
read_ptid (const char *buf
, const char **obuf
);
1028 static void remote_async_inferior_event_handler (gdb_client_data
);
1030 static bool remote_read_description_p (struct target_ops
*target
);
1032 static void remote_console_output (const char *msg
);
1034 static void remote_btrace_reset (remote_state
*rs
);
1036 static void remote_unpush_and_throw (remote_target
*target
);
1040 static struct cmd_list_element
*remote_cmdlist
;
1042 /* For "set remote" and "show remote". */
1044 static struct cmd_list_element
*remote_set_cmdlist
;
1045 static struct cmd_list_element
*remote_show_cmdlist
;
1047 /* Controls whether GDB is willing to use range stepping. */
1049 static bool use_range_stepping
= true;
1051 /* Private data that we'll store in (struct thread_info)->priv. */
1052 struct remote_thread_info
: public private_thread_info
1058 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1059 sequence of bytes. */
1060 gdb::byte_vector thread_handle
;
1062 /* Whether the target stopped for a breakpoint/watchpoint. */
1063 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1065 /* This is set to the data address of the access causing the target
1066 to stop for a watchpoint. */
1067 CORE_ADDR watch_data_address
= 0;
1069 /* Fields used by the vCont action coalescing implemented in
1070 remote_resume / remote_commit_resume. remote_resume stores each
1071 thread's last resume request in these fields, so that a later
1072 remote_commit_resume knows which is the proper action for this
1073 thread to include in the vCont packet. */
1075 /* True if the last target_resume call for this thread was a step
1076 request, false if a continue request. */
1077 int last_resume_step
= 0;
1079 /* The signal specified in the last target_resume call for this
1081 gdb_signal last_resume_sig
= GDB_SIGNAL_0
;
1083 /* Whether this thread was already vCont-resumed on the remote
1085 int vcont_resumed
= 0;
1088 remote_state::remote_state ()
1093 remote_state::~remote_state ()
1095 xfree (this->last_pass_packet
);
1096 xfree (this->last_program_signals_packet
);
1097 xfree (this->finished_object
);
1098 xfree (this->finished_annex
);
1101 /* Utility: generate error from an incoming stub packet. */
1103 trace_error (char *buf
)
1106 return; /* not an error msg */
1109 case '1': /* malformed packet error */
1110 if (*++buf
== '0') /* general case: */
1111 error (_("remote.c: error in outgoing packet."));
1113 error (_("remote.c: error in outgoing packet at field #%ld."),
1114 strtol (buf
, NULL
, 16));
1116 error (_("Target returns error code '%s'."), buf
);
1120 /* Utility: wait for reply from stub, while accepting "O" packets. */
1123 remote_target::remote_get_noisy_reply ()
1125 struct remote_state
*rs
= get_remote_state ();
1127 do /* Loop on reply from remote stub. */
1131 QUIT
; /* Allow user to bail out with ^C. */
1132 getpkt (&rs
->buf
, 0);
1133 buf
= rs
->buf
.data ();
1136 else if (startswith (buf
, "qRelocInsn:"))
1139 CORE_ADDR from
, to
, org_to
;
1141 int adjusted_size
= 0;
1144 p
= buf
+ strlen ("qRelocInsn:");
1145 pp
= unpack_varlen_hex (p
, &ul
);
1147 error (_("invalid qRelocInsn packet: %s"), buf
);
1151 unpack_varlen_hex (p
, &ul
);
1158 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1161 catch (const gdb_exception
&ex
)
1163 if (ex
.error
== MEMORY_ERROR
)
1165 /* Propagate memory errors silently back to the
1166 target. The stub may have limited the range of
1167 addresses we can write to, for example. */
1171 /* Something unexpectedly bad happened. Be verbose
1172 so we can tell what, and propagate the error back
1173 to the stub, so it doesn't get stuck waiting for
1175 exception_fprintf (gdb_stderr
, ex
,
1176 _("warning: relocating instruction: "));
1183 adjusted_size
= to
- org_to
;
1185 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1189 else if (buf
[0] == 'O' && buf
[1] != 'K')
1190 remote_console_output (buf
+ 1); /* 'O' message from stub */
1192 return buf
; /* Here's the actual reply. */
1197 struct remote_arch_state
*
1198 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1200 remote_arch_state
*rsa
;
1202 auto it
= this->m_arch_states
.find (gdbarch
);
1203 if (it
== this->m_arch_states
.end ())
1205 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1206 std::forward_as_tuple (gdbarch
),
1207 std::forward_as_tuple (gdbarch
));
1208 rsa
= &p
.first
->second
;
1210 /* Make sure that the packet buffer is plenty big enough for
1211 this architecture. */
1212 if (this->buf
.size () < rsa
->remote_packet_size
)
1213 this->buf
.resize (2 * rsa
->remote_packet_size
);
1221 /* Fetch the global remote target state. */
1224 remote_target::get_remote_state ()
1226 /* Make sure that the remote architecture state has been
1227 initialized, because doing so might reallocate rs->buf. Any
1228 function which calls getpkt also needs to be mindful of changes
1229 to rs->buf, but this call limits the number of places which run
1231 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1233 return &m_remote_state
;
1236 /* Fetch the remote exec-file from the current program space. */
1239 get_remote_exec_file (void)
1241 char *remote_exec_file
;
1243 remote_exec_file
= remote_pspace_data
.get (current_program_space
);
1244 if (remote_exec_file
== NULL
)
1247 return remote_exec_file
;
1250 /* Set the remote exec file for PSPACE. */
1253 set_pspace_remote_exec_file (struct program_space
*pspace
,
1254 const char *remote_exec_file
)
1256 char *old_file
= remote_pspace_data
.get (pspace
);
1259 remote_pspace_data
.set (pspace
, xstrdup (remote_exec_file
));
1262 /* The "set/show remote exec-file" set command hook. */
1265 set_remote_exec_file (const char *ignored
, int from_tty
,
1266 struct cmd_list_element
*c
)
1268 gdb_assert (remote_exec_file_var
!= NULL
);
1269 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
1272 /* The "set/show remote exec-file" show command hook. */
1275 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1276 struct cmd_list_element
*cmd
, const char *value
)
1278 fprintf_filtered (file
, "%s\n", get_remote_exec_file ());
1282 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1284 int regnum
, num_remote_regs
, offset
;
1285 struct packet_reg
**remote_regs
;
1287 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1289 struct packet_reg
*r
= ®s
[regnum
];
1291 if (register_size (gdbarch
, regnum
) == 0)
1292 /* Do not try to fetch zero-sized (placeholder) registers. */
1295 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1300 /* Define the g/G packet format as the contents of each register
1301 with a remote protocol number, in order of ascending protocol
1304 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1305 for (num_remote_regs
= 0, regnum
= 0;
1306 regnum
< gdbarch_num_regs (gdbarch
);
1308 if (regs
[regnum
].pnum
!= -1)
1309 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1311 std::sort (remote_regs
, remote_regs
+ num_remote_regs
,
1312 [] (const packet_reg
*a
, const packet_reg
*b
)
1313 { return a
->pnum
< b
->pnum
; });
1315 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1317 remote_regs
[regnum
]->in_g_packet
= 1;
1318 remote_regs
[regnum
]->offset
= offset
;
1319 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1325 /* Given the architecture described by GDBARCH, return the remote
1326 protocol register's number and the register's offset in the g/G
1327 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1328 If the target does not have a mapping for REGNUM, return false,
1329 otherwise, return true. */
1332 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1333 int *pnum
, int *poffset
)
1335 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1337 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1339 map_regcache_remote_table (gdbarch
, regs
.data ());
1341 *pnum
= regs
[regnum
].pnum
;
1342 *poffset
= regs
[regnum
].offset
;
1347 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1349 /* Use the architecture to build a regnum<->pnum table, which will be
1350 1:1 unless a feature set specifies otherwise. */
1351 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1353 /* Record the maximum possible size of the g packet - it may turn out
1355 this->sizeof_g_packet
1356 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1358 /* Default maximum number of characters in a packet body. Many
1359 remote stubs have a hardwired buffer size of 400 bytes
1360 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1361 as the maximum packet-size to ensure that the packet and an extra
1362 NUL character can always fit in the buffer. This stops GDB
1363 trashing stubs that try to squeeze an extra NUL into what is
1364 already a full buffer (As of 1999-12-04 that was most stubs). */
1365 this->remote_packet_size
= 400 - 1;
1367 /* This one is filled in when a ``g'' packet is received. */
1368 this->actual_register_packet_size
= 0;
1370 /* Should rsa->sizeof_g_packet needs more space than the
1371 default, adjust the size accordingly. Remember that each byte is
1372 encoded as two characters. 32 is the overhead for the packet
1373 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1374 (``$NN:G...#NN'') is a better guess, the below has been padded a
1376 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1377 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1380 /* Get a pointer to the current remote target. If not connected to a
1381 remote target, return NULL. */
1383 static remote_target
*
1384 get_current_remote_target ()
1386 target_ops
*proc_target
= current_inferior ()->process_target ();
1387 return dynamic_cast<remote_target
*> (proc_target
);
1390 /* Return the current allowed size of a remote packet. This is
1391 inferred from the current architecture, and should be used to
1392 limit the length of outgoing packets. */
1394 remote_target::get_remote_packet_size ()
1396 struct remote_state
*rs
= get_remote_state ();
1397 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1399 if (rs
->explicit_packet_size
)
1400 return rs
->explicit_packet_size
;
1402 return rsa
->remote_packet_size
;
1405 static struct packet_reg
*
1406 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1409 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1413 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1415 gdb_assert (r
->regnum
== regnum
);
1420 static struct packet_reg
*
1421 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1426 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1428 struct packet_reg
*r
= &rsa
->regs
[i
];
1430 if (r
->pnum
== pnum
)
1436 /* Allow the user to specify what sequence to send to the remote
1437 when he requests a program interruption: Although ^C is usually
1438 what remote systems expect (this is the default, here), it is
1439 sometimes preferable to send a break. On other systems such
1440 as the Linux kernel, a break followed by g, which is Magic SysRq g
1441 is required in order to interrupt the execution. */
1442 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1443 const char interrupt_sequence_break
[] = "BREAK";
1444 const char interrupt_sequence_break_g
[] = "BREAK-g";
1445 static const char *const interrupt_sequence_modes
[] =
1447 interrupt_sequence_control_c
,
1448 interrupt_sequence_break
,
1449 interrupt_sequence_break_g
,
1452 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1455 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1456 struct cmd_list_element
*c
,
1459 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1460 fprintf_filtered (file
,
1461 _("Send the ASCII ETX character (Ctrl-c) "
1462 "to the remote target to interrupt the "
1463 "execution of the program.\n"));
1464 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1465 fprintf_filtered (file
,
1466 _("send a break signal to the remote target "
1467 "to interrupt the execution of the program.\n"));
1468 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1469 fprintf_filtered (file
,
1470 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1471 "the remote target to interrupt the execution "
1472 "of Linux kernel.\n"));
1474 internal_error (__FILE__
, __LINE__
,
1475 _("Invalid value for interrupt_sequence_mode: %s."),
1476 interrupt_sequence_mode
);
1479 /* This boolean variable specifies whether interrupt_sequence is sent
1480 to the remote target when gdb connects to it.
1481 This is mostly needed when you debug the Linux kernel: The Linux kernel
1482 expects BREAK g which is Magic SysRq g for connecting gdb. */
1483 static bool interrupt_on_connect
= false;
1485 /* This variable is used to implement the "set/show remotebreak" commands.
1486 Since these commands are now deprecated in favor of "set/show remote
1487 interrupt-sequence", it no longer has any effect on the code. */
1488 static bool remote_break
;
1491 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1494 interrupt_sequence_mode
= interrupt_sequence_break
;
1496 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1500 show_remotebreak (struct ui_file
*file
, int from_tty
,
1501 struct cmd_list_element
*c
,
1506 /* This variable sets the number of bits in an address that are to be
1507 sent in a memory ("M" or "m") packet. Normally, after stripping
1508 leading zeros, the entire address would be sent. This variable
1509 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1510 initial implementation of remote.c restricted the address sent in
1511 memory packets to ``host::sizeof long'' bytes - (typically 32
1512 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1513 address was never sent. Since fixing this bug may cause a break in
1514 some remote targets this variable is principally provided to
1515 facilitate backward compatibility. */
1517 static unsigned int remote_address_size
;
1520 /* User configurable variables for the number of characters in a
1521 memory read/write packet. MIN (rsa->remote_packet_size,
1522 rsa->sizeof_g_packet) is the default. Some targets need smaller
1523 values (fifo overruns, et.al.) and some users need larger values
1524 (speed up transfers). The variables ``preferred_*'' (the user
1525 request), ``current_*'' (what was actually set) and ``forced_*''
1526 (Positive - a soft limit, negative - a hard limit). */
1528 struct memory_packet_config
1535 /* The default max memory-write-packet-size, when the setting is
1536 "fixed". The 16k is historical. (It came from older GDB's using
1537 alloca for buffers and the knowledge (folklore?) that some hosts
1538 don't cope very well with large alloca calls.) */
1539 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1541 /* The minimum remote packet size for memory transfers. Ensures we
1542 can write at least one byte. */
1543 #define MIN_MEMORY_PACKET_SIZE 20
1545 /* Get the memory packet size, assuming it is fixed. */
1548 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1550 gdb_assert (config
->fixed_p
);
1552 if (config
->size
<= 0)
1553 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1555 return config
->size
;
1558 /* Compute the current size of a read/write packet. Since this makes
1559 use of ``actual_register_packet_size'' the computation is dynamic. */
1562 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1564 struct remote_state
*rs
= get_remote_state ();
1565 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1568 if (config
->fixed_p
)
1569 what_they_get
= get_fixed_memory_packet_size (config
);
1572 what_they_get
= get_remote_packet_size ();
1573 /* Limit the packet to the size specified by the user. */
1574 if (config
->size
> 0
1575 && what_they_get
> config
->size
)
1576 what_they_get
= config
->size
;
1578 /* Limit it to the size of the targets ``g'' response unless we have
1579 permission from the stub to use a larger packet size. */
1580 if (rs
->explicit_packet_size
== 0
1581 && rsa
->actual_register_packet_size
> 0
1582 && what_they_get
> rsa
->actual_register_packet_size
)
1583 what_they_get
= rsa
->actual_register_packet_size
;
1585 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1586 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1588 /* Make sure there is room in the global buffer for this packet
1589 (including its trailing NUL byte). */
1590 if (rs
->buf
.size () < what_they_get
+ 1)
1591 rs
->buf
.resize (2 * what_they_get
);
1593 return what_they_get
;
1596 /* Update the size of a read/write packet. If they user wants
1597 something really big then do a sanity check. */
1600 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1602 int fixed_p
= config
->fixed_p
;
1603 long size
= config
->size
;
1606 error (_("Argument required (integer, `fixed' or `limited')."));
1607 else if (strcmp (args
, "hard") == 0
1608 || strcmp (args
, "fixed") == 0)
1610 else if (strcmp (args
, "soft") == 0
1611 || strcmp (args
, "limit") == 0)
1617 size
= strtoul (args
, &end
, 0);
1619 error (_("Invalid %s (bad syntax)."), config
->name
);
1621 /* Instead of explicitly capping the size of a packet to or
1622 disallowing it, the user is allowed to set the size to
1623 something arbitrarily large. */
1627 if (fixed_p
&& !config
->fixed_p
)
1629 /* So that the query shows the correct value. */
1630 long query_size
= (size
<= 0
1631 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1634 if (! query (_("The target may not be able to correctly handle a %s\n"
1635 "of %ld bytes. Change the packet size? "),
1636 config
->name
, query_size
))
1637 error (_("Packet size not changed."));
1639 /* Update the config. */
1640 config
->fixed_p
= fixed_p
;
1641 config
->size
= size
;
1645 show_memory_packet_size (struct memory_packet_config
*config
)
1647 if (config
->size
== 0)
1648 printf_filtered (_("The %s is 0 (default). "), config
->name
);
1650 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1651 if (config
->fixed_p
)
1652 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1653 get_fixed_memory_packet_size (config
));
1656 remote_target
*remote
= get_current_remote_target ();
1659 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1660 remote
->get_memory_packet_size (config
));
1662 puts_filtered ("The actual limit will be further reduced "
1663 "dependent on the target.\n");
1667 /* FIXME: needs to be per-remote-target. */
1668 static struct memory_packet_config memory_write_packet_config
=
1670 "memory-write-packet-size",
1674 set_memory_write_packet_size (const char *args
, int from_tty
)
1676 set_memory_packet_size (args
, &memory_write_packet_config
);
1680 show_memory_write_packet_size (const char *args
, int from_tty
)
1682 show_memory_packet_size (&memory_write_packet_config
);
1685 /* Show the number of hardware watchpoints that can be used. */
1688 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1689 struct cmd_list_element
*c
,
1692 fprintf_filtered (file
, _("The maximum number of target hardware "
1693 "watchpoints is %s.\n"), value
);
1696 /* Show the length limit (in bytes) for hardware watchpoints. */
1699 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1700 struct cmd_list_element
*c
,
1703 fprintf_filtered (file
, _("The maximum length (in bytes) of a target "
1704 "hardware watchpoint is %s.\n"), value
);
1707 /* Show the number of hardware breakpoints that can be used. */
1710 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1711 struct cmd_list_element
*c
,
1714 fprintf_filtered (file
, _("The maximum number of target hardware "
1715 "breakpoints is %s.\n"), value
);
1718 /* Controls the maximum number of characters to display in the debug output
1719 for each remote packet. The remaining characters are omitted. */
1721 static int remote_packet_max_chars
= 512;
1723 /* Show the maximum number of characters to display for each remote packet
1724 when remote debugging is enabled. */
1727 show_remote_packet_max_chars (struct ui_file
*file
, int from_tty
,
1728 struct cmd_list_element
*c
,
1731 fprintf_filtered (file
, _("Number of remote packet characters to "
1732 "display is %s.\n"), value
);
1736 remote_target::get_memory_write_packet_size ()
1738 return get_memory_packet_size (&memory_write_packet_config
);
1741 /* FIXME: needs to be per-remote-target. */
1742 static struct memory_packet_config memory_read_packet_config
=
1744 "memory-read-packet-size",
1748 set_memory_read_packet_size (const char *args
, int from_tty
)
1750 set_memory_packet_size (args
, &memory_read_packet_config
);
1754 show_memory_read_packet_size (const char *args
, int from_tty
)
1756 show_memory_packet_size (&memory_read_packet_config
);
1760 remote_target::get_memory_read_packet_size ()
1762 long size
= get_memory_packet_size (&memory_read_packet_config
);
1764 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1765 extra buffer size argument before the memory read size can be
1766 increased beyond this. */
1767 if (size
> get_remote_packet_size ())
1768 size
= get_remote_packet_size ();
1774 struct packet_config
1779 /* If auto, GDB auto-detects support for this packet or feature,
1780 either through qSupported, or by trying the packet and looking
1781 at the response. If true, GDB assumes the target supports this
1782 packet. If false, the packet is disabled. Configs that don't
1783 have an associated command always have this set to auto. */
1784 enum auto_boolean detect
;
1786 /* Does the target support this packet? */
1787 enum packet_support support
;
1790 static enum packet_support
packet_config_support (struct packet_config
*config
);
1791 static enum packet_support
packet_support (int packet
);
1794 show_packet_config_cmd (struct packet_config
*config
)
1796 const char *support
= "internal-error";
1798 switch (packet_config_support (config
))
1801 support
= "enabled";
1803 case PACKET_DISABLE
:
1804 support
= "disabled";
1806 case PACKET_SUPPORT_UNKNOWN
:
1807 support
= "unknown";
1810 switch (config
->detect
)
1812 case AUTO_BOOLEAN_AUTO
:
1813 printf_filtered (_("Support for the `%s' packet "
1814 "is auto-detected, currently %s.\n"),
1815 config
->name
, support
);
1817 case AUTO_BOOLEAN_TRUE
:
1818 case AUTO_BOOLEAN_FALSE
:
1819 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1820 config
->name
, support
);
1826 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1827 const char *title
, int legacy
)
1833 config
->name
= name
;
1834 config
->title
= title
;
1835 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1837 show_doc
= xstrprintf ("Show current use of remote "
1838 "protocol `%s' (%s) packet.",
1840 /* set/show TITLE-packet {auto,on,off} */
1841 cmd_name
= xstrprintf ("%s-packet", title
);
1842 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1843 &config
->detect
, set_doc
,
1844 show_doc
, NULL
, /* help_doc */
1846 show_remote_protocol_packet_cmd
,
1847 &remote_set_cmdlist
, &remote_show_cmdlist
);
1848 /* The command code copies the documentation strings. */
1851 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1856 legacy_name
= xstrprintf ("%s-packet", name
);
1857 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1858 &remote_set_cmdlist
);
1859 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1860 &remote_show_cmdlist
);
1864 static enum packet_result
1865 packet_check_result (const char *buf
)
1869 /* The stub recognized the packet request. Check that the
1870 operation succeeded. */
1872 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1874 /* "Enn" - definitely an error. */
1875 return PACKET_ERROR
;
1877 /* Always treat "E." as an error. This will be used for
1878 more verbose error messages, such as E.memtypes. */
1879 if (buf
[0] == 'E' && buf
[1] == '.')
1880 return PACKET_ERROR
;
1882 /* The packet may or may not be OK. Just assume it is. */
1886 /* The stub does not support the packet. */
1887 return PACKET_UNKNOWN
;
1890 static enum packet_result
1891 packet_check_result (const gdb::char_vector
&buf
)
1893 return packet_check_result (buf
.data ());
1896 static enum packet_result
1897 packet_ok (const char *buf
, struct packet_config
*config
)
1899 enum packet_result result
;
1901 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1902 && config
->support
== PACKET_DISABLE
)
1903 internal_error (__FILE__
, __LINE__
,
1904 _("packet_ok: attempt to use a disabled packet"));
1906 result
= packet_check_result (buf
);
1911 /* The stub recognized the packet request. */
1912 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1915 fprintf_unfiltered (gdb_stdlog
,
1916 "Packet %s (%s) is supported\n",
1917 config
->name
, config
->title
);
1918 config
->support
= PACKET_ENABLE
;
1921 case PACKET_UNKNOWN
:
1922 /* The stub does not support the packet. */
1923 if (config
->detect
== AUTO_BOOLEAN_AUTO
1924 && config
->support
== PACKET_ENABLE
)
1926 /* If the stub previously indicated that the packet was
1927 supported then there is a protocol error. */
1928 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1929 config
->name
, config
->title
);
1931 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
1933 /* The user set it wrong. */
1934 error (_("Enabled packet %s (%s) not recognized by stub"),
1935 config
->name
, config
->title
);
1939 fprintf_unfiltered (gdb_stdlog
,
1940 "Packet %s (%s) is NOT supported\n",
1941 config
->name
, config
->title
);
1942 config
->support
= PACKET_DISABLE
;
1949 static enum packet_result
1950 packet_ok (const gdb::char_vector
&buf
, struct packet_config
*config
)
1952 return packet_ok (buf
.data (), config
);
1969 PACKET_vFile_pwrite
,
1971 PACKET_vFile_unlink
,
1972 PACKET_vFile_readlink
,
1975 PACKET_qXfer_features
,
1976 PACKET_qXfer_exec_file
,
1977 PACKET_qXfer_libraries
,
1978 PACKET_qXfer_libraries_svr4
,
1979 PACKET_qXfer_memory_map
,
1980 PACKET_qXfer_osdata
,
1981 PACKET_qXfer_threads
,
1982 PACKET_qXfer_statictrace_read
,
1983 PACKET_qXfer_traceframe_info
,
1989 PACKET_QPassSignals
,
1990 PACKET_QCatchSyscalls
,
1991 PACKET_QProgramSignals
,
1992 PACKET_QSetWorkingDir
,
1993 PACKET_QStartupWithShell
,
1994 PACKET_QEnvironmentHexEncoded
,
1995 PACKET_QEnvironmentReset
,
1996 PACKET_QEnvironmentUnset
,
1998 PACKET_qSearch_memory
,
2001 PACKET_QStartNoAckMode
,
2003 PACKET_qXfer_siginfo_read
,
2004 PACKET_qXfer_siginfo_write
,
2007 /* Support for conditional tracepoints. */
2008 PACKET_ConditionalTracepoints
,
2010 /* Support for target-side breakpoint conditions. */
2011 PACKET_ConditionalBreakpoints
,
2013 /* Support for target-side breakpoint commands. */
2014 PACKET_BreakpointCommands
,
2016 /* Support for fast tracepoints. */
2017 PACKET_FastTracepoints
,
2019 /* Support for static tracepoints. */
2020 PACKET_StaticTracepoints
,
2022 /* Support for installing tracepoints while a trace experiment is
2024 PACKET_InstallInTrace
,
2028 PACKET_TracepointSource
,
2031 PACKET_QDisableRandomization
,
2033 PACKET_QTBuffer_size
,
2037 PACKET_qXfer_btrace
,
2039 /* Support for the QNonStop packet. */
2042 /* Support for the QThreadEvents packet. */
2043 PACKET_QThreadEvents
,
2045 /* Support for multi-process extensions. */
2046 PACKET_multiprocess_feature
,
2048 /* Support for enabling and disabling tracepoints while a trace
2049 experiment is running. */
2050 PACKET_EnableDisableTracepoints_feature
,
2052 /* Support for collecting strings using the tracenz bytecode. */
2053 PACKET_tracenz_feature
,
2055 /* Support for continuing to run a trace experiment while GDB is
2057 PACKET_DisconnectedTracing_feature
,
2059 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2060 PACKET_augmented_libraries_svr4_read_feature
,
2062 /* Support for the qXfer:btrace-conf:read packet. */
2063 PACKET_qXfer_btrace_conf
,
2065 /* Support for the Qbtrace-conf:bts:size packet. */
2066 PACKET_Qbtrace_conf_bts_size
,
2068 /* Support for swbreak+ feature. */
2069 PACKET_swbreak_feature
,
2071 /* Support for hwbreak+ feature. */
2072 PACKET_hwbreak_feature
,
2074 /* Support for fork events. */
2075 PACKET_fork_event_feature
,
2077 /* Support for vfork events. */
2078 PACKET_vfork_event_feature
,
2080 /* Support for the Qbtrace-conf:pt:size packet. */
2081 PACKET_Qbtrace_conf_pt_size
,
2083 /* Support for exec events. */
2084 PACKET_exec_event_feature
,
2086 /* Support for query supported vCont actions. */
2087 PACKET_vContSupported
,
2089 /* Support remote CTRL-C. */
2092 /* Support TARGET_WAITKIND_NO_RESUMED. */
2098 /* FIXME: needs to be per-remote-target. Ignoring this for now,
2099 assuming all remote targets are the same server (thus all support
2100 the same packets). */
2101 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
2103 /* Returns the packet's corresponding "set remote foo-packet" command
2104 state. See struct packet_config for more details. */
2106 static enum auto_boolean
2107 packet_set_cmd_state (int packet
)
2109 return remote_protocol_packets
[packet
].detect
;
2112 /* Returns whether a given packet or feature is supported. This takes
2113 into account the state of the corresponding "set remote foo-packet"
2114 command, which may be used to bypass auto-detection. */
2116 static enum packet_support
2117 packet_config_support (struct packet_config
*config
)
2119 switch (config
->detect
)
2121 case AUTO_BOOLEAN_TRUE
:
2122 return PACKET_ENABLE
;
2123 case AUTO_BOOLEAN_FALSE
:
2124 return PACKET_DISABLE
;
2125 case AUTO_BOOLEAN_AUTO
:
2126 return config
->support
;
2128 gdb_assert_not_reached (_("bad switch"));
2132 /* Same as packet_config_support, but takes the packet's enum value as
2135 static enum packet_support
2136 packet_support (int packet
)
2138 struct packet_config
*config
= &remote_protocol_packets
[packet
];
2140 return packet_config_support (config
);
2144 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
2145 struct cmd_list_element
*c
,
2148 struct packet_config
*packet
;
2150 for (packet
= remote_protocol_packets
;
2151 packet
< &remote_protocol_packets
[PACKET_MAX
];
2154 if (&packet
->detect
== c
->var
)
2156 show_packet_config_cmd (packet
);
2160 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
2164 /* Should we try one of the 'Z' requests? */
2168 Z_PACKET_SOFTWARE_BP
,
2169 Z_PACKET_HARDWARE_BP
,
2176 /* For compatibility with older distributions. Provide a ``set remote
2177 Z-packet ...'' command that updates all the Z packet types. */
2179 static enum auto_boolean remote_Z_packet_detect
;
2182 set_remote_protocol_Z_packet_cmd (const char *args
, int from_tty
,
2183 struct cmd_list_element
*c
)
2187 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2188 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
2192 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
2193 struct cmd_list_element
*c
,
2198 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2200 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
2204 /* Returns true if the multi-process extensions are in effect. */
2207 remote_multi_process_p (struct remote_state
*rs
)
2209 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
2212 /* Returns true if fork events are supported. */
2215 remote_fork_event_p (struct remote_state
*rs
)
2217 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
2220 /* Returns true if vfork events are supported. */
2223 remote_vfork_event_p (struct remote_state
*rs
)
2225 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
2228 /* Returns true if exec events are supported. */
2231 remote_exec_event_p (struct remote_state
*rs
)
2233 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
2236 /* Insert fork catchpoint target routine. If fork events are enabled
2237 then return success, nothing more to do. */
2240 remote_target::insert_fork_catchpoint (int pid
)
2242 struct remote_state
*rs
= get_remote_state ();
2244 return !remote_fork_event_p (rs
);
2247 /* Remove fork catchpoint target routine. Nothing to do, just
2251 remote_target::remove_fork_catchpoint (int pid
)
2256 /* Insert vfork catchpoint target routine. If vfork events are enabled
2257 then return success, nothing more to do. */
2260 remote_target::insert_vfork_catchpoint (int pid
)
2262 struct remote_state
*rs
= get_remote_state ();
2264 return !remote_vfork_event_p (rs
);
2267 /* Remove vfork catchpoint target routine. Nothing to do, just
2271 remote_target::remove_vfork_catchpoint (int pid
)
2276 /* Insert exec catchpoint target routine. If exec events are
2277 enabled, just return success. */
2280 remote_target::insert_exec_catchpoint (int pid
)
2282 struct remote_state
*rs
= get_remote_state ();
2284 return !remote_exec_event_p (rs
);
2287 /* Remove exec catchpoint target routine. Nothing to do, just
2291 remote_target::remove_exec_catchpoint (int pid
)
2298 /* Take advantage of the fact that the TID field is not used, to tag
2299 special ptids with it set to != 0. */
2300 static const ptid_t
magic_null_ptid (42000, -1, 1);
2301 static const ptid_t
not_sent_ptid (42000, -2, 1);
2302 static const ptid_t
any_thread_ptid (42000, 0, 1);
2304 /* Find out if the stub attached to PID (and hence GDB should offer to
2305 detach instead of killing it when bailing out). */
2308 remote_target::remote_query_attached (int pid
)
2310 struct remote_state
*rs
= get_remote_state ();
2311 size_t size
= get_remote_packet_size ();
2313 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
2316 if (remote_multi_process_p (rs
))
2317 xsnprintf (rs
->buf
.data (), size
, "qAttached:%x", pid
);
2319 xsnprintf (rs
->buf
.data (), size
, "qAttached");
2322 getpkt (&rs
->buf
, 0);
2324 switch (packet_ok (rs
->buf
,
2325 &remote_protocol_packets
[PACKET_qAttached
]))
2328 if (strcmp (rs
->buf
.data (), "1") == 0)
2332 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
2334 case PACKET_UNKNOWN
:
2341 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2342 has been invented by GDB, instead of reported by the target. Since
2343 we can be connected to a remote system before before knowing about
2344 any inferior, mark the target with execution when we find the first
2345 inferior. If ATTACHED is 1, then we had just attached to this
2346 inferior. If it is 0, then we just created this inferior. If it
2347 is -1, then try querying the remote stub to find out if it had
2348 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2349 attempt to open this inferior's executable as the main executable
2350 if no main executable is open already. */
2353 remote_target::remote_add_inferior (bool fake_pid_p
, int pid
, int attached
,
2356 struct inferior
*inf
;
2358 /* Check whether this process we're learning about is to be
2359 considered attached, or if is to be considered to have been
2360 spawned by the stub. */
2362 attached
= remote_query_attached (pid
);
2364 if (gdbarch_has_global_solist (target_gdbarch ()))
2366 /* If the target shares code across all inferiors, then every
2367 attach adds a new inferior. */
2368 inf
= add_inferior (pid
);
2370 /* ... and every inferior is bound to the same program space.
2371 However, each inferior may still have its own address
2373 inf
->aspace
= maybe_new_address_space ();
2374 inf
->pspace
= current_program_space
;
2378 /* In the traditional debugging scenario, there's a 1-1 match
2379 between program/address spaces. We simply bind the inferior
2380 to the program space's address space. */
2381 inf
= current_inferior ();
2383 /* However, if the current inferior is already bound to a
2384 process, find some other empty inferior. */
2388 for (inferior
*it
: all_inferiors ())
2397 /* Since all inferiors were already bound to a process, add
2399 inf
= add_inferior_with_spaces ();
2401 switch_to_inferior_no_thread (inf
);
2403 inferior_appeared (inf
, pid
);
2406 inf
->attach_flag
= attached
;
2407 inf
->fake_pid_p
= fake_pid_p
;
2409 /* If no main executable is currently open then attempt to
2410 open the file that was executed to create this inferior. */
2411 if (try_open_exec
&& get_exec_file (0) == NULL
)
2412 exec_file_locate_attach (pid
, 0, 1);
2414 /* Check for exec file mismatch, and let the user solve it. */
2415 validate_exec_file (1);
2420 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2421 static remote_thread_info
*get_remote_thread_info (remote_target
*target
,
2424 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2425 according to RUNNING. */
2428 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
)
2430 struct remote_state
*rs
= get_remote_state ();
2431 struct thread_info
*thread
;
2433 /* GDB historically didn't pull threads in the initial connection
2434 setup. If the remote target doesn't even have a concept of
2435 threads (e.g., a bare-metal target), even if internally we
2436 consider that a single-threaded target, mentioning a new thread
2437 might be confusing to the user. Be silent then, preserving the
2438 age old behavior. */
2439 if (rs
->starting_up
)
2440 thread
= add_thread_silent (this, ptid
);
2442 thread
= add_thread (this, ptid
);
2444 get_remote_thread_info (thread
)->vcont_resumed
= executing
;
2445 set_executing (this, ptid
, executing
);
2446 set_running (this, ptid
, running
);
2451 /* Come here when we learn about a thread id from the remote target.
2452 It may be the first time we hear about such thread, so take the
2453 opportunity to add it to GDB's thread list. In case this is the
2454 first time we're noticing its corresponding inferior, add it to
2455 GDB's inferior list as well. EXECUTING indicates whether the
2456 thread is (internally) executing or stopped. */
2459 remote_target::remote_notice_new_inferior (ptid_t currthread
, int executing
)
2461 /* In non-stop mode, we assume new found threads are (externally)
2462 running until proven otherwise with a stop reply. In all-stop,
2463 we can only get here if all threads are stopped. */
2464 int running
= target_is_non_stop_p () ? 1 : 0;
2466 /* If this is a new thread, add it to GDB's thread list.
2467 If we leave it up to WFI to do this, bad things will happen. */
2469 thread_info
*tp
= find_thread_ptid (this, currthread
);
2470 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2472 /* We're seeing an event on a thread id we knew had exited.
2473 This has to be a new thread reusing the old id. Add it. */
2474 remote_add_thread (currthread
, running
, executing
);
2478 if (!in_thread_list (this, currthread
))
2480 struct inferior
*inf
= NULL
;
2481 int pid
= currthread
.pid ();
2483 if (inferior_ptid
.is_pid ()
2484 && pid
== inferior_ptid
.pid ())
2486 /* inferior_ptid has no thread member yet. This can happen
2487 with the vAttach -> remote_wait,"TAAthread:" path if the
2488 stub doesn't support qC. This is the first stop reported
2489 after an attach, so this is the main thread. Update the
2490 ptid in the thread list. */
2491 if (in_thread_list (this, ptid_t (pid
)))
2492 thread_change_ptid (this, inferior_ptid
, currthread
);
2495 remote_add_thread (currthread
, running
, executing
);
2496 inferior_ptid
= currthread
;
2501 if (magic_null_ptid
== inferior_ptid
)
2503 /* inferior_ptid is not set yet. This can happen with the
2504 vRun -> remote_wait,"TAAthread:" path if the stub
2505 doesn't support qC. This is the first stop reported
2506 after an attach, so this is the main thread. Update the
2507 ptid in the thread list. */
2508 thread_change_ptid (this, inferior_ptid
, currthread
);
2512 /* When connecting to a target remote, or to a target
2513 extended-remote which already was debugging an inferior, we
2514 may not know about it yet. Add it before adding its child
2515 thread, so notifications are emitted in a sensible order. */
2516 if (find_inferior_pid (this, currthread
.pid ()) == NULL
)
2518 struct remote_state
*rs
= get_remote_state ();
2519 bool fake_pid_p
= !remote_multi_process_p (rs
);
2521 inf
= remote_add_inferior (fake_pid_p
,
2522 currthread
.pid (), -1, 1);
2525 /* This is really a new thread. Add it. */
2526 thread_info
*new_thr
2527 = remote_add_thread (currthread
, running
, executing
);
2529 /* If we found a new inferior, let the common code do whatever
2530 it needs to with it (e.g., read shared libraries, insert
2531 breakpoints), unless we're just setting up an all-stop
2535 struct remote_state
*rs
= get_remote_state ();
2537 if (!rs
->starting_up
)
2538 notice_new_inferior (new_thr
, executing
, 0);
2543 /* Return THREAD's private thread data, creating it if necessary. */
2545 static remote_thread_info
*
2546 get_remote_thread_info (thread_info
*thread
)
2548 gdb_assert (thread
!= NULL
);
2550 if (thread
->priv
== NULL
)
2551 thread
->priv
.reset (new remote_thread_info
);
2553 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2556 /* Return PTID's private thread data, creating it if necessary. */
2558 static remote_thread_info
*
2559 get_remote_thread_info (remote_target
*target
, ptid_t ptid
)
2561 thread_info
*thr
= find_thread_ptid (target
, ptid
);
2562 return get_remote_thread_info (thr
);
2565 /* Call this function as a result of
2566 1) A halt indication (T packet) containing a thread id
2567 2) A direct query of currthread
2568 3) Successful execution of set thread */
2571 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2573 rs
->general_thread
= currthread
;
2576 /* If 'QPassSignals' is supported, tell the remote stub what signals
2577 it can simply pass through to the inferior without reporting. */
2580 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2582 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2584 char *pass_packet
, *p
;
2586 struct remote_state
*rs
= get_remote_state ();
2588 gdb_assert (pass_signals
.size () < 256);
2589 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2591 if (pass_signals
[i
])
2594 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2595 strcpy (pass_packet
, "QPassSignals:");
2596 p
= pass_packet
+ strlen (pass_packet
);
2597 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2599 if (pass_signals
[i
])
2602 *p
++ = tohex (i
>> 4);
2603 *p
++ = tohex (i
& 15);
2612 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2614 putpkt (pass_packet
);
2615 getpkt (&rs
->buf
, 0);
2616 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2617 if (rs
->last_pass_packet
)
2618 xfree (rs
->last_pass_packet
);
2619 rs
->last_pass_packet
= pass_packet
;
2622 xfree (pass_packet
);
2626 /* If 'QCatchSyscalls' is supported, tell the remote stub
2627 to report syscalls to GDB. */
2630 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2631 gdb::array_view
<const int> syscall_counts
)
2633 const char *catch_packet
;
2634 enum packet_result result
;
2637 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2639 /* Not supported. */
2643 if (needed
&& any_count
== 0)
2645 /* Count how many syscalls are to be caught. */
2646 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2648 if (syscall_counts
[i
] != 0)
2655 fprintf_unfiltered (gdb_stdlog
,
2656 "remote_set_syscall_catchpoint "
2657 "pid %d needed %d any_count %d n_sysno %d\n",
2658 pid
, needed
, any_count
, n_sysno
);
2661 std::string built_packet
;
2664 /* Prepare a packet with the sysno list, assuming max 8+1
2665 characters for a sysno. If the resulting packet size is too
2666 big, fallback on the non-selective packet. */
2667 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2668 built_packet
.reserve (maxpktsz
);
2669 built_packet
= "QCatchSyscalls:1";
2672 /* Add in each syscall to be caught. */
2673 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2675 if (syscall_counts
[i
] != 0)
2676 string_appendf (built_packet
, ";%zx", i
);
2679 if (built_packet
.size () > get_remote_packet_size ())
2681 /* catch_packet too big. Fallback to less efficient
2682 non selective mode, with GDB doing the filtering. */
2683 catch_packet
= "QCatchSyscalls:1";
2686 catch_packet
= built_packet
.c_str ();
2689 catch_packet
= "QCatchSyscalls:0";
2691 struct remote_state
*rs
= get_remote_state ();
2693 putpkt (catch_packet
);
2694 getpkt (&rs
->buf
, 0);
2695 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2696 if (result
== PACKET_OK
)
2702 /* If 'QProgramSignals' is supported, tell the remote stub what
2703 signals it should pass through to the inferior when detaching. */
2706 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2708 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2712 struct remote_state
*rs
= get_remote_state ();
2714 gdb_assert (signals
.size () < 256);
2715 for (size_t i
= 0; i
< signals
.size (); i
++)
2720 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2721 strcpy (packet
, "QProgramSignals:");
2722 p
= packet
+ strlen (packet
);
2723 for (size_t i
= 0; i
< signals
.size (); i
++)
2725 if (signal_pass_state (i
))
2728 *p
++ = tohex (i
>> 4);
2729 *p
++ = tohex (i
& 15);
2738 if (!rs
->last_program_signals_packet
2739 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2742 getpkt (&rs
->buf
, 0);
2743 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2744 xfree (rs
->last_program_signals_packet
);
2745 rs
->last_program_signals_packet
= packet
;
2752 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2753 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2754 thread. If GEN is set, set the general thread, if not, then set
2755 the step/continue thread. */
2757 remote_target::set_thread (ptid_t ptid
, int gen
)
2759 struct remote_state
*rs
= get_remote_state ();
2760 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2761 char *buf
= rs
->buf
.data ();
2762 char *endbuf
= buf
+ get_remote_packet_size ();
2768 *buf
++ = gen
? 'g' : 'c';
2769 if (ptid
== magic_null_ptid
)
2770 xsnprintf (buf
, endbuf
- buf
, "0");
2771 else if (ptid
== any_thread_ptid
)
2772 xsnprintf (buf
, endbuf
- buf
, "0");
2773 else if (ptid
== minus_one_ptid
)
2774 xsnprintf (buf
, endbuf
- buf
, "-1");
2776 write_ptid (buf
, endbuf
, ptid
);
2778 getpkt (&rs
->buf
, 0);
2780 rs
->general_thread
= ptid
;
2782 rs
->continue_thread
= ptid
;
2786 remote_target::set_general_thread (ptid_t ptid
)
2788 set_thread (ptid
, 1);
2792 remote_target::set_continue_thread (ptid_t ptid
)
2794 set_thread (ptid
, 0);
2797 /* Change the remote current process. Which thread within the process
2798 ends up selected isn't important, as long as it is the same process
2799 as what INFERIOR_PTID points to.
2801 This comes from that fact that there is no explicit notion of
2802 "selected process" in the protocol. The selected process for
2803 general operations is the process the selected general thread
2807 remote_target::set_general_process ()
2809 struct remote_state
*rs
= get_remote_state ();
2811 /* If the remote can't handle multiple processes, don't bother. */
2812 if (!remote_multi_process_p (rs
))
2815 /* We only need to change the remote current thread if it's pointing
2816 at some other process. */
2817 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2818 set_general_thread (inferior_ptid
);
2822 /* Return nonzero if this is the main thread that we made up ourselves
2823 to model non-threaded targets as single-threaded. */
2826 remote_thread_always_alive (ptid_t ptid
)
2828 if (ptid
== magic_null_ptid
)
2829 /* The main thread is always alive. */
2832 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2833 /* The main thread is always alive. This can happen after a
2834 vAttach, if the remote side doesn't support
2841 /* Return nonzero if the thread PTID is still alive on the remote
2845 remote_target::thread_alive (ptid_t ptid
)
2847 struct remote_state
*rs
= get_remote_state ();
2850 /* Check if this is a thread that we made up ourselves to model
2851 non-threaded targets as single-threaded. */
2852 if (remote_thread_always_alive (ptid
))
2855 p
= rs
->buf
.data ();
2856 endp
= p
+ get_remote_packet_size ();
2859 write_ptid (p
, endp
, ptid
);
2862 getpkt (&rs
->buf
, 0);
2863 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2866 /* Return a pointer to a thread name if we know it and NULL otherwise.
2867 The thread_info object owns the memory for the name. */
2870 remote_target::thread_name (struct thread_info
*info
)
2872 if (info
->priv
!= NULL
)
2874 const std::string
&name
= get_remote_thread_info (info
)->name
;
2875 return !name
.empty () ? name
.c_str () : NULL
;
2881 /* About these extended threadlist and threadinfo packets. They are
2882 variable length packets but, the fields within them are often fixed
2883 length. They are redundant enough to send over UDP as is the
2884 remote protocol in general. There is a matching unit test module
2887 /* WARNING: This threadref data structure comes from the remote O.S.,
2888 libstub protocol encoding, and remote.c. It is not particularly
2891 /* Right now, the internal structure is int. We want it to be bigger.
2892 Plan to fix this. */
2894 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2896 /* gdb_ext_thread_info is an internal GDB data structure which is
2897 equivalent to the reply of the remote threadinfo packet. */
2899 struct gdb_ext_thread_info
2901 threadref threadid
; /* External form of thread reference. */
2902 int active
; /* Has state interesting to GDB?
2904 char display
[256]; /* Brief state display, name,
2905 blocked/suspended. */
2906 char shortname
[32]; /* To be used to name threads. */
2907 char more_display
[256]; /* Long info, statistics, queue depth,
2911 /* The volume of remote transfers can be limited by submitting
2912 a mask containing bits specifying the desired information.
2913 Use a union of these values as the 'selection' parameter to
2914 get_thread_info. FIXME: Make these TAG names more thread specific. */
2916 #define TAG_THREADID 1
2917 #define TAG_EXISTS 2
2918 #define TAG_DISPLAY 4
2919 #define TAG_THREADNAME 8
2920 #define TAG_MOREDISPLAY 16
2922 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2924 static char *unpack_nibble (char *buf
, int *val
);
2926 static char *unpack_byte (char *buf
, int *value
);
2928 static char *pack_int (char *buf
, int value
);
2930 static char *unpack_int (char *buf
, int *value
);
2932 static char *unpack_string (char *src
, char *dest
, int length
);
2934 static char *pack_threadid (char *pkt
, threadref
*id
);
2936 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2938 void int_to_threadref (threadref
*id
, int value
);
2940 static int threadref_to_int (threadref
*ref
);
2942 static void copy_threadref (threadref
*dest
, threadref
*src
);
2944 static int threadmatch (threadref
*dest
, threadref
*src
);
2946 static char *pack_threadinfo_request (char *pkt
, int mode
,
2949 static char *pack_threadlist_request (char *pkt
, int startflag
,
2951 threadref
*nextthread
);
2953 static int remote_newthread_step (threadref
*ref
, void *context
);
2956 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2957 buffer we're allowed to write to. Returns
2958 BUF+CHARACTERS_WRITTEN. */
2961 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2964 struct remote_state
*rs
= get_remote_state ();
2966 if (remote_multi_process_p (rs
))
2970 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2972 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2976 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2978 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2983 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2984 last parsed char. Returns null_ptid if no thread id is found, and
2985 throws an error if the thread id has an invalid format. */
2988 read_ptid (const char *buf
, const char **obuf
)
2990 const char *p
= buf
;
2992 ULONGEST pid
= 0, tid
= 0;
2996 /* Multi-process ptid. */
2997 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2999 error (_("invalid remote ptid: %s"), p
);
3002 pp
= unpack_varlen_hex (p
+ 1, &tid
);
3005 return ptid_t (pid
, tid
, 0);
3008 /* No multi-process. Just a tid. */
3009 pp
= unpack_varlen_hex (p
, &tid
);
3011 /* Return null_ptid when no thread id is found. */
3019 /* Since the stub is not sending a process id, then default to
3020 what's in inferior_ptid, unless it's null at this point. If so,
3021 then since there's no way to know the pid of the reported
3022 threads, use the magic number. */
3023 if (inferior_ptid
== null_ptid
)
3024 pid
= magic_null_ptid
.pid ();
3026 pid
= inferior_ptid
.pid ();
3030 return ptid_t (pid
, tid
, 0);
3036 if (ch
>= 'a' && ch
<= 'f')
3037 return ch
- 'a' + 10;
3038 if (ch
>= '0' && ch
<= '9')
3040 if (ch
>= 'A' && ch
<= 'F')
3041 return ch
- 'A' + 10;
3046 stub_unpack_int (char *buff
, int fieldlength
)
3053 nibble
= stubhex (*buff
++);
3057 retval
= retval
<< 4;
3063 unpack_nibble (char *buf
, int *val
)
3065 *val
= fromhex (*buf
++);
3070 unpack_byte (char *buf
, int *value
)
3072 *value
= stub_unpack_int (buf
, 2);
3077 pack_int (char *buf
, int value
)
3079 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3080 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3081 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3082 buf
= pack_hex_byte (buf
, (value
& 0xff));
3087 unpack_int (char *buf
, int *value
)
3089 *value
= stub_unpack_int (buf
, 8);
3093 #if 0 /* Currently unused, uncomment when needed. */
3094 static char *pack_string (char *pkt
, char *string
);
3097 pack_string (char *pkt
, char *string
)
3102 len
= strlen (string
);
3104 len
= 200; /* Bigger than most GDB packets, junk??? */
3105 pkt
= pack_hex_byte (pkt
, len
);
3109 if ((ch
== '\0') || (ch
== '#'))
3110 ch
= '*'; /* Protect encapsulation. */
3115 #endif /* 0 (unused) */
3118 unpack_string (char *src
, char *dest
, int length
)
3127 pack_threadid (char *pkt
, threadref
*id
)
3130 unsigned char *altid
;
3132 altid
= (unsigned char *) id
;
3133 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3135 pkt
= pack_hex_byte (pkt
, *altid
++);
3141 unpack_threadid (char *inbuf
, threadref
*id
)
3144 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3147 altref
= (char *) id
;
3149 while (inbuf
< limit
)
3151 x
= stubhex (*inbuf
++);
3152 y
= stubhex (*inbuf
++);
3153 *altref
++ = (x
<< 4) | y
;
3158 /* Externally, threadrefs are 64 bits but internally, they are still
3159 ints. This is due to a mismatch of specifications. We would like
3160 to use 64bit thread references internally. This is an adapter
3164 int_to_threadref (threadref
*id
, int value
)
3166 unsigned char *scan
;
3168 scan
= (unsigned char *) id
;
3174 *scan
++ = (value
>> 24) & 0xff;
3175 *scan
++ = (value
>> 16) & 0xff;
3176 *scan
++ = (value
>> 8) & 0xff;
3177 *scan
++ = (value
& 0xff);
3181 threadref_to_int (threadref
*ref
)
3184 unsigned char *scan
;
3190 value
= (value
<< 8) | ((*scan
++) & 0xff);
3195 copy_threadref (threadref
*dest
, threadref
*src
)
3198 unsigned char *csrc
, *cdest
;
3200 csrc
= (unsigned char *) src
;
3201 cdest
= (unsigned char *) dest
;
3208 threadmatch (threadref
*dest
, threadref
*src
)
3210 /* Things are broken right now, so just assume we got a match. */
3212 unsigned char *srcp
, *destp
;
3214 srcp
= (char *) src
;
3215 destp
= (char *) dest
;
3219 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3226 threadid:1, # always request threadid
3233 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3236 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3238 *pkt
++ = 'q'; /* Info Query */
3239 *pkt
++ = 'P'; /* process or thread info */
3240 pkt
= pack_int (pkt
, mode
); /* mode */
3241 pkt
= pack_threadid (pkt
, id
); /* threadid */
3242 *pkt
= '\0'; /* terminate */
3246 /* These values tag the fields in a thread info response packet. */
3247 /* Tagging the fields allows us to request specific fields and to
3248 add more fields as time goes by. */
3250 #define TAG_THREADID 1 /* Echo the thread identifier. */
3251 #define TAG_EXISTS 2 /* Is this process defined enough to
3252 fetch registers and its stack? */
3253 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3254 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3255 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3259 remote_target::remote_unpack_thread_info_response (char *pkt
,
3260 threadref
*expectedref
,
3261 gdb_ext_thread_info
*info
)
3263 struct remote_state
*rs
= get_remote_state ();
3267 char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3270 /* info->threadid = 0; FIXME: implement zero_threadref. */
3272 info
->display
[0] = '\0';
3273 info
->shortname
[0] = '\0';
3274 info
->more_display
[0] = '\0';
3276 /* Assume the characters indicating the packet type have been
3278 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3279 pkt
= unpack_threadid (pkt
, &ref
);
3282 warning (_("Incomplete response to threadinfo request."));
3283 if (!threadmatch (&ref
, expectedref
))
3284 { /* This is an answer to a different request. */
3285 warning (_("ERROR RMT Thread info mismatch."));
3288 copy_threadref (&info
->threadid
, &ref
);
3290 /* Loop on tagged fields , try to bail if something goes wrong. */
3292 /* Packets are terminated with nulls. */
3293 while ((pkt
< limit
) && mask
&& *pkt
)
3295 pkt
= unpack_int (pkt
, &tag
); /* tag */
3296 pkt
= unpack_byte (pkt
, &length
); /* length */
3297 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3299 warning (_("ERROR RMT: threadinfo tag mismatch."));
3303 if (tag
== TAG_THREADID
)
3307 warning (_("ERROR RMT: length of threadid is not 16."));
3311 pkt
= unpack_threadid (pkt
, &ref
);
3312 mask
= mask
& ~TAG_THREADID
;
3315 if (tag
== TAG_EXISTS
)
3317 info
->active
= stub_unpack_int (pkt
, length
);
3319 mask
= mask
& ~(TAG_EXISTS
);
3322 warning (_("ERROR RMT: 'exists' length too long."));
3328 if (tag
== TAG_THREADNAME
)
3330 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3331 mask
= mask
& ~TAG_THREADNAME
;
3334 if (tag
== TAG_DISPLAY
)
3336 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3337 mask
= mask
& ~TAG_DISPLAY
;
3340 if (tag
== TAG_MOREDISPLAY
)
3342 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3343 mask
= mask
& ~TAG_MOREDISPLAY
;
3346 warning (_("ERROR RMT: unknown thread info tag."));
3347 break; /* Not a tag we know about. */
3353 remote_target::remote_get_threadinfo (threadref
*threadid
,
3355 gdb_ext_thread_info
*info
)
3357 struct remote_state
*rs
= get_remote_state ();
3360 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3362 getpkt (&rs
->buf
, 0);
3364 if (rs
->buf
[0] == '\0')
3367 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3372 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3375 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3376 threadref
*nextthread
)
3378 *pkt
++ = 'q'; /* info query packet */
3379 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3380 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3381 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3382 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3387 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3390 remote_target::parse_threadlist_response (char *pkt
, int result_limit
,
3391 threadref
*original_echo
,
3392 threadref
*resultlist
,
3395 struct remote_state
*rs
= get_remote_state ();
3397 int count
, resultcount
, done
;
3400 /* Assume the 'q' and 'M chars have been stripped. */
3401 limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3402 /* done parse past here */
3403 pkt
= unpack_byte (pkt
, &count
); /* count field */
3404 pkt
= unpack_nibble (pkt
, &done
);
3405 /* The first threadid is the argument threadid. */
3406 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3407 while ((count
-- > 0) && (pkt
< limit
))
3409 pkt
= unpack_threadid (pkt
, resultlist
++);
3410 if (resultcount
++ >= result_limit
)
3418 /* Fetch the next batch of threads from the remote. Returns -1 if the
3419 qL packet is not supported, 0 on error and 1 on success. */
3422 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3423 int result_limit
, int *done
, int *result_count
,
3424 threadref
*threadlist
)
3426 struct remote_state
*rs
= get_remote_state ();
3429 /* Truncate result limit to be smaller than the packet size. */
3430 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3431 >= get_remote_packet_size ())
3432 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3434 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3437 getpkt (&rs
->buf
, 0);
3438 if (rs
->buf
[0] == '\0')
3440 /* Packet not supported. */
3445 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3446 &rs
->echo_nextthread
, threadlist
, done
);
3448 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3450 /* FIXME: This is a good reason to drop the packet. */
3451 /* Possibly, there is a duplicate response. */
3453 retransmit immediatly - race conditions
3454 retransmit after timeout - yes
3456 wait for packet, then exit
3458 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3459 return 0; /* I choose simply exiting. */
3461 if (*result_count
<= 0)
3465 warning (_("RMT ERROR : failed to get remote thread list."));
3468 return result
; /* break; */
3470 if (*result_count
> result_limit
)
3473 warning (_("RMT ERROR: threadlist response longer than requested."));
3479 /* Fetch the list of remote threads, with the qL packet, and call
3480 STEPFUNCTION for each thread found. Stops iterating and returns 1
3481 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3482 STEPFUNCTION returns false. If the packet is not supported,
3486 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3487 void *context
, int looplimit
)
3489 struct remote_state
*rs
= get_remote_state ();
3490 int done
, i
, result_count
;
3498 if (loopcount
++ > looplimit
)
3501 warning (_("Remote fetch threadlist -infinite loop-."));
3504 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3505 MAXTHREADLISTRESULTS
,
3506 &done
, &result_count
,
3507 rs
->resultthreadlist
);
3510 /* Clear for later iterations. */
3512 /* Setup to resume next batch of thread references, set nextthread. */
3513 if (result_count
>= 1)
3514 copy_threadref (&rs
->nextthread
,
3515 &rs
->resultthreadlist
[result_count
- 1]);
3517 while (result_count
--)
3519 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3529 /* A thread found on the remote target. */
3533 explicit thread_item (ptid_t ptid_
)
3537 thread_item (thread_item
&&other
) = default;
3538 thread_item
&operator= (thread_item
&&other
) = default;
3540 DISABLE_COPY_AND_ASSIGN (thread_item
);
3542 /* The thread's PTID. */
3545 /* The thread's extra info. */
3548 /* The thread's name. */
3551 /* The core the thread was running on. -1 if not known. */
3554 /* The thread handle associated with the thread. */
3555 gdb::byte_vector thread_handle
;
3558 /* Context passed around to the various methods listing remote
3559 threads. As new threads are found, they're added to the ITEMS
3562 struct threads_listing_context
3564 /* Return true if this object contains an entry for a thread with ptid
3567 bool contains_thread (ptid_t ptid
) const
3569 auto match_ptid
= [&] (const thread_item
&item
)
3571 return item
.ptid
== ptid
;
3574 auto it
= std::find_if (this->items
.begin (),
3578 return it
!= this->items
.end ();
3581 /* Remove the thread with ptid PTID. */
3583 void remove_thread (ptid_t ptid
)
3585 auto match_ptid
= [&] (const thread_item
&item
)
3587 return item
.ptid
== ptid
;
3590 auto it
= std::remove_if (this->items
.begin (),
3594 if (it
!= this->items
.end ())
3595 this->items
.erase (it
);
3598 /* The threads found on the remote target. */
3599 std::vector
<thread_item
> items
;
3603 remote_newthread_step (threadref
*ref
, void *data
)
3605 struct threads_listing_context
*context
3606 = (struct threads_listing_context
*) data
;
3607 int pid
= inferior_ptid
.pid ();
3608 int lwp
= threadref_to_int (ref
);
3609 ptid_t
ptid (pid
, lwp
);
3611 context
->items
.emplace_back (ptid
);
3613 return 1; /* continue iterator */
3616 #define CRAZY_MAX_THREADS 1000
3619 remote_target::remote_current_thread (ptid_t oldpid
)
3621 struct remote_state
*rs
= get_remote_state ();
3624 getpkt (&rs
->buf
, 0);
3625 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3630 result
= read_ptid (&rs
->buf
[2], &obuf
);
3631 if (*obuf
!= '\0' && remote_debug
)
3632 fprintf_unfiltered (gdb_stdlog
,
3633 "warning: garbage in qC reply\n");
3641 /* List remote threads using the deprecated qL packet. */
3644 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3646 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3647 CRAZY_MAX_THREADS
) >= 0)
3653 #if defined(HAVE_LIBEXPAT)
3656 start_thread (struct gdb_xml_parser
*parser
,
3657 const struct gdb_xml_element
*element
,
3659 std::vector
<gdb_xml_value
> &attributes
)
3661 struct threads_listing_context
*data
3662 = (struct threads_listing_context
*) user_data
;
3663 struct gdb_xml_value
*attr
;
3665 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3666 ptid_t ptid
= read_ptid (id
, NULL
);
3668 data
->items
.emplace_back (ptid
);
3669 thread_item
&item
= data
->items
.back ();
3671 attr
= xml_find_attribute (attributes
, "core");
3673 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3675 attr
= xml_find_attribute (attributes
, "name");
3677 item
.name
= (const char *) attr
->value
.get ();
3679 attr
= xml_find_attribute (attributes
, "handle");
3681 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3685 end_thread (struct gdb_xml_parser
*parser
,
3686 const struct gdb_xml_element
*element
,
3687 void *user_data
, const char *body_text
)
3689 struct threads_listing_context
*data
3690 = (struct threads_listing_context
*) user_data
;
3692 if (body_text
!= NULL
&& *body_text
!= '\0')
3693 data
->items
.back ().extra
= body_text
;
3696 const struct gdb_xml_attribute thread_attributes
[] = {
3697 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3698 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3699 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3700 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3701 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3704 const struct gdb_xml_element thread_children
[] = {
3705 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3708 const struct gdb_xml_element threads_children
[] = {
3709 { "thread", thread_attributes
, thread_children
,
3710 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3711 start_thread
, end_thread
},
3712 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3715 const struct gdb_xml_element threads_elements
[] = {
3716 { "threads", NULL
, threads_children
,
3717 GDB_XML_EF_NONE
, NULL
, NULL
},
3718 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3723 /* List remote threads using qXfer:threads:read. */
3726 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3728 #if defined(HAVE_LIBEXPAT)
3729 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3731 gdb::optional
<gdb::char_vector
> xml
3732 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3734 if (xml
&& (*xml
)[0] != '\0')
3736 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3737 threads_elements
, xml
->data (), context
);
3747 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3750 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3752 struct remote_state
*rs
= get_remote_state ();
3754 if (rs
->use_threadinfo_query
)
3758 putpkt ("qfThreadInfo");
3759 getpkt (&rs
->buf
, 0);
3760 bufp
= rs
->buf
.data ();
3761 if (bufp
[0] != '\0') /* q packet recognized */
3763 while (*bufp
++ == 'm') /* reply contains one or more TID */
3767 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3768 context
->items
.emplace_back (ptid
);
3770 while (*bufp
++ == ','); /* comma-separated list */
3771 putpkt ("qsThreadInfo");
3772 getpkt (&rs
->buf
, 0);
3773 bufp
= rs
->buf
.data ();
3779 /* Packet not recognized. */
3780 rs
->use_threadinfo_query
= 0;
3787 /* Implement the to_update_thread_list function for the remote
3791 remote_target::update_thread_list ()
3793 struct threads_listing_context context
;
3796 /* We have a few different mechanisms to fetch the thread list. Try
3797 them all, starting with the most preferred one first, falling
3798 back to older methods. */
3799 if (remote_get_threads_with_qxfer (&context
)
3800 || remote_get_threads_with_qthreadinfo (&context
)
3801 || remote_get_threads_with_ql (&context
))
3805 if (context
.items
.empty ()
3806 && remote_thread_always_alive (inferior_ptid
))
3808 /* Some targets don't really support threads, but still
3809 reply an (empty) thread list in response to the thread
3810 listing packets, instead of replying "packet not
3811 supported". Exit early so we don't delete the main
3816 /* CONTEXT now holds the current thread list on the remote
3817 target end. Delete GDB-side threads no longer found on the
3819 for (thread_info
*tp
: all_threads_safe ())
3821 if (tp
->inf
->process_target () != this)
3824 if (!context
.contains_thread (tp
->ptid
))
3831 /* Remove any unreported fork child threads from CONTEXT so
3832 that we don't interfere with follow fork, which is where
3833 creation of such threads is handled. */
3834 remove_new_fork_children (&context
);
3836 /* And now add threads we don't know about yet to our list. */
3837 for (thread_item
&item
: context
.items
)
3839 if (item
.ptid
!= null_ptid
)
3841 /* In non-stop mode, we assume new found threads are
3842 executing until proven otherwise with a stop reply.
3843 In all-stop, we can only get here if all threads are
3845 int executing
= target_is_non_stop_p () ? 1 : 0;
3847 remote_notice_new_inferior (item
.ptid
, executing
);
3849 thread_info
*tp
= find_thread_ptid (this, item
.ptid
);
3850 remote_thread_info
*info
= get_remote_thread_info (tp
);
3851 info
->core
= item
.core
;
3852 info
->extra
= std::move (item
.extra
);
3853 info
->name
= std::move (item
.name
);
3854 info
->thread_handle
= std::move (item
.thread_handle
);
3861 /* If no thread listing method is supported, then query whether
3862 each known thread is alive, one by one, with the T packet.
3863 If the target doesn't support threads at all, then this is a
3864 no-op. See remote_thread_alive. */
3870 * Collect a descriptive string about the given thread.
3871 * The target may say anything it wants to about the thread
3872 * (typically info about its blocked / runnable state, name, etc.).
3873 * This string will appear in the info threads display.
3875 * Optional: targets are not required to implement this function.
3879 remote_target::extra_thread_info (thread_info
*tp
)
3881 struct remote_state
*rs
= get_remote_state ();
3884 struct gdb_ext_thread_info threadinfo
;
3886 if (rs
->remote_desc
== 0) /* paranoia */
3887 internal_error (__FILE__
, __LINE__
,
3888 _("remote_threads_extra_info"));
3890 if (tp
->ptid
== magic_null_ptid
3891 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
3892 /* This is the main thread which was added by GDB. The remote
3893 server doesn't know about it. */
3896 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
3898 /* If already have cached info, use it. */
3899 if (!extra
.empty ())
3900 return extra
.c_str ();
3902 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3904 /* If we're using qXfer:threads:read, then the extra info is
3905 included in the XML. So if we didn't have anything cached,
3906 it's because there's really no extra info. */
3910 if (rs
->use_threadextra_query
)
3912 char *b
= rs
->buf
.data ();
3913 char *endb
= b
+ get_remote_packet_size ();
3915 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3917 write_ptid (b
, endb
, tp
->ptid
);
3920 getpkt (&rs
->buf
, 0);
3921 if (rs
->buf
[0] != 0)
3923 extra
.resize (strlen (rs
->buf
.data ()) / 2);
3924 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
3925 return extra
.c_str ();
3929 /* If the above query fails, fall back to the old method. */
3930 rs
->use_threadextra_query
= 0;
3931 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3932 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3933 int_to_threadref (&id
, tp
->ptid
.lwp ());
3934 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3935 if (threadinfo
.active
)
3937 if (*threadinfo
.shortname
)
3938 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
3939 if (*threadinfo
.display
)
3941 if (!extra
.empty ())
3943 string_appendf (extra
, " State: %s", threadinfo
.display
);
3945 if (*threadinfo
.more_display
)
3947 if (!extra
.empty ())
3949 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
3951 return extra
.c_str ();
3958 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
3959 struct static_tracepoint_marker
*marker
)
3961 struct remote_state
*rs
= get_remote_state ();
3962 char *p
= rs
->buf
.data ();
3964 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3966 p
+= hexnumstr (p
, addr
);
3968 getpkt (&rs
->buf
, 0);
3969 p
= rs
->buf
.data ();
3972 error (_("Remote failure reply: %s"), p
);
3976 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
3983 std::vector
<static_tracepoint_marker
>
3984 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
3986 struct remote_state
*rs
= get_remote_state ();
3987 std::vector
<static_tracepoint_marker
> markers
;
3989 static_tracepoint_marker marker
;
3991 /* Ask for a first packet of static tracepoint marker
3994 getpkt (&rs
->buf
, 0);
3995 p
= rs
->buf
.data ();
3997 error (_("Remote failure reply: %s"), p
);
4003 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
4005 if (strid
== NULL
|| marker
.str_id
== strid
)
4006 markers
.push_back (std::move (marker
));
4008 while (*p
++ == ','); /* comma-separated list */
4009 /* Ask for another packet of static tracepoint definition. */
4011 getpkt (&rs
->buf
, 0);
4012 p
= rs
->buf
.data ();
4019 /* Implement the to_get_ada_task_ptid function for the remote targets. */
4022 remote_target::get_ada_task_ptid (long lwp
, long thread
)
4024 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
4028 /* Restart the remote side; this is an extended protocol operation. */
4031 remote_target::extended_remote_restart ()
4033 struct remote_state
*rs
= get_remote_state ();
4035 /* Send the restart command; for reasons I don't understand the
4036 remote side really expects a number after the "R". */
4037 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
4040 remote_fileio_reset ();
4043 /* Clean up connection to a remote debugger. */
4046 remote_target::close ()
4048 /* Make sure we leave stdin registered in the event loop. */
4051 trace_reset_local_state ();
4056 remote_target::~remote_target ()
4058 struct remote_state
*rs
= get_remote_state ();
4060 /* Check for NULL because we may get here with a partially
4061 constructed target/connection. */
4062 if (rs
->remote_desc
== nullptr)
4065 serial_close (rs
->remote_desc
);
4067 /* We are destroying the remote target, so we should discard
4068 everything of this target. */
4069 discard_pending_stop_replies_in_queue ();
4071 if (rs
->remote_async_inferior_event_token
)
4072 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4074 delete rs
->notif_state
;
4077 /* Query the remote side for the text, data and bss offsets. */
4080 remote_target::get_offsets ()
4082 struct remote_state
*rs
= get_remote_state ();
4085 int lose
, num_segments
= 0, do_sections
, do_segments
;
4086 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4087 struct symfile_segment_data
*data
;
4089 if (symfile_objfile
== NULL
)
4092 putpkt ("qOffsets");
4093 getpkt (&rs
->buf
, 0);
4094 buf
= rs
->buf
.data ();
4096 if (buf
[0] == '\000')
4097 return; /* Return silently. Stub doesn't support
4101 warning (_("Remote failure reply: %s"), buf
);
4105 /* Pick up each field in turn. This used to be done with scanf, but
4106 scanf will make trouble if CORE_ADDR size doesn't match
4107 conversion directives correctly. The following code will work
4108 with any size of CORE_ADDR. */
4109 text_addr
= data_addr
= bss_addr
= 0;
4113 if (startswith (ptr
, "Text="))
4116 /* Don't use strtol, could lose on big values. */
4117 while (*ptr
&& *ptr
!= ';')
4118 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4120 if (startswith (ptr
, ";Data="))
4123 while (*ptr
&& *ptr
!= ';')
4124 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4129 if (!lose
&& startswith (ptr
, ";Bss="))
4132 while (*ptr
&& *ptr
!= ';')
4133 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4135 if (bss_addr
!= data_addr
)
4136 warning (_("Target reported unsupported offsets: %s"), buf
);
4141 else if (startswith (ptr
, "TextSeg="))
4144 /* Don't use strtol, could lose on big values. */
4145 while (*ptr
&& *ptr
!= ';')
4146 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4149 if (startswith (ptr
, ";DataSeg="))
4152 while (*ptr
&& *ptr
!= ';')
4153 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4161 error (_("Malformed response to offset query, %s"), buf
);
4162 else if (*ptr
!= '\0')
4163 warning (_("Target reported unsupported offsets: %s"), buf
);
4165 section_offsets offs
= symfile_objfile
->section_offsets
;
4167 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
4168 do_segments
= (data
!= NULL
);
4169 do_sections
= num_segments
== 0;
4171 if (num_segments
> 0)
4173 segments
[0] = text_addr
;
4174 segments
[1] = data_addr
;
4176 /* If we have two segments, we can still try to relocate everything
4177 by assuming that the .text and .data offsets apply to the whole
4178 text and data segments. Convert the offsets given in the packet
4179 to base addresses for symfile_map_offsets_to_segments. */
4180 else if (data
&& data
->num_segments
== 2)
4182 segments
[0] = data
->segment_bases
[0] + text_addr
;
4183 segments
[1] = data
->segment_bases
[1] + data_addr
;
4186 /* If the object file has only one segment, assume that it is text
4187 rather than data; main programs with no writable data are rare,
4188 but programs with no code are useless. Of course the code might
4189 have ended up in the data segment... to detect that we would need
4190 the permissions here. */
4191 else if (data
&& data
->num_segments
== 1)
4193 segments
[0] = data
->segment_bases
[0] + text_addr
;
4196 /* There's no way to relocate by segment. */
4202 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
4203 offs
, num_segments
, segments
);
4205 if (ret
== 0 && !do_sections
)
4206 error (_("Can not handle qOffsets TextSeg "
4207 "response with this symbol file"));
4214 free_symfile_segment_data (data
);
4218 offs
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
4220 /* This is a temporary kludge to force data and bss to use the
4221 same offsets because that's what nlmconv does now. The real
4222 solution requires changes to the stub and remote.c that I
4223 don't have time to do right now. */
4225 offs
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
4226 offs
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
4229 objfile_relocate (symfile_objfile
, offs
);
4232 /* Send interrupt_sequence to remote target. */
4235 remote_target::send_interrupt_sequence ()
4237 struct remote_state
*rs
= get_remote_state ();
4239 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4240 remote_serial_write ("\x03", 1);
4241 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4242 serial_send_break (rs
->remote_desc
);
4243 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4245 serial_send_break (rs
->remote_desc
);
4246 remote_serial_write ("g", 1);
4249 internal_error (__FILE__
, __LINE__
,
4250 _("Invalid value for interrupt_sequence_mode: %s."),
4251 interrupt_sequence_mode
);
4255 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4256 and extract the PTID. Returns NULL_PTID if not found. */
4259 stop_reply_extract_thread (char *stop_reply
)
4261 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4265 /* Txx r:val ; r:val (...) */
4268 /* Look for "register" named "thread". */
4273 p1
= strchr (p
, ':');
4277 if (strncmp (p
, "thread", p1
- p
) == 0)
4278 return read_ptid (++p1
, &p
);
4280 p1
= strchr (p
, ';');
4292 /* Determine the remote side's current thread. If we have a stop
4293 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4294 "thread" register we can extract the current thread from. If not,
4295 ask the remote which is the current thread with qC. The former
4296 method avoids a roundtrip. */
4299 remote_target::get_current_thread (char *wait_status
)
4301 ptid_t ptid
= null_ptid
;
4303 /* Note we don't use remote_parse_stop_reply as that makes use of
4304 the target architecture, which we haven't yet fully determined at
4306 if (wait_status
!= NULL
)
4307 ptid
= stop_reply_extract_thread (wait_status
);
4308 if (ptid
== null_ptid
)
4309 ptid
= remote_current_thread (inferior_ptid
);
4314 /* Query the remote target for which is the current thread/process,
4315 add it to our tables, and update INFERIOR_PTID. The caller is
4316 responsible for setting the state such that the remote end is ready
4317 to return the current thread.
4319 This function is called after handling the '?' or 'vRun' packets,
4320 whose response is a stop reply from which we can also try
4321 extracting the thread. If the target doesn't support the explicit
4322 qC query, we infer the current thread from that stop reply, passed
4323 in in WAIT_STATUS, which may be NULL. */
4326 remote_target::add_current_inferior_and_thread (char *wait_status
)
4328 struct remote_state
*rs
= get_remote_state ();
4329 bool fake_pid_p
= false;
4331 inferior_ptid
= null_ptid
;
4333 /* Now, if we have thread information, update inferior_ptid. */
4334 ptid_t curr_ptid
= get_current_thread (wait_status
);
4336 if (curr_ptid
!= null_ptid
)
4338 if (!remote_multi_process_p (rs
))
4343 /* Without this, some commands which require an active target
4344 (such as kill) won't work. This variable serves (at least)
4345 double duty as both the pid of the target process (if it has
4346 such), and as a flag indicating that a target is active. */
4347 curr_ptid
= magic_null_ptid
;
4351 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4353 /* Add the main thread and switch to it. Don't try reading
4354 registers yet, since we haven't fetched the target description
4356 thread_info
*tp
= add_thread_silent (this, curr_ptid
);
4357 switch_to_thread_no_regs (tp
);
4360 /* Print info about a thread that was found already stopped on
4364 print_one_stopped_thread (struct thread_info
*thread
)
4366 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4368 switch_to_thread (thread
);
4369 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4370 set_current_sal_from_frame (get_current_frame ());
4372 thread
->suspend
.waitstatus_pending_p
= 0;
4374 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4376 enum gdb_signal sig
= ws
->value
.sig
;
4378 if (signal_print_state (sig
))
4379 gdb::observers::signal_received
.notify (sig
);
4381 gdb::observers::normal_stop
.notify (NULL
, 1);
4384 /* Process all initial stop replies the remote side sent in response
4385 to the ? packet. These indicate threads that were already stopped
4386 on initial connection. We mark these threads as stopped and print
4387 their current frame before giving the user the prompt. */
4390 remote_target::process_initial_stop_replies (int from_tty
)
4392 int pending_stop_replies
= stop_reply_queue_length ();
4393 struct thread_info
*selected
= NULL
;
4394 struct thread_info
*lowest_stopped
= NULL
;
4395 struct thread_info
*first
= NULL
;
4397 /* Consume the initial pending events. */
4398 while (pending_stop_replies
-- > 0)
4400 ptid_t waiton_ptid
= minus_one_ptid
;
4402 struct target_waitstatus ws
;
4403 int ignore_event
= 0;
4405 memset (&ws
, 0, sizeof (ws
));
4406 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4408 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4412 case TARGET_WAITKIND_IGNORE
:
4413 case TARGET_WAITKIND_NO_RESUMED
:
4414 case TARGET_WAITKIND_SIGNALLED
:
4415 case TARGET_WAITKIND_EXITED
:
4416 /* We shouldn't see these, but if we do, just ignore. */
4418 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
4422 case TARGET_WAITKIND_EXECD
:
4423 xfree (ws
.value
.execd_pathname
);
4432 thread_info
*evthread
= find_thread_ptid (this, event_ptid
);
4434 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4436 enum gdb_signal sig
= ws
.value
.sig
;
4438 /* Stubs traditionally report SIGTRAP as initial signal,
4439 instead of signal 0. Suppress it. */
4440 if (sig
== GDB_SIGNAL_TRAP
)
4442 evthread
->suspend
.stop_signal
= sig
;
4446 evthread
->suspend
.waitstatus
= ws
;
4448 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4449 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4450 evthread
->suspend
.waitstatus_pending_p
= 1;
4452 set_executing (this, event_ptid
, false);
4453 set_running (this, event_ptid
, false);
4454 get_remote_thread_info (evthread
)->vcont_resumed
= 0;
4457 /* "Notice" the new inferiors before anything related to
4458 registers/memory. */
4459 for (inferior
*inf
: all_non_exited_inferiors (this))
4461 inf
->needs_setup
= 1;
4465 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4466 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4471 /* If all-stop on top of non-stop, pause all threads. Note this
4472 records the threads' stop pc, so must be done after "noticing"
4476 stop_all_threads ();
4478 /* If all threads of an inferior were already stopped, we
4479 haven't setup the inferior yet. */
4480 for (inferior
*inf
: all_non_exited_inferiors (this))
4482 if (inf
->needs_setup
)
4484 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4485 switch_to_thread_no_regs (thread
);
4491 /* Now go over all threads that are stopped, and print their current
4492 frame. If all-stop, then if there's a signalled thread, pick
4494 for (thread_info
*thread
: all_non_exited_threads (this))
4500 thread
->set_running (false);
4501 else if (thread
->state
!= THREAD_STOPPED
)
4504 if (selected
== NULL
4505 && thread
->suspend
.waitstatus_pending_p
)
4508 if (lowest_stopped
== NULL
4509 || thread
->inf
->num
< lowest_stopped
->inf
->num
4510 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4511 lowest_stopped
= thread
;
4514 print_one_stopped_thread (thread
);
4517 /* In all-stop, we only print the status of one thread, and leave
4518 others with their status pending. */
4521 thread_info
*thread
= selected
;
4523 thread
= lowest_stopped
;
4527 print_one_stopped_thread (thread
);
4530 /* For "info program". */
4531 thread_info
*thread
= inferior_thread ();
4532 if (thread
->state
== THREAD_STOPPED
)
4533 set_last_target_status (this, inferior_ptid
, thread
->suspend
.waitstatus
);
4536 /* Start the remote connection and sync state. */
4539 remote_target::start_remote (int from_tty
, int extended_p
)
4541 struct remote_state
*rs
= get_remote_state ();
4542 struct packet_config
*noack_config
;
4543 char *wait_status
= NULL
;
4545 /* Signal other parts that we're going through the initial setup,
4546 and so things may not be stable yet. E.g., we don't try to
4547 install tracepoints until we've relocated symbols. Also, a
4548 Ctrl-C before we're connected and synced up can't interrupt the
4549 target. Instead, it offers to drop the (potentially wedged)
4551 rs
->starting_up
= 1;
4555 if (interrupt_on_connect
)
4556 send_interrupt_sequence ();
4558 /* Ack any packet which the remote side has already sent. */
4559 remote_serial_write ("+", 1);
4561 /* The first packet we send to the target is the optional "supported
4562 packets" request. If the target can answer this, it will tell us
4563 which later probes to skip. */
4564 remote_query_supported ();
4566 /* If the stub wants to get a QAllow, compose one and send it. */
4567 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4570 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4571 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4572 as a reply to known packet. For packet "vFile:setfs:" it is an
4573 invalid reply and GDB would return error in
4574 remote_hostio_set_filesystem, making remote files access impossible.
4575 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4576 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4578 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4580 putpkt (v_mustreplyempty
);
4581 getpkt (&rs
->buf
, 0);
4582 if (strcmp (rs
->buf
.data (), "OK") == 0)
4583 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4584 else if (strcmp (rs
->buf
.data (), "") != 0)
4585 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4589 /* Next, we possibly activate noack mode.
4591 If the QStartNoAckMode packet configuration is set to AUTO,
4592 enable noack mode if the stub reported a wish for it with
4595 If set to TRUE, then enable noack mode even if the stub didn't
4596 report it in qSupported. If the stub doesn't reply OK, the
4597 session ends with an error.
4599 If FALSE, then don't activate noack mode, regardless of what the
4600 stub claimed should be the default with qSupported. */
4602 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4603 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4605 putpkt ("QStartNoAckMode");
4606 getpkt (&rs
->buf
, 0);
4607 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4613 /* Tell the remote that we are using the extended protocol. */
4615 getpkt (&rs
->buf
, 0);
4618 /* Let the target know which signals it is allowed to pass down to
4620 update_signals_program_target ();
4622 /* Next, if the target can specify a description, read it. We do
4623 this before anything involving memory or registers. */
4624 target_find_description ();
4626 /* Next, now that we know something about the target, update the
4627 address spaces in the program spaces. */
4628 update_address_spaces ();
4630 /* On OSs where the list of libraries is global to all
4631 processes, we fetch them early. */
4632 if (gdbarch_has_global_solist (target_gdbarch ()))
4633 solib_add (NULL
, from_tty
, auto_solib_add
);
4635 if (target_is_non_stop_p ())
4637 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4638 error (_("Non-stop mode requested, but remote "
4639 "does not support non-stop"));
4641 putpkt ("QNonStop:1");
4642 getpkt (&rs
->buf
, 0);
4644 if (strcmp (rs
->buf
.data (), "OK") != 0)
4645 error (_("Remote refused setting non-stop mode with: %s"),
4648 /* Find about threads and processes the stub is already
4649 controlling. We default to adding them in the running state.
4650 The '?' query below will then tell us about which threads are
4652 this->update_thread_list ();
4654 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4656 /* Don't assume that the stub can operate in all-stop mode.
4657 Request it explicitly. */
4658 putpkt ("QNonStop:0");
4659 getpkt (&rs
->buf
, 0);
4661 if (strcmp (rs
->buf
.data (), "OK") != 0)
4662 error (_("Remote refused setting all-stop mode with: %s"),
4666 /* Upload TSVs regardless of whether the target is running or not. The
4667 remote stub, such as GDBserver, may have some predefined or builtin
4668 TSVs, even if the target is not running. */
4669 if (get_trace_status (current_trace_status ()) != -1)
4671 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4673 upload_trace_state_variables (&uploaded_tsvs
);
4674 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4677 /* Check whether the target is running now. */
4679 getpkt (&rs
->buf
, 0);
4681 if (!target_is_non_stop_p ())
4683 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4686 error (_("The target is not running (try extended-remote?)"));
4688 /* We're connected, but not running. Drop out before we
4689 call start_remote. */
4690 rs
->starting_up
= 0;
4695 /* Save the reply for later. */
4696 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4697 strcpy (wait_status
, rs
->buf
.data ());
4700 /* Fetch thread list. */
4701 target_update_thread_list ();
4703 /* Let the stub know that we want it to return the thread. */
4704 set_continue_thread (minus_one_ptid
);
4706 if (thread_count (this) == 0)
4708 /* Target has no concept of threads at all. GDB treats
4709 non-threaded target as single-threaded; add a main
4711 add_current_inferior_and_thread (wait_status
);
4715 /* We have thread information; select the thread the target
4716 says should be current. If we're reconnecting to a
4717 multi-threaded program, this will ideally be the thread
4718 that last reported an event before GDB disconnected. */
4719 ptid_t curr_thread
= get_current_thread (wait_status
);
4720 if (curr_thread
== null_ptid
)
4722 /* Odd... The target was able to list threads, but not
4723 tell us which thread was current (no "thread"
4724 register in T stop reply?). Just pick the first
4725 thread in the thread list then. */
4728 fprintf_unfiltered (gdb_stdlog
,
4729 "warning: couldn't determine remote "
4730 "current thread; picking first in list.\n");
4732 for (thread_info
*tp
: all_non_exited_threads (this,
4735 switch_to_thread (tp
);
4740 switch_to_thread (find_thread_ptid (this, curr_thread
));
4743 /* init_wait_for_inferior should be called before get_offsets in order
4744 to manage `inserted' flag in bp loc in a correct state.
4745 breakpoint_init_inferior, called from init_wait_for_inferior, set
4746 `inserted' flag to 0, while before breakpoint_re_set, called from
4747 start_remote, set `inserted' flag to 1. In the initialization of
4748 inferior, breakpoint_init_inferior should be called first, and then
4749 breakpoint_re_set can be called. If this order is broken, state of
4750 `inserted' flag is wrong, and cause some problems on breakpoint
4752 init_wait_for_inferior ();
4754 get_offsets (); /* Get text, data & bss offsets. */
4756 /* If we could not find a description using qXfer, and we know
4757 how to do it some other way, try again. This is not
4758 supported for non-stop; it could be, but it is tricky if
4759 there are no stopped threads when we connect. */
4760 if (remote_read_description_p (this)
4761 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4763 target_clear_description ();
4764 target_find_description ();
4767 /* Use the previously fetched status. */
4768 gdb_assert (wait_status
!= NULL
);
4769 strcpy (rs
->buf
.data (), wait_status
);
4770 rs
->cached_wait_status
= 1;
4772 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4776 /* Clear WFI global state. Do this before finding about new
4777 threads and inferiors, and setting the current inferior.
4778 Otherwise we would clear the proceed status of the current
4779 inferior when we want its stop_soon state to be preserved
4780 (see notice_new_inferior). */
4781 init_wait_for_inferior ();
4783 /* In non-stop, we will either get an "OK", meaning that there
4784 are no stopped threads at this time; or, a regular stop
4785 reply. In the latter case, there may be more than one thread
4786 stopped --- we pull them all out using the vStopped
4788 if (strcmp (rs
->buf
.data (), "OK") != 0)
4790 struct notif_client
*notif
= ¬if_client_stop
;
4792 /* remote_notif_get_pending_replies acks this one, and gets
4794 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4795 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4796 remote_notif_get_pending_events (notif
);
4799 if (thread_count (this) == 0)
4802 error (_("The target is not running (try extended-remote?)"));
4804 /* We're connected, but not running. Drop out before we
4805 call start_remote. */
4806 rs
->starting_up
= 0;
4810 /* In non-stop mode, any cached wait status will be stored in
4811 the stop reply queue. */
4812 gdb_assert (wait_status
== NULL
);
4814 /* Report all signals during attach/startup. */
4817 /* If there are already stopped threads, mark them stopped and
4818 report their stops before giving the prompt to the user. */
4819 process_initial_stop_replies (from_tty
);
4821 if (target_can_async_p ())
4825 /* If we connected to a live target, do some additional setup. */
4826 if (target_has_execution
)
4828 if (symfile_objfile
) /* No use without a symbol-file. */
4829 remote_check_symbols ();
4832 /* Possibly the target has been engaged in a trace run started
4833 previously; find out where things are at. */
4834 if (get_trace_status (current_trace_status ()) != -1)
4836 struct uploaded_tp
*uploaded_tps
= NULL
;
4838 if (current_trace_status ()->running
)
4839 printf_filtered (_("Trace is already running on the target.\n"));
4841 upload_tracepoints (&uploaded_tps
);
4843 merge_uploaded_tracepoints (&uploaded_tps
);
4846 /* Possibly the target has been engaged in a btrace record started
4847 previously; find out where things are at. */
4848 remote_btrace_maybe_reopen ();
4850 /* The thread and inferior lists are now synchronized with the
4851 target, our symbols have been relocated, and we're merged the
4852 target's tracepoints with ours. We're done with basic start
4854 rs
->starting_up
= 0;
4856 /* Maybe breakpoints are global and need to be inserted now. */
4857 if (breakpoints_should_be_inserted_now ())
4858 insert_breakpoints ();
4862 remote_target::connection_string ()
4864 remote_state
*rs
= get_remote_state ();
4866 if (rs
->remote_desc
->name
!= NULL
)
4867 return rs
->remote_desc
->name
;
4872 /* Open a connection to a remote debugger.
4873 NAME is the filename used for communication. */
4876 remote_target::open (const char *name
, int from_tty
)
4878 open_1 (name
, from_tty
, 0);
4881 /* Open a connection to a remote debugger using the extended
4882 remote gdb protocol. NAME is the filename used for communication. */
4885 extended_remote_target::open (const char *name
, int from_tty
)
4887 open_1 (name
, from_tty
, 1 /*extended_p */);
4890 /* Reset all packets back to "unknown support". Called when opening a
4891 new connection to a remote target. */
4894 reset_all_packet_configs_support (void)
4898 for (i
= 0; i
< PACKET_MAX
; i
++)
4899 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4902 /* Initialize all packet configs. */
4905 init_all_packet_configs (void)
4909 for (i
= 0; i
< PACKET_MAX
; i
++)
4911 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4912 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4916 /* Symbol look-up. */
4919 remote_target::remote_check_symbols ()
4924 /* The remote side has no concept of inferiors that aren't running
4925 yet, it only knows about running processes. If we're connected
4926 but our current inferior is not running, we should not invite the
4927 remote target to request symbol lookups related to its
4928 (unrelated) current process. */
4929 if (!target_has_execution
)
4932 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4935 /* Make sure the remote is pointing at the right process. Note
4936 there's no way to select "no process". */
4937 set_general_process ();
4939 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4940 because we need both at the same time. */
4941 gdb::char_vector
msg (get_remote_packet_size ());
4942 gdb::char_vector
reply (get_remote_packet_size ());
4944 /* Invite target to request symbol lookups. */
4946 putpkt ("qSymbol::");
4948 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4950 while (startswith (reply
.data (), "qSymbol:"))
4952 struct bound_minimal_symbol sym
;
4955 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
4958 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
4959 if (sym
.minsym
== NULL
)
4960 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
4964 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4965 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4967 /* If this is a function address, return the start of code
4968 instead of any data function descriptor. */
4969 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4971 current_top_target ());
4973 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4974 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4977 putpkt (msg
.data ());
4982 static struct serial
*
4983 remote_serial_open (const char *name
)
4985 static int udp_warning
= 0;
4987 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4988 of in ser-tcp.c, because it is the remote protocol assuming that the
4989 serial connection is reliable and not the serial connection promising
4991 if (!udp_warning
&& startswith (name
, "udp:"))
4993 warning (_("The remote protocol may be unreliable over UDP.\n"
4994 "Some events may be lost, rendering further debugging "
4999 return serial_open (name
);
5002 /* Inform the target of our permission settings. The permission flags
5003 work without this, but if the target knows the settings, it can do
5004 a couple things. First, it can add its own check, to catch cases
5005 that somehow manage to get by the permissions checks in target
5006 methods. Second, if the target is wired to disallow particular
5007 settings (for instance, a system in the field that is not set up to
5008 be able to stop at a breakpoint), it can object to any unavailable
5012 remote_target::set_permissions ()
5014 struct remote_state
*rs
= get_remote_state ();
5016 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
5017 "WriteReg:%x;WriteMem:%x;"
5018 "InsertBreak:%x;InsertTrace:%x;"
5019 "InsertFastTrace:%x;Stop:%x",
5020 may_write_registers
, may_write_memory
,
5021 may_insert_breakpoints
, may_insert_tracepoints
,
5022 may_insert_fast_tracepoints
, may_stop
);
5024 getpkt (&rs
->buf
, 0);
5026 /* If the target didn't like the packet, warn the user. Do not try
5027 to undo the user's settings, that would just be maddening. */
5028 if (strcmp (rs
->buf
.data (), "OK") != 0)
5029 warning (_("Remote refused setting permissions with: %s"),
5033 /* This type describes each known response to the qSupported
5035 struct protocol_feature
5037 /* The name of this protocol feature. */
5040 /* The default for this protocol feature. */
5041 enum packet_support default_support
;
5043 /* The function to call when this feature is reported, or after
5044 qSupported processing if the feature is not supported.
5045 The first argument points to this structure. The second
5046 argument indicates whether the packet requested support be
5047 enabled, disabled, or probed (or the default, if this function
5048 is being called at the end of processing and this feature was
5049 not reported). The third argument may be NULL; if not NULL, it
5050 is a NUL-terminated string taken from the packet following
5051 this feature's name and an equals sign. */
5052 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5053 enum packet_support
, const char *);
5055 /* The corresponding packet for this feature. Only used if
5056 FUNC is remote_supported_packet. */
5061 remote_supported_packet (remote_target
*remote
,
5062 const struct protocol_feature
*feature
,
5063 enum packet_support support
,
5064 const char *argument
)
5068 warning (_("Remote qSupported response supplied an unexpected value for"
5069 " \"%s\"."), feature
->name
);
5073 remote_protocol_packets
[feature
->packet
].support
= support
;
5077 remote_target::remote_packet_size (const protocol_feature
*feature
,
5078 enum packet_support support
, const char *value
)
5080 struct remote_state
*rs
= get_remote_state ();
5085 if (support
!= PACKET_ENABLE
)
5088 if (value
== NULL
|| *value
== '\0')
5090 warning (_("Remote target reported \"%s\" without a size."),
5096 packet_size
= strtol (value
, &value_end
, 16);
5097 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5099 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5100 feature
->name
, value
);
5104 /* Record the new maximum packet size. */
5105 rs
->explicit_packet_size
= packet_size
;
5109 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5110 enum packet_support support
, const char *value
)
5112 remote
->remote_packet_size (feature
, support
, value
);
5115 static const struct protocol_feature remote_protocol_features
[] = {
5116 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5117 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5118 PACKET_qXfer_auxv
},
5119 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5120 PACKET_qXfer_exec_file
},
5121 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5122 PACKET_qXfer_features
},
5123 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5124 PACKET_qXfer_libraries
},
5125 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5126 PACKET_qXfer_libraries_svr4
},
5127 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5128 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5129 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5130 PACKET_qXfer_memory_map
},
5131 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5132 PACKET_qXfer_osdata
},
5133 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5134 PACKET_qXfer_threads
},
5135 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5136 PACKET_qXfer_traceframe_info
},
5137 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5138 PACKET_QPassSignals
},
5139 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5140 PACKET_QCatchSyscalls
},
5141 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5142 PACKET_QProgramSignals
},
5143 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5144 PACKET_QSetWorkingDir
},
5145 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5146 PACKET_QStartupWithShell
},
5147 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5148 PACKET_QEnvironmentHexEncoded
},
5149 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5150 PACKET_QEnvironmentReset
},
5151 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5152 PACKET_QEnvironmentUnset
},
5153 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5154 PACKET_QStartNoAckMode
},
5155 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5156 PACKET_multiprocess_feature
},
5157 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5158 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5159 PACKET_qXfer_siginfo_read
},
5160 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5161 PACKET_qXfer_siginfo_write
},
5162 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5163 PACKET_ConditionalTracepoints
},
5164 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5165 PACKET_ConditionalBreakpoints
},
5166 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5167 PACKET_BreakpointCommands
},
5168 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5169 PACKET_FastTracepoints
},
5170 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5171 PACKET_StaticTracepoints
},
5172 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5173 PACKET_InstallInTrace
},
5174 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5175 PACKET_DisconnectedTracing_feature
},
5176 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5178 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5180 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5181 PACKET_TracepointSource
},
5182 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5184 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5185 PACKET_EnableDisableTracepoints_feature
},
5186 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5187 PACKET_qXfer_fdpic
},
5188 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5190 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5191 PACKET_QDisableRandomization
},
5192 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5193 { "QTBuffer:size", PACKET_DISABLE
,
5194 remote_supported_packet
, PACKET_QTBuffer_size
},
5195 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5196 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5197 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5198 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5199 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5200 PACKET_qXfer_btrace
},
5201 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5202 PACKET_qXfer_btrace_conf
},
5203 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5204 PACKET_Qbtrace_conf_bts_size
},
5205 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5206 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5207 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5208 PACKET_fork_event_feature
},
5209 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5210 PACKET_vfork_event_feature
},
5211 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5212 PACKET_exec_event_feature
},
5213 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5214 PACKET_Qbtrace_conf_pt_size
},
5215 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5216 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5217 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5220 static char *remote_support_xml
;
5222 /* Register string appended to "xmlRegisters=" in qSupported query. */
5225 register_remote_support_xml (const char *xml
)
5227 #if defined(HAVE_LIBEXPAT)
5228 if (remote_support_xml
== NULL
)
5229 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5232 char *copy
= xstrdup (remote_support_xml
+ 13);
5234 char *p
= strtok_r (copy
, ",", &saveptr
);
5238 if (strcmp (p
, xml
) == 0)
5245 while ((p
= strtok_r (NULL
, ",", &saveptr
)) != NULL
);
5248 remote_support_xml
= reconcat (remote_support_xml
,
5249 remote_support_xml
, ",", xml
,
5256 remote_query_supported_append (std::string
*msg
, const char *append
)
5260 msg
->append (append
);
5264 remote_target::remote_query_supported ()
5266 struct remote_state
*rs
= get_remote_state ();
5269 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5271 /* The packet support flags are handled differently for this packet
5272 than for most others. We treat an error, a disabled packet, and
5273 an empty response identically: any features which must be reported
5274 to be used will be automatically disabled. An empty buffer
5275 accomplishes this, since that is also the representation for a list
5276 containing no features. */
5279 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5283 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5284 remote_query_supported_append (&q
, "multiprocess+");
5286 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5287 remote_query_supported_append (&q
, "swbreak+");
5288 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5289 remote_query_supported_append (&q
, "hwbreak+");
5291 remote_query_supported_append (&q
, "qRelocInsn+");
5293 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5294 != AUTO_BOOLEAN_FALSE
)
5295 remote_query_supported_append (&q
, "fork-events+");
5296 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5297 != AUTO_BOOLEAN_FALSE
)
5298 remote_query_supported_append (&q
, "vfork-events+");
5299 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5300 != AUTO_BOOLEAN_FALSE
)
5301 remote_query_supported_append (&q
, "exec-events+");
5303 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5304 remote_query_supported_append (&q
, "vContSupported+");
5306 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5307 remote_query_supported_append (&q
, "QThreadEvents+");
5309 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5310 remote_query_supported_append (&q
, "no-resumed+");
5312 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5313 the qSupported:xmlRegisters=i386 handling. */
5314 if (remote_support_xml
!= NULL
5315 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5316 remote_query_supported_append (&q
, remote_support_xml
);
5318 q
= "qSupported:" + q
;
5319 putpkt (q
.c_str ());
5321 getpkt (&rs
->buf
, 0);
5323 /* If an error occured, warn, but do not return - just reset the
5324 buffer to empty and go on to disable features. */
5325 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5328 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5333 memset (seen
, 0, sizeof (seen
));
5335 next
= rs
->buf
.data ();
5338 enum packet_support is_supported
;
5339 char *p
, *end
, *name_end
, *value
;
5341 /* First separate out this item from the rest of the packet. If
5342 there's another item after this, we overwrite the separator
5343 (terminated strings are much easier to work with). */
5345 end
= strchr (p
, ';');
5348 end
= p
+ strlen (p
);
5358 warning (_("empty item in \"qSupported\" response"));
5363 name_end
= strchr (p
, '=');
5366 /* This is a name=value entry. */
5367 is_supported
= PACKET_ENABLE
;
5368 value
= name_end
+ 1;
5377 is_supported
= PACKET_ENABLE
;
5381 is_supported
= PACKET_DISABLE
;
5385 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5389 warning (_("unrecognized item \"%s\" "
5390 "in \"qSupported\" response"), p
);
5396 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5397 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5399 const struct protocol_feature
*feature
;
5402 feature
= &remote_protocol_features
[i
];
5403 feature
->func (this, feature
, is_supported
, value
);
5408 /* If we increased the packet size, make sure to increase the global
5409 buffer size also. We delay this until after parsing the entire
5410 qSupported packet, because this is the same buffer we were
5412 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5413 rs
->buf
.resize (rs
->explicit_packet_size
);
5415 /* Handle the defaults for unmentioned features. */
5416 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5419 const struct protocol_feature
*feature
;
5421 feature
= &remote_protocol_features
[i
];
5422 feature
->func (this, feature
, feature
->default_support
, NULL
);
5426 /* Serial QUIT handler for the remote serial descriptor.
5428 Defers handling a Ctrl-C until we're done with the current
5429 command/response packet sequence, unless:
5431 - We're setting up the connection. Don't send a remote interrupt
5432 request, as we're not fully synced yet. Quit immediately
5435 - The target has been resumed in the foreground
5436 (target_terminal::is_ours is false) with a synchronous resume
5437 packet, and we're blocked waiting for the stop reply, thus a
5438 Ctrl-C should be immediately sent to the target.
5440 - We get a second Ctrl-C while still within the same serial read or
5441 write. In that case the serial is seemingly wedged --- offer to
5444 - We see a second Ctrl-C without target response, after having
5445 previously interrupted the target. In that case the target/stub
5446 is probably wedged --- offer to quit/disconnect.
5450 remote_target::remote_serial_quit_handler ()
5452 struct remote_state
*rs
= get_remote_state ();
5454 if (check_quit_flag ())
5456 /* If we're starting up, we're not fully synced yet. Quit
5458 if (rs
->starting_up
)
5460 else if (rs
->got_ctrlc_during_io
)
5462 if (query (_("The target is not responding to GDB commands.\n"
5463 "Stop debugging it? ")))
5464 remote_unpush_and_throw (this);
5466 /* If ^C has already been sent once, offer to disconnect. */
5467 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5469 /* All-stop protocol, and blocked waiting for stop reply. Send
5470 an interrupt request. */
5471 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5472 target_interrupt ();
5474 rs
->got_ctrlc_during_io
= 1;
5478 /* The remote_target that is current while the quit handler is
5479 overridden with remote_serial_quit_handler. */
5480 static remote_target
*curr_quit_handler_target
;
5483 remote_serial_quit_handler ()
5485 curr_quit_handler_target
->remote_serial_quit_handler ();
5488 /* Remove the remote target from the target stack of each inferior
5489 that is using it. Upper targets depend on it so remove them
5493 remote_unpush_target (remote_target
*target
)
5495 /* We have to unpush the target from all inferiors, even those that
5497 scoped_restore_current_inferior restore_current_inferior
;
5499 for (inferior
*inf
: all_inferiors (target
))
5501 switch_to_inferior_no_thread (inf
);
5502 pop_all_targets_at_and_above (process_stratum
);
5503 generic_mourn_inferior ();
5508 remote_unpush_and_throw (remote_target
*target
)
5510 remote_unpush_target (target
);
5511 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5515 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5517 remote_target
*curr_remote
= get_current_remote_target ();
5520 error (_("To open a remote debug connection, you need to specify what\n"
5521 "serial device is attached to the remote system\n"
5522 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5524 /* If we're connected to a running target, target_preopen will kill it.
5525 Ask this question first, before target_preopen has a chance to kill
5527 if (curr_remote
!= NULL
&& !target_has_execution
)
5530 && !query (_("Already connected to a remote target. Disconnect? ")))
5531 error (_("Still connected."));
5534 /* Here the possibly existing remote target gets unpushed. */
5535 target_preopen (from_tty
);
5537 remote_fileio_reset ();
5538 reopen_exec_file ();
5541 remote_target
*remote
5542 = (extended_p
? new extended_remote_target () : new remote_target ());
5543 target_ops_up
target_holder (remote
);
5545 remote_state
*rs
= remote
->get_remote_state ();
5547 /* See FIXME above. */
5548 if (!target_async_permitted
)
5549 rs
->wait_forever_enabled_p
= 1;
5551 rs
->remote_desc
= remote_serial_open (name
);
5552 if (!rs
->remote_desc
)
5553 perror_with_name (name
);
5555 if (baud_rate
!= -1)
5557 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5559 /* The requested speed could not be set. Error out to
5560 top level after closing remote_desc. Take care to
5561 set remote_desc to NULL to avoid closing remote_desc
5563 serial_close (rs
->remote_desc
);
5564 rs
->remote_desc
= NULL
;
5565 perror_with_name (name
);
5569 serial_setparity (rs
->remote_desc
, serial_parity
);
5570 serial_raw (rs
->remote_desc
);
5572 /* If there is something sitting in the buffer we might take it as a
5573 response to a command, which would be bad. */
5574 serial_flush_input (rs
->remote_desc
);
5578 puts_filtered ("Remote debugging using ");
5579 puts_filtered (name
);
5580 puts_filtered ("\n");
5583 /* Switch to using the remote target now. */
5584 push_target (std::move (target_holder
));
5586 /* Register extra event sources in the event loop. */
5587 rs
->remote_async_inferior_event_token
5588 = create_async_event_handler (remote_async_inferior_event_handler
,
5590 rs
->notif_state
= remote_notif_state_allocate (remote
);
5592 /* Reset the target state; these things will be queried either by
5593 remote_query_supported or as they are needed. */
5594 reset_all_packet_configs_support ();
5595 rs
->cached_wait_status
= 0;
5596 rs
->explicit_packet_size
= 0;
5598 rs
->extended
= extended_p
;
5599 rs
->waiting_for_stop_reply
= 0;
5600 rs
->ctrlc_pending_p
= 0;
5601 rs
->got_ctrlc_during_io
= 0;
5603 rs
->general_thread
= not_sent_ptid
;
5604 rs
->continue_thread
= not_sent_ptid
;
5605 rs
->remote_traceframe_number
= -1;
5607 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5609 /* Probe for ability to use "ThreadInfo" query, as required. */
5610 rs
->use_threadinfo_query
= 1;
5611 rs
->use_threadextra_query
= 1;
5613 rs
->readahead_cache
.invalidate ();
5615 if (target_async_permitted
)
5617 /* FIXME: cagney/1999-09-23: During the initial connection it is
5618 assumed that the target is already ready and able to respond to
5619 requests. Unfortunately remote_start_remote() eventually calls
5620 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5621 around this. Eventually a mechanism that allows
5622 wait_for_inferior() to expect/get timeouts will be
5624 rs
->wait_forever_enabled_p
= 0;
5627 /* First delete any symbols previously loaded from shared libraries. */
5628 no_shared_libraries (NULL
, 0);
5630 /* Start the remote connection. If error() or QUIT, discard this
5631 target (we'd otherwise be in an inconsistent state) and then
5632 propogate the error on up the exception chain. This ensures that
5633 the caller doesn't stumble along blindly assuming that the
5634 function succeeded. The CLI doesn't have this problem but other
5635 UI's, such as MI do.
5637 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5638 this function should return an error indication letting the
5639 caller restore the previous state. Unfortunately the command
5640 ``target remote'' is directly wired to this function making that
5641 impossible. On a positive note, the CLI side of this problem has
5642 been fixed - the function set_cmd_context() makes it possible for
5643 all the ``target ....'' commands to share a common callback
5644 function. See cli-dump.c. */
5649 remote
->start_remote (from_tty
, extended_p
);
5651 catch (const gdb_exception
&ex
)
5653 /* Pop the partially set up target - unless something else did
5654 already before throwing the exception. */
5655 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5656 remote_unpush_target (remote
);
5661 remote_btrace_reset (rs
);
5663 if (target_async_permitted
)
5664 rs
->wait_forever_enabled_p
= 1;
5667 /* Detach the specified process. */
5670 remote_target::remote_detach_pid (int pid
)
5672 struct remote_state
*rs
= get_remote_state ();
5674 /* This should not be necessary, but the handling for D;PID in
5675 GDBserver versions prior to 8.2 incorrectly assumes that the
5676 selected process points to the same process we're detaching,
5677 leading to misbehavior (and possibly GDBserver crashing) when it
5678 does not. Since it's easy and cheap, work around it by forcing
5679 GDBserver to select GDB's current process. */
5680 set_general_process ();
5682 if (remote_multi_process_p (rs
))
5683 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5685 strcpy (rs
->buf
.data (), "D");
5688 getpkt (&rs
->buf
, 0);
5690 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5692 else if (rs
->buf
[0] == '\0')
5693 error (_("Remote doesn't know how to detach"));
5695 error (_("Can't detach process."));
5698 /* This detaches a program to which we previously attached, using
5699 inferior_ptid to identify the process. After this is done, GDB
5700 can be used to debug some other program. We better not have left
5701 any breakpoints in the target program or it'll die when it hits
5705 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5707 int pid
= inferior_ptid
.pid ();
5708 struct remote_state
*rs
= get_remote_state ();
5711 if (!target_has_execution
)
5712 error (_("No process to detach from."));
5714 target_announce_detach (from_tty
);
5716 /* Tell the remote target to detach. */
5717 remote_detach_pid (pid
);
5719 /* Exit only if this is the only active inferior. */
5720 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors (this) == 1)
5721 puts_filtered (_("Ending remote debugging.\n"));
5723 thread_info
*tp
= find_thread_ptid (this, inferior_ptid
);
5725 /* Check to see if we are detaching a fork parent. Note that if we
5726 are detaching a fork child, tp == NULL. */
5727 is_fork_parent
= (tp
!= NULL
5728 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5730 /* If doing detach-on-fork, we don't mourn, because that will delete
5731 breakpoints that should be available for the followed inferior. */
5732 if (!is_fork_parent
)
5734 /* Save the pid as a string before mourning, since that will
5735 unpush the remote target, and we need the string after. */
5736 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5738 target_mourn_inferior (inferior_ptid
);
5739 if (print_inferior_events
)
5740 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5741 inf
->num
, infpid
.c_str ());
5745 inferior_ptid
= null_ptid
;
5746 detach_inferior (current_inferior ());
5751 remote_target::detach (inferior
*inf
, int from_tty
)
5753 remote_detach_1 (inf
, from_tty
);
5757 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5759 remote_detach_1 (inf
, from_tty
);
5762 /* Target follow-fork function for remote targets. On entry, and
5763 at return, the current inferior is the fork parent.
5765 Note that although this is currently only used for extended-remote,
5766 it is named remote_follow_fork in anticipation of using it for the
5767 remote target as well. */
5770 remote_target::follow_fork (int follow_child
, int detach_fork
)
5772 struct remote_state
*rs
= get_remote_state ();
5773 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5775 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5776 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5778 /* When following the parent and detaching the child, we detach
5779 the child here. For the case of following the child and
5780 detaching the parent, the detach is done in the target-
5781 independent follow fork code in infrun.c. We can't use
5782 target_detach when detaching an unfollowed child because
5783 the client side doesn't know anything about the child. */
5784 if (detach_fork
&& !follow_child
)
5786 /* Detach the fork child. */
5790 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5791 child_pid
= child_ptid
.pid ();
5793 remote_detach_pid (child_pid
);
5799 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5800 in the program space of the new inferior. On entry and at return the
5801 current inferior is the exec'ing inferior. INF is the new exec'd
5802 inferior, which may be the same as the exec'ing inferior unless
5803 follow-exec-mode is "new". */
5806 remote_target::follow_exec (struct inferior
*inf
, const char *execd_pathname
)
5808 /* We know that this is a target file name, so if it has the "target:"
5809 prefix we strip it off before saving it in the program space. */
5810 if (is_target_filename (execd_pathname
))
5811 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5813 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5816 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5819 remote_target::disconnect (const char *args
, int from_tty
)
5822 error (_("Argument given to \"disconnect\" when remotely debugging."));
5824 /* Make sure we unpush even the extended remote targets. Calling
5825 target_mourn_inferior won't unpush, and
5826 remote_target::mourn_inferior won't unpush if there is more than
5827 one inferior left. */
5828 remote_unpush_target (this);
5831 puts_filtered ("Ending remote debugging.\n");
5834 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5835 be chatty about it. */
5838 extended_remote_target::attach (const char *args
, int from_tty
)
5840 struct remote_state
*rs
= get_remote_state ();
5842 char *wait_status
= NULL
;
5844 pid
= parse_pid_to_attach (args
);
5846 /* Remote PID can be freely equal to getpid, do not check it here the same
5847 way as in other targets. */
5849 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5850 error (_("This target does not support attaching to a process"));
5854 const char *exec_file
= get_exec_file (0);
5857 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5858 target_pid_to_str (ptid_t (pid
)).c_str ());
5860 printf_unfiltered (_("Attaching to %s\n"),
5861 target_pid_to_str (ptid_t (pid
)).c_str ());
5864 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5866 getpkt (&rs
->buf
, 0);
5868 switch (packet_ok (rs
->buf
,
5869 &remote_protocol_packets
[PACKET_vAttach
]))
5872 if (!target_is_non_stop_p ())
5874 /* Save the reply for later. */
5875 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5876 strcpy (wait_status
, rs
->buf
.data ());
5878 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5879 error (_("Attaching to %s failed with: %s"),
5880 target_pid_to_str (ptid_t (pid
)).c_str (),
5883 case PACKET_UNKNOWN
:
5884 error (_("This target does not support attaching to a process"));
5886 error (_("Attaching to %s failed"),
5887 target_pid_to_str (ptid_t (pid
)).c_str ());
5890 set_current_inferior (remote_add_inferior (false, pid
, 1, 0));
5892 inferior_ptid
= ptid_t (pid
);
5894 if (target_is_non_stop_p ())
5896 struct thread_info
*thread
;
5898 /* Get list of threads. */
5899 update_thread_list ();
5901 thread
= first_thread_of_inferior (current_inferior ());
5903 inferior_ptid
= thread
->ptid
;
5905 inferior_ptid
= ptid_t (pid
);
5907 /* Invalidate our notion of the remote current thread. */
5908 record_currthread (rs
, minus_one_ptid
);
5912 /* Now, if we have thread information, update inferior_ptid. */
5913 inferior_ptid
= remote_current_thread (inferior_ptid
);
5915 /* Add the main thread to the thread list. */
5916 thread_info
*thr
= add_thread_silent (this, inferior_ptid
);
5917 /* Don't consider the thread stopped until we've processed the
5918 saved stop reply. */
5919 set_executing (this, thr
->ptid
, true);
5922 /* Next, if the target can specify a description, read it. We do
5923 this before anything involving memory or registers. */
5924 target_find_description ();
5926 if (!target_is_non_stop_p ())
5928 /* Use the previously fetched status. */
5929 gdb_assert (wait_status
!= NULL
);
5931 if (target_can_async_p ())
5933 struct notif_event
*reply
5934 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
5936 push_stop_reply ((struct stop_reply
*) reply
);
5942 gdb_assert (wait_status
!= NULL
);
5943 strcpy (rs
->buf
.data (), wait_status
);
5944 rs
->cached_wait_status
= 1;
5948 gdb_assert (wait_status
== NULL
);
5951 /* Implementation of the to_post_attach method. */
5954 extended_remote_target::post_attach (int pid
)
5956 /* Get text, data & bss offsets. */
5959 /* In certain cases GDB might not have had the chance to start
5960 symbol lookup up until now. This could happen if the debugged
5961 binary is not using shared libraries, the vsyscall page is not
5962 present (on Linux) and the binary itself hadn't changed since the
5963 debugging process was started. */
5964 if (symfile_objfile
!= NULL
)
5965 remote_check_symbols();
5969 /* Check for the availability of vCont. This function should also check
5973 remote_target::remote_vcont_probe ()
5975 remote_state
*rs
= get_remote_state ();
5978 strcpy (rs
->buf
.data (), "vCont?");
5980 getpkt (&rs
->buf
, 0);
5981 buf
= rs
->buf
.data ();
5983 /* Make sure that the features we assume are supported. */
5984 if (startswith (buf
, "vCont"))
5987 int support_c
, support_C
;
5989 rs
->supports_vCont
.s
= 0;
5990 rs
->supports_vCont
.S
= 0;
5993 rs
->supports_vCont
.t
= 0;
5994 rs
->supports_vCont
.r
= 0;
5995 while (p
&& *p
== ';')
5998 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5999 rs
->supports_vCont
.s
= 1;
6000 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6001 rs
->supports_vCont
.S
= 1;
6002 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6004 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6006 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6007 rs
->supports_vCont
.t
= 1;
6008 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
6009 rs
->supports_vCont
.r
= 1;
6011 p
= strchr (p
, ';');
6014 /* If c, and C are not all supported, we can't use vCont. Clearing
6015 BUF will make packet_ok disable the packet. */
6016 if (!support_c
|| !support_C
)
6020 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
6021 rs
->supports_vCont_probed
= true;
6024 /* Helper function for building "vCont" resumptions. Write a
6025 resumption to P. ENDP points to one-passed-the-end of the buffer
6026 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
6027 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
6028 resumed thread should be single-stepped and/or signalled. If PTID
6029 equals minus_one_ptid, then all threads are resumed; if PTID
6030 represents a process, then all threads of the process are resumed;
6031 the thread to be stepped and/or signalled is given in the global
6035 remote_target::append_resumption (char *p
, char *endp
,
6036 ptid_t ptid
, int step
, gdb_signal siggnal
)
6038 struct remote_state
*rs
= get_remote_state ();
6040 if (step
&& siggnal
!= GDB_SIGNAL_0
)
6041 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
6043 /* GDB is willing to range step. */
6044 && use_range_stepping
6045 /* Target supports range stepping. */
6046 && rs
->supports_vCont
.r
6047 /* We don't currently support range stepping multiple
6048 threads with a wildcard (though the protocol allows it,
6049 so stubs shouldn't make an active effort to forbid
6051 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6053 struct thread_info
*tp
;
6055 if (ptid
== minus_one_ptid
)
6057 /* If we don't know about the target thread's tid, then
6058 we're resuming magic_null_ptid (see caller). */
6059 tp
= find_thread_ptid (this, magic_null_ptid
);
6062 tp
= find_thread_ptid (this, ptid
);
6063 gdb_assert (tp
!= NULL
);
6065 if (tp
->control
.may_range_step
)
6067 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6069 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6070 phex_nz (tp
->control
.step_range_start
,
6072 phex_nz (tp
->control
.step_range_end
,
6076 p
+= xsnprintf (p
, endp
- p
, ";s");
6079 p
+= xsnprintf (p
, endp
- p
, ";s");
6080 else if (siggnal
!= GDB_SIGNAL_0
)
6081 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6083 p
+= xsnprintf (p
, endp
- p
, ";c");
6085 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6089 /* All (-1) threads of process. */
6090 nptid
= ptid_t (ptid
.pid (), -1, 0);
6092 p
+= xsnprintf (p
, endp
- p
, ":");
6093 p
= write_ptid (p
, endp
, nptid
);
6095 else if (ptid
!= minus_one_ptid
)
6097 p
+= xsnprintf (p
, endp
- p
, ":");
6098 p
= write_ptid (p
, endp
, ptid
);
6104 /* Clear the thread's private info on resume. */
6107 resume_clear_thread_private_info (struct thread_info
*thread
)
6109 if (thread
->priv
!= NULL
)
6111 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6113 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6114 priv
->watch_data_address
= 0;
6118 /* Append a vCont continue-with-signal action for threads that have a
6119 non-zero stop signal. */
6122 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6125 for (thread_info
*thread
: all_non_exited_threads (this, ptid
))
6126 if (inferior_ptid
!= thread
->ptid
6127 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6129 p
= append_resumption (p
, endp
, thread
->ptid
,
6130 0, thread
->suspend
.stop_signal
);
6131 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6132 resume_clear_thread_private_info (thread
);
6138 /* Set the target running, using the packets that use Hc
6142 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6145 struct remote_state
*rs
= get_remote_state ();
6148 rs
->last_sent_signal
= siggnal
;
6149 rs
->last_sent_step
= step
;
6151 /* The c/s/C/S resume packets use Hc, so set the continue
6153 if (ptid
== minus_one_ptid
)
6154 set_continue_thread (any_thread_ptid
);
6156 set_continue_thread (ptid
);
6158 for (thread_info
*thread
: all_non_exited_threads (this))
6159 resume_clear_thread_private_info (thread
);
6161 buf
= rs
->buf
.data ();
6162 if (::execution_direction
== EXEC_REVERSE
)
6164 /* We don't pass signals to the target in reverse exec mode. */
6165 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6166 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6169 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6170 error (_("Remote reverse-step not supported."));
6171 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6172 error (_("Remote reverse-continue not supported."));
6174 strcpy (buf
, step
? "bs" : "bc");
6176 else if (siggnal
!= GDB_SIGNAL_0
)
6178 buf
[0] = step
? 'S' : 'C';
6179 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6180 buf
[2] = tohex (((int) siggnal
) & 0xf);
6184 strcpy (buf
, step
? "s" : "c");
6189 /* Resume the remote inferior by using a "vCont" packet. The thread
6190 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6191 resumed thread should be single-stepped and/or signalled. If PTID
6192 equals minus_one_ptid, then all threads are resumed; the thread to
6193 be stepped and/or signalled is given in the global INFERIOR_PTID.
6194 This function returns non-zero iff it resumes the inferior.
6196 This function issues a strict subset of all possible vCont commands
6200 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6201 enum gdb_signal siggnal
)
6203 struct remote_state
*rs
= get_remote_state ();
6207 /* No reverse execution actions defined for vCont. */
6208 if (::execution_direction
== EXEC_REVERSE
)
6211 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6212 remote_vcont_probe ();
6214 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6217 p
= rs
->buf
.data ();
6218 endp
= p
+ get_remote_packet_size ();
6220 /* If we could generate a wider range of packets, we'd have to worry
6221 about overflowing BUF. Should there be a generic
6222 "multi-part-packet" packet? */
6224 p
+= xsnprintf (p
, endp
- p
, "vCont");
6226 if (ptid
== magic_null_ptid
)
6228 /* MAGIC_NULL_PTID means that we don't have any active threads,
6229 so we don't have any TID numbers the inferior will
6230 understand. Make sure to only send forms that do not specify
6232 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6234 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6236 /* Resume all threads (of all processes, or of a single
6237 process), with preference for INFERIOR_PTID. This assumes
6238 inferior_ptid belongs to the set of all threads we are about
6240 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6242 /* Step inferior_ptid, with or without signal. */
6243 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6246 /* Also pass down any pending signaled resumption for other
6247 threads not the current. */
6248 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6250 /* And continue others without a signal. */
6251 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6255 /* Scheduler locking; resume only PTID. */
6256 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6259 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6262 if (target_is_non_stop_p ())
6264 /* In non-stop, the stub replies to vCont with "OK". The stop
6265 reply will be reported asynchronously by means of a `%Stop'
6267 getpkt (&rs
->buf
, 0);
6268 if (strcmp (rs
->buf
.data (), "OK") != 0)
6269 error (_("Unexpected vCont reply in non-stop mode: %s"),
6276 /* Tell the remote machine to resume. */
6279 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6281 struct remote_state
*rs
= get_remote_state ();
6283 /* When connected in non-stop mode, the core resumes threads
6284 individually. Resuming remote threads directly in target_resume
6285 would thus result in sending one packet per thread. Instead, to
6286 minimize roundtrip latency, here we just store the resume
6287 request; the actual remote resumption will be done in
6288 target_commit_resume / remote_commit_resume, where we'll be able
6289 to do vCont action coalescing. */
6290 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6292 remote_thread_info
*remote_thr
;
6294 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6295 remote_thr
= get_remote_thread_info (this, inferior_ptid
);
6297 remote_thr
= get_remote_thread_info (this, ptid
);
6299 remote_thr
->last_resume_step
= step
;
6300 remote_thr
->last_resume_sig
= siggnal
;
6304 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6305 (explained in remote-notif.c:handle_notification) so
6306 remote_notif_process is not called. We need find a place where
6307 it is safe to start a 'vNotif' sequence. It is good to do it
6308 before resuming inferior, because inferior was stopped and no RSP
6309 traffic at that moment. */
6310 if (!target_is_non_stop_p ())
6311 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6313 rs
->last_resume_exec_dir
= ::execution_direction
;
6315 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6316 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6317 remote_resume_with_hc (ptid
, step
, siggnal
);
6319 /* We are about to start executing the inferior, let's register it
6320 with the event loop. NOTE: this is the one place where all the
6321 execution commands end up. We could alternatively do this in each
6322 of the execution commands in infcmd.c. */
6323 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6324 into infcmd.c in order to allow inferior function calls to work
6325 NOT asynchronously. */
6326 if (target_can_async_p ())
6329 /* We've just told the target to resume. The remote server will
6330 wait for the inferior to stop, and then send a stop reply. In
6331 the mean time, we can't start another command/query ourselves
6332 because the stub wouldn't be ready to process it. This applies
6333 only to the base all-stop protocol, however. In non-stop (which
6334 only supports vCont), the stub replies with an "OK", and is
6335 immediate able to process further serial input. */
6336 if (!target_is_non_stop_p ())
6337 rs
->waiting_for_stop_reply
= 1;
6340 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6342 /* Private per-inferior info for target remote processes. */
6344 struct remote_inferior
: public private_inferior
6346 /* Whether we can send a wildcard vCont for this process. */
6347 bool may_wildcard_vcont
= true;
6350 /* Get the remote private inferior data associated to INF. */
6352 static remote_inferior
*
6353 get_remote_inferior (inferior
*inf
)
6355 if (inf
->priv
== NULL
)
6356 inf
->priv
.reset (new remote_inferior
);
6358 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6361 /* Class used to track the construction of a vCont packet in the
6362 outgoing packet buffer. This is used to send multiple vCont
6363 packets if we have more actions than would fit a single packet. */
6368 explicit vcont_builder (remote_target
*remote
)
6375 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6380 /* The remote target. */
6381 remote_target
*m_remote
;
6383 /* Pointer to the first action. P points here if no action has been
6385 char *m_first_action
;
6387 /* Where the next action will be appended. */
6390 /* The end of the buffer. Must never write past this. */
6394 /* Prepare the outgoing buffer for a new vCont packet. */
6397 vcont_builder::restart ()
6399 struct remote_state
*rs
= m_remote
->get_remote_state ();
6401 m_p
= rs
->buf
.data ();
6402 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6403 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6404 m_first_action
= m_p
;
6407 /* If the vCont packet being built has any action, send it to the
6411 vcont_builder::flush ()
6413 struct remote_state
*rs
;
6415 if (m_p
== m_first_action
)
6418 rs
= m_remote
->get_remote_state ();
6419 m_remote
->putpkt (rs
->buf
);
6420 m_remote
->getpkt (&rs
->buf
, 0);
6421 if (strcmp (rs
->buf
.data (), "OK") != 0)
6422 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6425 /* The largest action is range-stepping, with its two addresses. This
6426 is more than sufficient. If a new, bigger action is created, it'll
6427 quickly trigger a failed assertion in append_resumption (and we'll
6429 #define MAX_ACTION_SIZE 200
6431 /* Append a new vCont action in the outgoing packet being built. If
6432 the action doesn't fit the packet along with previous actions, push
6433 what we've got so far to the remote end and start over a new vCont
6434 packet (with the new action). */
6437 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6439 char buf
[MAX_ACTION_SIZE
+ 1];
6441 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6442 ptid
, step
, siggnal
);
6444 /* Check whether this new action would fit in the vCont packet along
6445 with previous actions. If not, send what we've got so far and
6446 start a new vCont packet. */
6447 size_t rsize
= endp
- buf
;
6448 if (rsize
> m_endp
- m_p
)
6453 /* Should now fit. */
6454 gdb_assert (rsize
<= m_endp
- m_p
);
6457 memcpy (m_p
, buf
, rsize
);
6462 /* to_commit_resume implementation. */
6465 remote_target::commit_resume ()
6467 int any_process_wildcard
;
6468 int may_global_wildcard_vcont
;
6470 /* If connected in all-stop mode, we'd send the remote resume
6471 request directly from remote_resume. Likewise if
6472 reverse-debugging, as there are no defined vCont actions for
6473 reverse execution. */
6474 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6477 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6478 instead of resuming all threads of each process individually.
6479 However, if any thread of a process must remain halted, we can't
6480 send wildcard resumes and must send one action per thread.
6482 Care must be taken to not resume threads/processes the server
6483 side already told us are stopped, but the core doesn't know about
6484 yet, because the events are still in the vStopped notification
6487 #1 => vCont s:p1.1;c
6489 #3 <= %Stopped T05 p1.1
6494 #8 (infrun handles the stop for p1.1 and continues stepping)
6495 #9 => vCont s:p1.1;c
6497 The last vCont above would resume thread p1.2 by mistake, because
6498 the server has no idea that the event for p1.2 had not been
6501 The server side must similarly ignore resume actions for the
6502 thread that has a pending %Stopped notification (and any other
6503 threads with events pending), until GDB acks the notification
6504 with vStopped. Otherwise, e.g., the following case is
6507 #1 => g (or any other packet)
6509 #3 <= %Stopped T05 p1.2
6510 #4 => vCont s:p1.1;c
6513 Above, the server must not resume thread p1.2. GDB can't know
6514 that p1.2 stopped until it acks the %Stopped notification, and
6515 since from GDB's perspective all threads should be running, it
6518 Finally, special care must also be given to handling fork/vfork
6519 events. A (v)fork event actually tells us that two processes
6520 stopped -- the parent and the child. Until we follow the fork,
6521 we must not resume the child. Therefore, if we have a pending
6522 fork follow, we must not send a global wildcard resume action
6523 (vCont;c). We can still send process-wide wildcards though. */
6525 /* Start by assuming a global wildcard (vCont;c) is possible. */
6526 may_global_wildcard_vcont
= 1;
6528 /* And assume every process is individually wildcard-able too. */
6529 for (inferior
*inf
: all_non_exited_inferiors (this))
6531 remote_inferior
*priv
= get_remote_inferior (inf
);
6533 priv
->may_wildcard_vcont
= true;
6536 /* Check for any pending events (not reported or processed yet) and
6537 disable process and global wildcard resumes appropriately. */
6538 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6540 for (thread_info
*tp
: all_non_exited_threads (this))
6542 /* If a thread of a process is not meant to be resumed, then we
6543 can't wildcard that process. */
6546 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6548 /* And if we can't wildcard a process, we can't wildcard
6549 everything either. */
6550 may_global_wildcard_vcont
= 0;
6554 /* If a thread is the parent of an unfollowed fork, then we
6555 can't do a global wildcard, as that would resume the fork
6557 if (is_pending_fork_parent_thread (tp
))
6558 may_global_wildcard_vcont
= 0;
6561 /* Now let's build the vCont packet(s). Actions must be appended
6562 from narrower to wider scopes (thread -> process -> global). If
6563 we end up with too many actions for a single packet vcont_builder
6564 flushes the current vCont packet to the remote side and starts a
6566 struct vcont_builder
vcont_builder (this);
6568 /* Threads first. */
6569 for (thread_info
*tp
: all_non_exited_threads (this))
6571 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6573 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6576 gdb_assert (!thread_is_in_step_over_chain (tp
));
6578 if (!remote_thr
->last_resume_step
6579 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6580 && get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6582 /* We'll send a wildcard resume instead. */
6583 remote_thr
->vcont_resumed
= 1;
6587 vcont_builder
.push_action (tp
->ptid
,
6588 remote_thr
->last_resume_step
,
6589 remote_thr
->last_resume_sig
);
6590 remote_thr
->vcont_resumed
= 1;
6593 /* Now check whether we can send any process-wide wildcard. This is
6594 to avoid sending a global wildcard in the case nothing is
6595 supposed to be resumed. */
6596 any_process_wildcard
= 0;
6598 for (inferior
*inf
: all_non_exited_inferiors (this))
6600 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6602 any_process_wildcard
= 1;
6607 if (any_process_wildcard
)
6609 /* If all processes are wildcard-able, then send a single "c"
6610 action, otherwise, send an "all (-1) threads of process"
6611 continue action for each running process, if any. */
6612 if (may_global_wildcard_vcont
)
6614 vcont_builder
.push_action (minus_one_ptid
,
6615 false, GDB_SIGNAL_0
);
6619 for (inferior
*inf
: all_non_exited_inferiors (this))
6621 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6623 vcont_builder
.push_action (ptid_t (inf
->pid
),
6624 false, GDB_SIGNAL_0
);
6630 vcont_builder
.flush ();
6635 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6636 thread, all threads of a remote process, or all threads of all
6640 remote_target::remote_stop_ns (ptid_t ptid
)
6642 struct remote_state
*rs
= get_remote_state ();
6643 char *p
= rs
->buf
.data ();
6644 char *endp
= p
+ get_remote_packet_size ();
6646 /* FIXME: This supports_vCont_probed check is a workaround until
6647 packet_support is per-connection. */
6648 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
6649 || !rs
->supports_vCont_probed
)
6650 remote_vcont_probe ();
6652 if (!rs
->supports_vCont
.t
)
6653 error (_("Remote server does not support stopping threads"));
6655 if (ptid
== minus_one_ptid
6656 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6657 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6662 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6665 /* All (-1) threads of process. */
6666 nptid
= ptid_t (ptid
.pid (), -1, 0);
6669 /* Small optimization: if we already have a stop reply for
6670 this thread, no use in telling the stub we want this
6672 if (peek_stop_reply (ptid
))
6678 write_ptid (p
, endp
, nptid
);
6681 /* In non-stop, we get an immediate OK reply. The stop reply will
6682 come in asynchronously by notification. */
6684 getpkt (&rs
->buf
, 0);
6685 if (strcmp (rs
->buf
.data (), "OK") != 0)
6686 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6690 /* All-stop version of target_interrupt. Sends a break or a ^C to
6691 interrupt the remote target. It is undefined which thread of which
6692 process reports the interrupt. */
6695 remote_target::remote_interrupt_as ()
6697 struct remote_state
*rs
= get_remote_state ();
6699 rs
->ctrlc_pending_p
= 1;
6701 /* If the inferior is stopped already, but the core didn't know
6702 about it yet, just ignore the request. The cached wait status
6703 will be collected in remote_wait. */
6704 if (rs
->cached_wait_status
)
6707 /* Send interrupt_sequence to remote target. */
6708 send_interrupt_sequence ();
6711 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6712 the remote target. It is undefined which thread of which process
6713 reports the interrupt. Throws an error if the packet is not
6714 supported by the server. */
6717 remote_target::remote_interrupt_ns ()
6719 struct remote_state
*rs
= get_remote_state ();
6720 char *p
= rs
->buf
.data ();
6721 char *endp
= p
+ get_remote_packet_size ();
6723 xsnprintf (p
, endp
- p
, "vCtrlC");
6725 /* In non-stop, we get an immediate OK reply. The stop reply will
6726 come in asynchronously by notification. */
6728 getpkt (&rs
->buf
, 0);
6730 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6734 case PACKET_UNKNOWN
:
6735 error (_("No support for interrupting the remote target."));
6737 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6741 /* Implement the to_stop function for the remote targets. */
6744 remote_target::stop (ptid_t ptid
)
6747 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6749 if (target_is_non_stop_p ())
6750 remote_stop_ns (ptid
);
6753 /* We don't currently have a way to transparently pause the
6754 remote target in all-stop mode. Interrupt it instead. */
6755 remote_interrupt_as ();
6759 /* Implement the to_interrupt function for the remote targets. */
6762 remote_target::interrupt ()
6765 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6767 if (target_is_non_stop_p ())
6768 remote_interrupt_ns ();
6770 remote_interrupt_as ();
6773 /* Implement the to_pass_ctrlc function for the remote targets. */
6776 remote_target::pass_ctrlc ()
6778 struct remote_state
*rs
= get_remote_state ();
6781 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6783 /* If we're starting up, we're not fully synced yet. Quit
6785 if (rs
->starting_up
)
6787 /* If ^C has already been sent once, offer to disconnect. */
6788 else if (rs
->ctrlc_pending_p
)
6791 target_interrupt ();
6794 /* Ask the user what to do when an interrupt is received. */
6797 remote_target::interrupt_query ()
6799 struct remote_state
*rs
= get_remote_state ();
6801 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6803 if (query (_("The target is not responding to interrupt requests.\n"
6804 "Stop debugging it? ")))
6806 remote_unpush_target (this);
6807 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6812 if (query (_("Interrupted while waiting for the program.\n"
6813 "Give up waiting? ")))
6818 /* Enable/disable target terminal ownership. Most targets can use
6819 terminal groups to control terminal ownership. Remote targets are
6820 different in that explicit transfer of ownership to/from GDB/target
6824 remote_target::terminal_inferior ()
6826 /* NOTE: At this point we could also register our selves as the
6827 recipient of all input. Any characters typed could then be
6828 passed on down to the target. */
6832 remote_target::terminal_ours ()
6837 remote_console_output (const char *msg
)
6841 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6844 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6848 gdb_stdtarg
->puts (tb
);
6850 gdb_stdtarg
->flush ();
6853 struct stop_reply
: public notif_event
6857 /* The identifier of the thread about this event */
6860 /* The remote state this event is associated with. When the remote
6861 connection, represented by a remote_state object, is closed,
6862 all the associated stop_reply events should be released. */
6863 struct remote_state
*rs
;
6865 struct target_waitstatus ws
;
6867 /* The architecture associated with the expedited registers. */
6870 /* Expedited registers. This makes remote debugging a bit more
6871 efficient for those targets that provide critical registers as
6872 part of their normal status mechanism (as another roundtrip to
6873 fetch them is avoided). */
6874 std::vector
<cached_reg_t
> regcache
;
6876 enum target_stop_reason stop_reason
;
6878 CORE_ADDR watch_data_address
;
6883 /* Return the length of the stop reply queue. */
6886 remote_target::stop_reply_queue_length ()
6888 remote_state
*rs
= get_remote_state ();
6889 return rs
->stop_reply_queue
.size ();
6893 remote_notif_stop_parse (remote_target
*remote
,
6894 struct notif_client
*self
, const char *buf
,
6895 struct notif_event
*event
)
6897 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6901 remote_notif_stop_ack (remote_target
*remote
,
6902 struct notif_client
*self
, const char *buf
,
6903 struct notif_event
*event
)
6905 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6908 putpkt (remote
, self
->ack_command
);
6910 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6912 /* We got an unknown stop reply. */
6913 error (_("Unknown stop reply"));
6916 remote
->push_stop_reply (stop_reply
);
6920 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
6921 struct notif_client
*self
)
6923 /* We can't get pending events in remote_notif_process for
6924 notification stop, and we have to do this in remote_wait_ns
6925 instead. If we fetch all queued events from stub, remote stub
6926 may exit and we have no chance to process them back in
6928 remote_state
*rs
= remote
->get_remote_state ();
6929 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
6933 stop_reply::~stop_reply ()
6935 for (cached_reg_t
®
: regcache
)
6939 static notif_event_up
6940 remote_notif_stop_alloc_reply ()
6942 return notif_event_up (new struct stop_reply ());
6945 /* A client of notification Stop. */
6947 struct notif_client notif_client_stop
=
6951 remote_notif_stop_parse
,
6952 remote_notif_stop_ack
,
6953 remote_notif_stop_can_get_pending_events
,
6954 remote_notif_stop_alloc_reply
,
6958 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6959 the pid of the process that owns the threads we want to check, or
6960 -1 if we want to check all threads. */
6963 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6966 if (ws
->kind
== TARGET_WAITKIND_FORKED
6967 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6969 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
6976 /* Return the thread's pending status used to determine whether the
6977 thread is a fork parent stopped at a fork event. */
6979 static struct target_waitstatus
*
6980 thread_pending_fork_status (struct thread_info
*thread
)
6982 if (thread
->suspend
.waitstatus_pending_p
)
6983 return &thread
->suspend
.waitstatus
;
6985 return &thread
->pending_follow
;
6988 /* Determine if THREAD is a pending fork parent thread. */
6991 is_pending_fork_parent_thread (struct thread_info
*thread
)
6993 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6996 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6999 /* If CONTEXT contains any fork child threads that have not been
7000 reported yet, remove them from the CONTEXT list. If such a
7001 thread exists it is because we are stopped at a fork catchpoint
7002 and have not yet called follow_fork, which will set up the
7003 host-side data structures for the new process. */
7006 remote_target::remove_new_fork_children (threads_listing_context
*context
)
7009 struct notif_client
*notif
= ¬if_client_stop
;
7011 /* For any threads stopped at a fork event, remove the corresponding
7012 fork child threads from the CONTEXT list. */
7013 for (thread_info
*thread
: all_non_exited_threads (this))
7015 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
7017 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
7018 context
->remove_thread (ws
->value
.related_pid
);
7021 /* Check for any pending fork events (not reported or processed yet)
7022 in process PID and remove those fork child threads from the
7023 CONTEXT list as well. */
7024 remote_notif_get_pending_events (notif
);
7025 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7026 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7027 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
7028 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
7029 context
->remove_thread (event
->ws
.value
.related_pid
);
7032 /* Check whether any event pending in the vStopped queue would prevent
7033 a global or process wildcard vCont action. Clear
7034 *may_global_wildcard if we can't do a global wildcard (vCont;c),
7035 and clear the event inferior's may_wildcard_vcont flag if we can't
7036 do a process-wide wildcard resume (vCont;c:pPID.-1). */
7039 remote_target::check_pending_events_prevent_wildcard_vcont
7040 (int *may_global_wildcard
)
7042 struct notif_client
*notif
= ¬if_client_stop
;
7044 remote_notif_get_pending_events (notif
);
7045 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7047 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
7048 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
7051 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7052 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
7053 *may_global_wildcard
= 0;
7055 struct inferior
*inf
= find_inferior_ptid (this, event
->ptid
);
7057 /* This may be the first time we heard about this process.
7058 Regardless, we must not do a global wildcard resume, otherwise
7059 we'd resume this process too. */
7060 *may_global_wildcard
= 0;
7062 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7066 /* Discard all pending stop replies of inferior INF. */
7069 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7071 struct stop_reply
*reply
;
7072 struct remote_state
*rs
= get_remote_state ();
7073 struct remote_notif_state
*rns
= rs
->notif_state
;
7075 /* This function can be notified when an inferior exists. When the
7076 target is not remote, the notification state is NULL. */
7077 if (rs
->remote_desc
== NULL
)
7080 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7082 /* Discard the in-flight notification. */
7083 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7086 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7089 /* Discard the stop replies we have already pulled with
7091 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7092 rs
->stop_reply_queue
.end (),
7093 [=] (const stop_reply_up
&event
)
7095 return event
->ptid
.pid () == inf
->pid
;
7097 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7100 /* Discard the stop replies for RS in stop_reply_queue. */
7103 remote_target::discard_pending_stop_replies_in_queue ()
7105 remote_state
*rs
= get_remote_state ();
7107 /* Discard the stop replies we have already pulled with
7109 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7110 rs
->stop_reply_queue
.end (),
7111 [=] (const stop_reply_up
&event
)
7113 return event
->rs
== rs
;
7115 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7118 /* Remove the first reply in 'stop_reply_queue' which matches
7122 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7124 remote_state
*rs
= get_remote_state ();
7126 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7127 rs
->stop_reply_queue
.end (),
7128 [=] (const stop_reply_up
&event
)
7130 return event
->ptid
.matches (ptid
);
7132 struct stop_reply
*result
;
7133 if (iter
== rs
->stop_reply_queue
.end ())
7137 result
= iter
->release ();
7138 rs
->stop_reply_queue
.erase (iter
);
7142 fprintf_unfiltered (gdb_stdlog
,
7143 "notif: discard queued event: 'Stop' in %s\n",
7144 target_pid_to_str (ptid
).c_str ());
7149 /* Look for a queued stop reply belonging to PTID. If one is found,
7150 remove it from the queue, and return it. Returns NULL if none is
7151 found. If there are still queued events left to process, tell the
7152 event loop to get back to target_wait soon. */
7155 remote_target::queued_stop_reply (ptid_t ptid
)
7157 remote_state
*rs
= get_remote_state ();
7158 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7160 if (!rs
->stop_reply_queue
.empty ())
7162 /* There's still at least an event left. */
7163 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7169 /* Push a fully parsed stop reply in the stop reply queue. Since we
7170 know that we now have at least one queued event left to pass to the
7171 core side, tell the event loop to get back to target_wait soon. */
7174 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7176 remote_state
*rs
= get_remote_state ();
7177 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7180 fprintf_unfiltered (gdb_stdlog
,
7181 "notif: push 'Stop' %s to queue %d\n",
7182 target_pid_to_str (new_event
->ptid
).c_str (),
7183 int (rs
->stop_reply_queue
.size ()));
7185 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7188 /* Returns true if we have a stop reply for PTID. */
7191 remote_target::peek_stop_reply (ptid_t ptid
)
7193 remote_state
*rs
= get_remote_state ();
7194 for (auto &event
: rs
->stop_reply_queue
)
7195 if (ptid
== event
->ptid
7196 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7201 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7202 starting with P and ending with PEND matches PREFIX. */
7205 strprefix (const char *p
, const char *pend
, const char *prefix
)
7207 for ( ; p
< pend
; p
++, prefix
++)
7210 return *prefix
== '\0';
7213 /* Parse the stop reply in BUF. Either the function succeeds, and the
7214 result is stored in EVENT, or throws an error. */
7217 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7219 remote_arch_state
*rsa
= NULL
;
7224 event
->ptid
= null_ptid
;
7225 event
->rs
= get_remote_state ();
7226 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7227 event
->ws
.value
.integer
= 0;
7228 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7229 event
->regcache
.clear ();
7234 case 'T': /* Status with PC, SP, FP, ... */
7235 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7236 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7238 n... = register number
7239 r... = register contents
7242 p
= &buf
[3]; /* after Txx */
7248 p1
= strchr (p
, ':');
7250 error (_("Malformed packet(a) (missing colon): %s\n\
7254 error (_("Malformed packet(a) (missing register number): %s\n\
7258 /* Some "registers" are actually extended stop information.
7259 Note if you're adding a new entry here: GDB 7.9 and
7260 earlier assume that all register "numbers" that start
7261 with an hex digit are real register numbers. Make sure
7262 the server only sends such a packet if it knows the
7263 client understands it. */
7265 if (strprefix (p
, p1
, "thread"))
7266 event
->ptid
= read_ptid (++p1
, &p
);
7267 else if (strprefix (p
, p1
, "syscall_entry"))
7271 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7272 p
= unpack_varlen_hex (++p1
, &sysno
);
7273 event
->ws
.value
.syscall_number
= (int) sysno
;
7275 else if (strprefix (p
, p1
, "syscall_return"))
7279 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7280 p
= unpack_varlen_hex (++p1
, &sysno
);
7281 event
->ws
.value
.syscall_number
= (int) sysno
;
7283 else if (strprefix (p
, p1
, "watch")
7284 || strprefix (p
, p1
, "rwatch")
7285 || strprefix (p
, p1
, "awatch"))
7287 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7288 p
= unpack_varlen_hex (++p1
, &addr
);
7289 event
->watch_data_address
= (CORE_ADDR
) addr
;
7291 else if (strprefix (p
, p1
, "swbreak"))
7293 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7295 /* Make sure the stub doesn't forget to indicate support
7297 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7298 error (_("Unexpected swbreak stop reason"));
7300 /* The value part is documented as "must be empty",
7301 though we ignore it, in case we ever decide to make
7302 use of it in a backward compatible way. */
7303 p
= strchrnul (p1
+ 1, ';');
7305 else if (strprefix (p
, p1
, "hwbreak"))
7307 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7309 /* Make sure the stub doesn't forget to indicate support
7311 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7312 error (_("Unexpected hwbreak stop reason"));
7315 p
= strchrnul (p1
+ 1, ';');
7317 else if (strprefix (p
, p1
, "library"))
7319 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7320 p
= strchrnul (p1
+ 1, ';');
7322 else if (strprefix (p
, p1
, "replaylog"))
7324 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7325 /* p1 will indicate "begin" or "end", but it makes
7326 no difference for now, so ignore it. */
7327 p
= strchrnul (p1
+ 1, ';');
7329 else if (strprefix (p
, p1
, "core"))
7333 p
= unpack_varlen_hex (++p1
, &c
);
7336 else if (strprefix (p
, p1
, "fork"))
7338 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7339 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7341 else if (strprefix (p
, p1
, "vfork"))
7343 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7344 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7346 else if (strprefix (p
, p1
, "vforkdone"))
7348 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7349 p
= strchrnul (p1
+ 1, ';');
7351 else if (strprefix (p
, p1
, "exec"))
7356 /* Determine the length of the execd pathname. */
7357 p
= unpack_varlen_hex (++p1
, &ignored
);
7358 pathlen
= (p
- p1
) / 2;
7360 /* Save the pathname for event reporting and for
7361 the next run command. */
7362 gdb::unique_xmalloc_ptr
<char[]> pathname
7363 ((char *) xmalloc (pathlen
+ 1));
7364 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7365 pathname
[pathlen
] = '\0';
7367 /* This is freed during event handling. */
7368 event
->ws
.value
.execd_pathname
= pathname
.release ();
7369 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7371 /* Skip the registers included in this packet, since
7372 they may be for an architecture different from the
7373 one used by the original program. */
7376 else if (strprefix (p
, p1
, "create"))
7378 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7379 p
= strchrnul (p1
+ 1, ';');
7388 p
= strchrnul (p1
+ 1, ';');
7393 /* Maybe a real ``P'' register number. */
7394 p_temp
= unpack_varlen_hex (p
, &pnum
);
7395 /* If the first invalid character is the colon, we got a
7396 register number. Otherwise, it's an unknown stop
7400 /* If we haven't parsed the event's thread yet, find
7401 it now, in order to find the architecture of the
7402 reported expedited registers. */
7403 if (event
->ptid
== null_ptid
)
7405 const char *thr
= strstr (p1
+ 1, ";thread:");
7407 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7411 /* Either the current thread hasn't changed,
7412 or the inferior is not multi-threaded.
7413 The event must be for the thread we last
7414 set as (or learned as being) current. */
7415 event
->ptid
= event
->rs
->general_thread
;
7422 = (event
->ptid
== null_ptid
7424 : find_inferior_ptid (this, event
->ptid
));
7425 /* If this is the first time we learn anything
7426 about this process, skip the registers
7427 included in this packet, since we don't yet
7428 know which architecture to use to parse them.
7429 We'll determine the architecture later when
7430 we process the stop reply and retrieve the
7431 target description, via
7432 remote_notice_new_inferior ->
7433 post_create_inferior. */
7436 p
= strchrnul (p1
+ 1, ';');
7441 event
->arch
= inf
->gdbarch
;
7442 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7446 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7447 cached_reg_t cached_reg
;
7450 error (_("Remote sent bad register number %s: %s\n\
7452 hex_string (pnum
), p
, buf
);
7454 cached_reg
.num
= reg
->regnum
;
7455 cached_reg
.data
= (gdb_byte
*)
7456 xmalloc (register_size (event
->arch
, reg
->regnum
));
7459 fieldsize
= hex2bin (p
, cached_reg
.data
,
7460 register_size (event
->arch
, reg
->regnum
));
7462 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7463 warning (_("Remote reply is too short: %s"), buf
);
7465 event
->regcache
.push_back (cached_reg
);
7469 /* Not a number. Silently skip unknown optional
7471 p
= strchrnul (p1
+ 1, ';');
7476 error (_("Remote register badly formatted: %s\nhere: %s"),
7481 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7485 case 'S': /* Old style status, just signal only. */
7489 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7490 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7491 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7492 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7494 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7497 case 'w': /* Thread exited. */
7501 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7502 p
= unpack_varlen_hex (&buf
[1], &value
);
7503 event
->ws
.value
.integer
= value
;
7505 error (_("stop reply packet badly formatted: %s"), buf
);
7506 event
->ptid
= read_ptid (++p
, NULL
);
7509 case 'W': /* Target exited. */
7514 /* GDB used to accept only 2 hex chars here. Stubs should
7515 only send more if they detect GDB supports multi-process
7517 p
= unpack_varlen_hex (&buf
[1], &value
);
7521 /* The remote process exited. */
7522 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7523 event
->ws
.value
.integer
= value
;
7527 /* The remote process exited with a signal. */
7528 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7529 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7530 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7532 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7535 /* If no process is specified, return null_ptid, and let the
7536 caller figure out the right process to use. */
7546 else if (startswith (p
, "process:"))
7550 p
+= sizeof ("process:") - 1;
7551 unpack_varlen_hex (p
, &upid
);
7555 error (_("unknown stop reply packet: %s"), buf
);
7558 error (_("unknown stop reply packet: %s"), buf
);
7559 event
->ptid
= ptid_t (pid
);
7563 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7564 event
->ptid
= minus_one_ptid
;
7568 if (target_is_non_stop_p () && event
->ptid
== null_ptid
)
7569 error (_("No process or thread specified in stop reply: %s"), buf
);
7572 /* When the stub wants to tell GDB about a new notification reply, it
7573 sends a notification (%Stop, for example). Those can come it at
7574 any time, hence, we have to make sure that any pending
7575 putpkt/getpkt sequence we're making is finished, before querying
7576 the stub for more events with the corresponding ack command
7577 (vStopped, for example). E.g., if we started a vStopped sequence
7578 immediately upon receiving the notification, something like this
7586 1.6) <-- (registers reply to step #1.3)
7588 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7591 To solve this, whenever we parse a %Stop notification successfully,
7592 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7593 doing whatever we were doing:
7599 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7600 2.5) <-- (registers reply to step #2.3)
7602 Eventually after step #2.5, we return to the event loop, which
7603 notices there's an event on the
7604 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7605 associated callback --- the function below. At this point, we're
7606 always safe to start a vStopped sequence. :
7609 2.7) <-- T05 thread:2
7615 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7617 struct remote_state
*rs
= get_remote_state ();
7619 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7622 fprintf_unfiltered (gdb_stdlog
,
7623 "notif: process: '%s' ack pending event\n",
7627 nc
->ack (this, nc
, rs
->buf
.data (),
7628 rs
->notif_state
->pending_event
[nc
->id
]);
7629 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7633 getpkt (&rs
->buf
, 0);
7634 if (strcmp (rs
->buf
.data (), "OK") == 0)
7637 remote_notif_ack (this, nc
, rs
->buf
.data ());
7643 fprintf_unfiltered (gdb_stdlog
,
7644 "notif: process: '%s' no pending reply\n",
7649 /* Wrapper around remote_target::remote_notif_get_pending_events to
7650 avoid having to export the whole remote_target class. */
7653 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7655 remote
->remote_notif_get_pending_events (nc
);
7658 /* Called when it is decided that STOP_REPLY holds the info of the
7659 event that is to be returned to the core. This function always
7660 destroys STOP_REPLY. */
7663 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7664 struct target_waitstatus
*status
)
7668 *status
= stop_reply
->ws
;
7669 ptid
= stop_reply
->ptid
;
7671 /* If no thread/process was reported by the stub, assume the current
7673 if (ptid
== null_ptid
)
7674 ptid
= inferior_ptid
;
7676 if (status
->kind
!= TARGET_WAITKIND_EXITED
7677 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7678 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7680 /* Expedited registers. */
7681 if (!stop_reply
->regcache
.empty ())
7683 struct regcache
*regcache
7684 = get_thread_arch_regcache (this, ptid
, stop_reply
->arch
);
7686 for (cached_reg_t
®
: stop_reply
->regcache
)
7688 regcache
->raw_supply (reg
.num
, reg
.data
);
7692 stop_reply
->regcache
.clear ();
7695 remote_notice_new_inferior (ptid
, 0);
7696 remote_thread_info
*remote_thr
= get_remote_thread_info (this, ptid
);
7697 remote_thr
->core
= stop_reply
->core
;
7698 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7699 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7700 remote_thr
->vcont_resumed
= 0;
7707 /* The non-stop mode version of target_wait. */
7710 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7712 struct remote_state
*rs
= get_remote_state ();
7713 struct stop_reply
*stop_reply
;
7717 /* If in non-stop mode, get out of getpkt even if a
7718 notification is received. */
7720 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7723 if (ret
!= -1 && !is_notif
)
7726 case 'E': /* Error of some sort. */
7727 /* We're out of sync with the target now. Did it continue
7728 or not? We can't tell which thread it was in non-stop,
7729 so just ignore this. */
7730 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7732 case 'O': /* Console output. */
7733 remote_console_output (&rs
->buf
[1]);
7736 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7740 /* Acknowledge a pending stop reply that may have arrived in the
7742 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7743 remote_notif_get_pending_events (¬if_client_stop
);
7745 /* If indeed we noticed a stop reply, we're done. */
7746 stop_reply
= queued_stop_reply (ptid
);
7747 if (stop_reply
!= NULL
)
7748 return process_stop_reply (stop_reply
, status
);
7750 /* Still no event. If we're just polling for an event, then
7751 return to the event loop. */
7752 if (options
& TARGET_WNOHANG
)
7754 status
->kind
= TARGET_WAITKIND_IGNORE
;
7755 return minus_one_ptid
;
7758 /* Otherwise do a blocking wait. */
7759 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7763 /* Return the first resumed thread. */
7766 first_remote_resumed_thread (remote_target
*target
)
7768 for (thread_info
*tp
: all_non_exited_threads (target
, minus_one_ptid
))
7774 /* Wait until the remote machine stops, then return, storing status in
7775 STATUS just as `wait' would. */
7778 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
, int options
)
7780 struct remote_state
*rs
= get_remote_state ();
7781 ptid_t event_ptid
= null_ptid
;
7783 struct stop_reply
*stop_reply
;
7787 status
->kind
= TARGET_WAITKIND_IGNORE
;
7788 status
->value
.integer
= 0;
7790 stop_reply
= queued_stop_reply (ptid
);
7791 if (stop_reply
!= NULL
)
7792 return process_stop_reply (stop_reply
, status
);
7794 if (rs
->cached_wait_status
)
7795 /* Use the cached wait status, but only once. */
7796 rs
->cached_wait_status
= 0;
7801 int forever
= ((options
& TARGET_WNOHANG
) == 0
7802 && rs
->wait_forever_enabled_p
);
7804 if (!rs
->waiting_for_stop_reply
)
7806 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7807 return minus_one_ptid
;
7810 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7811 _never_ wait for ever -> test on target_is_async_p().
7812 However, before we do that we need to ensure that the caller
7813 knows how to take the target into/out of async mode. */
7814 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
7816 /* GDB gets a notification. Return to core as this event is
7818 if (ret
!= -1 && is_notif
)
7819 return minus_one_ptid
;
7821 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7822 return minus_one_ptid
;
7825 buf
= rs
->buf
.data ();
7827 /* Assume that the target has acknowledged Ctrl-C unless we receive
7828 an 'F' or 'O' packet. */
7829 if (buf
[0] != 'F' && buf
[0] != 'O')
7830 rs
->ctrlc_pending_p
= 0;
7834 case 'E': /* Error of some sort. */
7835 /* We're out of sync with the target now. Did it continue or
7836 not? Not is more likely, so report a stop. */
7837 rs
->waiting_for_stop_reply
= 0;
7839 warning (_("Remote failure reply: %s"), buf
);
7840 status
->kind
= TARGET_WAITKIND_STOPPED
;
7841 status
->value
.sig
= GDB_SIGNAL_0
;
7843 case 'F': /* File-I/O request. */
7844 /* GDB may access the inferior memory while handling the File-I/O
7845 request, but we don't want GDB accessing memory while waiting
7846 for a stop reply. See the comments in putpkt_binary. Set
7847 waiting_for_stop_reply to 0 temporarily. */
7848 rs
->waiting_for_stop_reply
= 0;
7849 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
7850 rs
->ctrlc_pending_p
= 0;
7851 /* GDB handled the File-I/O request, and the target is running
7852 again. Keep waiting for events. */
7853 rs
->waiting_for_stop_reply
= 1;
7855 case 'N': case 'T': case 'S': case 'X': case 'W':
7857 /* There is a stop reply to handle. */
7858 rs
->waiting_for_stop_reply
= 0;
7861 = (struct stop_reply
*) remote_notif_parse (this,
7865 event_ptid
= process_stop_reply (stop_reply
, status
);
7868 case 'O': /* Console output. */
7869 remote_console_output (buf
+ 1);
7872 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7874 /* Zero length reply means that we tried 'S' or 'C' and the
7875 remote system doesn't support it. */
7876 target_terminal::ours_for_output ();
7878 ("Can't send signals to this remote system. %s not sent.\n",
7879 gdb_signal_to_name (rs
->last_sent_signal
));
7880 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7881 target_terminal::inferior ();
7883 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7889 warning (_("Invalid remote reply: %s"), buf
);
7893 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7894 return minus_one_ptid
;
7895 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7897 /* Nothing interesting happened. If we're doing a non-blocking
7898 poll, we're done. Otherwise, go back to waiting. */
7899 if (options
& TARGET_WNOHANG
)
7900 return minus_one_ptid
;
7904 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7905 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7907 if (event_ptid
!= null_ptid
)
7908 record_currthread (rs
, event_ptid
);
7910 event_ptid
= first_remote_resumed_thread (this);
7914 /* A process exit. Invalidate our notion of current thread. */
7915 record_currthread (rs
, minus_one_ptid
);
7916 /* It's possible that the packet did not include a pid. */
7917 if (event_ptid
== null_ptid
)
7918 event_ptid
= first_remote_resumed_thread (this);
7919 /* EVENT_PTID could still be NULL_PTID. Double-check. */
7920 if (event_ptid
== null_ptid
)
7921 event_ptid
= magic_null_ptid
;
7927 /* Wait until the remote machine stops, then return, storing status in
7928 STATUS just as `wait' would. */
7931 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7935 if (target_is_non_stop_p ())
7936 event_ptid
= wait_ns (ptid
, status
, options
);
7938 event_ptid
= wait_as (ptid
, status
, options
);
7940 if (target_is_async_p ())
7942 remote_state
*rs
= get_remote_state ();
7944 /* If there are are events left in the queue tell the event loop
7946 if (!rs
->stop_reply_queue
.empty ())
7947 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7953 /* Fetch a single register using a 'p' packet. */
7956 remote_target::fetch_register_using_p (struct regcache
*regcache
,
7959 struct gdbarch
*gdbarch
= regcache
->arch ();
7960 struct remote_state
*rs
= get_remote_state ();
7962 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7965 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7968 if (reg
->pnum
== -1)
7971 p
= rs
->buf
.data ();
7973 p
+= hexnumstr (p
, reg
->pnum
);
7976 getpkt (&rs
->buf
, 0);
7978 buf
= rs
->buf
.data ();
7980 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
7984 case PACKET_UNKNOWN
:
7987 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7988 gdbarch_register_name (regcache
->arch (),
7993 /* If this register is unfetchable, tell the regcache. */
7996 regcache
->raw_supply (reg
->regnum
, NULL
);
8000 /* Otherwise, parse and supply the value. */
8006 error (_("fetch_register_using_p: early buf termination"));
8008 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8011 regcache
->raw_supply (reg
->regnum
, regp
);
8015 /* Fetch the registers included in the target's 'g' packet. */
8018 remote_target::send_g_packet ()
8020 struct remote_state
*rs
= get_remote_state ();
8023 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
8025 getpkt (&rs
->buf
, 0);
8026 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8027 error (_("Could not read registers; remote failure reply '%s'"),
8030 /* We can get out of synch in various cases. If the first character
8031 in the buffer is not a hex character, assume that has happened
8032 and try to fetch another packet to read. */
8033 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
8034 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
8035 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
8036 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
8039 fprintf_unfiltered (gdb_stdlog
,
8040 "Bad register packet; fetching a new packet\n");
8041 getpkt (&rs
->buf
, 0);
8044 buf_len
= strlen (rs
->buf
.data ());
8046 /* Sanity check the received packet. */
8047 if (buf_len
% 2 != 0)
8048 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
8054 remote_target::process_g_packet (struct regcache
*regcache
)
8056 struct gdbarch
*gdbarch
= regcache
->arch ();
8057 struct remote_state
*rs
= get_remote_state ();
8058 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8063 buf_len
= strlen (rs
->buf
.data ());
8065 /* Further sanity checks, with knowledge of the architecture. */
8066 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
8067 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8069 rsa
->sizeof_g_packet
, buf_len
/ 2,
8072 /* Save the size of the packet sent to us by the target. It is used
8073 as a heuristic when determining the max size of packets that the
8074 target can safely receive. */
8075 if (rsa
->actual_register_packet_size
== 0)
8076 rsa
->actual_register_packet_size
= buf_len
;
8078 /* If this is smaller than we guessed the 'g' packet would be,
8079 update our records. A 'g' reply that doesn't include a register's
8080 value implies either that the register is not available, or that
8081 the 'p' packet must be used. */
8082 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8084 long sizeof_g_packet
= buf_len
/ 2;
8086 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8088 long offset
= rsa
->regs
[i
].offset
;
8089 long reg_size
= register_size (gdbarch
, i
);
8091 if (rsa
->regs
[i
].pnum
== -1)
8094 if (offset
>= sizeof_g_packet
)
8095 rsa
->regs
[i
].in_g_packet
= 0;
8096 else if (offset
+ reg_size
> sizeof_g_packet
)
8097 error (_("Truncated register %d in remote 'g' packet"), i
);
8099 rsa
->regs
[i
].in_g_packet
= 1;
8102 /* Looks valid enough, we can assume this is the correct length
8103 for a 'g' packet. It's important not to adjust
8104 rsa->sizeof_g_packet if we have truncated registers otherwise
8105 this "if" won't be run the next time the method is called
8106 with a packet of the same size and one of the internal errors
8107 below will trigger instead. */
8108 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8111 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8113 /* Unimplemented registers read as all bits zero. */
8114 memset (regs
, 0, rsa
->sizeof_g_packet
);
8116 /* Reply describes registers byte by byte, each byte encoded as two
8117 hex characters. Suck them all up, then supply them to the
8118 register cacheing/storage mechanism. */
8120 p
= rs
->buf
.data ();
8121 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8123 if (p
[0] == 0 || p
[1] == 0)
8124 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8125 internal_error (__FILE__
, __LINE__
,
8126 _("unexpected end of 'g' packet reply"));
8128 if (p
[0] == 'x' && p
[1] == 'x')
8129 regs
[i
] = 0; /* 'x' */
8131 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8135 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8137 struct packet_reg
*r
= &rsa
->regs
[i
];
8138 long reg_size
= register_size (gdbarch
, i
);
8142 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8143 /* This shouldn't happen - we adjusted in_g_packet above. */
8144 internal_error (__FILE__
, __LINE__
,
8145 _("unexpected end of 'g' packet reply"));
8146 else if (rs
->buf
[r
->offset
* 2] == 'x')
8148 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8149 /* The register isn't available, mark it as such (at
8150 the same time setting the value to zero). */
8151 regcache
->raw_supply (r
->regnum
, NULL
);
8154 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8160 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8163 process_g_packet (regcache
);
8166 /* Make the remote selected traceframe match GDB's selected
8170 remote_target::set_remote_traceframe ()
8173 struct remote_state
*rs
= get_remote_state ();
8175 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8178 /* Avoid recursion, remote_trace_find calls us again. */
8179 rs
->remote_traceframe_number
= get_traceframe_number ();
8181 newnum
= target_trace_find (tfind_number
,
8182 get_traceframe_number (), 0, 0, NULL
);
8184 /* Should not happen. If it does, all bets are off. */
8185 if (newnum
!= get_traceframe_number ())
8186 warning (_("could not set remote traceframe"));
8190 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8192 struct gdbarch
*gdbarch
= regcache
->arch ();
8193 struct remote_state
*rs
= get_remote_state ();
8194 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8197 set_remote_traceframe ();
8198 set_general_thread (regcache
->ptid ());
8202 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8204 gdb_assert (reg
!= NULL
);
8206 /* If this register might be in the 'g' packet, try that first -
8207 we are likely to read more than one register. If this is the
8208 first 'g' packet, we might be overly optimistic about its
8209 contents, so fall back to 'p'. */
8210 if (reg
->in_g_packet
)
8212 fetch_registers_using_g (regcache
);
8213 if (reg
->in_g_packet
)
8217 if (fetch_register_using_p (regcache
, reg
))
8220 /* This register is not available. */
8221 regcache
->raw_supply (reg
->regnum
, NULL
);
8226 fetch_registers_using_g (regcache
);
8228 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8229 if (!rsa
->regs
[i
].in_g_packet
)
8230 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8232 /* This register is not available. */
8233 regcache
->raw_supply (i
, NULL
);
8237 /* Prepare to store registers. Since we may send them all (using a
8238 'G' request), we have to read out the ones we don't want to change
8242 remote_target::prepare_to_store (struct regcache
*regcache
)
8244 struct remote_state
*rs
= get_remote_state ();
8245 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8248 /* Make sure the entire registers array is valid. */
8249 switch (packet_support (PACKET_P
))
8251 case PACKET_DISABLE
:
8252 case PACKET_SUPPORT_UNKNOWN
:
8253 /* Make sure all the necessary registers are cached. */
8254 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8255 if (rsa
->regs
[i
].in_g_packet
)
8256 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8263 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8264 packet was not recognized. */
8267 remote_target::store_register_using_P (const struct regcache
*regcache
,
8270 struct gdbarch
*gdbarch
= regcache
->arch ();
8271 struct remote_state
*rs
= get_remote_state ();
8272 /* Try storing a single register. */
8273 char *buf
= rs
->buf
.data ();
8274 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8277 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8280 if (reg
->pnum
== -1)
8283 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8284 p
= buf
+ strlen (buf
);
8285 regcache
->raw_collect (reg
->regnum
, regp
);
8286 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8288 getpkt (&rs
->buf
, 0);
8290 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8295 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8296 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8297 case PACKET_UNKNOWN
:
8300 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8304 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8305 contents of the register cache buffer. FIXME: ignores errors. */
8308 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8310 struct remote_state
*rs
= get_remote_state ();
8311 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8315 /* Extract all the registers in the regcache copying them into a
8320 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8321 memset (regs
, 0, rsa
->sizeof_g_packet
);
8322 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8324 struct packet_reg
*r
= &rsa
->regs
[i
];
8327 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8331 /* Command describes registers byte by byte,
8332 each byte encoded as two hex characters. */
8333 p
= rs
->buf
.data ();
8335 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8337 getpkt (&rs
->buf
, 0);
8338 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8339 error (_("Could not write registers; remote failure reply '%s'"),
8343 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8344 of the register cache buffer. FIXME: ignores errors. */
8347 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8349 struct gdbarch
*gdbarch
= regcache
->arch ();
8350 struct remote_state
*rs
= get_remote_state ();
8351 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8354 set_remote_traceframe ();
8355 set_general_thread (regcache
->ptid ());
8359 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8361 gdb_assert (reg
!= NULL
);
8363 /* Always prefer to store registers using the 'P' packet if
8364 possible; we often change only a small number of registers.
8365 Sometimes we change a larger number; we'd need help from a
8366 higher layer to know to use 'G'. */
8367 if (store_register_using_P (regcache
, reg
))
8370 /* For now, don't complain if we have no way to write the
8371 register. GDB loses track of unavailable registers too
8372 easily. Some day, this may be an error. We don't have
8373 any way to read the register, either... */
8374 if (!reg
->in_g_packet
)
8377 store_registers_using_G (regcache
);
8381 store_registers_using_G (regcache
);
8383 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8384 if (!rsa
->regs
[i
].in_g_packet
)
8385 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8386 /* See above for why we do not issue an error here. */
8391 /* Return the number of hex digits in num. */
8394 hexnumlen (ULONGEST num
)
8398 for (i
= 0; num
!= 0; i
++)
8401 return std::max (i
, 1);
8404 /* Set BUF to the minimum number of hex digits representing NUM. */
8407 hexnumstr (char *buf
, ULONGEST num
)
8409 int len
= hexnumlen (num
);
8411 return hexnumnstr (buf
, num
, len
);
8415 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8418 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8424 for (i
= width
- 1; i
>= 0; i
--)
8426 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8433 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8436 remote_address_masked (CORE_ADDR addr
)
8438 unsigned int address_size
= remote_address_size
;
8440 /* If "remoteaddresssize" was not set, default to target address size. */
8442 address_size
= gdbarch_addr_bit (target_gdbarch ());
8444 if (address_size
> 0
8445 && address_size
< (sizeof (ULONGEST
) * 8))
8447 /* Only create a mask when that mask can safely be constructed
8448 in a ULONGEST variable. */
8451 mask
= (mask
<< address_size
) - 1;
8457 /* Determine whether the remote target supports binary downloading.
8458 This is accomplished by sending a no-op memory write of zero length
8459 to the target at the specified address. It does not suffice to send
8460 the whole packet, since many stubs strip the eighth bit and
8461 subsequently compute a wrong checksum, which causes real havoc with
8464 NOTE: This can still lose if the serial line is not eight-bit
8465 clean. In cases like this, the user should clear "remote
8469 remote_target::check_binary_download (CORE_ADDR addr
)
8471 struct remote_state
*rs
= get_remote_state ();
8473 switch (packet_support (PACKET_X
))
8475 case PACKET_DISABLE
:
8479 case PACKET_SUPPORT_UNKNOWN
:
8483 p
= rs
->buf
.data ();
8485 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8487 p
+= hexnumstr (p
, (ULONGEST
) 0);
8491 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8492 getpkt (&rs
->buf
, 0);
8494 if (rs
->buf
[0] == '\0')
8497 fprintf_unfiltered (gdb_stdlog
,
8498 "binary downloading NOT "
8499 "supported by target\n");
8500 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8505 fprintf_unfiltered (gdb_stdlog
,
8506 "binary downloading supported by target\n");
8507 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8514 /* Helper function to resize the payload in order to try to get a good
8515 alignment. We try to write an amount of data such that the next write will
8516 start on an address aligned on REMOTE_ALIGN_WRITES. */
8519 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8521 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8524 /* Write memory data directly to the remote machine.
8525 This does not inform the data cache; the data cache uses this.
8526 HEADER is the starting part of the packet.
8527 MEMADDR is the address in the remote memory space.
8528 MYADDR is the address of the buffer in our space.
8529 LEN_UNITS is the number of addressable units to write.
8530 UNIT_SIZE is the length in bytes of an addressable unit.
8531 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8532 should send data as binary ('X'), or hex-encoded ('M').
8534 The function creates packet of the form
8535 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8537 where encoding of <DATA> is terminated by PACKET_FORMAT.
8539 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8542 Return the transferred status, error or OK (an
8543 'enum target_xfer_status' value). Save the number of addressable units
8544 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8546 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8547 exchange between gdb and the stub could look like (?? in place of the
8553 -> $M1000,3:eeeeffffeeee#??
8557 <- eeeeffffeeeedddd */
8560 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8561 const gdb_byte
*myaddr
,
8564 ULONGEST
*xfered_len_units
,
8565 char packet_format
, int use_length
)
8567 struct remote_state
*rs
= get_remote_state ();
8573 int payload_capacity_bytes
;
8574 int payload_length_bytes
;
8576 if (packet_format
!= 'X' && packet_format
!= 'M')
8577 internal_error (__FILE__
, __LINE__
,
8578 _("remote_write_bytes_aux: bad packet format"));
8581 return TARGET_XFER_EOF
;
8583 payload_capacity_bytes
= get_memory_write_packet_size ();
8585 /* The packet buffer will be large enough for the payload;
8586 get_memory_packet_size ensures this. */
8589 /* Compute the size of the actual payload by subtracting out the
8590 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8592 payload_capacity_bytes
-= strlen ("$,:#NN");
8594 /* The comma won't be used. */
8595 payload_capacity_bytes
+= 1;
8596 payload_capacity_bytes
-= strlen (header
);
8597 payload_capacity_bytes
-= hexnumlen (memaddr
);
8599 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8601 strcat (rs
->buf
.data (), header
);
8602 p
= rs
->buf
.data () + strlen (header
);
8604 /* Compute a best guess of the number of bytes actually transfered. */
8605 if (packet_format
== 'X')
8607 /* Best guess at number of bytes that will fit. */
8608 todo_units
= std::min (len_units
,
8609 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8611 payload_capacity_bytes
-= hexnumlen (todo_units
);
8612 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8616 /* Number of bytes that will fit. */
8618 = std::min (len_units
,
8619 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8621 payload_capacity_bytes
-= hexnumlen (todo_units
);
8622 todo_units
= std::min (todo_units
,
8623 (payload_capacity_bytes
/ unit_size
) / 2);
8626 if (todo_units
<= 0)
8627 internal_error (__FILE__
, __LINE__
,
8628 _("minimum packet size too small to write data"));
8630 /* If we already need another packet, then try to align the end
8631 of this packet to a useful boundary. */
8632 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8633 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8635 /* Append "<memaddr>". */
8636 memaddr
= remote_address_masked (memaddr
);
8637 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8644 /* Append the length and retain its location and size. It may need to be
8645 adjusted once the packet body has been created. */
8647 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8655 /* Append the packet body. */
8656 if (packet_format
== 'X')
8658 /* Binary mode. Send target system values byte by byte, in
8659 increasing byte addresses. Only escape certain critical
8661 payload_length_bytes
=
8662 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8663 &units_written
, payload_capacity_bytes
);
8665 /* If not all TODO units fit, then we'll need another packet. Make
8666 a second try to keep the end of the packet aligned. Don't do
8667 this if the packet is tiny. */
8668 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8672 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8674 if (new_todo_units
!= units_written
)
8675 payload_length_bytes
=
8676 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8677 (gdb_byte
*) p
, &units_written
,
8678 payload_capacity_bytes
);
8681 p
+= payload_length_bytes
;
8682 if (use_length
&& units_written
< todo_units
)
8684 /* Escape chars have filled up the buffer prematurely,
8685 and we have actually sent fewer units than planned.
8686 Fix-up the length field of the packet. Use the same
8687 number of characters as before. */
8688 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8690 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8695 /* Normal mode: Send target system values byte by byte, in
8696 increasing byte addresses. Each byte is encoded as a two hex
8698 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8699 units_written
= todo_units
;
8702 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8703 getpkt (&rs
->buf
, 0);
8705 if (rs
->buf
[0] == 'E')
8706 return TARGET_XFER_E_IO
;
8708 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8709 send fewer units than we'd planned. */
8710 *xfered_len_units
= (ULONGEST
) units_written
;
8711 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8714 /* Write memory data directly to the remote machine.
8715 This does not inform the data cache; the data cache uses this.
8716 MEMADDR is the address in the remote memory space.
8717 MYADDR is the address of the buffer in our space.
8718 LEN is the number of bytes.
8720 Return the transferred status, error or OK (an
8721 'enum target_xfer_status' value). Save the number of bytes
8722 transferred in *XFERED_LEN. Only transfer a single packet. */
8725 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8726 ULONGEST len
, int unit_size
,
8727 ULONGEST
*xfered_len
)
8729 const char *packet_format
= NULL
;
8731 /* Check whether the target supports binary download. */
8732 check_binary_download (memaddr
);
8734 switch (packet_support (PACKET_X
))
8737 packet_format
= "X";
8739 case PACKET_DISABLE
:
8740 packet_format
= "M";
8742 case PACKET_SUPPORT_UNKNOWN
:
8743 internal_error (__FILE__
, __LINE__
,
8744 _("remote_write_bytes: bad internal state"));
8746 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8749 return remote_write_bytes_aux (packet_format
,
8750 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8751 packet_format
[0], 1);
8754 /* Read memory data directly from the remote machine.
8755 This does not use the data cache; the data cache uses this.
8756 MEMADDR is the address in the remote memory space.
8757 MYADDR is the address of the buffer in our space.
8758 LEN_UNITS is the number of addressable memory units to read..
8759 UNIT_SIZE is the length in bytes of an addressable unit.
8761 Return the transferred status, error or OK (an
8762 'enum target_xfer_status' value). Save the number of bytes
8763 transferred in *XFERED_LEN_UNITS.
8765 See the comment of remote_write_bytes_aux for an example of
8766 memory read/write exchange between gdb and the stub. */
8769 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8771 int unit_size
, ULONGEST
*xfered_len_units
)
8773 struct remote_state
*rs
= get_remote_state ();
8774 int buf_size_bytes
; /* Max size of packet output buffer. */
8779 buf_size_bytes
= get_memory_read_packet_size ();
8780 /* The packet buffer will be large enough for the payload;
8781 get_memory_packet_size ensures this. */
8783 /* Number of units that will fit. */
8784 todo_units
= std::min (len_units
,
8785 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8787 /* Construct "m"<memaddr>","<len>". */
8788 memaddr
= remote_address_masked (memaddr
);
8789 p
= rs
->buf
.data ();
8791 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8793 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8796 getpkt (&rs
->buf
, 0);
8797 if (rs
->buf
[0] == 'E'
8798 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8799 && rs
->buf
[3] == '\0')
8800 return TARGET_XFER_E_IO
;
8801 /* Reply describes memory byte by byte, each byte encoded as two hex
8803 p
= rs
->buf
.data ();
8804 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8805 /* Return what we have. Let higher layers handle partial reads. */
8806 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8807 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8810 /* Using the set of read-only target sections of remote, read live
8813 For interface/parameters/return description see target.h,
8817 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
8821 ULONGEST
*xfered_len
)
8823 struct target_section
*secp
;
8824 struct target_section_table
*table
;
8826 secp
= target_section_by_addr (this, memaddr
);
8828 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
8830 struct target_section
*p
;
8831 ULONGEST memend
= memaddr
+ len
;
8833 table
= target_get_section_table (this);
8835 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8837 if (memaddr
>= p
->addr
)
8839 if (memend
<= p
->endaddr
)
8841 /* Entire transfer is within this section. */
8842 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8845 else if (memaddr
>= p
->endaddr
)
8847 /* This section ends before the transfer starts. */
8852 /* This section overlaps the transfer. Just do half. */
8853 len
= p
->endaddr
- memaddr
;
8854 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8861 return TARGET_XFER_EOF
;
8864 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8865 first if the requested memory is unavailable in traceframe.
8866 Otherwise, fall back to remote_read_bytes_1. */
8869 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
8870 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8871 ULONGEST
*xfered_len
)
8874 return TARGET_XFER_EOF
;
8876 if (get_traceframe_number () != -1)
8878 std::vector
<mem_range
> available
;
8880 /* If we fail to get the set of available memory, then the
8881 target does not support querying traceframe info, and so we
8882 attempt reading from the traceframe anyway (assuming the
8883 target implements the old QTro packet then). */
8884 if (traceframe_available_memory (&available
, memaddr
, len
))
8886 if (available
.empty () || available
[0].start
!= memaddr
)
8888 enum target_xfer_status res
;
8890 /* Don't read into the traceframe's available
8892 if (!available
.empty ())
8894 LONGEST oldlen
= len
;
8896 len
= available
[0].start
- memaddr
;
8897 gdb_assert (len
<= oldlen
);
8900 /* This goes through the topmost target again. */
8901 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
8902 len
, unit_size
, xfered_len
);
8903 if (res
== TARGET_XFER_OK
)
8904 return TARGET_XFER_OK
;
8907 /* No use trying further, we know some memory starting
8908 at MEMADDR isn't available. */
8910 return (*xfered_len
!= 0) ?
8911 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
8915 /* Don't try to read more than how much is available, in
8916 case the target implements the deprecated QTro packet to
8917 cater for older GDBs (the target's knowledge of read-only
8918 sections may be outdated by now). */
8919 len
= available
[0].length
;
8923 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8928 /* Sends a packet with content determined by the printf format string
8929 FORMAT and the remaining arguments, then gets the reply. Returns
8930 whether the packet was a success, a failure, or unknown. */
8933 remote_target::remote_send_printf (const char *format
, ...)
8935 struct remote_state
*rs
= get_remote_state ();
8936 int max_size
= get_remote_packet_size ();
8939 va_start (ap
, format
);
8942 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
8946 if (size
>= max_size
)
8947 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8949 if (putpkt (rs
->buf
) < 0)
8950 error (_("Communication problem with target."));
8953 getpkt (&rs
->buf
, 0);
8955 return packet_check_result (rs
->buf
);
8958 /* Flash writing can take quite some time. We'll set
8959 effectively infinite timeout for flash operations.
8960 In future, we'll need to decide on a better approach. */
8961 static const int remote_flash_timeout
= 1000;
8964 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
8966 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8967 enum packet_result ret
;
8968 scoped_restore restore_timeout
8969 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8971 ret
= remote_send_printf ("vFlashErase:%s,%s",
8972 phex (address
, addr_size
),
8976 case PACKET_UNKNOWN
:
8977 error (_("Remote target does not support flash erase"));
8979 error (_("Error erasing flash with vFlashErase packet"));
8986 remote_target::remote_flash_write (ULONGEST address
,
8987 ULONGEST length
, ULONGEST
*xfered_len
,
8988 const gdb_byte
*data
)
8990 scoped_restore restore_timeout
8991 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8992 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8997 remote_target::flash_done ()
9001 scoped_restore restore_timeout
9002 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
9004 ret
= remote_send_printf ("vFlashDone");
9008 case PACKET_UNKNOWN
:
9009 error (_("Remote target does not support vFlashDone"));
9011 error (_("Error finishing flash operation"));
9018 remote_target::files_info ()
9020 puts_filtered ("Debugging a target over a serial line.\n");
9023 /* Stuff for dealing with the packets which are part of this protocol.
9024 See comment at top of file for details. */
9026 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
9027 error to higher layers. Called when a serial error is detected.
9028 The exception message is STRING, followed by a colon and a blank,
9029 the system error message for errno at function entry and final dot
9030 for output compatibility with throw_perror_with_name. */
9033 unpush_and_perror (remote_target
*target
, const char *string
)
9035 int saved_errno
= errno
;
9037 remote_unpush_target (target
);
9038 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
9039 safe_strerror (saved_errno
));
9042 /* Read a single character from the remote end. The current quit
9043 handler is overridden to avoid quitting in the middle of packet
9044 sequence, as that would break communication with the remote server.
9045 See remote_serial_quit_handler for more detail. */
9048 remote_target::readchar (int timeout
)
9051 struct remote_state
*rs
= get_remote_state ();
9054 scoped_restore restore_quit_target
9055 = make_scoped_restore (&curr_quit_handler_target
, this);
9056 scoped_restore restore_quit
9057 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9059 rs
->got_ctrlc_during_io
= 0;
9061 ch
= serial_readchar (rs
->remote_desc
, timeout
);
9063 if (rs
->got_ctrlc_during_io
)
9070 switch ((enum serial_rc
) ch
)
9073 remote_unpush_target (this);
9074 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9077 unpush_and_perror (this, _("Remote communication error. "
9078 "Target disconnected."));
9080 case SERIAL_TIMEOUT
:
9086 /* Wrapper for serial_write that closes the target and throws if
9087 writing fails. The current quit handler is overridden to avoid
9088 quitting in the middle of packet sequence, as that would break
9089 communication with the remote server. See
9090 remote_serial_quit_handler for more detail. */
9093 remote_target::remote_serial_write (const char *str
, int len
)
9095 struct remote_state
*rs
= get_remote_state ();
9097 scoped_restore restore_quit_target
9098 = make_scoped_restore (&curr_quit_handler_target
, this);
9099 scoped_restore restore_quit
9100 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9102 rs
->got_ctrlc_during_io
= 0;
9104 if (serial_write (rs
->remote_desc
, str
, len
))
9106 unpush_and_perror (this, _("Remote communication error. "
9107 "Target disconnected."));
9110 if (rs
->got_ctrlc_during_io
)
9114 /* Return a string representing an escaped version of BUF, of len N.
9115 E.g. \n is converted to \\n, \t to \\t, etc. */
9118 escape_buffer (const char *buf
, int n
)
9122 stb
.putstrn (buf
, n
, '\\');
9123 return std::move (stb
.string ());
9126 /* Display a null-terminated packet on stdout, for debugging, using C
9130 print_packet (const char *buf
)
9132 puts_filtered ("\"");
9133 fputstr_filtered (buf
, '"', gdb_stdout
);
9134 puts_filtered ("\"");
9138 remote_target::putpkt (const char *buf
)
9140 return putpkt_binary (buf
, strlen (buf
));
9143 /* Wrapper around remote_target::putpkt to avoid exporting
9147 putpkt (remote_target
*remote
, const char *buf
)
9149 return remote
->putpkt (buf
);
9152 /* Send a packet to the remote machine, with error checking. The data
9153 of the packet is in BUF. The string in BUF can be at most
9154 get_remote_packet_size () - 5 to account for the $, # and checksum,
9155 and for a possible /0 if we are debugging (remote_debug) and want
9156 to print the sent packet as a string. */
9159 remote_target::putpkt_binary (const char *buf
, int cnt
)
9161 struct remote_state
*rs
= get_remote_state ();
9163 unsigned char csum
= 0;
9164 gdb::def_vector
<char> data (cnt
+ 6);
9165 char *buf2
= data
.data ();
9171 /* Catch cases like trying to read memory or listing threads while
9172 we're waiting for a stop reply. The remote server wouldn't be
9173 ready to handle this request, so we'd hang and timeout. We don't
9174 have to worry about this in synchronous mode, because in that
9175 case it's not possible to issue a command while the target is
9176 running. This is not a problem in non-stop mode, because in that
9177 case, the stub is always ready to process serial input. */
9178 if (!target_is_non_stop_p ()
9179 && target_is_async_p ()
9180 && rs
->waiting_for_stop_reply
)
9182 error (_("Cannot execute this command while the target is running.\n"
9183 "Use the \"interrupt\" command to stop the target\n"
9184 "and then try again."));
9187 /* We're sending out a new packet. Make sure we don't look at a
9188 stale cached response. */
9189 rs
->cached_wait_status
= 0;
9191 /* Copy the packet into buffer BUF2, encapsulating it
9192 and giving it a checksum. */
9197 for (i
= 0; i
< cnt
; i
++)
9203 *p
++ = tohex ((csum
>> 4) & 0xf);
9204 *p
++ = tohex (csum
& 0xf);
9206 /* Send it over and over until we get a positive ack. */
9210 int started_error_output
= 0;
9216 int len
= (int) (p
- buf2
);
9219 if (remote_packet_max_chars
< 0)
9222 max_chars
= remote_packet_max_chars
;
9225 = escape_buffer (buf2
, std::min (len
, max_chars
));
9227 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9229 if (len
> max_chars
)
9230 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9233 fprintf_unfiltered (gdb_stdlog
, "...");
9235 gdb_flush (gdb_stdlog
);
9237 remote_serial_write (buf2
, p
- buf2
);
9239 /* If this is a no acks version of the remote protocol, send the
9240 packet and move on. */
9244 /* Read until either a timeout occurs (-2) or '+' is read.
9245 Handle any notification that arrives in the mean time. */
9248 ch
= readchar (remote_timeout
);
9256 case SERIAL_TIMEOUT
:
9259 if (started_error_output
)
9261 putchar_unfiltered ('\n');
9262 started_error_output
= 0;
9271 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9275 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9277 case SERIAL_TIMEOUT
:
9281 break; /* Retransmit buffer. */
9285 fprintf_unfiltered (gdb_stdlog
,
9286 "Packet instead of Ack, ignoring it\n");
9287 /* It's probably an old response sent because an ACK
9288 was lost. Gobble up the packet and ack it so it
9289 doesn't get retransmitted when we resend this
9292 remote_serial_write ("+", 1);
9293 continue; /* Now, go look for +. */
9300 /* If we got a notification, handle it, and go back to looking
9302 /* We've found the start of a notification. Now
9303 collect the data. */
9304 val
= read_frame (&rs
->buf
);
9309 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9311 fprintf_unfiltered (gdb_stdlog
,
9312 " Notification received: %s\n",
9315 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9316 /* We're in sync now, rewait for the ack. */
9323 if (!started_error_output
)
9325 started_error_output
= 1;
9326 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9328 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9329 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9338 if (!started_error_output
)
9340 started_error_output
= 1;
9341 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9343 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9347 break; /* Here to retransmit. */
9351 /* This is wrong. If doing a long backtrace, the user should be
9352 able to get out next time we call QUIT, without anything as
9353 violent as interrupt_query. If we want to provide a way out of
9354 here without getting to the next QUIT, it should be based on
9355 hitting ^C twice as in remote_wait. */
9367 /* Come here after finding the start of a frame when we expected an
9368 ack. Do our best to discard the rest of this packet. */
9371 remote_target::skip_frame ()
9377 c
= readchar (remote_timeout
);
9380 case SERIAL_TIMEOUT
:
9381 /* Nothing we can do. */
9384 /* Discard the two bytes of checksum and stop. */
9385 c
= readchar (remote_timeout
);
9387 c
= readchar (remote_timeout
);
9390 case '*': /* Run length encoding. */
9391 /* Discard the repeat count. */
9392 c
= readchar (remote_timeout
);
9397 /* A regular character. */
9403 /* Come here after finding the start of the frame. Collect the rest
9404 into *BUF, verifying the checksum, length, and handling run-length
9405 compression. NUL terminate the buffer. If there is not enough room,
9408 Returns -1 on error, number of characters in buffer (ignoring the
9409 trailing NULL) on success. (could be extended to return one of the
9410 SERIAL status indications). */
9413 remote_target::read_frame (gdb::char_vector
*buf_p
)
9418 char *buf
= buf_p
->data ();
9419 struct remote_state
*rs
= get_remote_state ();
9426 c
= readchar (remote_timeout
);
9429 case SERIAL_TIMEOUT
:
9431 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9435 fputs_filtered ("Saw new packet start in middle of old one\n",
9437 return -1; /* Start a new packet, count retries. */
9440 unsigned char pktcsum
;
9446 check_0
= readchar (remote_timeout
);
9448 check_1
= readchar (remote_timeout
);
9450 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9453 fputs_filtered ("Timeout in checksum, retrying\n",
9457 else if (check_0
< 0 || check_1
< 0)
9460 fputs_filtered ("Communication error in checksum\n",
9465 /* Don't recompute the checksum; with no ack packets we
9466 don't have any way to indicate a packet retransmission
9471 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9472 if (csum
== pktcsum
)
9477 std::string str
= escape_buffer (buf
, bc
);
9479 fprintf_unfiltered (gdb_stdlog
,
9480 "Bad checksum, sentsum=0x%x, "
9481 "csum=0x%x, buf=%s\n",
9482 pktcsum
, csum
, str
.c_str ());
9484 /* Number of characters in buffer ignoring trailing
9488 case '*': /* Run length encoding. */
9493 c
= readchar (remote_timeout
);
9495 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9497 /* The character before ``*'' is repeated. */
9499 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9501 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9503 /* Make some more room in the buffer. */
9504 buf_p
->resize (buf_p
->size () + repeat
);
9505 buf
= buf_p
->data ();
9508 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9514 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9518 if (bc
>= buf_p
->size () - 1)
9520 /* Make some more room in the buffer. */
9521 buf_p
->resize (buf_p
->size () * 2);
9522 buf
= buf_p
->data ();
9532 /* Set this to the maximum number of seconds to wait instead of waiting forever
9533 in target_wait(). If this timer times out, then it generates an error and
9534 the command is aborted. This replaces most of the need for timeouts in the
9535 GDB test suite, and makes it possible to distinguish between a hung target
9536 and one with slow communications. */
9538 static int watchdog
= 0;
9540 show_watchdog (struct ui_file
*file
, int from_tty
,
9541 struct cmd_list_element
*c
, const char *value
)
9543 fprintf_filtered (file
, _("Watchdog timer is %s.\n"), value
);
9546 /* Read a packet from the remote machine, with error checking, and
9547 store it in *BUF. Resize *BUF if necessary to hold the result. If
9548 FOREVER, wait forever rather than timing out; this is used (in
9549 synchronous mode) to wait for a target that is is executing user
9551 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9552 don't have to change all the calls to getpkt to deal with the
9553 return value, because at the moment I don't know what the right
9554 thing to do it for those. */
9557 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9559 getpkt_sane (buf
, forever
);
9563 /* Read a packet from the remote machine, with error checking, and
9564 store it in *BUF. Resize *BUF if necessary to hold the result. If
9565 FOREVER, wait forever rather than timing out; this is used (in
9566 synchronous mode) to wait for a target that is is executing user
9567 code to stop. If FOREVER == 0, this function is allowed to time
9568 out gracefully and return an indication of this to the caller.
9569 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9570 consider receiving a notification enough reason to return to the
9571 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9572 holds a notification or not (a regular packet). */
9575 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9576 int forever
, int expecting_notif
,
9579 struct remote_state
*rs
= get_remote_state ();
9585 /* We're reading a new response. Make sure we don't look at a
9586 previously cached response. */
9587 rs
->cached_wait_status
= 0;
9589 strcpy (buf
->data (), "timeout");
9592 timeout
= watchdog
> 0 ? watchdog
: -1;
9593 else if (expecting_notif
)
9594 timeout
= 0; /* There should already be a char in the buffer. If
9597 timeout
= remote_timeout
;
9601 /* Process any number of notifications, and then return when
9605 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9607 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9609 /* This can loop forever if the remote side sends us
9610 characters continuously, but if it pauses, we'll get
9611 SERIAL_TIMEOUT from readchar because of timeout. Then
9612 we'll count that as a retry.
9614 Note that even when forever is set, we will only wait
9615 forever prior to the start of a packet. After that, we
9616 expect characters to arrive at a brisk pace. They should
9617 show up within remote_timeout intervals. */
9619 c
= readchar (timeout
);
9620 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9622 if (c
== SERIAL_TIMEOUT
)
9624 if (expecting_notif
)
9625 return -1; /* Don't complain, it's normal to not get
9626 anything in this case. */
9628 if (forever
) /* Watchdog went off? Kill the target. */
9630 remote_unpush_target (this);
9631 throw_error (TARGET_CLOSE_ERROR
,
9632 _("Watchdog timeout has expired. "
9633 "Target detached."));
9636 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9640 /* We've found the start of a packet or notification.
9641 Now collect the data. */
9642 val
= read_frame (buf
);
9647 remote_serial_write ("-", 1);
9650 if (tries
> MAX_TRIES
)
9652 /* We have tried hard enough, and just can't receive the
9653 packet/notification. Give up. */
9654 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9656 /* Skip the ack char if we're in no-ack mode. */
9657 if (!rs
->noack_mode
)
9658 remote_serial_write ("+", 1);
9662 /* If we got an ordinary packet, return that to our caller. */
9669 if (remote_packet_max_chars
< 0)
9672 max_chars
= remote_packet_max_chars
;
9675 = escape_buffer (buf
->data (),
9676 std::min (val
, max_chars
));
9678 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9681 if (val
> max_chars
)
9682 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9685 fprintf_unfiltered (gdb_stdlog
, "\n");
9688 /* Skip the ack char if we're in no-ack mode. */
9689 if (!rs
->noack_mode
)
9690 remote_serial_write ("+", 1);
9691 if (is_notif
!= NULL
)
9696 /* If we got a notification, handle it, and go back to looking
9700 gdb_assert (c
== '%');
9704 std::string str
= escape_buffer (buf
->data (), val
);
9706 fprintf_unfiltered (gdb_stdlog
,
9707 " Notification received: %s\n",
9710 if (is_notif
!= NULL
)
9713 handle_notification (rs
->notif_state
, buf
->data ());
9715 /* Notifications require no acknowledgement. */
9717 if (expecting_notif
)
9724 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9726 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9730 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9733 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9736 /* Kill any new fork children of process PID that haven't been
9737 processed by follow_fork. */
9740 remote_target::kill_new_fork_children (int pid
)
9742 remote_state
*rs
= get_remote_state ();
9743 struct notif_client
*notif
= ¬if_client_stop
;
9745 /* Kill the fork child threads of any threads in process PID
9746 that are stopped at a fork event. */
9747 for (thread_info
*thread
: all_non_exited_threads (this))
9749 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9751 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9753 int child_pid
= ws
->value
.related_pid
.pid ();
9756 res
= remote_vkill (child_pid
);
9758 error (_("Can't kill fork child process %d"), child_pid
);
9762 /* Check for any pending fork events (not reported or processed yet)
9763 in process PID and kill those fork child threads as well. */
9764 remote_notif_get_pending_events (notif
);
9765 for (auto &event
: rs
->stop_reply_queue
)
9766 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9768 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9771 res
= remote_vkill (child_pid
);
9773 error (_("Can't kill fork child process %d"), child_pid
);
9778 /* Target hook to kill the current inferior. */
9781 remote_target::kill ()
9784 int pid
= inferior_ptid
.pid ();
9785 struct remote_state
*rs
= get_remote_state ();
9787 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9789 /* If we're stopped while forking and we haven't followed yet,
9790 kill the child task. We need to do this before killing the
9791 parent task because if this is a vfork then the parent will
9793 kill_new_fork_children (pid
);
9795 res
= remote_vkill (pid
);
9798 target_mourn_inferior (inferior_ptid
);
9803 /* If we are in 'target remote' mode and we are killing the only
9804 inferior, then we will tell gdbserver to exit and unpush the
9806 if (res
== -1 && !remote_multi_process_p (rs
)
9807 && number_of_live_inferiors (this) == 1)
9811 /* We've killed the remote end, we get to mourn it. If we are
9812 not in extended mode, mourning the inferior also unpushes
9813 remote_ops from the target stack, which closes the remote
9815 target_mourn_inferior (inferior_ptid
);
9820 error (_("Can't kill process"));
9823 /* Send a kill request to the target using the 'vKill' packet. */
9826 remote_target::remote_vkill (int pid
)
9828 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9831 remote_state
*rs
= get_remote_state ();
9833 /* Tell the remote target to detach. */
9834 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
9836 getpkt (&rs
->buf
, 0);
9838 switch (packet_ok (rs
->buf
,
9839 &remote_protocol_packets
[PACKET_vKill
]))
9845 case PACKET_UNKNOWN
:
9848 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9852 /* Send a kill request to the target using the 'k' packet. */
9855 remote_target::remote_kill_k ()
9857 /* Catch errors so the user can quit from gdb even when we
9858 aren't on speaking terms with the remote system. */
9863 catch (const gdb_exception_error
&ex
)
9865 if (ex
.error
== TARGET_CLOSE_ERROR
)
9867 /* If we got an (EOF) error that caused the target
9868 to go away, then we're done, that's what we wanted.
9869 "k" is susceptible to cause a premature EOF, given
9870 that the remote server isn't actually required to
9871 reply to "k", and it can happen that it doesn't
9872 even get to reply ACK to the "k". */
9876 /* Otherwise, something went wrong. We didn't actually kill
9877 the target. Just propagate the exception, and let the
9878 user or higher layers decide what to do. */
9884 remote_target::mourn_inferior ()
9886 struct remote_state
*rs
= get_remote_state ();
9888 /* We're no longer interested in notification events of an inferior
9889 that exited or was killed/detached. */
9890 discard_pending_stop_replies (current_inferior ());
9892 /* In 'target remote' mode with one inferior, we close the connection. */
9893 if (!rs
->extended
&& number_of_live_inferiors (this) <= 1)
9895 remote_unpush_target (this);
9899 /* In case we got here due to an error, but we're going to stay
9901 rs
->waiting_for_stop_reply
= 0;
9903 /* If the current general thread belonged to the process we just
9904 detached from or has exited, the remote side current general
9905 thread becomes undefined. Considering a case like this:
9907 - We just got here due to a detach.
9908 - The process that we're detaching from happens to immediately
9909 report a global breakpoint being hit in non-stop mode, in the
9910 same thread we had selected before.
9911 - GDB attaches to this process again.
9912 - This event happens to be the next event we handle.
9914 GDB would consider that the current general thread didn't need to
9915 be set on the stub side (with Hg), since for all it knew,
9916 GENERAL_THREAD hadn't changed.
9918 Notice that although in all-stop mode, the remote server always
9919 sets the current thread to the thread reporting the stop event,
9920 that doesn't happen in non-stop mode; in non-stop, the stub *must
9921 not* change the current thread when reporting a breakpoint hit,
9922 due to the decoupling of event reporting and event handling.
9924 To keep things simple, we always invalidate our notion of the
9926 record_currthread (rs
, minus_one_ptid
);
9928 /* Call common code to mark the inferior as not running. */
9929 generic_mourn_inferior ();
9933 extended_remote_target::supports_disable_randomization ()
9935 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9939 remote_target::extended_remote_disable_randomization (int val
)
9941 struct remote_state
*rs
= get_remote_state ();
9944 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9945 "QDisableRandomization:%x", val
);
9947 reply
= remote_get_noisy_reply ();
9949 error (_("Target does not support QDisableRandomization."));
9950 if (strcmp (reply
, "OK") != 0)
9951 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9955 remote_target::extended_remote_run (const std::string
&args
)
9957 struct remote_state
*rs
= get_remote_state ();
9959 const char *remote_exec_file
= get_remote_exec_file ();
9961 /* If the user has disabled vRun support, or we have detected that
9962 support is not available, do not try it. */
9963 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9966 strcpy (rs
->buf
.data (), "vRun;");
9967 len
= strlen (rs
->buf
.data ());
9969 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9970 error (_("Remote file name too long for run packet"));
9971 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
9972 strlen (remote_exec_file
));
9978 gdb_argv
argv (args
.c_str ());
9979 for (i
= 0; argv
[i
] != NULL
; i
++)
9981 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9982 error (_("Argument list too long for run packet"));
9983 rs
->buf
[len
++] = ';';
9984 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
9989 rs
->buf
[len
++] = '\0';
9992 getpkt (&rs
->buf
, 0);
9994 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9997 /* We have a wait response. All is well. */
9999 case PACKET_UNKNOWN
:
10002 if (remote_exec_file
[0] == '\0')
10003 error (_("Running the default executable on the remote target failed; "
10004 "try \"set remote exec-file\"?"));
10006 error (_("Running \"%s\" on the remote target failed"),
10009 gdb_assert_not_reached (_("bad switch"));
10013 /* Helper function to send set/unset environment packets. ACTION is
10014 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
10015 or "QEnvironmentUnsetVariable". VALUE is the variable to be
10019 remote_target::send_environment_packet (const char *action
,
10020 const char *packet
,
10023 remote_state
*rs
= get_remote_state ();
10025 /* Convert the environment variable to an hex string, which
10026 is the best format to be transmitted over the wire. */
10027 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
10030 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10031 "%s:%s", packet
, encoded_value
.c_str ());
10034 getpkt (&rs
->buf
, 0);
10035 if (strcmp (rs
->buf
.data (), "OK") != 0)
10036 warning (_("Unable to %s environment variable '%s' on remote."),
10040 /* Helper function to handle the QEnvironment* packets. */
10043 remote_target::extended_remote_environment_support ()
10045 remote_state
*rs
= get_remote_state ();
10047 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
10049 putpkt ("QEnvironmentReset");
10050 getpkt (&rs
->buf
, 0);
10051 if (strcmp (rs
->buf
.data (), "OK") != 0)
10052 warning (_("Unable to reset environment on remote."));
10055 gdb_environ
*e
= ¤t_inferior ()->environment
;
10057 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
10058 for (const std::string
&el
: e
->user_set_env ())
10059 send_environment_packet ("set", "QEnvironmentHexEncoded",
10062 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
10063 for (const std::string
&el
: e
->user_unset_env ())
10064 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
10067 /* Helper function to set the current working directory for the
10068 inferior in the remote target. */
10071 remote_target::extended_remote_set_inferior_cwd ()
10073 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10075 const char *inferior_cwd
= get_inferior_cwd ();
10076 remote_state
*rs
= get_remote_state ();
10078 if (inferior_cwd
!= NULL
)
10080 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10081 strlen (inferior_cwd
));
10083 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10084 "QSetWorkingDir:%s", hexpath
.c_str ());
10088 /* An empty inferior_cwd means that the user wants us to
10089 reset the remote server's inferior's cwd. */
10090 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10091 "QSetWorkingDir:");
10095 getpkt (&rs
->buf
, 0);
10096 if (packet_ok (rs
->buf
,
10097 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10100 Remote replied unexpectedly while setting the inferior's working\n\
10107 /* In the extended protocol we want to be able to do things like
10108 "run" and have them basically work as expected. So we need
10109 a special create_inferior function. We support changing the
10110 executable file and the command line arguments, but not the
10114 extended_remote_target::create_inferior (const char *exec_file
,
10115 const std::string
&args
,
10116 char **env
, int from_tty
)
10120 struct remote_state
*rs
= get_remote_state ();
10121 const char *remote_exec_file
= get_remote_exec_file ();
10123 /* If running asynchronously, register the target file descriptor
10124 with the event loop. */
10125 if (target_can_async_p ())
10128 /* Disable address space randomization if requested (and supported). */
10129 if (supports_disable_randomization ())
10130 extended_remote_disable_randomization (disable_randomization
);
10132 /* If startup-with-shell is on, we inform gdbserver to start the
10133 remote inferior using a shell. */
10134 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10136 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10137 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10139 getpkt (&rs
->buf
, 0);
10140 if (strcmp (rs
->buf
.data (), "OK") != 0)
10142 Remote replied unexpectedly while setting startup-with-shell: %s"),
10146 extended_remote_environment_support ();
10148 extended_remote_set_inferior_cwd ();
10150 /* Now restart the remote server. */
10151 run_worked
= extended_remote_run (args
) != -1;
10154 /* vRun was not supported. Fail if we need it to do what the
10156 if (remote_exec_file
[0])
10157 error (_("Remote target does not support \"set remote exec-file\""));
10158 if (!args
.empty ())
10159 error (_("Remote target does not support \"set args\" or run ARGS"));
10161 /* Fall back to "R". */
10162 extended_remote_restart ();
10165 /* vRun's success return is a stop reply. */
10166 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10167 add_current_inferior_and_thread (stop_reply
);
10169 /* Get updated offsets, if the stub uses qOffsets. */
10174 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10175 the list of conditions (in agent expression bytecode format), if any, the
10176 target needs to evaluate. The output is placed into the packet buffer
10177 started from BUF and ended at BUF_END. */
10180 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10181 struct bp_target_info
*bp_tgt
, char *buf
,
10184 if (bp_tgt
->conditions
.empty ())
10187 buf
+= strlen (buf
);
10188 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10191 /* Send conditions to the target. */
10192 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10194 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10195 buf
+= strlen (buf
);
10196 for (int i
= 0; i
< aexpr
->len
; ++i
)
10197 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10204 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10205 struct bp_target_info
*bp_tgt
, char *buf
)
10207 if (bp_tgt
->tcommands
.empty ())
10210 buf
+= strlen (buf
);
10212 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10213 buf
+= strlen (buf
);
10215 /* Concatenate all the agent expressions that are commands into the
10217 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10219 sprintf (buf
, "X%x,", aexpr
->len
);
10220 buf
+= strlen (buf
);
10221 for (int i
= 0; i
< aexpr
->len
; ++i
)
10222 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10227 /* Insert a breakpoint. On targets that have software breakpoint
10228 support, we ask the remote target to do the work; on targets
10229 which don't, we insert a traditional memory breakpoint. */
10232 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10233 struct bp_target_info
*bp_tgt
)
10235 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10236 If it succeeds, then set the support to PACKET_ENABLE. If it
10237 fails, and the user has explicitly requested the Z support then
10238 report an error, otherwise, mark it disabled and go on. */
10240 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10242 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10243 struct remote_state
*rs
;
10246 /* Make sure the remote is pointing at the right process, if
10248 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10249 set_general_process ();
10251 rs
= get_remote_state ();
10252 p
= rs
->buf
.data ();
10253 endbuf
= p
+ get_remote_packet_size ();
10258 addr
= (ULONGEST
) remote_address_masked (addr
);
10259 p
+= hexnumstr (p
, addr
);
10260 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10262 if (supports_evaluation_of_breakpoint_conditions ())
10263 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10265 if (can_run_breakpoint_commands ())
10266 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10269 getpkt (&rs
->buf
, 0);
10271 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10277 case PACKET_UNKNOWN
:
10282 /* If this breakpoint has target-side commands but this stub doesn't
10283 support Z0 packets, throw error. */
10284 if (!bp_tgt
->tcommands
.empty ())
10285 throw_error (NOT_SUPPORTED_ERROR
, _("\
10286 Target doesn't support breakpoints that have target side commands."));
10288 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10292 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10293 struct bp_target_info
*bp_tgt
,
10294 enum remove_bp_reason reason
)
10296 CORE_ADDR addr
= bp_tgt
->placed_address
;
10297 struct remote_state
*rs
= get_remote_state ();
10299 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10301 char *p
= rs
->buf
.data ();
10302 char *endbuf
= p
+ get_remote_packet_size ();
10304 /* Make sure the remote is pointing at the right process, if
10306 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10307 set_general_process ();
10313 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10314 p
+= hexnumstr (p
, addr
);
10315 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10318 getpkt (&rs
->buf
, 0);
10320 return (rs
->buf
[0] == 'E');
10323 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10326 static enum Z_packet_type
10327 watchpoint_to_Z_packet (int type
)
10332 return Z_PACKET_WRITE_WP
;
10335 return Z_PACKET_READ_WP
;
10338 return Z_PACKET_ACCESS_WP
;
10341 internal_error (__FILE__
, __LINE__
,
10342 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10347 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10348 enum target_hw_bp_type type
, struct expression
*cond
)
10350 struct remote_state
*rs
= get_remote_state ();
10351 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10353 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10355 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10358 /* Make sure the remote is pointing at the right process, if
10360 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10361 set_general_process ();
10363 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10364 p
= strchr (rs
->buf
.data (), '\0');
10365 addr
= remote_address_masked (addr
);
10366 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10367 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10370 getpkt (&rs
->buf
, 0);
10372 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10376 case PACKET_UNKNOWN
:
10381 internal_error (__FILE__
, __LINE__
,
10382 _("remote_insert_watchpoint: reached end of function"));
10386 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10387 CORE_ADDR start
, int length
)
10389 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10391 return diff
< length
;
10396 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10397 enum target_hw_bp_type type
, struct expression
*cond
)
10399 struct remote_state
*rs
= get_remote_state ();
10400 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10402 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10404 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10407 /* Make sure the remote is pointing at the right process, if
10409 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10410 set_general_process ();
10412 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10413 p
= strchr (rs
->buf
.data (), '\0');
10414 addr
= remote_address_masked (addr
);
10415 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10416 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10418 getpkt (&rs
->buf
, 0);
10420 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10423 case PACKET_UNKNOWN
:
10428 internal_error (__FILE__
, __LINE__
,
10429 _("remote_remove_watchpoint: reached end of function"));
10433 static int remote_hw_watchpoint_limit
= -1;
10434 static int remote_hw_watchpoint_length_limit
= -1;
10435 static int remote_hw_breakpoint_limit
= -1;
10438 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10440 if (remote_hw_watchpoint_length_limit
== 0)
10442 else if (remote_hw_watchpoint_length_limit
< 0)
10444 else if (len
<= remote_hw_watchpoint_length_limit
)
10451 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10453 if (type
== bp_hardware_breakpoint
)
10455 if (remote_hw_breakpoint_limit
== 0)
10457 else if (remote_hw_breakpoint_limit
< 0)
10459 else if (cnt
<= remote_hw_breakpoint_limit
)
10464 if (remote_hw_watchpoint_limit
== 0)
10466 else if (remote_hw_watchpoint_limit
< 0)
10470 else if (cnt
<= remote_hw_watchpoint_limit
)
10476 /* The to_stopped_by_sw_breakpoint method of target remote. */
10479 remote_target::stopped_by_sw_breakpoint ()
10481 struct thread_info
*thread
= inferior_thread ();
10483 return (thread
->priv
!= NULL
10484 && (get_remote_thread_info (thread
)->stop_reason
10485 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10488 /* The to_supports_stopped_by_sw_breakpoint method of target
10492 remote_target::supports_stopped_by_sw_breakpoint ()
10494 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10497 /* The to_stopped_by_hw_breakpoint method of target remote. */
10500 remote_target::stopped_by_hw_breakpoint ()
10502 struct thread_info
*thread
= inferior_thread ();
10504 return (thread
->priv
!= NULL
10505 && (get_remote_thread_info (thread
)->stop_reason
10506 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10509 /* The to_supports_stopped_by_hw_breakpoint method of target
10513 remote_target::supports_stopped_by_hw_breakpoint ()
10515 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10519 remote_target::stopped_by_watchpoint ()
10521 struct thread_info
*thread
= inferior_thread ();
10523 return (thread
->priv
!= NULL
10524 && (get_remote_thread_info (thread
)->stop_reason
10525 == TARGET_STOPPED_BY_WATCHPOINT
));
10529 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10531 struct thread_info
*thread
= inferior_thread ();
10533 if (thread
->priv
!= NULL
10534 && (get_remote_thread_info (thread
)->stop_reason
10535 == TARGET_STOPPED_BY_WATCHPOINT
))
10537 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10546 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10547 struct bp_target_info
*bp_tgt
)
10549 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10550 struct remote_state
*rs
;
10554 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10557 /* Make sure the remote is pointing at the right process, if
10559 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10560 set_general_process ();
10562 rs
= get_remote_state ();
10563 p
= rs
->buf
.data ();
10564 endbuf
= p
+ get_remote_packet_size ();
10570 addr
= remote_address_masked (addr
);
10571 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10572 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10574 if (supports_evaluation_of_breakpoint_conditions ())
10575 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10577 if (can_run_breakpoint_commands ())
10578 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10581 getpkt (&rs
->buf
, 0);
10583 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10586 if (rs
->buf
[1] == '.')
10588 message
= strchr (&rs
->buf
[2], '.');
10590 error (_("Remote failure reply: %s"), message
+ 1);
10593 case PACKET_UNKNOWN
:
10598 internal_error (__FILE__
, __LINE__
,
10599 _("remote_insert_hw_breakpoint: reached end of function"));
10604 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10605 struct bp_target_info
*bp_tgt
)
10608 struct remote_state
*rs
= get_remote_state ();
10609 char *p
= rs
->buf
.data ();
10610 char *endbuf
= p
+ get_remote_packet_size ();
10612 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10615 /* Make sure the remote is pointing at the right process, if
10617 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10618 set_general_process ();
10624 addr
= remote_address_masked (bp_tgt
->placed_address
);
10625 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10626 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10629 getpkt (&rs
->buf
, 0);
10631 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10634 case PACKET_UNKNOWN
:
10639 internal_error (__FILE__
, __LINE__
,
10640 _("remote_remove_hw_breakpoint: reached end of function"));
10643 /* Verify memory using the "qCRC:" request. */
10646 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10648 struct remote_state
*rs
= get_remote_state ();
10649 unsigned long host_crc
, target_crc
;
10652 /* It doesn't make sense to use qCRC if the remote target is
10653 connected but not running. */
10654 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10656 enum packet_result result
;
10658 /* Make sure the remote is pointing at the right process. */
10659 set_general_process ();
10661 /* FIXME: assumes lma can fit into long. */
10662 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10663 (long) lma
, (long) size
);
10666 /* Be clever; compute the host_crc before waiting for target
10668 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10670 getpkt (&rs
->buf
, 0);
10672 result
= packet_ok (rs
->buf
,
10673 &remote_protocol_packets
[PACKET_qCRC
]);
10674 if (result
== PACKET_ERROR
)
10676 else if (result
== PACKET_OK
)
10678 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10679 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10681 return (host_crc
== target_crc
);
10685 return simple_verify_memory (this, data
, lma
, size
);
10688 /* compare-sections command
10690 With no arguments, compares each loadable section in the exec bfd
10691 with the same memory range on the target, and reports mismatches.
10692 Useful for verifying the image on the target against the exec file. */
10695 compare_sections_command (const char *args
, int from_tty
)
10698 const char *sectname
;
10699 bfd_size_type size
;
10702 int mismatched
= 0;
10707 error (_("command cannot be used without an exec file"));
10709 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10715 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10717 if (!(s
->flags
& SEC_LOAD
))
10718 continue; /* Skip non-loadable section. */
10720 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10721 continue; /* Skip writeable sections */
10723 size
= bfd_section_size (s
);
10725 continue; /* Skip zero-length section. */
10727 sectname
= bfd_section_name (s
);
10728 if (args
&& strcmp (args
, sectname
) != 0)
10729 continue; /* Not the section selected by user. */
10731 matched
= 1; /* Do this section. */
10734 gdb::byte_vector
sectdata (size
);
10735 bfd_get_section_contents (exec_bfd
, s
, sectdata
.data (), 0, size
);
10737 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10740 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10741 paddress (target_gdbarch (), lma
),
10742 paddress (target_gdbarch (), lma
+ size
));
10744 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10745 paddress (target_gdbarch (), lma
),
10746 paddress (target_gdbarch (), lma
+ size
));
10748 printf_filtered ("matched.\n");
10751 printf_filtered ("MIS-MATCHED!\n");
10755 if (mismatched
> 0)
10756 warning (_("One or more sections of the target image does not match\n\
10757 the loaded file\n"));
10758 if (args
&& !matched
)
10759 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10762 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10763 into remote target. The number of bytes written to the remote
10764 target is returned, or -1 for error. */
10767 remote_target::remote_write_qxfer (const char *object_name
,
10768 const char *annex
, const gdb_byte
*writebuf
,
10769 ULONGEST offset
, LONGEST len
,
10770 ULONGEST
*xfered_len
,
10771 struct packet_config
*packet
)
10775 struct remote_state
*rs
= get_remote_state ();
10776 int max_size
= get_memory_write_packet_size ();
10778 if (packet_config_support (packet
) == PACKET_DISABLE
)
10779 return TARGET_XFER_E_IO
;
10781 /* Insert header. */
10782 i
= snprintf (rs
->buf
.data (), max_size
,
10783 "qXfer:%s:write:%s:%s:",
10784 object_name
, annex
? annex
: "",
10785 phex_nz (offset
, sizeof offset
));
10786 max_size
-= (i
+ 1);
10788 /* Escape as much data as fits into rs->buf. */
10789 buf_len
= remote_escape_output
10790 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10792 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10793 || getpkt_sane (&rs
->buf
, 0) < 0
10794 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10795 return TARGET_XFER_E_IO
;
10797 unpack_varlen_hex (rs
->buf
.data (), &n
);
10800 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10803 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10804 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10805 number of bytes read is returned, or 0 for EOF, or -1 for error.
10806 The number of bytes read may be less than LEN without indicating an
10807 EOF. PACKET is checked and updated to indicate whether the remote
10808 target supports this object. */
10811 remote_target::remote_read_qxfer (const char *object_name
,
10813 gdb_byte
*readbuf
, ULONGEST offset
,
10815 ULONGEST
*xfered_len
,
10816 struct packet_config
*packet
)
10818 struct remote_state
*rs
= get_remote_state ();
10819 LONGEST i
, n
, packet_len
;
10821 if (packet_config_support (packet
) == PACKET_DISABLE
)
10822 return TARGET_XFER_E_IO
;
10824 /* Check whether we've cached an end-of-object packet that matches
10826 if (rs
->finished_object
)
10828 if (strcmp (object_name
, rs
->finished_object
) == 0
10829 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10830 && offset
== rs
->finished_offset
)
10831 return TARGET_XFER_EOF
;
10834 /* Otherwise, we're now reading something different. Discard
10836 xfree (rs
->finished_object
);
10837 xfree (rs
->finished_annex
);
10838 rs
->finished_object
= NULL
;
10839 rs
->finished_annex
= NULL
;
10842 /* Request only enough to fit in a single packet. The actual data
10843 may not, since we don't know how much of it will need to be escaped;
10844 the target is free to respond with slightly less data. We subtract
10845 five to account for the response type and the protocol frame. */
10846 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10847 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
10848 "qXfer:%s:read:%s:%s,%s",
10849 object_name
, annex
? annex
: "",
10850 phex_nz (offset
, sizeof offset
),
10851 phex_nz (n
, sizeof n
));
10852 i
= putpkt (rs
->buf
);
10854 return TARGET_XFER_E_IO
;
10857 packet_len
= getpkt_sane (&rs
->buf
, 0);
10858 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10859 return TARGET_XFER_E_IO
;
10861 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10862 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
10864 /* 'm' means there is (or at least might be) more data after this
10865 batch. That does not make sense unless there's at least one byte
10866 of data in this reply. */
10867 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10868 error (_("Remote qXfer reply contained no data."));
10870 /* Got some data. */
10871 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
10872 packet_len
- 1, readbuf
, n
);
10874 /* 'l' is an EOF marker, possibly including a final block of data,
10875 or possibly empty. If we have the final block of a non-empty
10876 object, record this fact to bypass a subsequent partial read. */
10877 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10879 rs
->finished_object
= xstrdup (object_name
);
10880 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10881 rs
->finished_offset
= offset
+ i
;
10885 return TARGET_XFER_EOF
;
10889 return TARGET_XFER_OK
;
10893 enum target_xfer_status
10894 remote_target::xfer_partial (enum target_object object
,
10895 const char *annex
, gdb_byte
*readbuf
,
10896 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10897 ULONGEST
*xfered_len
)
10899 struct remote_state
*rs
;
10903 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10905 set_remote_traceframe ();
10906 set_general_thread (inferior_ptid
);
10908 rs
= get_remote_state ();
10910 /* Handle memory using the standard memory routines. */
10911 if (object
== TARGET_OBJECT_MEMORY
)
10913 /* If the remote target is connected but not running, we should
10914 pass this request down to a lower stratum (e.g. the executable
10916 if (!target_has_execution
)
10917 return TARGET_XFER_EOF
;
10919 if (writebuf
!= NULL
)
10920 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10923 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
10927 /* Handle extra signal info using qxfer packets. */
10928 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10931 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
10932 xfered_len
, &remote_protocol_packets
10933 [PACKET_qXfer_siginfo_read
]);
10935 return remote_write_qxfer ("siginfo", annex
,
10936 writebuf
, offset
, len
, xfered_len
,
10937 &remote_protocol_packets
10938 [PACKET_qXfer_siginfo_write
]);
10941 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10944 return remote_read_qxfer ("statictrace", annex
,
10945 readbuf
, offset
, len
, xfered_len
,
10946 &remote_protocol_packets
10947 [PACKET_qXfer_statictrace_read
]);
10949 return TARGET_XFER_E_IO
;
10952 /* Only handle flash writes. */
10953 if (writebuf
!= NULL
)
10957 case TARGET_OBJECT_FLASH
:
10958 return remote_flash_write (offset
, len
, xfered_len
,
10962 return TARGET_XFER_E_IO
;
10966 /* Map pre-existing objects onto letters. DO NOT do this for new
10967 objects!!! Instead specify new query packets. */
10970 case TARGET_OBJECT_AVR
:
10974 case TARGET_OBJECT_AUXV
:
10975 gdb_assert (annex
== NULL
);
10976 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
10978 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10980 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10981 return remote_read_qxfer
10982 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
10983 &remote_protocol_packets
[PACKET_qXfer_features
]);
10985 case TARGET_OBJECT_LIBRARIES
:
10986 return remote_read_qxfer
10987 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10988 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10990 case TARGET_OBJECT_LIBRARIES_SVR4
:
10991 return remote_read_qxfer
10992 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10993 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10995 case TARGET_OBJECT_MEMORY_MAP
:
10996 gdb_assert (annex
== NULL
);
10997 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
10999 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
11001 case TARGET_OBJECT_OSDATA
:
11002 /* Should only get here if we're connected. */
11003 gdb_assert (rs
->remote_desc
);
11004 return remote_read_qxfer
11005 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
11006 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
11008 case TARGET_OBJECT_THREADS
:
11009 gdb_assert (annex
== NULL
);
11010 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
11012 &remote_protocol_packets
[PACKET_qXfer_threads
]);
11014 case TARGET_OBJECT_TRACEFRAME_INFO
:
11015 gdb_assert (annex
== NULL
);
11016 return remote_read_qxfer
11017 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
11018 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
11020 case TARGET_OBJECT_FDPIC
:
11021 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
11023 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
11025 case TARGET_OBJECT_OPENVMS_UIB
:
11026 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
11028 &remote_protocol_packets
[PACKET_qXfer_uib
]);
11030 case TARGET_OBJECT_BTRACE
:
11031 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
11033 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
11035 case TARGET_OBJECT_BTRACE_CONF
:
11036 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
11038 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
11040 case TARGET_OBJECT_EXEC_FILE
:
11041 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
11043 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
11046 return TARGET_XFER_E_IO
;
11049 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
11050 large enough let the caller deal with it. */
11051 if (len
< get_remote_packet_size ())
11052 return TARGET_XFER_E_IO
;
11053 len
= get_remote_packet_size ();
11055 /* Except for querying the minimum buffer size, target must be open. */
11056 if (!rs
->remote_desc
)
11057 error (_("remote query is only available after target open"));
11059 gdb_assert (annex
!= NULL
);
11060 gdb_assert (readbuf
!= NULL
);
11062 p2
= rs
->buf
.data ();
11064 *p2
++ = query_type
;
11066 /* We used one buffer char for the remote protocol q command and
11067 another for the query type. As the remote protocol encapsulation
11068 uses 4 chars plus one extra in case we are debugging
11069 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11072 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11074 /* Bad caller may have sent forbidden characters. */
11075 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11080 gdb_assert (annex
[i
] == '\0');
11082 i
= putpkt (rs
->buf
);
11084 return TARGET_XFER_E_IO
;
11086 getpkt (&rs
->buf
, 0);
11087 strcpy ((char *) readbuf
, rs
->buf
.data ());
11089 *xfered_len
= strlen ((char *) readbuf
);
11090 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11093 /* Implementation of to_get_memory_xfer_limit. */
11096 remote_target::get_memory_xfer_limit ()
11098 return get_memory_write_packet_size ();
11102 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11103 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11104 CORE_ADDR
*found_addrp
)
11106 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11107 struct remote_state
*rs
= get_remote_state ();
11108 int max_size
= get_memory_write_packet_size ();
11109 struct packet_config
*packet
=
11110 &remote_protocol_packets
[PACKET_qSearch_memory
];
11111 /* Number of packet bytes used to encode the pattern;
11112 this could be more than PATTERN_LEN due to escape characters. */
11113 int escaped_pattern_len
;
11114 /* Amount of pattern that was encodable in the packet. */
11115 int used_pattern_len
;
11118 ULONGEST found_addr
;
11120 /* Don't go to the target if we don't have to. This is done before
11121 checking packet_config_support to avoid the possibility that a
11122 success for this edge case means the facility works in
11124 if (pattern_len
> search_space_len
)
11126 if (pattern_len
== 0)
11128 *found_addrp
= start_addr
;
11132 /* If we already know the packet isn't supported, fall back to the simple
11133 way of searching memory. */
11135 if (packet_config_support (packet
) == PACKET_DISABLE
)
11137 /* Target doesn't provided special support, fall back and use the
11138 standard support (copy memory and do the search here). */
11139 return simple_search_memory (this, start_addr
, search_space_len
,
11140 pattern
, pattern_len
, found_addrp
);
11143 /* Make sure the remote is pointing at the right process. */
11144 set_general_process ();
11146 /* Insert header. */
11147 i
= snprintf (rs
->buf
.data (), max_size
,
11148 "qSearch:memory:%s;%s;",
11149 phex_nz (start_addr
, addr_size
),
11150 phex_nz (search_space_len
, sizeof (search_space_len
)));
11151 max_size
-= (i
+ 1);
11153 /* Escape as much data as fits into rs->buf. */
11154 escaped_pattern_len
=
11155 remote_escape_output (pattern
, pattern_len
, 1,
11156 (gdb_byte
*) rs
->buf
.data () + i
,
11157 &used_pattern_len
, max_size
);
11159 /* Bail if the pattern is too large. */
11160 if (used_pattern_len
!= pattern_len
)
11161 error (_("Pattern is too large to transmit to remote target."));
11163 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11164 || getpkt_sane (&rs
->buf
, 0) < 0
11165 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11167 /* The request may not have worked because the command is not
11168 supported. If so, fall back to the simple way. */
11169 if (packet_config_support (packet
) == PACKET_DISABLE
)
11171 return simple_search_memory (this, start_addr
, search_space_len
,
11172 pattern
, pattern_len
, found_addrp
);
11177 if (rs
->buf
[0] == '0')
11179 else if (rs
->buf
[0] == '1')
11182 if (rs
->buf
[1] != ',')
11183 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11184 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11185 *found_addrp
= found_addr
;
11188 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11194 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11196 struct remote_state
*rs
= get_remote_state ();
11197 char *p
= rs
->buf
.data ();
11199 if (!rs
->remote_desc
)
11200 error (_("remote rcmd is only available after target open"));
11202 /* Send a NULL command across as an empty command. */
11203 if (command
== NULL
)
11206 /* The query prefix. */
11207 strcpy (rs
->buf
.data (), "qRcmd,");
11208 p
= strchr (rs
->buf
.data (), '\0');
11210 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11211 > get_remote_packet_size ())
11212 error (_("\"monitor\" command ``%s'' is too long."), command
);
11214 /* Encode the actual command. */
11215 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11217 if (putpkt (rs
->buf
) < 0)
11218 error (_("Communication problem with target."));
11220 /* get/display the response */
11225 /* XXX - see also remote_get_noisy_reply(). */
11226 QUIT
; /* Allow user to bail out with ^C. */
11228 if (getpkt_sane (&rs
->buf
, 0) == -1)
11230 /* Timeout. Continue to (try to) read responses.
11231 This is better than stopping with an error, assuming the stub
11232 is still executing the (long) monitor command.
11233 If needed, the user can interrupt gdb using C-c, obtaining
11234 an effect similar to stop on timeout. */
11237 buf
= rs
->buf
.data ();
11238 if (buf
[0] == '\0')
11239 error (_("Target does not support this command."));
11240 if (buf
[0] == 'O' && buf
[1] != 'K')
11242 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11245 if (strcmp (buf
, "OK") == 0)
11247 if (strlen (buf
) == 3 && buf
[0] == 'E'
11248 && isdigit (buf
[1]) && isdigit (buf
[2]))
11250 error (_("Protocol error with Rcmd"));
11252 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11254 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11256 fputc_unfiltered (c
, outbuf
);
11262 std::vector
<mem_region
>
11263 remote_target::memory_map ()
11265 std::vector
<mem_region
> result
;
11266 gdb::optional
<gdb::char_vector
> text
11267 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11270 result
= parse_memory_map (text
->data ());
11276 packet_command (const char *args
, int from_tty
)
11278 remote_target
*remote
= get_current_remote_target ();
11280 if (remote
== nullptr)
11281 error (_("command can only be used with remote target"));
11283 remote
->packet_command (args
, from_tty
);
11287 remote_target::packet_command (const char *args
, int from_tty
)
11290 error (_("remote-packet command requires packet text as argument"));
11292 puts_filtered ("sending: ");
11293 print_packet (args
);
11294 puts_filtered ("\n");
11297 remote_state
*rs
= get_remote_state ();
11299 getpkt (&rs
->buf
, 0);
11300 puts_filtered ("received: ");
11301 print_packet (rs
->buf
.data ());
11302 puts_filtered ("\n");
11306 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11308 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11310 static void threadset_test_cmd (char *cmd
, int tty
);
11312 static void threadalive_test (char *cmd
, int tty
);
11314 static void threadlist_test_cmd (char *cmd
, int tty
);
11316 int get_and_display_threadinfo (threadref
*ref
);
11318 static void threadinfo_test_cmd (char *cmd
, int tty
);
11320 static int thread_display_step (threadref
*ref
, void *context
);
11322 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11324 static void init_remote_threadtests (void);
11326 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11329 threadset_test_cmd (const char *cmd
, int tty
)
11331 int sample_thread
= SAMPLE_THREAD
;
11333 printf_filtered (_("Remote threadset test\n"));
11334 set_general_thread (sample_thread
);
11339 threadalive_test (const char *cmd
, int tty
)
11341 int sample_thread
= SAMPLE_THREAD
;
11342 int pid
= inferior_ptid
.pid ();
11343 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11345 if (remote_thread_alive (ptid
))
11346 printf_filtered ("PASS: Thread alive test\n");
11348 printf_filtered ("FAIL: Thread alive test\n");
11351 void output_threadid (char *title
, threadref
*ref
);
11354 output_threadid (char *title
, threadref
*ref
)
11358 pack_threadid (&hexid
[0], ref
); /* Convert thread id into hex. */
11360 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11364 threadlist_test_cmd (const char *cmd
, int tty
)
11367 threadref nextthread
;
11368 int done
, result_count
;
11369 threadref threadlist
[3];
11371 printf_filtered ("Remote Threadlist test\n");
11372 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11373 &result_count
, &threadlist
[0]))
11374 printf_filtered ("FAIL: threadlist test\n");
11377 threadref
*scan
= threadlist
;
11378 threadref
*limit
= scan
+ result_count
;
11380 while (scan
< limit
)
11381 output_threadid (" thread ", scan
++);
11386 display_thread_info (struct gdb_ext_thread_info
*info
)
11388 output_threadid ("Threadid: ", &info
->threadid
);
11389 printf_filtered ("Name: %s\n ", info
->shortname
);
11390 printf_filtered ("State: %s\n", info
->display
);
11391 printf_filtered ("other: %s\n\n", info
->more_display
);
11395 get_and_display_threadinfo (threadref
*ref
)
11399 struct gdb_ext_thread_info threadinfo
;
11401 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11402 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11403 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11404 display_thread_info (&threadinfo
);
11409 threadinfo_test_cmd (const char *cmd
, int tty
)
11411 int athread
= SAMPLE_THREAD
;
11415 int_to_threadref (&thread
, athread
);
11416 printf_filtered ("Remote Threadinfo test\n");
11417 if (!get_and_display_threadinfo (&thread
))
11418 printf_filtered ("FAIL cannot get thread info\n");
11422 thread_display_step (threadref
*ref
, void *context
)
11424 /* output_threadid(" threadstep ",ref); *//* simple test */
11425 return get_and_display_threadinfo (ref
);
11429 threadlist_update_test_cmd (const char *cmd
, int tty
)
11431 printf_filtered ("Remote Threadlist update test\n");
11432 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11436 init_remote_threadtests (void)
11438 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11439 _("Fetch and print the remote list of "
11440 "thread identifiers, one pkt only."));
11441 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11442 _("Fetch and display info about one thread."));
11443 add_com ("tset", class_obscure
, threadset_test_cmd
,
11444 _("Test setting to a different thread."));
11445 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11446 _("Iterate through updating all remote thread info."));
11447 add_com ("talive", class_obscure
, threadalive_test
,
11448 _("Remote thread alive test."));
11453 /* Convert a thread ID to a string. */
11456 remote_target::pid_to_str (ptid_t ptid
)
11458 struct remote_state
*rs
= get_remote_state ();
11460 if (ptid
== null_ptid
)
11461 return normal_pid_to_str (ptid
);
11462 else if (ptid
.is_pid ())
11464 /* Printing an inferior target id. */
11466 /* When multi-process extensions are off, there's no way in the
11467 remote protocol to know the remote process id, if there's any
11468 at all. There's one exception --- when we're connected with
11469 target extended-remote, and we manually attached to a process
11470 with "attach PID". We don't record anywhere a flag that
11471 allows us to distinguish that case from the case of
11472 connecting with extended-remote and the stub already being
11473 attached to a process, and reporting yes to qAttached, hence
11474 no smart special casing here. */
11475 if (!remote_multi_process_p (rs
))
11476 return "Remote target";
11478 return normal_pid_to_str (ptid
);
11482 if (magic_null_ptid
== ptid
)
11483 return "Thread <main>";
11484 else if (remote_multi_process_p (rs
))
11485 if (ptid
.lwp () == 0)
11486 return normal_pid_to_str (ptid
);
11488 return string_printf ("Thread %d.%ld",
11489 ptid
.pid (), ptid
.lwp ());
11491 return string_printf ("Thread %ld", ptid
.lwp ());
11495 /* Get the address of the thread local variable in OBJFILE which is
11496 stored at OFFSET within the thread local storage for thread PTID. */
11499 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11502 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11504 struct remote_state
*rs
= get_remote_state ();
11505 char *p
= rs
->buf
.data ();
11506 char *endp
= p
+ get_remote_packet_size ();
11507 enum packet_result result
;
11509 strcpy (p
, "qGetTLSAddr:");
11511 p
= write_ptid (p
, endp
, ptid
);
11513 p
+= hexnumstr (p
, offset
);
11515 p
+= hexnumstr (p
, lm
);
11519 getpkt (&rs
->buf
, 0);
11520 result
= packet_ok (rs
->buf
,
11521 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11522 if (result
== PACKET_OK
)
11526 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11529 else if (result
== PACKET_UNKNOWN
)
11530 throw_error (TLS_GENERIC_ERROR
,
11531 _("Remote target doesn't support qGetTLSAddr packet"));
11533 throw_error (TLS_GENERIC_ERROR
,
11534 _("Remote target failed to process qGetTLSAddr request"));
11537 throw_error (TLS_GENERIC_ERROR
,
11538 _("TLS not supported or disabled on this target"));
11543 /* Provide thread local base, i.e. Thread Information Block address.
11544 Returns 1 if ptid is found and thread_local_base is non zero. */
11547 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11549 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11551 struct remote_state
*rs
= get_remote_state ();
11552 char *p
= rs
->buf
.data ();
11553 char *endp
= p
+ get_remote_packet_size ();
11554 enum packet_result result
;
11556 strcpy (p
, "qGetTIBAddr:");
11558 p
= write_ptid (p
, endp
, ptid
);
11562 getpkt (&rs
->buf
, 0);
11563 result
= packet_ok (rs
->buf
,
11564 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11565 if (result
== PACKET_OK
)
11568 unpack_varlen_hex (rs
->buf
.data (), &val
);
11570 *addr
= (CORE_ADDR
) val
;
11573 else if (result
== PACKET_UNKNOWN
)
11574 error (_("Remote target doesn't support qGetTIBAddr packet"));
11576 error (_("Remote target failed to process qGetTIBAddr request"));
11579 error (_("qGetTIBAddr not supported or disabled on this target"));
11584 /* Support for inferring a target description based on the current
11585 architecture and the size of a 'g' packet. While the 'g' packet
11586 can have any size (since optional registers can be left off the
11587 end), some sizes are easily recognizable given knowledge of the
11588 approximate architecture. */
11590 struct remote_g_packet_guess
11592 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11599 const struct target_desc
*tdesc
;
11602 struct remote_g_packet_data
: public allocate_on_obstack
11604 std::vector
<remote_g_packet_guess
> guesses
;
11607 static struct gdbarch_data
*remote_g_packet_data_handle
;
11610 remote_g_packet_data_init (struct obstack
*obstack
)
11612 return new (obstack
) remote_g_packet_data
;
11616 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11617 const struct target_desc
*tdesc
)
11619 struct remote_g_packet_data
*data
11620 = ((struct remote_g_packet_data
*)
11621 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11623 gdb_assert (tdesc
!= NULL
);
11625 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11626 if (guess
.bytes
== bytes
)
11627 internal_error (__FILE__
, __LINE__
,
11628 _("Duplicate g packet description added for size %d"),
11631 data
->guesses
.emplace_back (bytes
, tdesc
);
11634 /* Return true if remote_read_description would do anything on this target
11635 and architecture, false otherwise. */
11638 remote_read_description_p (struct target_ops
*target
)
11640 struct remote_g_packet_data
*data
11641 = ((struct remote_g_packet_data
*)
11642 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11644 return !data
->guesses
.empty ();
11647 const struct target_desc
*
11648 remote_target::read_description ()
11650 struct remote_g_packet_data
*data
11651 = ((struct remote_g_packet_data
*)
11652 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11654 /* Do not try this during initial connection, when we do not know
11655 whether there is a running but stopped thread. */
11656 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
11657 return beneath ()->read_description ();
11659 if (!data
->guesses
.empty ())
11661 int bytes
= send_g_packet ();
11663 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11664 if (guess
.bytes
== bytes
)
11665 return guess
.tdesc
;
11667 /* We discard the g packet. A minor optimization would be to
11668 hold on to it, and fill the register cache once we have selected
11669 an architecture, but it's too tricky to do safely. */
11672 return beneath ()->read_description ();
11675 /* Remote file transfer support. This is host-initiated I/O, not
11676 target-initiated; for target-initiated, see remote-fileio.c. */
11678 /* If *LEFT is at least the length of STRING, copy STRING to
11679 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11680 decrease *LEFT. Otherwise raise an error. */
11683 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11685 int len
= strlen (string
);
11688 error (_("Packet too long for target."));
11690 memcpy (*buffer
, string
, len
);
11694 /* NUL-terminate the buffer as a convenience, if there is
11700 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11701 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11702 decrease *LEFT. Otherwise raise an error. */
11705 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11708 if (2 * len
> *left
)
11709 error (_("Packet too long for target."));
11711 bin2hex (bytes
, *buffer
, len
);
11712 *buffer
+= 2 * len
;
11715 /* NUL-terminate the buffer as a convenience, if there is
11721 /* If *LEFT is large enough, convert VALUE to hex and add it to
11722 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11723 decrease *LEFT. Otherwise raise an error. */
11726 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11728 int len
= hexnumlen (value
);
11731 error (_("Packet too long for target."));
11733 hexnumstr (*buffer
, value
);
11737 /* NUL-terminate the buffer as a convenience, if there is
11743 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11744 value, *REMOTE_ERRNO to the remote error number or zero if none
11745 was included, and *ATTACHMENT to point to the start of the annex
11746 if any. The length of the packet isn't needed here; there may
11747 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11749 Return 0 if the packet could be parsed, -1 if it could not. If
11750 -1 is returned, the other variables may not be initialized. */
11753 remote_hostio_parse_result (char *buffer
, int *retcode
,
11754 int *remote_errno
, char **attachment
)
11759 *attachment
= NULL
;
11761 if (buffer
[0] != 'F')
11765 *retcode
= strtol (&buffer
[1], &p
, 16);
11766 if (errno
!= 0 || p
== &buffer
[1])
11769 /* Check for ",errno". */
11773 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11774 if (errno
!= 0 || p
+ 1 == p2
)
11779 /* Check for ";attachment". If there is no attachment, the
11780 packet should end here. */
11783 *attachment
= p
+ 1;
11786 else if (*p
== '\0')
11792 /* Send a prepared I/O packet to the target and read its response.
11793 The prepared packet is in the global RS->BUF before this function
11794 is called, and the answer is there when we return.
11796 COMMAND_BYTES is the length of the request to send, which may include
11797 binary data. WHICH_PACKET is the packet configuration to check
11798 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11799 is set to the error number and -1 is returned. Otherwise the value
11800 returned by the function is returned.
11802 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11803 attachment is expected; an error will be reported if there's a
11804 mismatch. If one is found, *ATTACHMENT will be set to point into
11805 the packet buffer and *ATTACHMENT_LEN will be set to the
11806 attachment's length. */
11809 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11810 int *remote_errno
, char **attachment
,
11811 int *attachment_len
)
11813 struct remote_state
*rs
= get_remote_state ();
11814 int ret
, bytes_read
;
11815 char *attachment_tmp
;
11817 if (packet_support (which_packet
) == PACKET_DISABLE
)
11819 *remote_errno
= FILEIO_ENOSYS
;
11823 putpkt_binary (rs
->buf
.data (), command_bytes
);
11824 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11826 /* If it timed out, something is wrong. Don't try to parse the
11828 if (bytes_read
< 0)
11830 *remote_errno
= FILEIO_EINVAL
;
11834 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11837 *remote_errno
= FILEIO_EINVAL
;
11839 case PACKET_UNKNOWN
:
11840 *remote_errno
= FILEIO_ENOSYS
;
11846 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
11849 *remote_errno
= FILEIO_EINVAL
;
11853 /* Make sure we saw an attachment if and only if we expected one. */
11854 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11855 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11857 *remote_errno
= FILEIO_EINVAL
;
11861 /* If an attachment was found, it must point into the packet buffer;
11862 work out how many bytes there were. */
11863 if (attachment_tmp
!= NULL
)
11865 *attachment
= attachment_tmp
;
11866 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
11872 /* See declaration.h. */
11875 readahead_cache::invalidate ()
11880 /* See declaration.h. */
11883 readahead_cache::invalidate_fd (int fd
)
11885 if (this->fd
== fd
)
11889 /* Set the filesystem remote_hostio functions that take FILENAME
11890 arguments will use. Return 0 on success, or -1 if an error
11891 occurs (and set *REMOTE_ERRNO). */
11894 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
11897 struct remote_state
*rs
= get_remote_state ();
11898 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11899 char *p
= rs
->buf
.data ();
11900 int left
= get_remote_packet_size () - 1;
11904 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11907 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11910 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11912 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11913 remote_buffer_add_string (&p
, &left
, arg
);
11915 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
11916 remote_errno
, NULL
, NULL
);
11918 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11922 rs
->fs_pid
= required_pid
;
11927 /* Implementation of to_fileio_open. */
11930 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
11931 int flags
, int mode
, int warn_if_slow
,
11934 struct remote_state
*rs
= get_remote_state ();
11935 char *p
= rs
->buf
.data ();
11936 int left
= get_remote_packet_size () - 1;
11940 static int warning_issued
= 0;
11942 printf_unfiltered (_("Reading %s from remote target...\n"),
11945 if (!warning_issued
)
11947 warning (_("File transfers from remote targets can be slow."
11948 " Use \"set sysroot\" to access files locally"
11950 warning_issued
= 1;
11954 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11957 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11959 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11960 strlen (filename
));
11961 remote_buffer_add_string (&p
, &left
, ",");
11963 remote_buffer_add_int (&p
, &left
, flags
);
11964 remote_buffer_add_string (&p
, &left
, ",");
11966 remote_buffer_add_int (&p
, &left
, mode
);
11968 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
11969 remote_errno
, NULL
, NULL
);
11973 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
11974 int flags
, int mode
, int warn_if_slow
,
11977 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
11981 /* Implementation of to_fileio_pwrite. */
11984 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11985 ULONGEST offset
, int *remote_errno
)
11987 struct remote_state
*rs
= get_remote_state ();
11988 char *p
= rs
->buf
.data ();
11989 int left
= get_remote_packet_size ();
11992 rs
->readahead_cache
.invalidate_fd (fd
);
11994 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11996 remote_buffer_add_int (&p
, &left
, fd
);
11997 remote_buffer_add_string (&p
, &left
, ",");
11999 remote_buffer_add_int (&p
, &left
, offset
);
12000 remote_buffer_add_string (&p
, &left
, ",");
12002 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
12003 (get_remote_packet_size ()
12004 - (p
- rs
->buf
.data ())));
12006 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
12007 remote_errno
, NULL
, NULL
);
12011 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
12012 ULONGEST offset
, int *remote_errno
)
12014 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
12017 /* Helper for the implementation of to_fileio_pread. Read the file
12018 from the remote side with vFile:pread. */
12021 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
12022 ULONGEST offset
, int *remote_errno
)
12024 struct remote_state
*rs
= get_remote_state ();
12025 char *p
= rs
->buf
.data ();
12027 int left
= get_remote_packet_size ();
12028 int ret
, attachment_len
;
12031 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
12033 remote_buffer_add_int (&p
, &left
, fd
);
12034 remote_buffer_add_string (&p
, &left
, ",");
12036 remote_buffer_add_int (&p
, &left
, len
);
12037 remote_buffer_add_string (&p
, &left
, ",");
12039 remote_buffer_add_int (&p
, &left
, offset
);
12041 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
12042 remote_errno
, &attachment
,
12048 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12050 if (read_len
!= ret
)
12051 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
12056 /* See declaration.h. */
12059 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12063 && this->offset
<= offset
12064 && offset
< this->offset
+ this->bufsize
)
12066 ULONGEST max
= this->offset
+ this->bufsize
;
12068 if (offset
+ len
> max
)
12069 len
= max
- offset
;
12071 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12078 /* Implementation of to_fileio_pread. */
12081 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12082 ULONGEST offset
, int *remote_errno
)
12085 struct remote_state
*rs
= get_remote_state ();
12086 readahead_cache
*cache
= &rs
->readahead_cache
;
12088 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12091 cache
->hit_count
++;
12094 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12095 pulongest (cache
->hit_count
));
12099 cache
->miss_count
++;
12101 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12102 pulongest (cache
->miss_count
));
12105 cache
->offset
= offset
;
12106 cache
->bufsize
= get_remote_packet_size ();
12107 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12109 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12110 cache
->offset
, remote_errno
);
12113 cache
->invalidate_fd (fd
);
12117 cache
->bufsize
= ret
;
12118 return cache
->pread (fd
, read_buf
, len
, offset
);
12122 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12123 ULONGEST offset
, int *remote_errno
)
12125 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12128 /* Implementation of to_fileio_close. */
12131 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12133 struct remote_state
*rs
= get_remote_state ();
12134 char *p
= rs
->buf
.data ();
12135 int left
= get_remote_packet_size () - 1;
12137 rs
->readahead_cache
.invalidate_fd (fd
);
12139 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12141 remote_buffer_add_int (&p
, &left
, fd
);
12143 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12144 remote_errno
, NULL
, NULL
);
12148 remote_target::fileio_close (int fd
, int *remote_errno
)
12150 return remote_hostio_close (fd
, remote_errno
);
12153 /* Implementation of to_fileio_unlink. */
12156 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12159 struct remote_state
*rs
= get_remote_state ();
12160 char *p
= rs
->buf
.data ();
12161 int left
= get_remote_packet_size () - 1;
12163 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12166 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12168 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12169 strlen (filename
));
12171 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12172 remote_errno
, NULL
, NULL
);
12176 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12179 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12182 /* Implementation of to_fileio_readlink. */
12184 gdb::optional
<std::string
>
12185 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12188 struct remote_state
*rs
= get_remote_state ();
12189 char *p
= rs
->buf
.data ();
12191 int left
= get_remote_packet_size ();
12192 int len
, attachment_len
;
12195 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12198 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12200 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12201 strlen (filename
));
12203 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12204 remote_errno
, &attachment
,
12210 std::string
ret (len
, '\0');
12212 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12213 (gdb_byte
*) &ret
[0], len
);
12214 if (read_len
!= len
)
12215 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12220 /* Implementation of to_fileio_fstat. */
12223 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12225 struct remote_state
*rs
= get_remote_state ();
12226 char *p
= rs
->buf
.data ();
12227 int left
= get_remote_packet_size ();
12228 int attachment_len
, ret
;
12230 struct fio_stat fst
;
12233 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12235 remote_buffer_add_int (&p
, &left
, fd
);
12237 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12238 remote_errno
, &attachment
,
12242 if (*remote_errno
!= FILEIO_ENOSYS
)
12245 /* Strictly we should return -1, ENOSYS here, but when
12246 "set sysroot remote:" was implemented in August 2008
12247 BFD's need for a stat function was sidestepped with
12248 this hack. This was not remedied until March 2015
12249 so we retain the previous behavior to avoid breaking
12252 Note that the memset is a March 2015 addition; older
12253 GDBs set st_size *and nothing else* so the structure
12254 would have garbage in all other fields. This might
12255 break something but retaining the previous behavior
12256 here would be just too wrong. */
12258 memset (st
, 0, sizeof (struct stat
));
12259 st
->st_size
= INT_MAX
;
12263 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12264 (gdb_byte
*) &fst
, sizeof (fst
));
12266 if (read_len
!= ret
)
12267 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12269 if (read_len
!= sizeof (fst
))
12270 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12271 read_len
, (int) sizeof (fst
));
12273 remote_fileio_to_host_stat (&fst
, st
);
12278 /* Implementation of to_filesystem_is_local. */
12281 remote_target::filesystem_is_local ()
12283 /* Valgrind GDB presents itself as a remote target but works
12284 on the local filesystem: it does not implement remote get
12285 and users are not expected to set a sysroot. To handle
12286 this case we treat the remote filesystem as local if the
12287 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12288 does not support vFile:open. */
12289 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12291 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12293 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12295 int fd
, remote_errno
;
12297 /* Try opening a file to probe support. The supplied
12298 filename is irrelevant, we only care about whether
12299 the stub recognizes the packet or not. */
12300 fd
= remote_hostio_open (NULL
, "just probing",
12301 FILEIO_O_RDONLY
, 0700, 0,
12305 remote_hostio_close (fd
, &remote_errno
);
12307 ps
= packet_support (PACKET_vFile_open
);
12310 if (ps
== PACKET_DISABLE
)
12312 static int warning_issued
= 0;
12314 if (!warning_issued
)
12316 warning (_("remote target does not support file"
12317 " transfer, attempting to access files"
12318 " from local filesystem."));
12319 warning_issued
= 1;
12330 remote_fileio_errno_to_host (int errnum
)
12336 case FILEIO_ENOENT
:
12344 case FILEIO_EACCES
:
12346 case FILEIO_EFAULT
:
12350 case FILEIO_EEXIST
:
12352 case FILEIO_ENODEV
:
12354 case FILEIO_ENOTDIR
:
12356 case FILEIO_EISDIR
:
12358 case FILEIO_EINVAL
:
12360 case FILEIO_ENFILE
:
12362 case FILEIO_EMFILE
:
12366 case FILEIO_ENOSPC
:
12368 case FILEIO_ESPIPE
:
12372 case FILEIO_ENOSYS
:
12374 case FILEIO_ENAMETOOLONG
:
12375 return ENAMETOOLONG
;
12381 remote_hostio_error (int errnum
)
12383 int host_error
= remote_fileio_errno_to_host (errnum
);
12385 if (host_error
== -1)
12386 error (_("Unknown remote I/O error %d"), errnum
);
12388 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12391 /* A RAII wrapper around a remote file descriptor. */
12393 class scoped_remote_fd
12396 scoped_remote_fd (remote_target
*remote
, int fd
)
12397 : m_remote (remote
), m_fd (fd
)
12401 ~scoped_remote_fd ()
12408 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12412 /* Swallow exception before it escapes the dtor. If
12413 something goes wrong, likely the connection is gone,
12414 and there's nothing else that can be done. */
12419 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12421 /* Release ownership of the file descriptor, and return it. */
12422 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12429 /* Return the owned file descriptor. */
12430 int get () const noexcept
12436 /* The remote target. */
12437 remote_target
*m_remote
;
12439 /* The owned remote I/O file descriptor. */
12444 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12446 remote_target
*remote
= get_current_remote_target ();
12448 if (remote
== nullptr)
12449 error (_("command can only be used with remote target"));
12451 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12455 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12458 int retcode
, remote_errno
, bytes
, io_size
;
12459 int bytes_in_buffer
;
12463 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12465 perror_with_name (local_file
);
12467 scoped_remote_fd fd
12468 (this, remote_hostio_open (NULL
,
12469 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12471 0700, 0, &remote_errno
));
12472 if (fd
.get () == -1)
12473 remote_hostio_error (remote_errno
);
12475 /* Send up to this many bytes at once. They won't all fit in the
12476 remote packet limit, so we'll transfer slightly fewer. */
12477 io_size
= get_remote_packet_size ();
12478 gdb::byte_vector
buffer (io_size
);
12480 bytes_in_buffer
= 0;
12483 while (bytes_in_buffer
|| !saw_eof
)
12487 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12488 io_size
- bytes_in_buffer
,
12492 if (ferror (file
.get ()))
12493 error (_("Error reading %s."), local_file
);
12496 /* EOF. Unless there is something still in the
12497 buffer from the last iteration, we are done. */
12499 if (bytes_in_buffer
== 0)
12507 bytes
+= bytes_in_buffer
;
12508 bytes_in_buffer
= 0;
12510 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12511 offset
, &remote_errno
);
12514 remote_hostio_error (remote_errno
);
12515 else if (retcode
== 0)
12516 error (_("Remote write of %d bytes returned 0!"), bytes
);
12517 else if (retcode
< bytes
)
12519 /* Short write. Save the rest of the read data for the next
12521 bytes_in_buffer
= bytes
- retcode
;
12522 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12528 if (remote_hostio_close (fd
.release (), &remote_errno
))
12529 remote_hostio_error (remote_errno
);
12532 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12536 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12538 remote_target
*remote
= get_current_remote_target ();
12540 if (remote
== nullptr)
12541 error (_("command can only be used with remote target"));
12543 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12547 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12550 int remote_errno
, bytes
, io_size
;
12553 scoped_remote_fd fd
12554 (this, remote_hostio_open (NULL
,
12555 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12557 if (fd
.get () == -1)
12558 remote_hostio_error (remote_errno
);
12560 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12562 perror_with_name (local_file
);
12564 /* Send up to this many bytes at once. They won't all fit in the
12565 remote packet limit, so we'll transfer slightly fewer. */
12566 io_size
= get_remote_packet_size ();
12567 gdb::byte_vector
buffer (io_size
);
12572 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12575 /* Success, but no bytes, means end-of-file. */
12578 remote_hostio_error (remote_errno
);
12582 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12584 perror_with_name (local_file
);
12587 if (remote_hostio_close (fd
.release (), &remote_errno
))
12588 remote_hostio_error (remote_errno
);
12591 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12595 remote_file_delete (const char *remote_file
, int from_tty
)
12597 remote_target
*remote
= get_current_remote_target ();
12599 if (remote
== nullptr)
12600 error (_("command can only be used with remote target"));
12602 remote
->remote_file_delete (remote_file
, from_tty
);
12606 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12608 int retcode
, remote_errno
;
12610 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12612 remote_hostio_error (remote_errno
);
12615 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12619 remote_put_command (const char *args
, int from_tty
)
12622 error_no_arg (_("file to put"));
12624 gdb_argv
argv (args
);
12625 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12626 error (_("Invalid parameters to remote put"));
12628 remote_file_put (argv
[0], argv
[1], from_tty
);
12632 remote_get_command (const char *args
, int from_tty
)
12635 error_no_arg (_("file to get"));
12637 gdb_argv
argv (args
);
12638 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12639 error (_("Invalid parameters to remote get"));
12641 remote_file_get (argv
[0], argv
[1], from_tty
);
12645 remote_delete_command (const char *args
, int from_tty
)
12648 error_no_arg (_("file to delete"));
12650 gdb_argv
argv (args
);
12651 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12652 error (_("Invalid parameters to remote delete"));
12654 remote_file_delete (argv
[0], from_tty
);
12658 remote_command (const char *args
, int from_tty
)
12660 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12664 remote_target::can_execute_reverse ()
12666 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12667 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12674 remote_target::supports_non_stop ()
12680 remote_target::supports_disable_randomization ()
12682 /* Only supported in extended mode. */
12687 remote_target::supports_multi_process ()
12689 struct remote_state
*rs
= get_remote_state ();
12691 return remote_multi_process_p (rs
);
12695 remote_supports_cond_tracepoints ()
12697 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12701 remote_target::supports_evaluation_of_breakpoint_conditions ()
12703 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12707 remote_supports_fast_tracepoints ()
12709 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12713 remote_supports_static_tracepoints ()
12715 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12719 remote_supports_install_in_trace ()
12721 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12725 remote_target::supports_enable_disable_tracepoint ()
12727 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12732 remote_target::supports_string_tracing ()
12734 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12738 remote_target::can_run_breakpoint_commands ()
12740 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12744 remote_target::trace_init ()
12746 struct remote_state
*rs
= get_remote_state ();
12749 remote_get_noisy_reply ();
12750 if (strcmp (rs
->buf
.data (), "OK") != 0)
12751 error (_("Target does not support this command."));
12754 /* Recursive routine to walk through command list including loops, and
12755 download packets for each command. */
12758 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12759 struct command_line
*cmds
)
12761 struct remote_state
*rs
= get_remote_state ();
12762 struct command_line
*cmd
;
12764 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12766 QUIT
; /* Allow user to bail out with ^C. */
12767 strcpy (rs
->buf
.data (), "QTDPsrc:");
12768 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12769 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12770 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12772 remote_get_noisy_reply ();
12773 if (strcmp (rs
->buf
.data (), "OK"))
12774 warning (_("Target does not support source download."));
12776 if (cmd
->control_type
== while_control
12777 || cmd
->control_type
== while_stepping_control
)
12779 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12781 QUIT
; /* Allow user to bail out with ^C. */
12782 strcpy (rs
->buf
.data (), "QTDPsrc:");
12783 encode_source_string (num
, addr
, "cmd", "end",
12784 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12785 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12787 remote_get_noisy_reply ();
12788 if (strcmp (rs
->buf
.data (), "OK"))
12789 warning (_("Target does not support source download."));
12795 remote_target::download_tracepoint (struct bp_location
*loc
)
12799 std::vector
<std::string
> tdp_actions
;
12800 std::vector
<std::string
> stepping_actions
;
12802 struct breakpoint
*b
= loc
->owner
;
12803 struct tracepoint
*t
= (struct tracepoint
*) b
;
12804 struct remote_state
*rs
= get_remote_state ();
12806 const char *err_msg
= _("Tracepoint packet too large for target.");
12809 /* We use a buffer other than rs->buf because we'll build strings
12810 across multiple statements, and other statements in between could
12812 gdb::char_vector
buf (get_remote_packet_size ());
12814 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12816 tpaddr
= loc
->address
;
12817 sprintf_vma (addrbuf
, tpaddr
);
12818 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12819 b
->number
, addrbuf
, /* address */
12820 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12821 t
->step_count
, t
->pass_count
);
12823 if (ret
< 0 || ret
>= buf
.size ())
12824 error ("%s", err_msg
);
12826 /* Fast tracepoints are mostly handled by the target, but we can
12827 tell the target how big of an instruction block should be moved
12829 if (b
->type
== bp_fast_tracepoint
)
12831 /* Only test for support at download time; we may not know
12832 target capabilities at definition time. */
12833 if (remote_supports_fast_tracepoints ())
12835 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12838 size_left
= buf
.size () - strlen (buf
.data ());
12839 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12841 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12843 if (ret
< 0 || ret
>= size_left
)
12844 error ("%s", err_msg
);
12847 /* If it passed validation at definition but fails now,
12848 something is very wrong. */
12849 internal_error (__FILE__
, __LINE__
,
12850 _("Fast tracepoint not "
12851 "valid during download"));
12854 /* Fast tracepoints are functionally identical to regular
12855 tracepoints, so don't take lack of support as a reason to
12856 give up on the trace run. */
12857 warning (_("Target does not support fast tracepoints, "
12858 "downloading %d as regular tracepoint"), b
->number
);
12860 else if (b
->type
== bp_static_tracepoint
)
12862 /* Only test for support at download time; we may not know
12863 target capabilities at definition time. */
12864 if (remote_supports_static_tracepoints ())
12866 struct static_tracepoint_marker marker
;
12868 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12870 size_left
= buf
.size () - strlen (buf
.data ());
12871 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12874 if (ret
< 0 || ret
>= size_left
)
12875 error ("%s", err_msg
);
12878 error (_("Static tracepoint not valid during download"));
12881 /* Fast tracepoints are functionally identical to regular
12882 tracepoints, so don't take lack of support as a reason
12883 to give up on the trace run. */
12884 error (_("Target does not support static tracepoints"));
12886 /* If the tracepoint has a conditional, make it into an agent
12887 expression and append to the definition. */
12890 /* Only test support at download time, we may not know target
12891 capabilities at definition time. */
12892 if (remote_supports_cond_tracepoints ())
12894 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
12897 size_left
= buf
.size () - strlen (buf
.data ());
12899 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12900 size_left
, ":X%x,", aexpr
->len
);
12902 if (ret
< 0 || ret
>= size_left
)
12903 error ("%s", err_msg
);
12905 size_left
= buf
.size () - strlen (buf
.data ());
12907 /* Two bytes to encode each aexpr byte, plus the terminating
12909 if (aexpr
->len
* 2 + 1 > size_left
)
12910 error ("%s", err_msg
);
12912 pkt
= buf
.data () + strlen (buf
.data ());
12914 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12915 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12919 warning (_("Target does not support conditional tracepoints, "
12920 "ignoring tp %d cond"), b
->number
);
12923 if (b
->commands
|| *default_collect
)
12925 size_left
= buf
.size () - strlen (buf
.data ());
12927 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12930 if (ret
< 0 || ret
>= size_left
)
12931 error ("%s", err_msg
);
12934 putpkt (buf
.data ());
12935 remote_get_noisy_reply ();
12936 if (strcmp (rs
->buf
.data (), "OK"))
12937 error (_("Target does not support tracepoints."));
12939 /* do_single_steps (t); */
12940 for (auto action_it
= tdp_actions
.begin ();
12941 action_it
!= tdp_actions
.end (); action_it
++)
12943 QUIT
; /* Allow user to bail out with ^C. */
12945 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
12946 || !stepping_actions
.empty ());
12948 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
12949 b
->number
, addrbuf
, /* address */
12950 action_it
->c_str (),
12951 has_more
? '-' : 0);
12953 if (ret
< 0 || ret
>= buf
.size ())
12954 error ("%s", err_msg
);
12956 putpkt (buf
.data ());
12957 remote_get_noisy_reply ();
12958 if (strcmp (rs
->buf
.data (), "OK"))
12959 error (_("Error on target while setting tracepoints."));
12962 for (auto action_it
= stepping_actions
.begin ();
12963 action_it
!= stepping_actions
.end (); action_it
++)
12965 QUIT
; /* Allow user to bail out with ^C. */
12967 bool is_first
= action_it
== stepping_actions
.begin ();
12968 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
12970 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
12971 b
->number
, addrbuf
, /* address */
12972 is_first
? "S" : "",
12973 action_it
->c_str (),
12974 has_more
? "-" : "");
12976 if (ret
< 0 || ret
>= buf
.size ())
12977 error ("%s", err_msg
);
12979 putpkt (buf
.data ());
12980 remote_get_noisy_reply ();
12981 if (strcmp (rs
->buf
.data (), "OK"))
12982 error (_("Error on target while setting tracepoints."));
12985 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12987 if (b
->location
!= NULL
)
12989 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12991 if (ret
< 0 || ret
>= buf
.size ())
12992 error ("%s", err_msg
);
12994 encode_source_string (b
->number
, loc
->address
, "at",
12995 event_location_to_string (b
->location
.get ()),
12996 buf
.data () + strlen (buf
.data ()),
12997 buf
.size () - strlen (buf
.data ()));
12998 putpkt (buf
.data ());
12999 remote_get_noisy_reply ();
13000 if (strcmp (rs
->buf
.data (), "OK"))
13001 warning (_("Target does not support source download."));
13003 if (b
->cond_string
)
13005 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
13007 if (ret
< 0 || ret
>= buf
.size ())
13008 error ("%s", err_msg
);
13010 encode_source_string (b
->number
, loc
->address
,
13011 "cond", b
->cond_string
,
13012 buf
.data () + strlen (buf
.data ()),
13013 buf
.size () - strlen (buf
.data ()));
13014 putpkt (buf
.data ());
13015 remote_get_noisy_reply ();
13016 if (strcmp (rs
->buf
.data (), "OK"))
13017 warning (_("Target does not support source download."));
13019 remote_download_command_source (b
->number
, loc
->address
,
13020 breakpoint_commands (b
));
13025 remote_target::can_download_tracepoint ()
13027 struct remote_state
*rs
= get_remote_state ();
13028 struct trace_status
*ts
;
13031 /* Don't try to install tracepoints until we've relocated our
13032 symbols, and fetched and merged the target's tracepoint list with
13034 if (rs
->starting_up
)
13037 ts
= current_trace_status ();
13038 status
= get_trace_status (ts
);
13040 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
13043 /* If we are in a tracing experiment, but remote stub doesn't support
13044 installing tracepoint in trace, we have to return. */
13045 if (!remote_supports_install_in_trace ())
13053 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
13055 struct remote_state
*rs
= get_remote_state ();
13058 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13059 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13061 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13062 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13063 >= get_remote_packet_size ())
13064 error (_("Trace state variable name too long for tsv definition packet"));
13065 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13068 remote_get_noisy_reply ();
13069 if (rs
->buf
[0] == '\0')
13070 error (_("Target does not support this command."));
13071 if (strcmp (rs
->buf
.data (), "OK") != 0)
13072 error (_("Error on target while downloading trace state variable."));
13076 remote_target::enable_tracepoint (struct bp_location
*location
)
13078 struct remote_state
*rs
= get_remote_state ();
13081 sprintf_vma (addr_buf
, location
->address
);
13082 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13083 location
->owner
->number
, addr_buf
);
13085 remote_get_noisy_reply ();
13086 if (rs
->buf
[0] == '\0')
13087 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13088 if (strcmp (rs
->buf
.data (), "OK") != 0)
13089 error (_("Error on target while enabling tracepoint."));
13093 remote_target::disable_tracepoint (struct bp_location
*location
)
13095 struct remote_state
*rs
= get_remote_state ();
13098 sprintf_vma (addr_buf
, location
->address
);
13099 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13100 location
->owner
->number
, addr_buf
);
13102 remote_get_noisy_reply ();
13103 if (rs
->buf
[0] == '\0')
13104 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13105 if (strcmp (rs
->buf
.data (), "OK") != 0)
13106 error (_("Error on target while disabling tracepoint."));
13110 remote_target::trace_set_readonly_regions ()
13113 bfd_size_type size
;
13119 return; /* No information to give. */
13121 struct remote_state
*rs
= get_remote_state ();
13123 strcpy (rs
->buf
.data (), "QTro");
13124 offset
= strlen (rs
->buf
.data ());
13125 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
13127 char tmp1
[40], tmp2
[40];
13130 if ((s
->flags
& SEC_LOAD
) == 0 ||
13131 /* (s->flags & SEC_CODE) == 0 || */
13132 (s
->flags
& SEC_READONLY
) == 0)
13136 vma
= bfd_section_vma (s
);
13137 size
= bfd_section_size (s
);
13138 sprintf_vma (tmp1
, vma
);
13139 sprintf_vma (tmp2
, vma
+ size
);
13140 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13141 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13143 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13145 Too many sections for read-only sections definition packet."));
13148 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13150 offset
+= sec_length
;
13155 getpkt (&rs
->buf
, 0);
13160 remote_target::trace_start ()
13162 struct remote_state
*rs
= get_remote_state ();
13164 putpkt ("QTStart");
13165 remote_get_noisy_reply ();
13166 if (rs
->buf
[0] == '\0')
13167 error (_("Target does not support this command."));
13168 if (strcmp (rs
->buf
.data (), "OK") != 0)
13169 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13173 remote_target::get_trace_status (struct trace_status
*ts
)
13175 /* Initialize it just to avoid a GCC false warning. */
13177 enum packet_result result
;
13178 struct remote_state
*rs
= get_remote_state ();
13180 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13183 /* FIXME we need to get register block size some other way. */
13184 trace_regblock_size
13185 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13187 putpkt ("qTStatus");
13191 p
= remote_get_noisy_reply ();
13193 catch (const gdb_exception_error
&ex
)
13195 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13197 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13203 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13205 /* If the remote target doesn't do tracing, flag it. */
13206 if (result
== PACKET_UNKNOWN
)
13209 /* We're working with a live target. */
13210 ts
->filename
= NULL
;
13213 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13215 /* Function 'parse_trace_status' sets default value of each field of
13216 'ts' at first, so we don't have to do it here. */
13217 parse_trace_status (p
, ts
);
13219 return ts
->running
;
13223 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13224 struct uploaded_tp
*utp
)
13226 struct remote_state
*rs
= get_remote_state ();
13228 struct bp_location
*loc
;
13229 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13230 size_t size
= get_remote_packet_size ();
13235 tp
->traceframe_usage
= 0;
13236 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13238 /* If the tracepoint was never downloaded, don't go asking for
13240 if (tp
->number_on_target
== 0)
13242 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13243 phex_nz (loc
->address
, 0));
13245 reply
= remote_get_noisy_reply ();
13246 if (reply
&& *reply
)
13249 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13255 utp
->hit_count
= 0;
13256 utp
->traceframe_usage
= 0;
13257 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13258 phex_nz (utp
->addr
, 0));
13260 reply
= remote_get_noisy_reply ();
13261 if (reply
&& *reply
)
13264 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13270 remote_target::trace_stop ()
13272 struct remote_state
*rs
= get_remote_state ();
13275 remote_get_noisy_reply ();
13276 if (rs
->buf
[0] == '\0')
13277 error (_("Target does not support this command."));
13278 if (strcmp (rs
->buf
.data (), "OK") != 0)
13279 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13283 remote_target::trace_find (enum trace_find_type type
, int num
,
13284 CORE_ADDR addr1
, CORE_ADDR addr2
,
13287 struct remote_state
*rs
= get_remote_state ();
13288 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13290 int target_frameno
= -1, target_tracept
= -1;
13292 /* Lookups other than by absolute frame number depend on the current
13293 trace selected, so make sure it is correct on the remote end
13295 if (type
!= tfind_number
)
13296 set_remote_traceframe ();
13298 p
= rs
->buf
.data ();
13299 strcpy (p
, "QTFrame:");
13300 p
= strchr (p
, '\0');
13304 xsnprintf (p
, endbuf
- p
, "%x", num
);
13307 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13310 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13313 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13314 phex_nz (addr2
, 0));
13316 case tfind_outside
:
13317 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13318 phex_nz (addr2
, 0));
13321 error (_("Unknown trace find type %d"), type
);
13325 reply
= remote_get_noisy_reply ();
13326 if (*reply
== '\0')
13327 error (_("Target does not support this command."));
13329 while (reply
&& *reply
)
13334 target_frameno
= (int) strtol (p
, &reply
, 16);
13336 error (_("Unable to parse trace frame number"));
13337 /* Don't update our remote traceframe number cache on failure
13338 to select a remote traceframe. */
13339 if (target_frameno
== -1)
13344 target_tracept
= (int) strtol (p
, &reply
, 16);
13346 error (_("Unable to parse tracepoint number"));
13348 case 'O': /* "OK"? */
13349 if (reply
[1] == 'K' && reply
[2] == '\0')
13352 error (_("Bogus reply from target: %s"), reply
);
13355 error (_("Bogus reply from target: %s"), reply
);
13358 *tpp
= target_tracept
;
13360 rs
->remote_traceframe_number
= target_frameno
;
13361 return target_frameno
;
13365 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13367 struct remote_state
*rs
= get_remote_state ();
13371 set_remote_traceframe ();
13373 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13375 reply
= remote_get_noisy_reply ();
13376 if (reply
&& *reply
)
13380 unpack_varlen_hex (reply
+ 1, &uval
);
13381 *val
= (LONGEST
) uval
;
13389 remote_target::save_trace_data (const char *filename
)
13391 struct remote_state
*rs
= get_remote_state ();
13394 p
= rs
->buf
.data ();
13395 strcpy (p
, "QTSave:");
13397 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13398 >= get_remote_packet_size ())
13399 error (_("Remote file name too long for trace save packet"));
13400 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13403 reply
= remote_get_noisy_reply ();
13404 if (*reply
== '\0')
13405 error (_("Target does not support this command."));
13406 if (strcmp (reply
, "OK") != 0)
13407 error (_("Bogus reply from target: %s"), reply
);
13411 /* This is basically a memory transfer, but needs to be its own packet
13412 because we don't know how the target actually organizes its trace
13413 memory, plus we want to be able to ask for as much as possible, but
13414 not be unhappy if we don't get as much as we ask for. */
13417 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13419 struct remote_state
*rs
= get_remote_state ();
13424 p
= rs
->buf
.data ();
13425 strcpy (p
, "qTBuffer:");
13427 p
+= hexnumstr (p
, offset
);
13429 p
+= hexnumstr (p
, len
);
13433 reply
= remote_get_noisy_reply ();
13434 if (reply
&& *reply
)
13436 /* 'l' by itself means we're at the end of the buffer and
13437 there is nothing more to get. */
13441 /* Convert the reply into binary. Limit the number of bytes to
13442 convert according to our passed-in buffer size, rather than
13443 what was returned in the packet; if the target is
13444 unexpectedly generous and gives us a bigger reply than we
13445 asked for, we don't want to crash. */
13446 rslt
= hex2bin (reply
, buf
, len
);
13450 /* Something went wrong, flag as an error. */
13455 remote_target::set_disconnected_tracing (int val
)
13457 struct remote_state
*rs
= get_remote_state ();
13459 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13463 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13464 "QTDisconnected:%x", val
);
13466 reply
= remote_get_noisy_reply ();
13467 if (*reply
== '\0')
13468 error (_("Target does not support this command."));
13469 if (strcmp (reply
, "OK") != 0)
13470 error (_("Bogus reply from target: %s"), reply
);
13473 warning (_("Target does not support disconnected tracing."));
13477 remote_target::core_of_thread (ptid_t ptid
)
13479 thread_info
*info
= find_thread_ptid (this, ptid
);
13481 if (info
!= NULL
&& info
->priv
!= NULL
)
13482 return get_remote_thread_info (info
)->core
;
13488 remote_target::set_circular_trace_buffer (int val
)
13490 struct remote_state
*rs
= get_remote_state ();
13493 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13494 "QTBuffer:circular:%x", val
);
13496 reply
= remote_get_noisy_reply ();
13497 if (*reply
== '\0')
13498 error (_("Target does not support this command."));
13499 if (strcmp (reply
, "OK") != 0)
13500 error (_("Bogus reply from target: %s"), reply
);
13504 remote_target::traceframe_info ()
13506 gdb::optional
<gdb::char_vector
> text
13507 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13510 return parse_traceframe_info (text
->data ());
13515 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13516 instruction on which a fast tracepoint may be placed. Returns -1
13517 if the packet is not supported, and 0 if the minimum instruction
13518 length is unknown. */
13521 remote_target::get_min_fast_tracepoint_insn_len ()
13523 struct remote_state
*rs
= get_remote_state ();
13526 /* If we're not debugging a process yet, the IPA can't be
13528 if (!target_has_execution
)
13531 /* Make sure the remote is pointing at the right process. */
13532 set_general_process ();
13534 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13536 reply
= remote_get_noisy_reply ();
13537 if (*reply
== '\0')
13541 ULONGEST min_insn_len
;
13543 unpack_varlen_hex (reply
, &min_insn_len
);
13545 return (int) min_insn_len
;
13550 remote_target::set_trace_buffer_size (LONGEST val
)
13552 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13554 struct remote_state
*rs
= get_remote_state ();
13555 char *buf
= rs
->buf
.data ();
13556 char *endbuf
= buf
+ get_remote_packet_size ();
13557 enum packet_result result
;
13559 gdb_assert (val
>= 0 || val
== -1);
13560 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13561 /* Send -1 as literal "-1" to avoid host size dependency. */
13565 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13568 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13571 remote_get_noisy_reply ();
13572 result
= packet_ok (rs
->buf
,
13573 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13575 if (result
!= PACKET_OK
)
13576 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13581 remote_target::set_trace_notes (const char *user
, const char *notes
,
13582 const char *stop_notes
)
13584 struct remote_state
*rs
= get_remote_state ();
13586 char *buf
= rs
->buf
.data ();
13587 char *endbuf
= buf
+ get_remote_packet_size ();
13590 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13593 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13594 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13600 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13601 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13607 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13608 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13612 /* Ensure the buffer is terminated. */
13616 reply
= remote_get_noisy_reply ();
13617 if (*reply
== '\0')
13620 if (strcmp (reply
, "OK") != 0)
13621 error (_("Bogus reply from target: %s"), reply
);
13627 remote_target::use_agent (bool use
)
13629 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13631 struct remote_state
*rs
= get_remote_state ();
13633 /* If the stub supports QAgent. */
13634 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13636 getpkt (&rs
->buf
, 0);
13638 if (strcmp (rs
->buf
.data (), "OK") == 0)
13649 remote_target::can_use_agent ()
13651 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13654 struct btrace_target_info
13656 /* The ptid of the traced thread. */
13659 /* The obtained branch trace configuration. */
13660 struct btrace_config conf
;
13663 /* Reset our idea of our target's btrace configuration. */
13666 remote_btrace_reset (remote_state
*rs
)
13668 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13671 /* Synchronize the configuration with the target. */
13674 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13676 struct packet_config
*packet
;
13677 struct remote_state
*rs
;
13678 char *buf
, *pos
, *endbuf
;
13680 rs
= get_remote_state ();
13681 buf
= rs
->buf
.data ();
13682 endbuf
= buf
+ get_remote_packet_size ();
13684 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13685 if (packet_config_support (packet
) == PACKET_ENABLE
13686 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13689 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13693 getpkt (&rs
->buf
, 0);
13695 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13697 if (buf
[0] == 'E' && buf
[1] == '.')
13698 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13700 error (_("Failed to configure the BTS buffer size."));
13703 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13706 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13707 if (packet_config_support (packet
) == PACKET_ENABLE
13708 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13711 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13715 getpkt (&rs
->buf
, 0);
13717 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13719 if (buf
[0] == 'E' && buf
[1] == '.')
13720 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13722 error (_("Failed to configure the trace buffer size."));
13725 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13729 /* Read the current thread's btrace configuration from the target and
13730 store it into CONF. */
13733 btrace_read_config (struct btrace_config
*conf
)
13735 gdb::optional
<gdb::char_vector
> xml
13736 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13738 parse_xml_btrace_conf (conf
, xml
->data ());
13741 /* Maybe reopen target btrace. */
13744 remote_target::remote_btrace_maybe_reopen ()
13746 struct remote_state
*rs
= get_remote_state ();
13747 int btrace_target_pushed
= 0;
13748 #if !defined (HAVE_LIBIPT)
13752 /* Don't bother walking the entirety of the remote thread list when
13753 we know the feature isn't supported by the remote. */
13754 if (packet_support (PACKET_qXfer_btrace_conf
) != PACKET_ENABLE
)
13757 scoped_restore_current_thread restore_thread
;
13759 for (thread_info
*tp
: all_non_exited_threads (this))
13761 set_general_thread (tp
->ptid
);
13763 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13764 btrace_read_config (&rs
->btrace_config
);
13766 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13769 #if !defined (HAVE_LIBIPT)
13770 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13775 warning (_("Target is recording using Intel Processor Trace "
13776 "but support was disabled at compile time."));
13781 #endif /* !defined (HAVE_LIBIPT) */
13783 /* Push target, once, but before anything else happens. This way our
13784 changes to the threads will be cleaned up by unpushing the target
13785 in case btrace_read_config () throws. */
13786 if (!btrace_target_pushed
)
13788 btrace_target_pushed
= 1;
13789 record_btrace_push_target ();
13790 printf_filtered (_("Target is recording using %s.\n"),
13791 btrace_format_string (rs
->btrace_config
.format
));
13794 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13795 tp
->btrace
.target
->ptid
= tp
->ptid
;
13796 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13800 /* Enable branch tracing. */
13802 struct btrace_target_info
*
13803 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13805 struct btrace_target_info
*tinfo
= NULL
;
13806 struct packet_config
*packet
= NULL
;
13807 struct remote_state
*rs
= get_remote_state ();
13808 char *buf
= rs
->buf
.data ();
13809 char *endbuf
= buf
+ get_remote_packet_size ();
13811 switch (conf
->format
)
13813 case BTRACE_FORMAT_BTS
:
13814 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13817 case BTRACE_FORMAT_PT
:
13818 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13822 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13823 error (_("Target does not support branch tracing."));
13825 btrace_sync_conf (conf
);
13827 set_general_thread (ptid
);
13829 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13831 getpkt (&rs
->buf
, 0);
13833 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13835 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13836 error (_("Could not enable branch tracing for %s: %s"),
13837 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
13839 error (_("Could not enable branch tracing for %s."),
13840 target_pid_to_str (ptid
).c_str ());
13843 tinfo
= XCNEW (struct btrace_target_info
);
13844 tinfo
->ptid
= ptid
;
13846 /* If we fail to read the configuration, we lose some information, but the
13847 tracing itself is not impacted. */
13850 btrace_read_config (&tinfo
->conf
);
13852 catch (const gdb_exception_error
&err
)
13854 if (err
.message
!= NULL
)
13855 warning ("%s", err
.what ());
13861 /* Disable branch tracing. */
13864 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
13866 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13867 struct remote_state
*rs
= get_remote_state ();
13868 char *buf
= rs
->buf
.data ();
13869 char *endbuf
= buf
+ get_remote_packet_size ();
13871 if (packet_config_support (packet
) != PACKET_ENABLE
)
13872 error (_("Target does not support branch tracing."));
13874 set_general_thread (tinfo
->ptid
);
13876 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13878 getpkt (&rs
->buf
, 0);
13880 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13882 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13883 error (_("Could not disable branch tracing for %s: %s"),
13884 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
13886 error (_("Could not disable branch tracing for %s."),
13887 target_pid_to_str (tinfo
->ptid
).c_str ());
13893 /* Teardown branch tracing. */
13896 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
13898 /* We must not talk to the target during teardown. */
13902 /* Read the branch trace. */
13905 remote_target::read_btrace (struct btrace_data
*btrace
,
13906 struct btrace_target_info
*tinfo
,
13907 enum btrace_read_type type
)
13909 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13912 if (packet_config_support (packet
) != PACKET_ENABLE
)
13913 error (_("Target does not support branch tracing."));
13915 #if !defined(HAVE_LIBEXPAT)
13916 error (_("Cannot process branch tracing result. XML parsing not supported."));
13921 case BTRACE_READ_ALL
:
13924 case BTRACE_READ_NEW
:
13927 case BTRACE_READ_DELTA
:
13931 internal_error (__FILE__
, __LINE__
,
13932 _("Bad branch tracing read type: %u."),
13933 (unsigned int) type
);
13936 gdb::optional
<gdb::char_vector
> xml
13937 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
13939 return BTRACE_ERR_UNKNOWN
;
13941 parse_xml_btrace (btrace
, xml
->data ());
13943 return BTRACE_ERR_NONE
;
13946 const struct btrace_config
*
13947 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
13949 return &tinfo
->conf
;
13953 remote_target::augmented_libraries_svr4_read ()
13955 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13959 /* Implementation of to_load. */
13962 remote_target::load (const char *name
, int from_tty
)
13964 generic_load (name
, from_tty
);
13967 /* Accepts an integer PID; returns a string representing a file that
13968 can be opened on the remote side to get the symbols for the child
13969 process. Returns NULL if the operation is not supported. */
13972 remote_target::pid_to_exec_file (int pid
)
13974 static gdb::optional
<gdb::char_vector
> filename
;
13975 char *annex
= NULL
;
13977 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13980 inferior
*inf
= find_inferior_pid (this, pid
);
13982 internal_error (__FILE__
, __LINE__
,
13983 _("not currently attached to process %d"), pid
);
13985 if (!inf
->fake_pid_p
)
13987 const int annex_size
= 9;
13989 annex
= (char *) alloca (annex_size
);
13990 xsnprintf (annex
, annex_size
, "%x", pid
);
13993 filename
= target_read_stralloc (current_top_target (),
13994 TARGET_OBJECT_EXEC_FILE
, annex
);
13996 return filename
? filename
->data () : nullptr;
13999 /* Implement the to_can_do_single_step target_ops method. */
14002 remote_target::can_do_single_step ()
14004 /* We can only tell whether target supports single step or not by
14005 supported s and S vCont actions if the stub supports vContSupported
14006 feature. If the stub doesn't support vContSupported feature,
14007 we have conservatively to think target doesn't supports single
14009 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
14011 struct remote_state
*rs
= get_remote_state ();
14013 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14014 remote_vcont_probe ();
14016 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
14022 /* Implementation of the to_execution_direction method for the remote
14025 enum exec_direction_kind
14026 remote_target::execution_direction ()
14028 struct remote_state
*rs
= get_remote_state ();
14030 return rs
->last_resume_exec_dir
;
14033 /* Return pointer to the thread_info struct which corresponds to
14034 THREAD_HANDLE (having length HANDLE_LEN). */
14037 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
14041 for (thread_info
*tp
: all_non_exited_threads (this))
14043 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14045 if (tp
->inf
== inf
&& priv
!= NULL
)
14047 if (handle_len
!= priv
->thread_handle
.size ())
14048 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14049 handle_len
, priv
->thread_handle
.size ());
14050 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14060 remote_target::thread_info_to_thread_handle (struct thread_info
*tp
)
14062 remote_thread_info
*priv
= get_remote_thread_info (tp
);
14063 return priv
->thread_handle
;
14067 remote_target::can_async_p ()
14069 struct remote_state
*rs
= get_remote_state ();
14071 /* We don't go async if the user has explicitly prevented it with the
14072 "maint set target-async" command. */
14073 if (!target_async_permitted
)
14076 /* We're async whenever the serial device is. */
14077 return serial_can_async_p (rs
->remote_desc
);
14081 remote_target::is_async_p ()
14083 struct remote_state
*rs
= get_remote_state ();
14085 if (!target_async_permitted
)
14086 /* We only enable async when the user specifically asks for it. */
14089 /* We're async whenever the serial device is. */
14090 return serial_is_async_p (rs
->remote_desc
);
14093 /* Pass the SERIAL event on and up to the client. One day this code
14094 will be able to delay notifying the client of an event until the
14095 point where an entire packet has been received. */
14097 static serial_event_ftype remote_async_serial_handler
;
14100 remote_async_serial_handler (struct serial
*scb
, void *context
)
14102 /* Don't propogate error information up to the client. Instead let
14103 the client find out about the error by querying the target. */
14104 inferior_event_handler (INF_REG_EVENT
, NULL
);
14108 remote_async_inferior_event_handler (gdb_client_data data
)
14110 inferior_event_handler (INF_REG_EVENT
, data
);
14114 remote_target::async_wait_fd ()
14116 struct remote_state
*rs
= get_remote_state ();
14117 return rs
->remote_desc
->fd
;
14121 remote_target::async (int enable
)
14123 struct remote_state
*rs
= get_remote_state ();
14127 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14129 /* If there are pending events in the stop reply queue tell the
14130 event loop to process them. */
14131 if (!rs
->stop_reply_queue
.empty ())
14132 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14133 /* For simplicity, below we clear the pending events token
14134 without remembering whether it is marked, so here we always
14135 mark it. If there's actually no pending notification to
14136 process, this ends up being a no-op (other than a spurious
14137 event-loop wakeup). */
14138 if (target_is_non_stop_p ())
14139 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14143 serial_async (rs
->remote_desc
, NULL
, NULL
);
14144 /* If the core is disabling async, it doesn't want to be
14145 disturbed with target events. Clear all async event sources
14147 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14148 if (target_is_non_stop_p ())
14149 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14153 /* Implementation of the to_thread_events method. */
14156 remote_target::thread_events (int enable
)
14158 struct remote_state
*rs
= get_remote_state ();
14159 size_t size
= get_remote_packet_size ();
14161 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14164 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14166 getpkt (&rs
->buf
, 0);
14168 switch (packet_ok (rs
->buf
,
14169 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14172 if (strcmp (rs
->buf
.data (), "OK") != 0)
14173 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14176 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14178 case PACKET_UNKNOWN
:
14184 set_remote_cmd (const char *args
, int from_tty
)
14186 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
14190 show_remote_cmd (const char *args
, int from_tty
)
14192 /* We can't just use cmd_show_list here, because we want to skip
14193 the redundant "show remote Z-packet" and the legacy aliases. */
14194 struct cmd_list_element
*list
= remote_show_cmdlist
;
14195 struct ui_out
*uiout
= current_uiout
;
14197 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14198 for (; list
!= NULL
; list
= list
->next
)
14199 if (strcmp (list
->name
, "Z-packet") == 0)
14201 else if (list
->type
== not_set_cmd
)
14202 /* Alias commands are exactly like the original, except they
14203 don't have the normal type. */
14207 ui_out_emit_tuple
option_emitter (uiout
, "option");
14209 uiout
->field_string ("name", list
->name
);
14210 uiout
->text (": ");
14211 if (list
->type
== show_cmd
)
14212 do_show_command (NULL
, from_tty
, list
);
14214 cmd_func (list
, NULL
, from_tty
);
14219 /* Function to be called whenever a new objfile (shlib) is detected. */
14221 remote_new_objfile (struct objfile
*objfile
)
14223 remote_target
*remote
= get_current_remote_target ();
14225 if (remote
!= NULL
) /* Have a remote connection. */
14226 remote
->remote_check_symbols ();
14229 /* Pull all the tracepoints defined on the target and create local
14230 data structures representing them. We don't want to create real
14231 tracepoints yet, we don't want to mess up the user's existing
14235 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14237 struct remote_state
*rs
= get_remote_state ();
14240 /* Ask for a first packet of tracepoint definition. */
14242 getpkt (&rs
->buf
, 0);
14243 p
= rs
->buf
.data ();
14244 while (*p
&& *p
!= 'l')
14246 parse_tracepoint_definition (p
, utpp
);
14247 /* Ask for another packet of tracepoint definition. */
14249 getpkt (&rs
->buf
, 0);
14250 p
= rs
->buf
.data ();
14256 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14258 struct remote_state
*rs
= get_remote_state ();
14261 /* Ask for a first packet of variable definition. */
14263 getpkt (&rs
->buf
, 0);
14264 p
= rs
->buf
.data ();
14265 while (*p
&& *p
!= 'l')
14267 parse_tsv_definition (p
, utsvp
);
14268 /* Ask for another packet of variable definition. */
14270 getpkt (&rs
->buf
, 0);
14271 p
= rs
->buf
.data ();
14276 /* The "set/show range-stepping" show hook. */
14279 show_range_stepping (struct ui_file
*file
, int from_tty
,
14280 struct cmd_list_element
*c
,
14283 fprintf_filtered (file
,
14284 _("Debugger's willingness to use range stepping "
14285 "is %s.\n"), value
);
14288 /* Return true if the vCont;r action is supported by the remote
14292 remote_target::vcont_r_supported ()
14294 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14295 remote_vcont_probe ();
14297 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14298 && get_remote_state ()->supports_vCont
.r
);
14301 /* The "set/show range-stepping" set hook. */
14304 set_range_stepping (const char *ignore_args
, int from_tty
,
14305 struct cmd_list_element
*c
)
14307 /* When enabling, check whether range stepping is actually supported
14308 by the target, and warn if not. */
14309 if (use_range_stepping
)
14311 remote_target
*remote
= get_current_remote_target ();
14313 || !remote
->vcont_r_supported ())
14314 warning (_("Range stepping is not supported by the current target"));
14318 void _initialize_remote ();
14320 _initialize_remote ()
14322 struct cmd_list_element
*cmd
;
14323 const char *cmd_name
;
14325 /* architecture specific data */
14326 remote_g_packet_data_handle
=
14327 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14329 add_target (remote_target_info
, remote_target::open
);
14330 add_target (extended_remote_target_info
, extended_remote_target::open
);
14332 /* Hook into new objfile notification. */
14333 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14336 init_remote_threadtests ();
14339 /* set/show remote ... */
14341 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14342 Remote protocol specific variables.\n\
14343 Configure various remote-protocol specific variables such as\n\
14344 the packets being used."),
14345 &remote_set_cmdlist
, "set remote ",
14346 0 /* allow-unknown */, &setlist
);
14347 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14348 Remote protocol specific variables.\n\
14349 Configure various remote-protocol specific variables such as\n\
14350 the packets being used."),
14351 &remote_show_cmdlist
, "show remote ",
14352 0 /* allow-unknown */, &showlist
);
14354 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14355 Compare section data on target to the exec file.\n\
14356 Argument is a single section name (default: all loaded sections).\n\
14357 To compare only read-only loaded sections, specify the -r option."),
14360 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14361 Send an arbitrary packet to a remote target.\n\
14362 maintenance packet TEXT\n\
14363 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14364 this command sends the string TEXT to the inferior, and displays the\n\
14365 response packet. GDB supplies the initial `$' character, and the\n\
14366 terminating `#' character and checksum."),
14369 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14370 Set whether to send break if interrupted."), _("\
14371 Show whether to send break if interrupted."), _("\
14372 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14373 set_remotebreak
, show_remotebreak
,
14374 &setlist
, &showlist
);
14375 cmd_name
= "remotebreak";
14376 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14377 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14378 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14379 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14380 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14382 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14383 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14385 Set interrupt sequence to remote target."), _("\
14386 Show interrupt sequence to remote target."), _("\
14387 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14388 NULL
, show_interrupt_sequence
,
14389 &remote_set_cmdlist
,
14390 &remote_show_cmdlist
);
14392 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14393 &interrupt_on_connect
, _("\
14394 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14395 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14396 If set, interrupt sequence is sent to remote target."),
14398 &remote_set_cmdlist
, &remote_show_cmdlist
);
14400 /* Install commands for configuring memory read/write packets. */
14402 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14403 Set the maximum number of bytes per memory write packet (deprecated)."),
14405 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14406 Show the maximum number of bytes per memory write packet (deprecated)."),
14408 add_cmd ("memory-write-packet-size", no_class
,
14409 set_memory_write_packet_size
, _("\
14410 Set the maximum number of bytes per memory-write packet.\n\
14411 Specify the number of bytes in a packet or 0 (zero) for the\n\
14412 default packet size. The actual limit is further reduced\n\
14413 dependent on the target. Specify ``fixed'' to disable the\n\
14414 further restriction and ``limit'' to enable that restriction."),
14415 &remote_set_cmdlist
);
14416 add_cmd ("memory-read-packet-size", no_class
,
14417 set_memory_read_packet_size
, _("\
14418 Set the maximum number of bytes per memory-read packet.\n\
14419 Specify the number of bytes in a packet or 0 (zero) for the\n\
14420 default packet size. The actual limit is further reduced\n\
14421 dependent on the target. Specify ``fixed'' to disable the\n\
14422 further restriction and ``limit'' to enable that restriction."),
14423 &remote_set_cmdlist
);
14424 add_cmd ("memory-write-packet-size", no_class
,
14425 show_memory_write_packet_size
,
14426 _("Show the maximum number of bytes per memory-write packet."),
14427 &remote_show_cmdlist
);
14428 add_cmd ("memory-read-packet-size", no_class
,
14429 show_memory_read_packet_size
,
14430 _("Show the maximum number of bytes per memory-read packet."),
14431 &remote_show_cmdlist
);
14433 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14434 &remote_hw_watchpoint_limit
, _("\
14435 Set the maximum number of target hardware watchpoints."), _("\
14436 Show the maximum number of target hardware watchpoints."), _("\
14437 Specify \"unlimited\" for unlimited hardware watchpoints."),
14438 NULL
, show_hardware_watchpoint_limit
,
14439 &remote_set_cmdlist
,
14440 &remote_show_cmdlist
);
14441 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14443 &remote_hw_watchpoint_length_limit
, _("\
14444 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14445 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14446 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14447 NULL
, show_hardware_watchpoint_length_limit
,
14448 &remote_set_cmdlist
, &remote_show_cmdlist
);
14449 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14450 &remote_hw_breakpoint_limit
, _("\
14451 Set the maximum number of target hardware breakpoints."), _("\
14452 Show the maximum number of target hardware breakpoints."), _("\
14453 Specify \"unlimited\" for unlimited hardware breakpoints."),
14454 NULL
, show_hardware_breakpoint_limit
,
14455 &remote_set_cmdlist
, &remote_show_cmdlist
);
14457 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14458 &remote_address_size
, _("\
14459 Set the maximum size of the address (in bits) in a memory packet."), _("\
14460 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14462 NULL
, /* FIXME: i18n: */
14463 &setlist
, &showlist
);
14465 init_all_packet_configs ();
14467 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14468 "X", "binary-download", 1);
14470 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14471 "vCont", "verbose-resume", 0);
14473 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14474 "QPassSignals", "pass-signals", 0);
14476 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14477 "QCatchSyscalls", "catch-syscalls", 0);
14479 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14480 "QProgramSignals", "program-signals", 0);
14482 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14483 "QSetWorkingDir", "set-working-dir", 0);
14485 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14486 "QStartupWithShell", "startup-with-shell", 0);
14488 add_packet_config_cmd (&remote_protocol_packets
14489 [PACKET_QEnvironmentHexEncoded
],
14490 "QEnvironmentHexEncoded", "environment-hex-encoded",
14493 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14494 "QEnvironmentReset", "environment-reset",
14497 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14498 "QEnvironmentUnset", "environment-unset",
14501 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14502 "qSymbol", "symbol-lookup", 0);
14504 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14505 "P", "set-register", 1);
14507 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14508 "p", "fetch-register", 1);
14510 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14511 "Z0", "software-breakpoint", 0);
14513 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14514 "Z1", "hardware-breakpoint", 0);
14516 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14517 "Z2", "write-watchpoint", 0);
14519 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14520 "Z3", "read-watchpoint", 0);
14522 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14523 "Z4", "access-watchpoint", 0);
14525 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14526 "qXfer:auxv:read", "read-aux-vector", 0);
14528 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14529 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14531 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14532 "qXfer:features:read", "target-features", 0);
14534 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14535 "qXfer:libraries:read", "library-info", 0);
14537 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14538 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14540 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14541 "qXfer:memory-map:read", "memory-map", 0);
14543 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14544 "qXfer:osdata:read", "osdata", 0);
14546 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14547 "qXfer:threads:read", "threads", 0);
14549 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14550 "qXfer:siginfo:read", "read-siginfo-object", 0);
14552 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14553 "qXfer:siginfo:write", "write-siginfo-object", 0);
14555 add_packet_config_cmd
14556 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14557 "qXfer:traceframe-info:read", "traceframe-info", 0);
14559 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14560 "qXfer:uib:read", "unwind-info-block", 0);
14562 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14563 "qGetTLSAddr", "get-thread-local-storage-address",
14566 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14567 "qGetTIBAddr", "get-thread-information-block-address",
14570 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14571 "bc", "reverse-continue", 0);
14573 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14574 "bs", "reverse-step", 0);
14576 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14577 "qSupported", "supported-packets", 0);
14579 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14580 "qSearch:memory", "search-memory", 0);
14582 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14583 "qTStatus", "trace-status", 0);
14585 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14586 "vFile:setfs", "hostio-setfs", 0);
14588 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14589 "vFile:open", "hostio-open", 0);
14591 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14592 "vFile:pread", "hostio-pread", 0);
14594 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14595 "vFile:pwrite", "hostio-pwrite", 0);
14597 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14598 "vFile:close", "hostio-close", 0);
14600 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14601 "vFile:unlink", "hostio-unlink", 0);
14603 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14604 "vFile:readlink", "hostio-readlink", 0);
14606 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14607 "vFile:fstat", "hostio-fstat", 0);
14609 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14610 "vAttach", "attach", 0);
14612 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14615 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14616 "QStartNoAckMode", "noack", 0);
14618 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14619 "vKill", "kill", 0);
14621 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14622 "qAttached", "query-attached", 0);
14624 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14625 "ConditionalTracepoints",
14626 "conditional-tracepoints", 0);
14628 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14629 "ConditionalBreakpoints",
14630 "conditional-breakpoints", 0);
14632 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14633 "BreakpointCommands",
14634 "breakpoint-commands", 0);
14636 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14637 "FastTracepoints", "fast-tracepoints", 0);
14639 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14640 "TracepointSource", "TracepointSource", 0);
14642 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14643 "QAllow", "allow", 0);
14645 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14646 "StaticTracepoints", "static-tracepoints", 0);
14648 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14649 "InstallInTrace", "install-in-trace", 0);
14651 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14652 "qXfer:statictrace:read", "read-sdata-object", 0);
14654 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14655 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14657 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14658 "QDisableRandomization", "disable-randomization", 0);
14660 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14661 "QAgent", "agent", 0);
14663 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14664 "QTBuffer:size", "trace-buffer-size", 0);
14666 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14667 "Qbtrace:off", "disable-btrace", 0);
14669 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14670 "Qbtrace:bts", "enable-btrace-bts", 0);
14672 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14673 "Qbtrace:pt", "enable-btrace-pt", 0);
14675 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14676 "qXfer:btrace", "read-btrace", 0);
14678 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14679 "qXfer:btrace-conf", "read-btrace-conf", 0);
14681 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14682 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14684 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14685 "multiprocess-feature", "multiprocess-feature", 0);
14687 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14688 "swbreak-feature", "swbreak-feature", 0);
14690 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14691 "hwbreak-feature", "hwbreak-feature", 0);
14693 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14694 "fork-event-feature", "fork-event-feature", 0);
14696 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14697 "vfork-event-feature", "vfork-event-feature", 0);
14699 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14700 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14702 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14703 "vContSupported", "verbose-resume-supported", 0);
14705 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14706 "exec-event-feature", "exec-event-feature", 0);
14708 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14709 "vCtrlC", "ctrl-c", 0);
14711 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14712 "QThreadEvents", "thread-events", 0);
14714 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14715 "N stop reply", "no-resumed-stop-reply", 0);
14717 /* Assert that we've registered "set remote foo-packet" commands
14718 for all packet configs. */
14722 for (i
= 0; i
< PACKET_MAX
; i
++)
14724 /* Ideally all configs would have a command associated. Some
14725 still don't though. */
14730 case PACKET_QNonStop
:
14731 case PACKET_EnableDisableTracepoints_feature
:
14732 case PACKET_tracenz_feature
:
14733 case PACKET_DisconnectedTracing_feature
:
14734 case PACKET_augmented_libraries_svr4_read_feature
:
14736 /* Additions to this list need to be well justified:
14737 pre-existing packets are OK; new packets are not. */
14745 /* This catches both forgetting to add a config command, and
14746 forgetting to remove a packet from the exception list. */
14747 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14751 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14752 Z sub-packet has its own set and show commands, but users may
14753 have sets to this variable in their .gdbinit files (or in their
14755 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14756 &remote_Z_packet_detect
, _("\
14757 Set use of remote protocol `Z' packets."), _("\
14758 Show use of remote protocol `Z' packets."), _("\
14759 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14761 set_remote_protocol_Z_packet_cmd
,
14762 show_remote_protocol_Z_packet_cmd
,
14763 /* FIXME: i18n: Use of remote protocol
14764 `Z' packets is %s. */
14765 &remote_set_cmdlist
, &remote_show_cmdlist
);
14767 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14768 Manipulate files on the remote system.\n\
14769 Transfer files to and from the remote target system."),
14770 &remote_cmdlist
, "remote ",
14771 0 /* allow-unknown */, &cmdlist
);
14773 add_cmd ("put", class_files
, remote_put_command
,
14774 _("Copy a local file to the remote system."),
14777 add_cmd ("get", class_files
, remote_get_command
,
14778 _("Copy a remote file to the local system."),
14781 add_cmd ("delete", class_files
, remote_delete_command
,
14782 _("Delete a remote file."),
14785 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14786 &remote_exec_file_var
, _("\
14787 Set the remote pathname for \"run\"."), _("\
14788 Show the remote pathname for \"run\"."), NULL
,
14789 set_remote_exec_file
,
14790 show_remote_exec_file
,
14791 &remote_set_cmdlist
,
14792 &remote_show_cmdlist
);
14794 add_setshow_boolean_cmd ("range-stepping", class_run
,
14795 &use_range_stepping
, _("\
14796 Enable or disable range stepping."), _("\
14797 Show whether target-assisted range stepping is enabled."), _("\
14798 If on, and the target supports it, when stepping a source line, GDB\n\
14799 tells the target to step the corresponding range of addresses itself instead\n\
14800 of issuing multiple single-steps. This speeds up source level\n\
14801 stepping. If off, GDB always issues single-steps, even if range\n\
14802 stepping is supported by the target. The default is on."),
14803 set_range_stepping
,
14804 show_range_stepping
,
14808 add_setshow_zinteger_cmd ("watchdog", class_maintenance
, &watchdog
, _("\
14809 Set watchdog timer."), _("\
14810 Show watchdog timer."), _("\
14811 When non-zero, this timeout is used instead of waiting forever for a target\n\
14812 to finish a low-level step or continue operation. If the specified amount\n\
14813 of time passes without a response from the target, an error occurs."),
14816 &setlist
, &showlist
);
14818 add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class
,
14819 &remote_packet_max_chars
, _("\
14820 Set the maximum number of characters to display for each remote packet."), _("\
14821 Show the maximum number of characters to display for each remote packet."), _("\
14822 Specify \"unlimited\" to display all the characters."),
14823 NULL
, show_remote_packet_max_chars
,
14824 &setdebuglist
, &showdebuglist
);
14826 /* Eventually initialize fileio. See fileio.c */
14827 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);